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
ea4b2cc3a2
commit
9529a1dfcf
27 files changed
+2325
-148
No files matched your search
@@ -16,6 +16,9 @@ void pcre_install(void);
|
||||
#ifdef WITH_TRANSPARENT
|
||||
void transparent_install(void);
|
||||
#endif
|
||||
#ifdef WITH_HTTPSRV
|
||||
void httpsrv_init(void);
|
||||
#endif
|
||||
#ifndef _WIN32
|
||||
#include <sys/resource.h>
|
||||
#ifndef NOPLUGINS
|
||||
@@ -535,6 +538,9 @@ int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int
|
||||
#ifdef WITH_TRANSPARENT
|
||||
transparent_install();
|
||||
#endif
|
||||
#ifdef WITH_HTTPSRV
|
||||
httpsrv_init();
|
||||
#endif
|
||||
|
||||
freeconf(&conf);
|
||||
initcommands();
|
||||
|
||||
+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;
|
||||
|
||||
+141
-19
@@ -9,7 +9,7 @@
|
||||
#include "proxy.h"
|
||||
|
||||
#ifdef WITH_HTTPSRV
|
||||
static int addhttprule(char *host, char *url, char *op, char *params);
|
||||
static int addhttprule(char *op, char *host, char *url, char *params);
|
||||
#endif
|
||||
#include "mdhash.h"
|
||||
#ifdef WITH_SSL
|
||||
@@ -264,10 +264,10 @@ static int h_proxy(int argc, unsigned char ** argv){
|
||||
else if(!strcmp((char *)argv[0], "admin")) {
|
||||
/* The same service as httpsrv, with the administration pages
|
||||
declared for it. */
|
||||
if(addhttprule("*", "/C*", "admin_counters", NULL) ||
|
||||
addhttprule("*", "/R", "admin_reload", NULL) ||
|
||||
addhttprule("*", "/S*", "admin_services", NULL) ||
|
||||
addhttprule("*", "*", "admin", NULL)){
|
||||
if(addhttprule("admin_counters", "*", "/C*", NULL) ||
|
||||
addhttprule("admin_reload", "*", "/R", NULL) ||
|
||||
addhttprule("admin_services", "*", "/S*", NULL) ||
|
||||
addhttprule("admin", "*", "**", NULL)){
|
||||
fprintf(stderr, "Failed to declare the admin pages, line %d\n", linenum);
|
||||
return 1;
|
||||
}
|
||||
@@ -802,8 +802,57 @@ struct redirdesc redirs[] = {
|
||||
};
|
||||
|
||||
#ifdef WITH_HTTPSRV
|
||||
/* Headers a rule adds are written as one argument, the lines separated by a
|
||||
backslash and an n, because a configuration line cannot hold a line ending.
|
||||
Those two characters become a real one here. A line ending which reached the
|
||||
argument as itself is dropped: what goes on the wire is decided here and not
|
||||
by whatever produced the string. */
|
||||
static unsigned char * parsehdrs(const unsigned char *arg)
|
||||
{
|
||||
unsigned char *out, *o;
|
||||
const unsigned char *p;
|
||||
size_t len = strlen((char *)arg);
|
||||
|
||||
out = malloc(len * 2 + 3);
|
||||
if(!out) return NULL;
|
||||
for(p = arg, o = out; *p; p++){
|
||||
if(*p == '\\' && p[1] == 'n'){
|
||||
*o++ = '\r';
|
||||
*o++ = '\n';
|
||||
p++;
|
||||
continue;
|
||||
}
|
||||
if(*p == '\r' || *p == '\n') continue;
|
||||
*o++ = *p;
|
||||
}
|
||||
if(o == out || o[-1] != '\n'){
|
||||
*o++ = '\r';
|
||||
*o++ = '\n';
|
||||
}
|
||||
*o = 0;
|
||||
return out;
|
||||
}
|
||||
|
||||
/* An optional argument which a star, or nothing at all, leaves at its
|
||||
default. */
|
||||
static int optnum(int argc, unsigned char **argv, int at, int def)
|
||||
{
|
||||
if(argc <= at || !strcmp((char *)argv[at], "*")) return def;
|
||||
return atoi((char *)argv[at]);
|
||||
}
|
||||
|
||||
static void freehttprule(struct httprule *rule)
|
||||
{
|
||||
if(rule->host.name) free(rule->host.name);
|
||||
if(rule->url.name) free(rule->url.name);
|
||||
if(rule->params) free(rule->params);
|
||||
if(rule->ctype) free(rule->ctype);
|
||||
if(rule->hdrs) free(rule->hdrs);
|
||||
free(rule);
|
||||
}
|
||||
|
||||
/* Installs one rule from code, for the pages a service predefines. */
|
||||
static int addhttprule(char *host, char *url, char *op, char *params)
|
||||
static int addhttprule(char *op, char *host, char *url, char *params)
|
||||
{
|
||||
struct httprule *rule, *tail;
|
||||
unsigned char hostbuf[64], urlbuf[128];
|
||||
@@ -811,6 +860,7 @@ static int addhttprule(char *host, char *url, char *op, char *params)
|
||||
rule = malloc(sizeof(struct httprule));
|
||||
if(!rule) return 1;
|
||||
memset(rule, 0, sizeof(struct httprule));
|
||||
rule->maxage = -1;
|
||||
|
||||
rule->op = httpopbyname((unsigned char *)op);
|
||||
if(rule->op < 0){
|
||||
@@ -820,7 +870,7 @@ static int addhttprule(char *host, char *url, char *op, char *params)
|
||||
|
||||
strcpy((char *)hostbuf, host);
|
||||
strcpy((char *)urlbuf, url);
|
||||
if(parsepattern(&rule->host, hostbuf) || parsepattern(&rule->url, urlbuf)){
|
||||
if(parsepattern(&rule->host, hostbuf) || parsepathpattern(&rule->url, urlbuf)){
|
||||
free(rule->host.name);
|
||||
free(rule);
|
||||
return 1;
|
||||
@@ -973,9 +1023,10 @@ static int h_http(int argc, unsigned char **argv){
|
||||
struct httprule *rule, *tail;
|
||||
int op;
|
||||
|
||||
op = httpopbyname(argv[3]);
|
||||
/* http OPERATION HOST URL [PARAMETERS] */
|
||||
op = httpopbyname(argv[1]);
|
||||
if(op < 0){
|
||||
fprintf(stderr, "Unknown http operation: %s line %d\n", argv[3], linenum);
|
||||
fprintf(stderr, "Unknown http operation: %s line %d\n", argv[1], linenum);
|
||||
return(1);
|
||||
}
|
||||
|
||||
@@ -983,23 +1034,75 @@ static int h_http(int argc, unsigned char **argv){
|
||||
if(!rule) return(21);
|
||||
memset(rule, 0, sizeof(struct httprule));
|
||||
rule->op = op;
|
||||
rule->maxage = -1;
|
||||
|
||||
if(parsepattern(&rule->host, argv[1]) || parsepattern(&rule->url, argv[2])){
|
||||
if(parsepattern(&rule->host, argv[2]) || parsepathpattern(&rule->url, argv[3])){
|
||||
fprintf(stderr, "No memory for http rule, line %d\n", linenum);
|
||||
free(rule->host.name);
|
||||
free(rule);
|
||||
return(21);
|
||||
}
|
||||
|
||||
if(argc > 4){
|
||||
if(argc > 4 && (!strcmp((char *)argv[1], "file") || !strcmp((char *)argv[1], "cache"))){
|
||||
/* PATH [TYPE [MAX-AGE [HEADERS [CODE]]]]. A star, or nothing,
|
||||
leaves each of them out: the type is worked out from the name,
|
||||
nothing is said about caching, no headers are added and the
|
||||
answer is the usual 200. */
|
||||
rule->params = (unsigned char *)strdup((char *)argv[4]);
|
||||
if(!rule->params){
|
||||
free(rule->host.name);
|
||||
free(rule->url.name);
|
||||
free(rule);
|
||||
if(argc > 5 && strcmp((char *)argv[5], "*"))
|
||||
rule->ctype = (unsigned char *)strdup((char *)argv[5]);
|
||||
rule->maxage = optnum(argc, argv, 6, -1);
|
||||
if(argc > 7 && strcmp((char *)argv[7], "*"))
|
||||
rule->hdrs = parsehdrs(argv[7]);
|
||||
rule->code = optnum(argc, argv, 8, 0);
|
||||
if(!rule->params
|
||||
|| (argc > 5 && strcmp((char *)argv[5], "*") && !rule->ctype)
|
||||
|| (argc > 7 && strcmp((char *)argv[7], "*") && !rule->hdrs)){
|
||||
freehttprule(rule);
|
||||
return(21);
|
||||
}
|
||||
}
|
||||
else if(!strcmp((char *)argv[1], "reply")){
|
||||
/* CODE [HEADERS], and no body at all. */
|
||||
rule->code = optnum(argc, argv, 4, 200);
|
||||
if(argc > 5 && strcmp((char *)argv[5], "*")){
|
||||
rule->hdrs = parsehdrs(argv[5]);
|
||||
if(!rule->hdrs){
|
||||
freehttprule(rule);
|
||||
return(21);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(argc > 4){
|
||||
/* What follows the URL belongs to the operation, and an operation
|
||||
such as redir reads more than one word of it. */
|
||||
int i, len = 0;
|
||||
|
||||
for(i = 4; i < argc; i++) len += (int)strlen((char *)argv[i]) + 1;
|
||||
rule->params = malloc(len);
|
||||
if(rule->params){
|
||||
int at = 0;
|
||||
|
||||
for(i = 4; i < argc; i++)
|
||||
at += sprintf((char *)rule->params + at, "%s%s",
|
||||
i > 4? " " : "", argv[i]);
|
||||
}
|
||||
if(!rule->params){
|
||||
freehttprule(rule);
|
||||
return(21);
|
||||
}
|
||||
}
|
||||
|
||||
if(rule->code && (rule->code < 100 || rule->code > 599)){
|
||||
fprintf(stderr, "Wrong http status: %d line %d\n", rule->code, linenum);
|
||||
freehttprule(rule);
|
||||
return(1);
|
||||
}
|
||||
if(rule->maxage < -1){
|
||||
fprintf(stderr, "Wrong max-age, line %d\n", linenum);
|
||||
freehttprule(rule);
|
||||
return(1);
|
||||
}
|
||||
|
||||
if(!conf.httprules) conf.httprules = rule;
|
||||
else {
|
||||
@@ -1495,7 +1598,7 @@ static int h_ace(int argc, unsigned char **argv){
|
||||
tl->ace = acl;
|
||||
|
||||
if((acl->action == COUNTIN)||(acl->action == COUNTOUT)||(acl->action == COUNTALL)) {
|
||||
unsigned long lim;
|
||||
uint64_t lim = 0;
|
||||
|
||||
tl->comment = ( char *)argv[1];
|
||||
while(isdigit(*tl->comment))tl->comment++;
|
||||
@@ -1503,9 +1606,9 @@ static int h_ace(int argc, unsigned char **argv){
|
||||
tl->comment = strdup(tl->comment);
|
||||
|
||||
sscanf((char *)argv[1], "%u", &tl->number);
|
||||
sscanf((char *)argv[3], "%lu", &lim);
|
||||
if(sscanf((char *)argv[3], "%"SCNu64"", &lim) != 1) lim = 0;
|
||||
tl->type = getrotate(*argv[2]);
|
||||
tl->traflim64 = ((uint64_t)lim)*(1024*1024);
|
||||
tl->traflim64 = lim*(1024*1024);
|
||||
if(!tl->traflim64) {
|
||||
free(tl);
|
||||
freeacl(acl);
|
||||
@@ -1801,6 +1904,9 @@ int h_server_verify(int argc, unsigned char **argv);
|
||||
int h_no_server_verify(int argc, unsigned char **argv);
|
||||
int h_client_mode(int argc, unsigned char **argv);
|
||||
#endif
|
||||
#ifdef WITH_HTTPSRV
|
||||
int h_http_content_type(int argc, unsigned char **argv);
|
||||
#endif
|
||||
#ifdef WITH_TRANSPARENT
|
||||
int h_transparent(int argc, unsigned char **argv);
|
||||
int h_notransparent(int argc, unsigned char **argv);
|
||||
@@ -1826,7 +1932,8 @@ struct commands commandhandlers[]={
|
||||
#endif
|
||||
#ifdef WITH_HTTPSRV
|
||||
{NULL, "httpsrv", h_proxy, 1, 0},
|
||||
{NULL, "http", h_http, 4, 5},
|
||||
{NULL, "http", h_http, 4, 0},
|
||||
{NULL, "http_content_type", h_http_content_type, 3, 3},
|
||||
#endif
|
||||
{NULL, "dnspr", h_proxy, 1, 0},
|
||||
{NULL, "internal", h_internal, 2, 2},
|
||||
@@ -1982,6 +2089,21 @@ int parsestr (unsigned char *str, unsigned char **argm, int nitems, unsigned cha
|
||||
argm[argc] = 0;
|
||||
return argc;
|
||||
case '$':
|
||||
/* Two dollars stand for one. That is how a literal dollar is
|
||||
written where a file to include would otherwise be read, and
|
||||
the second one is dropped here as a quote character is. */
|
||||
if(str[1] == '$'){
|
||||
str1 = str;
|
||||
do {
|
||||
*str1 = *(str1 + 1);
|
||||
}while(*(str1++));
|
||||
if(space){
|
||||
argm[argc++] = str;
|
||||
if(argc >= nitems) return argc;
|
||||
space = 0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if(comment){
|
||||
if(space){
|
||||
argm[argc++] = str;
|
||||
|
||||
+924
-86
File diff suppressed because it is too large.
Load diff
+65
@@ -629,6 +629,71 @@ static struct symbol regexp_symbols[] = {
|
||||
};
|
||||
|
||||
|
||||
/* Compiling and matching for patterns outside the pcre commands: a host name
|
||||
or a URL in an http rule, an access rule naming a host. They go through the
|
||||
same compile, with whatever pcre_options is set to, so one kind of regular
|
||||
expression is understood everywhere.
|
||||
*/
|
||||
void * pcre_pattern_compile(const unsigned char *pattern, char *errbuf, int errlen)
|
||||
{
|
||||
pcre2_code *re;
|
||||
int errcode;
|
||||
PCRE2_SIZE erroffset;
|
||||
|
||||
re = pcre2_compile((PCRE2_SPTR)pattern, PCRE2_ZERO_TERMINATED, pcre_options,
|
||||
&errcode, &erroffset, NULL);
|
||||
if(!re){
|
||||
if(errbuf && errlen > 0){
|
||||
PCRE2_UCHAR message[256];
|
||||
|
||||
pcre2_get_error_message(errcode, message, sizeof(message));
|
||||
snprintf(errbuf, errlen, "%s at offset %d", (char *)message, (int)erroffset);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
return re;
|
||||
}
|
||||
|
||||
void pcre_pattern_free(void *re)
|
||||
{
|
||||
if(re) pcre2_code_free((pcre2_code *)re);
|
||||
}
|
||||
|
||||
/* Returns the number of captures placed, or 0 when the subject does not
|
||||
match. Element 0 is the whole match. The match data is per call: a rule is
|
||||
matched from several threads at once.
|
||||
*/
|
||||
int pcre_pattern_match(void *re, const unsigned char *subject, struct capture *caps, int maxcaps)
|
||||
{
|
||||
pcre2_match_data *match_data;
|
||||
PCRE2_SIZE *ovector;
|
||||
int count, i, placed = 0;
|
||||
|
||||
if(!re || !subject) return 0;
|
||||
match_data = pcre2_match_data_create_from_pattern((pcre2_code *)re, NULL);
|
||||
if(!match_data) return 0;
|
||||
|
||||
count = pcre2_match((pcre2_code *)re, (PCRE2_SPTR)subject, PCRE2_ZERO_TERMINATED,
|
||||
0, 0, match_data, NULL);
|
||||
if(count > 0){
|
||||
ovector = pcre2_get_ovector_pointer(match_data);
|
||||
if(count > maxcaps) count = maxcaps;
|
||||
for(i = 0; i < count; i++){
|
||||
if(ovector[i*2] == PCRE2_UNSET){
|
||||
caps[i].start = 0;
|
||||
caps[i].len = 0;
|
||||
}
|
||||
else {
|
||||
caps[i].start = (int)ovector[i*2];
|
||||
caps[i].len = (int)(ovector[i*2+1] - ovector[i*2]);
|
||||
}
|
||||
}
|
||||
placed = count;
|
||||
}
|
||||
pcre2_match_data_free(match_data);
|
||||
return placed;
|
||||
}
|
||||
|
||||
void pcre_install(void){
|
||||
|
||||
struct filter *flt, *tmpflt;
|
||||
|
||||
+12
@@ -169,6 +169,7 @@ void daemonize(void);
|
||||
|
||||
#ifndef _WIN32
|
||||
size_t threadstacksize(int extra);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef WITH_ODBC
|
||||
@@ -386,7 +387,18 @@ int readconfig(FILE * fp);
|
||||
void initcommands(void);
|
||||
int connectwithpoll(struct clientparam *param, SOCKET sock, struct sockaddr *sa, SASIZETYPE size, int to);
|
||||
int bindwithrange(struct clientparam *param, SOCKET sock, PROXYSOCKADDRTYPE *sa, uint32_t range);
|
||||
#ifdef WITH_PCRE
|
||||
/* One regular expression implementation for the whole program: the pcre
|
||||
commands and every pattern that carries a pcre: prefix. */
|
||||
void * pcre_pattern_compile(const unsigned char *pattern, char *errbuf, int errlen);
|
||||
void pcre_pattern_free(void *re);
|
||||
int pcre_pattern_match(void *re, const unsigned char *subject, struct capture *caps, int maxcaps);
|
||||
#endif
|
||||
|
||||
int parsepattern(struct hostname *h, unsigned char *arg);
|
||||
int parsepathpattern(struct hostname *h, unsigned char *arg);
|
||||
int patternmatchcaps(const struct hostname *h, const unsigned char *str,
|
||||
struct capture *caps, int *ncaps);
|
||||
int patternmatch(const struct hostname *h, const unsigned char *str);
|
||||
int patternmatchpos(const struct hostname *h, const unsigned char *str, int *start, int *len);
|
||||
void applyportranges(struct clientparam * param, struct ace * acentry);
|
||||
|
||||
+31
-1
@@ -350,21 +350,47 @@ struct period {
|
||||
|
||||
#define MATCHBEGIN 1
|
||||
#define MATCHEND 2
|
||||
/* A pattern is either the star form above, matched by matchtype, or a regular
|
||||
expression compiled once when the configuration is read. */
|
||||
#define MATCHGLOB 4 /* stars anywhere: * within a path element, ** across */
|
||||
#define MATCHREGEX 5
|
||||
|
||||
/* What a star or a capturing group stood for. Element 0 is the whole
|
||||
subject, so a template writes it as $0 and the groups as $1 upwards. */
|
||||
#define MAXCAPTURES 10
|
||||
struct capture {
|
||||
int start;
|
||||
int len;
|
||||
};
|
||||
|
||||
struct hostname {
|
||||
struct hostname *next;
|
||||
unsigned char * name;
|
||||
int matchtype;
|
||||
void * re; /* compiled regular expression, MATCHREGEX only */
|
||||
};
|
||||
|
||||
/* A request handed to an http operation. */
|
||||
struct httpreq {
|
||||
struct capture caps[MAXCAPTURES];
|
||||
int ncaps;
|
||||
struct capture hostcaps[MAXCAPTURES];
|
||||
int nhostcaps;
|
||||
const char *ctype;
|
||||
const char *hdrs;
|
||||
int maxage;
|
||||
int code;
|
||||
time_t ims; /* what If-Modified-Since asked about, or 0 */
|
||||
int version; /* 0 for HTTP/1.0, 1 for HTTP/1.1 */
|
||||
int keepalive; /* whether the connection carries another request */
|
||||
int first; /* the first request on this connection */
|
||||
int chunkedreq; /* a body this server does not know how to read */
|
||||
struct clientparam *param;
|
||||
char method[16];
|
||||
char path[256];
|
||||
char query[512];
|
||||
char host[256];
|
||||
unsigned long contentlen;
|
||||
uint64_t contentlen;
|
||||
int globstart, globlen;
|
||||
};
|
||||
|
||||
@@ -377,6 +403,10 @@ struct httprule {
|
||||
struct hostname url;
|
||||
int op;
|
||||
unsigned char *params;
|
||||
unsigned char *ctype; /* type named by the rule, or NULL to work it out */
|
||||
unsigned char *hdrs; /* headers the rule adds, already CRLF separated */
|
||||
int maxage; /* seconds to allow caching for, or -1 to say nothing */
|
||||
int code; /* status the rule answers with, or 0 for the usual */
|
||||
};
|
||||
|
||||
struct ace {
|
||||
|
||||
Reference in new issue
Block a user