mirror of
https://github.com/3proxy/3proxy.git
synced 2026-11-22 23:59:41 +08:00
http server implemented, pcre support for hostnames in acls implemented
This commit is contained in:
1 parent
7bc34002df
commit
927b011bd4
27 files changed
+2325
-148
No files matched your search
+142
@@ -817,11 +817,43 @@ int bindwithrange(struct clientparam *param, SOCKET sock, PROXYSOCKADDRTYPE *sa,
|
||||
whatever replaces the star with a regular expression later - behaves the same
|
||||
way and gains the same syntax at the same time.
|
||||
*/
|
||||
/* A pattern written as a regular expression carries a prefix. Both spellings
|
||||
are taken so a configuration reads the way its author thinks of it. */
|
||||
static unsigned char * regexprefix(unsigned char *arg)
|
||||
{
|
||||
if(!strncmp((char *)arg, "pcre:", 5)) return arg + 5;
|
||||
if(!strncmp((char *)arg, "regex:", 6)) return arg + 6;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Shared by every pattern the configuration can carry. Returns 0 on success. */
|
||||
static int compileregex(struct hostname *h, unsigned char *pattern)
|
||||
{
|
||||
#ifdef WITH_PCRE
|
||||
char err[256];
|
||||
|
||||
h->re = pcre_pattern_compile(pattern, err, sizeof(err));
|
||||
if(!h->re){
|
||||
fprintf(stderr, "Bad regular expression '%s': %s\n", pattern, err);
|
||||
return 1;
|
||||
}
|
||||
h->matchtype = MATCHREGEX;
|
||||
h->name = (unsigned char *)strdup((char *)pattern);
|
||||
return h->name? 0 : 1;
|
||||
#else
|
||||
fprintf(stderr, "Regular expression '%s' needs a build with PCRE\n", pattern);
|
||||
return 1;
|
||||
#endif
|
||||
}
|
||||
|
||||
int parsepattern(struct hostname *h, unsigned char *arg)
|
||||
{
|
||||
int arglen;
|
||||
unsigned char *pattern;
|
||||
|
||||
h->re = NULL;
|
||||
if((pattern = regexprefix(arg))) return compileregex(h, pattern);
|
||||
|
||||
arglen = (int)strlen((char *)arg);
|
||||
h->matchtype = 3;
|
||||
pattern = arg;
|
||||
@@ -851,6 +883,14 @@ int patternmatchpos(const struct hostname *h, const unsigned char *str, int *sta
|
||||
char *found;
|
||||
|
||||
if(!h->name || !str) return 0;
|
||||
if(h->matchtype == MATCHREGEX || h->matchtype == MATCHGLOB){
|
||||
struct capture caps[MAXCAPTURES];
|
||||
|
||||
if(!patternmatchcaps(h, str, caps, NULL)) return 0;
|
||||
if(start) *start = caps[1].start;
|
||||
if(len) *len = caps[1].len;
|
||||
return 1;
|
||||
}
|
||||
|
||||
lname = (int)strlen((char *)h->name);
|
||||
lstr = (int)strlen((char *)str);
|
||||
@@ -903,9 +943,111 @@ int patternmatchpos(const struct hostname *h, const unsigned char *str, int *sta
|
||||
|
||||
int patternmatch(const struct hostname *h, const unsigned char *str)
|
||||
{
|
||||
return patternmatchcaps(h, str, NULL, NULL);
|
||||
}
|
||||
|
||||
/* Match a glob, recording what each star stood for.
|
||||
|
||||
A single star stands for any run of characters within one element of the
|
||||
path, so it stops at a slash; a double star crosses them. Stars are
|
||||
numbered in the order they appear, which is how a template refers to them.
|
||||
*/
|
||||
static int globmatch(const unsigned char *pat, const unsigned char *str,
|
||||
const unsigned char *subject, struct capture *caps, int maxcaps, int star)
|
||||
{
|
||||
while(*pat){
|
||||
if(*pat == '*'){
|
||||
int crosses = (pat[1] == '*');
|
||||
const unsigned char *rest = pat + (crosses? 2 : 1);
|
||||
int len;
|
||||
|
||||
for(len = 0; ; len++){
|
||||
if(star < maxcaps && caps){
|
||||
caps[star].start = (int)(str - subject);
|
||||
caps[star].len = len;
|
||||
}
|
||||
if(globmatch(rest, str + len, subject, caps, maxcaps, star + 1)) return 1;
|
||||
if(!str[len]) return 0;
|
||||
if(!crosses && str[len] == '/') return 0;
|
||||
}
|
||||
}
|
||||
if(*pat != *str) return 0;
|
||||
pat++;
|
||||
str++;
|
||||
}
|
||||
return *str == 0;
|
||||
}
|
||||
|
||||
/* Match a pattern of any kind and report what its stars or groups stood for.
|
||||
caps may be NULL when only the yes or no answer is wanted. */
|
||||
int patternmatchcaps(const struct hostname *h, const unsigned char *str,
|
||||
struct capture *caps, int *ncaps)
|
||||
{
|
||||
int n = 0;
|
||||
|
||||
if(ncaps) *ncaps = 0;
|
||||
if(!h || !str) return 0;
|
||||
|
||||
if(h->matchtype == MATCHREGEX){
|
||||
#ifdef WITH_PCRE
|
||||
struct capture local[MAXCAPTURES];
|
||||
|
||||
n = pcre_pattern_match(h->re, str, caps? caps : local, MAXCAPTURES);
|
||||
if(ncaps) *ncaps = n;
|
||||
return n > 0;
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
if(h->matchtype == MATCHGLOB){
|
||||
struct capture local[MAXCAPTURES];
|
||||
struct capture *use = caps? caps : local;
|
||||
int i;
|
||||
|
||||
for(i = 0; i < MAXCAPTURES; i++){
|
||||
use[i].start = 0;
|
||||
use[i].len = 0;
|
||||
}
|
||||
use[0].start = 0;
|
||||
use[0].len = (int)strlen((char *)str);
|
||||
if(!h->name) return 0;
|
||||
if(!globmatch(h->name, str, str, use, MAXCAPTURES, 1)) return 0;
|
||||
if(ncaps){
|
||||
for(n = MAXCAPTURES - 1; n > 0 && !use[n].len && !use[n].start; n--);
|
||||
*ncaps = n + 1;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* the star at one end or both, as an access rule has always written it */
|
||||
if(caps){
|
||||
int start = 0, len = 0;
|
||||
|
||||
if(!patternmatchpos(h, str, &start, &len)) return 0;
|
||||
caps[0].start = 0;
|
||||
caps[0].len = (int)strlen((char *)str);
|
||||
caps[1].start = start;
|
||||
caps[1].len = len;
|
||||
if(ncaps) *ncaps = 2;
|
||||
return 1;
|
||||
}
|
||||
return patternmatchpos(h, str, NULL, NULL);
|
||||
}
|
||||
|
||||
/* A URL in an http rule: stars anywhere, or a regular expression. */
|
||||
int parsepathpattern(struct hostname *h, unsigned char *arg)
|
||||
{
|
||||
unsigned char *pattern;
|
||||
|
||||
h->re = NULL;
|
||||
if((pattern = regexprefix(arg))) return compileregex(h, pattern);
|
||||
|
||||
h->matchtype = MATCHGLOB;
|
||||
h->name = (unsigned char *)strdup((char *)arg);
|
||||
return h->name? 0 : 1;
|
||||
}
|
||||
|
||||
int scanaddr(const unsigned char *s, uint32_t * ip, uint32_t * mask) {
|
||||
unsigned d1, d2, d3, d4, m;
|
||||
int res;
|
||||
|
||||
Reference in new issue
Block a user