X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=loaders.c;h=75d37db42bc61a1f96563097fe83a9b32471447c;hp=f3ea5a13c7c3ac0c34e61ed7f1cf720618b3ceaa;hb=4793e1be2b24df19d6aa42a84b95653d040054f9;hpb=1df3ac22a584579c66453e938809929e8e20e160 diff --git a/loaders.c b/loaders.c index f3ea5a13..75d37db4 100644 --- a/loaders.c +++ b/loaders.c @@ -1,4 +1,4 @@ -const char loaders_rcs[] = "$Id: loaders.c,v 1.1.1.1 2001/05/15 13:58:59 oes Exp $"; +const char loaders_rcs[] = "$Id: loaders.c,v 1.9 2001/05/26 17:12:07 jongfoster Exp $"; /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/loaders.c,v $ @@ -35,6 +35,49 @@ const char loaders_rcs[] = "$Id: loaders.c,v 1.1.1.1 2001/05/15 13:58:59 oes Exp * * Revisions : * $Log: loaders.c,v $ + * Revision 1.9 2001/05/26 17:12:07 jongfoster + * Fatal errors loading configuration files now give better error messages. + * + * Revision 1.8 2001/05/26 00:55:20 jongfoster + * Removing duplicated code. load_forwardfile() now uses create_url_spec() + * + * Revision 1.7 2001/05/26 00:28:36 jongfoster + * Automatic reloading of config file. + * Removed obsolete SIGHUP support (Unix) and Reload menu option (Win32). + * Most of the global variables have been moved to a new + * struct configuration_spec, accessed through csp->config->globalname + * Most of the globals remaining are used by the Win32 GUI. + * + * Revision 1.6 2001/05/23 12:27:33 oes + * + * Fixed ugly indentation of my last changes + * + * Revision 1.5 2001/05/23 10:39:05 oes + * - Added support for escaping the comment character + * in config files by a backslash + * - Added support for line continuation in config + * files + * - Fixed a buffer overflow bug with long config lines + * + * Revision 1.4 2001/05/22 18:56:28 oes + * CRLF -> LF + * + * Revision 1.3 2001/05/20 01:21:20 jongfoster + * Version 2.9.4 checkin. + * - Merged popupfile and cookiefile, and added control over PCRS + * filtering, in new "permissionsfile". + * - Implemented LOG_LEVEL_FATAL, so that if there is a configuration + * file error you now get a message box (in the Win32 GUI) rather + * than the program exiting with no explanation. + * - Made killpopup use the PCRS MIME-type checking and HTTP-header + * skipping. + * - Removed tabs from "config" + * - Moved duplicated url parsing code in "loaders.c" to a new funcition. + * - Bumped up version number. + * + * Revision 1.2 2001/05/17 23:01:01 oes + * - Cleaned CRLF's from the sources and related files + * * Revision 1.1.1.1 2001/05/15 13:58:59 oes * Initial import of version 2.9.3 source tree * @@ -85,30 +128,17 @@ const char loaders_h_rcs[] = LOADERS_H_VERSION; #define ijb_isspace(__X) isspace((int)(unsigned char)(__X)) -#define NLOADERS 8 -static int (*loaders[NLOADERS])(struct client_state *); - - /* * Currently active files. * These are also entered in the main linked list of files. */ -static struct file_list *current_blockfile = NULL; -static struct file_list *current_cookiefile = NULL; +static struct file_list *current_permissions_file = NULL; static struct file_list *current_forwardfile = NULL; #ifdef ACL_FILES static struct file_list *current_aclfile = NULL; #endif /* def ACL_FILES */ -#ifdef USE_IMAGE_LIST -static struct file_list *current_imagefile = NULL; -#endif /* def USE_IMAGE_LIST */ - -#ifdef KILLPOPUPS -static struct file_list * current_popupfile = NULL; -#endif /* def KILLPOPUPS */ - #ifdef TRUST_FILES static struct file_list *current_trustfile = NULL; #endif /* def TRUST_FILES */ @@ -118,6 +148,9 @@ static struct file_list *current_re_filterfile = NULL; #endif /* def PCRS */ +static int create_url_spec(struct url_spec * url, char * buf); + + /********************************************************************* * * Function : sweep @@ -159,17 +192,18 @@ void sweep(void) { /* mark this client's files as active */ - if (ncsp->blist) /* block files */ - { - ncsp->blist->active = 1; - } + /* + * Always have a configuration file. + * (Also note the slightly non-standard extra + * indirection here.) + */ + ncsp->config->config_file_list->active = 1; - if (ncsp->clist) /* cookie files */ + if (ncsp->permissions_list) /* permissions files */ { - ncsp->clist->active = 1; + ncsp->permissions_list->active = 1; } - /* FIXME: These were left out of the "10" release. Should they be here? */ if (ncsp->flist) /* forward files */ { ncsp->flist->active = 1; @@ -182,20 +216,6 @@ void sweep(void) } #endif /* def ACL_FILES */ -#ifdef USE_IMAGE_LIST - if (ncsp->ilist) /* image files */ - { - ncsp->ilist->active = 1; - } -#endif /* def USE_IMAGE_LIST */ - -#ifdef KILLPOPUPS - if (ncsp->plist) /* killpopup files */ - { - ncsp->plist->active = 1; - } -#endif /* def KILLPOPUPS */ - #ifdef PCRS if (ncsp->rlist) /* perl re files */ { @@ -217,9 +237,10 @@ void sweep(void) csp->next = ncsp->next; freez(ncsp->ip_addr_str); +#ifdef TRUST_FILES freez(ncsp->referrer); +#endif /* def TRUST_FILES */ freez(ncsp->x_forwarded); - freez(ncsp->ip_addr_str); freez(ncsp->iob->buf); free_http_request(ncsp->http); @@ -260,6 +281,125 @@ void sweep(void) } +/********************************************************************* + * + * Function : create_url_spec + * + * Description : Creates a "url_spec" structure from a string. + * When finished, free with unload_url(). + * + * Parameters : + * 1 : url = Target url_spec to be filled in. Must be + * zeroed out before the call (e.g. using zalloc). + * 2 : buf = Source pattern, null terminated. NOTE: The + * contents of this buffer are destroyed by this + * function. If this function succeeds, the + * buffer is copied to url->spec. If this + * function fails, the contents of the buffer + * are lost forever. + * + * Returns : 0 => Ok, everything else is an error. + * + *********************************************************************/ +static int create_url_spec(struct url_spec * url, char * buf) +{ + char *p; + struct url_spec tmp_url[1]; + + /* paranoia - should never happen. */ + if ((url == NULL) || (buf == NULL)) + { + return 1; + } + + /* save a copy of the orignal specification */ + if ((url->spec = strdup(buf)) == NULL) + { + return 1; + } + + if ((p = strchr(buf, '/'))) + { + if (NULL == (url->path = strdup(p))) + { + freez(url->spec); + return 1; + } + url->pathlen = strlen(url->path); + *p = '\0'; + } + else + { + url->path = NULL; + url->pathlen = 0; + } +#ifdef REGEX + if (url->path) + { + int errcode; + char rebuf[BUFSIZ]; + + if (NULL == (url->preg = zalloc(sizeof(*url->preg)))) + { + freez(url->spec); + freez(url->path); + return 1; + } + + sprintf(rebuf, "^(%s)", url->path); + + errcode = regcomp(url->preg, rebuf, + (REG_EXTENDED|REG_NOSUB|REG_ICASE)); + if (errcode) + { + size_t errlen = + regerror(errcode, + url->preg, buf, sizeof(buf)); + + buf[errlen] = '\0'; + + log_error(LOG_LEVEL_ERROR, "error compiling %s: %s", + url->spec, buf); + + freez(url->spec); + freez(url->path); + freez(url->preg); + + return 1; + } + } +#endif + if ((p = strchr(buf, ':')) == NULL) + { + url->port = 0; + } + else + { + *p++ = '\0'; + url->port = atoi(p); + } + + if ((url->domain = strdup(buf)) == NULL) + { + freez(url->spec); + freez(url->path); +#ifdef REGEX + freez(url->preg); +#endif /* def REGEX */ + return 1; + } + + /* split domain into components */ + + *tmp_url = dsplit(url->domain); + url->dbuf = tmp_url->dbuf; + url->dcnt = tmp_url->dcnt; + url->dvec = tmp_url->dvec; + + return 0; /* OK */ +} + + /********************************************************************* * * Function : unload_url @@ -318,82 +458,31 @@ static void unload_aclfile(void *f) } #endif /* def ACL_FILES */ -/********************************************************************* - * - * Function : unload_blockfile - * - * Description : Unloads a blockfile. - * - * Parameters : - * 1 : f = the data structure associated with the blockfile. - * - * Returns : N/A - * - *********************************************************************/ -static void unload_blockfile(void *f) -{ - struct block_spec *b = (struct block_spec *)f; - if (b == NULL) return; - - unload_blockfile(b->next); - - unload_url(b->url); - - freez(b); - -} - - -#ifdef USE_IMAGE_LIST -/********************************************************************* - * - * Function : unload_imagefile - * - * Description : Unloads an imagefile. - * - * Parameters : - * 1 : f = the data structure associated with the imagefile. - * - * Returns : N/A - * - *********************************************************************/ -static void unload_imagefile(void *f) -{ - struct block_spec *b = (struct block_spec *)f; - if (b == NULL) return; - - unload_imagefile(b->next); - - unload_url(b->url); - - freez(b); - -} -#endif /* def USE_IMAGE_LIST */ - /********************************************************************* * - * Function : unload_cookiefile + * Function : unload_permissions_file * - * Description : Unloads a cookiefile. + * Description : Unloads a permissions file. * * Parameters : - * 1 : f = the data structure associated with the cookiefile. + * 1 : file_data = the data structure associated with the + * permissions file. * * Returns : N/A * *********************************************************************/ -static void unload_cookiefile(void *f) +static void unload_permissions_file(void *file_data) { - struct cookie_spec *b = (struct cookie_spec *)f; - if (b == NULL) return; - - unload_cookiefile(b->next); - - unload_url(b->url); - - freez(b); + struct permissions_spec * next; + struct permissions_spec * cur = (struct permissions_spec *)file_data; + while (cur != NULL) + { + next = cur->next; + unload_url(cur->url); + freez(cur); + cur = next; + } } @@ -486,51 +575,6 @@ static void unload_re_filterfile(void *f) #endif /* def PCRS */ -#ifdef KILLPOPUPS -/********************************************************************* - * - * Function : unload_popupfile - * - * Description : Free the lists of blocked, and allowed popup sites. - * - * Parameters : - * 1 : csp = Current client state (buffers, headers, etc...) - * - * Returns : N/A - * - *********************************************************************/ -static void unload_popupfile(void * b) -{ - struct popup_settings * data = (struct popup_settings *) b; - struct popup_blocklist * cur = NULL; - struct popup_blocklist * temp= NULL; - - /* Free the blocked list. */ - cur = data->blocked; - while (cur != NULL) - { - temp = cur->next; - freez (cur->host_name); - free (cur); - cur = temp; - } - data->blocked = NULL; - - /* Free the allowed list. */ - cur = data->allowed; - while (cur != NULL) - { - temp = cur->next; - freez (cur->host_name); - free (cur); - cur = temp; - } - data->allowed = NULL; - -} -#endif /* def KILLPOPUPS */ - - /********************************************************************* * * Function : check_file_changed @@ -552,7 +596,7 @@ static void unload_popupfile(void * b) * heap, with the filename and lastmodified * fields filled, standard header giving file * name in proxy_args, and all others zeroed. - * (proxy_args is only filled in if + * (proxy_args is only filled in if !defined * SPLIT_PROXY_ARGS and !suppress_blocklists). * * Returns : If file unchanged: 0 (and sets newfl == NULL) @@ -560,9 +604,9 @@ static void unload_popupfile(void * b) * On error: 1 and sets newfl == NULL * *********************************************************************/ -static int check_file_changed(const struct file_list * current, - const char * filename, - struct file_list ** newfl) +int check_file_changed(const struct file_list * current, + const char * filename, + struct file_list ** newfl) { struct file_list *fs; struct stat statbuf[1]; @@ -626,8 +670,9 @@ static int check_file_changed(const struct file_list * current, * Function : read_config_line * * Description : Read a single non-empty line from a file and return - * it. Trims comments, leading and trailing whitespace. - * Also wites the file to fs->proxy_args. + * it. Trims comments, leading and trailing whitespace + * and respects escaping of newline and comment char. + * Also writes the file to fs->proxy_args. * * Parameters : * 1 : buf = Buffer to use. @@ -644,6 +689,9 @@ char *read_config_line(char *buf, int buflen, FILE *fp, struct file_list *fs) { char *p, *q; char linebuf[BUFSIZ]; + int contflag = 0; + + *buf = '\0'; while (fgets(linebuf, sizeof(linebuf), fp)) { @@ -660,17 +708,40 @@ char *read_config_line(char *buf, int buflen, FILE *fp, struct file_list *fs) } #endif /* ndef SPLIT_PROXY_ARGS */ - /* Trim off newline and any comment */ - if ((p = strpbrk(linebuf, "\r\n#")) != NULL) + /* Trim off newline */ + if ((p = strpbrk(linebuf, "\r\n")) != NULL) + { + *p = '\0'; + } + + /* Line continuation? Trim escape and set flag. */ + if ((p != linebuf) && (*--p == '\\')) { + contflag = 1; *p = '\0'; } + + /* If there's a comment char.. */ + if ((p = strpbrk(linebuf, "#")) != NULL) + { + /* ..and it's escaped, left-shift the line over the escape. */ + if ((p != linebuf) && (*(p-1) == '\\')) + { + q = p-1; + while ((*q++ = *p++) != '\0') /* nop */; + } + /* Else, chop off the rest of the line */ + else + { + *p = '\0'; + } + } /* Trim leading whitespace */ p = linebuf; while (*p && ijb_isspace(*p)) { - *p++; + p++; } if (*p) @@ -692,8 +763,8 @@ char *read_config_line(char *buf, int buflen, FILE *fp, struct file_list *fs) p = linebuf + strlen(linebuf) - 1; /* - * Note: the (p >= retval) below is paranoia, it's not really needed. - * When p == retval then ijb_isspace(*p) will be false and we'll drop + * Note: the (p >= linebuf) below is paranoia, it's not really needed. + * When p == linebuf then ijb_isspace(*p) will be false and we'll drop * out of the loop. */ while ((p >= linebuf) && ijb_isspace(*p)) @@ -705,8 +776,16 @@ char *read_config_line(char *buf, int buflen, FILE *fp, struct file_list *fs) /* More paranoia. This if statement is always true. */ if (*linebuf) { - strcpy(buf, linebuf); - return buf; + strncat(buf, linebuf, buflen - strlen(buf)); + if (contflag) + { + contflag = 0; + continue; + } + else + { + return buf; + } } } } @@ -737,7 +816,7 @@ int load_aclfile(struct client_state *csp) struct access_control_list *a, *bl; struct file_list *fs; - if (!check_file_changed(current_aclfile, aclfile, &fs)) + if (!check_file_changed(current_aclfile, csp->config->aclfile, &fs)) { /* No need to load */ if (csp) @@ -759,7 +838,7 @@ int load_aclfile(struct client_state *csp) goto load_aclfile_error; } - fp = fopen(aclfile, "r"); + fp = fopen(csp->config->aclfile, "r"); if (fp == NULL) { @@ -846,18 +925,61 @@ int load_aclfile(struct client_state *csp) return(0); load_aclfile_error: - log_error(LOG_LEVEL_ERROR, "can't load access control list %s: %E", aclfile); + log_error(LOG_LEVEL_FATAL, "can't load access control list %s: %E", + csp->config->aclfile); return(-1); } #endif /* def ACL_FILES */ +struct permission_alias +{ + const char * name; + unsigned mask; /* a bit set to "0" = remove permission */ + unsigned add; /* a bit set to "1" = add permission */ + struct permission_alias * next; +}; + + +/* + * Note: this is special-cased in the code so we don't need to + * fill in the ->next fields. + */ +static const struct permission_alias standard_aliases[] = +{ + { "+block", PERMIT_MASK_ALL, PERMIT_BLOCK }, +/* { "+cookies", PERMIT_MASK_ALL, PERMIT_COOKIE_SET | PERMIT_COOKIE_READ }, */ + { "+cookies-read", PERMIT_MASK_ALL, PERMIT_COOKIE_READ }, + { "+cookies-set", PERMIT_MASK_ALL, PERMIT_COOKIE_SET }, + { "+fast-redirects", PERMIT_MASK_ALL, PERMIT_FAST_REDIRECTS }, + { "+filter", PERMIT_MASK_ALL, PERMIT_RE_FILTER }, + { "+image", PERMIT_MASK_ALL, PERMIT_IMAGE }, + { "+popup", PERMIT_MASK_ALL, PERMIT_POPUPS }, + { "+popups", PERMIT_MASK_ALL, PERMIT_POPUPS }, + { "+referer", PERMIT_MASK_ALL, PERMIT_REFERER }, + { "+referrer", PERMIT_MASK_ALL, PERMIT_REFERER }, + { "-block", ~PERMIT_BLOCK, 0 }, +/* { "-cookies", ~(PERMIT_COOKIE_SET | PERMIT_COOKIE_READ), 0 }, */ + { "-cookies-read", ~PERMIT_COOKIE_READ, 0 }, + { "-cookies-set", ~PERMIT_COOKIE_SET, 0 }, + { "-fast-redirects", ~PERMIT_FAST_REDIRECTS, 0 }, + { "-filter", ~PERMIT_RE_FILTER, 0 }, + { "-image", ~PERMIT_IMAGE, 0 }, + { "-popup", ~PERMIT_POPUPS, 0 }, + { "-popups", ~PERMIT_POPUPS, 0 }, + { "-referer", ~PERMIT_REFERER, 0 }, + { "-referrer", ~PERMIT_REFERER, 0 }, + { NULL, 0, 0 } /* End marker */ +}; + + /********************************************************************* * - * Function : load_blockfile + * Function : load_permissions_file * - * Description : Read and parse a blockfile and add to files list. + * Description : Read and parse a permissions file and add to files + * list. * * Parameters : * 1 : csp = Current client state (buffers, headers, etc...) @@ -865,567 +987,394 @@ load_aclfile_error: * Returns : 0 => Ok, everything else is an error. * *********************************************************************/ -int load_blockfile(struct client_state *csp) +int load_permissions_file(struct client_state *csp) { FILE *fp; - struct block_spec *b, *bl; - char buf[BUFSIZ], *p, *q; - int port, reject; + struct permissions_spec *last_perm; + struct permissions_spec *perm; + char buf[BUFSIZ]; struct file_list *fs; - struct url_spec url[1]; +#define MODE_START_OF_FILE 1 +#define MODE_PERMISSIONS 2 +#define MODE_ALIAS 3 + int mode = MODE_START_OF_FILE; + unsigned curmask = PERMIT_MASK_ALL; + unsigned curadd = 0; + struct permission_alias * alias_list = NULL; - if (!check_file_changed(current_blockfile, blockfile, &fs)) + if (!check_file_changed(current_permissions_file, csp->config->permissions_file, &fs)) { /* No need to load */ if (csp) { - csp->blist = current_blockfile; + csp->permissions_list = current_permissions_file; } - return(0); + return 0; } if (!fs) { - goto load_blockfile_error; + log_error(LOG_LEVEL_FATAL, "can't load permissions file '%s': error finding file: %E", + csp->config->permissions_file); + return 1; /* never get here */ } - fs->f = bl = (struct block_spec *) zalloc(sizeof(*bl)); - if (bl == NULL) + fs->f = last_perm = (struct permissions_spec *)zalloc(sizeof(*last_perm)); + if (last_perm == NULL) { - goto load_blockfile_error; + log_error(LOG_LEVEL_FATAL, "can't load permissions file '%s': out of memory!", + csp->config->permissions_file); + return 1; /* never get here */ } - if ((fp = fopen(blockfile, "r")) == NULL) + if ((fp = fopen(csp->config->permissions_file, "r")) == NULL) { - goto load_blockfile_error; + log_error(LOG_LEVEL_FATAL, "can't load permissions file '%s': error opening file: %E", + csp->config->permissions_file); + return 1; /* never get here */ } while (read_config_line(buf, sizeof(buf), fp, fs) != NULL) { - reject = 1; - - if (*buf == '~') + if (*buf == '{') { - reject = 0; - p = buf; - q = p+1; - while ((*p++ = *q++)) + /* It's a header block */ + if (buf[1] == '{') { - /* nop */ - } - } + /* It's {{settings}} or {{alias}} */ + int len = strlen(buf); + char * start = buf + 2; + char * end = buf + len - 1; + if ((len < 5) || (*end-- != '}') || (*end-- != '}')) + { + /* too short */ + fclose(fp); + log_error(LOG_LEVEL_FATAL, + "can't load permissions file '%s': invalid line: %s", + csp->config->permissions_file, buf); + return 1; /* never get here */ + } - /* skip lines containing only ~ */ - if (*buf == '\0') - { - continue; - } + /* Trim leading and trailing whitespace. */ + while ((*end == ' ') || (*end == '\t')) + { + /* + * don't need to worry about going off front of string + * because we know there's a '{' there. + */ + end--; + } + end[1] = '\0'; + while ((*start == ' ') || (*start == '\t')) + { + start++; + } - /* allocate a new node */ - if (((b = zalloc(sizeof(*b))) == NULL) -#ifdef REGEX - || ((b->url->preg = zalloc(sizeof(*b->url->preg))) == NULL) -#endif - ) - { - fclose(fp); - goto load_blockfile_error; - } + if (*start == '\0') + { + /* too short */ + fclose(fp); + log_error(LOG_LEVEL_FATAL, + "can't load permissions file '%s': invalid line: {{ }}", + csp->config->permissions_file); + return 1; /* never get here */ + } - /* add it to the list */ - b->next = bl->next; - bl->next = b; + if (0 == strcmpic(start, "alias")) + { + /* it's an {{alias}} block */ - /* save a copy of the orignal specification */ - if ((b->url->spec = strdup(buf)) == NULL) - { - fclose(fp); - goto load_blockfile_error; - } + mode = MODE_ALIAS; + } + else + { + /* invalid {{something}} block */ + fclose(fp); + log_error(LOG_LEVEL_FATAL, + "can't load permissions file '%s': invalid line: {{%s}}", + csp->config->permissions_file, start); + return 1; /* never get here */ + } + } + else + { + /* It's a permissions block */ - b->reject = reject; + int more = 1; - if ((p = strchr(buf, '/'))) - { - b->url->path = strdup(p); - b->url->pathlen = strlen(b->url->path); - *p = '\0'; - } - else - { - b->url->path = NULL; - b->url->pathlen = 0; - } -#ifdef REGEX - if (b->url->path) - { - int errcode; - char rebuf[BUFSIZ]; + int len = strlen(buf); + char * start = buf + 1; + char * end = buf + len - 1; - sprintf(rebuf, "^(%s)", b->url->path); + if ((len < 3) || (*end-- != '}')) + { + /* too short */ + fclose(fp); + log_error(LOG_LEVEL_FATAL, + "can't load permissions file '%s': invalid line: %s", + csp->config->permissions_file, buf); + return 1; /* never get here */ + } - errcode = regcomp(b->url->preg, rebuf, - (REG_EXTENDED|REG_NOSUB|REG_ICASE)); + /* Trim leading and trailing whitespace. */ + while ((*end == ' ') || (*end == '\t')) + { + /* + * don't need to worry about going off front of string + * because we know there's a '{' there. + */ + end--; + } + end[1] = '\0'; + while ((*start == ' ') || (*start == '\t')) + { + start++; + } - if (errcode) - { - size_t errlen = - regerror(errcode, - b->url->preg, buf, sizeof(buf)); + if (*start == '\0') + { + /* too short */ + fclose(fp); + log_error(LOG_LEVEL_FATAL, + "can't load permissions file '%s': invalid line: { }", + csp->config->permissions_file); + return 1; /* never get here */ + } - buf[errlen] = '\0'; + mode = MODE_PERMISSIONS; + + curmask = PERMIT_MASK_ALL; + curadd = 0; - log_error(LOG_LEVEL_ERROR, "error compiling %s: %s\n", - b->url->spec, buf); - fclose(fp); - goto load_blockfile_error; + while (more) + { + const struct permission_alias * alias = standard_aliases; + char * option = start; + while ((*start != '\0') && (*start != ' ') && (*start != '\t')) + { + start++; + } + + more = (*start != 0); + if (more) + { + *start++ = '\0'; + + /* Eat all the whitespace between the options */ + while ((*start == ' ') || (*start == '\t')) + { + start++; + } + } + + /* handle option in 'option' */ + + /* Check for standard permission name */ + while ( (alias->name != NULL) && (0 != strcmpic(alias->name, option)) ) + { + alias++; + } + if (alias->name == NULL) + { + /* try user aliases. */ + alias = alias_list; + while ( (alias != NULL) && (0 != strcmpic(alias->name, option)) ) + { + alias = alias->next; + } + } + if (alias == NULL) + { + /* Bad permission name */ + fclose(fp); + log_error(LOG_LEVEL_FATAL, + "can't load permissions file '%s': invalid permission name: %s", + csp->config->permissions_file, option); + return 1; /* never get here */ + } + curmask &= alias->mask; + curadd &= alias->mask; + curadd |= alias->add; + } } } - else - { - freez(b->url->preg); - } -#endif - if ((p = strchr(buf, ':')) == NULL) - { - port = 0; - } - else + else if (mode == MODE_ALIAS) { - *p++ = '\0'; - port = atoi(p); - } + /* define an alias */ + struct permission_alias * new_alias; + int more = 1; - b->url->port = port; + char * start = strchr(buf, '='); + char * end = start; - if ((b->url->domain = strdup(buf)) == NULL) - { - fclose(fp); - goto load_blockfile_error; - } + if ((start == NULL) || (start == buf)) + { + log_error(LOG_LEVEL_FATAL, + "can't load permissions file '%s': invalid alias line: %s", + csp->config->permissions_file, buf); + return 1; /* never get here */ + } - /* split domain into components */ - *url = dsplit(b->url->domain); - b->url->dbuf = url->dbuf; - b->url->dcnt = url->dcnt; - b->url->dvec = url->dvec; - } - - fclose(fp); - -#ifndef SPLIT_PROXY_ARGS - if (!suppress_blocklists) - { - fs->proxy_args = strsav(fs->proxy_args, ""); - } -#endif /* ndef SPLIT_PROXY_ARGS */ - - /* the old one is now obsolete */ - if (current_blockfile) - { - current_blockfile->unloader = unload_blockfile; - } - - fs->next = files->next; - files->next = fs; - current_blockfile = fs; - - if (csp) - { - csp->blist = fs; - } - - return(0); - -load_blockfile_error: - log_error(LOG_LEVEL_ERROR, "can't load blockfile '%s': %E", blockfile); - return(-1); - -} - - -#ifdef USE_IMAGE_LIST -/********************************************************************* - * - * Function : load_imagefile - * - * Description : Read and parse an imagefile and add to files list. - * - * Parameters : - * 1 : csp = Current client state (buffers, headers, etc...) - * - * Returns : 0 => Ok, everything else is an error. - * - *********************************************************************/ -int load_imagefile(struct client_state *csp) -{ - FILE *fp; - - struct block_spec *b, *bl; - char buf[BUFSIZ], *p, *q; - int port, reject; - struct file_list *fs; - struct url_spec url[1]; - - if (!check_file_changed(current_imagefile, imagefile, &fs)) - { - /* No need to load */ - if (csp) - { - csp->ilist = current_imagefile; - } - return(0); - } - if (!fs) - { - goto load_imagefile_error; - } - - fs->f = bl = (struct block_spec *)zalloc(sizeof(*bl)); - if (bl == NULL) - { - goto load_imagefile_error; - } - - if ((fp = fopen(imagefile, "r")) == NULL) - { - goto load_imagefile_error; - } - - while (read_config_line(buf, sizeof(buf), fp, fs) != NULL) - { - reject = 1; - - if (*buf == '~') - { - reject = 0; - p = buf; - q = p+1; - while ((*p++ = *q++)) + if ((new_alias = zalloc(sizeof(*new_alias))) == NULL) { - /* nop */ + fclose(fp); + log_error(LOG_LEVEL_FATAL, + "can't load permissions file '%s': out of memory!", + csp->config->permissions_file); + return 1; /* never get here */ } - } - - /* skip lines containing only ~ */ - if (*buf == '\0') - { - continue; - } - /* allocate a new node */ - if (((b = zalloc(sizeof(*b))) == NULL) -#ifdef REGEX - || ((b->url->preg = zalloc(sizeof(*b->url->preg))) == NULL) -#endif - ) - { - fclose(fp); - goto load_imagefile_error; - } - - /* add it to the list */ - b->next = bl->next; - bl->next = b; - - /* save a copy of the orignal specification */ - if ((b->url->spec = strdup(buf)) == NULL) - { - fclose(fp); - goto load_imagefile_error; - } - - b->reject = reject; - - if ((p = strchr(buf, '/'))) - { - b->url->path = strdup(p); - b->url->pathlen = strlen(b->url->path); - *p = '\0'; - } - else - { - b->url->path = NULL; - b->url->pathlen = 0; - } -#ifdef REGEX - if (b->url->path) - { - int errcode; - char rebuf[BUFSIZ]; - - sprintf(rebuf, "^(%s)", b->url->path); - - errcode = regcomp(b->url->preg, rebuf, - (REG_EXTENDED|REG_NOSUB|REG_ICASE)); - - if (errcode) + /* Eat any the whitespace after the '=' */ + start++; + while ((*start == ' ') || (*start == '\t')) { - size_t errlen = - regerror(errcode, - b->url->preg, buf, sizeof(buf)); - - buf[errlen] = '\0'; - - log_error(LOG_LEVEL_ERROR, "error compiling %s: %s", - b->url->spec, buf); - fclose(fp); - goto load_imagefile_error; + start++; + } + if (*start == '\0') + { + log_error(LOG_LEVEL_FATAL, + "can't load permissions file '%s': invalid alias line: %s", + csp->config->permissions_file, buf); + return 1; /* never get here */ } - } - else - { - freez(b->url->preg); - } -#endif - if ((p = strchr(buf, ':')) == NULL) - { - port = 0; - } - else - { - *p++ = '\0'; - port = atoi(p); - } - - b->url->port = port; - - if ((b->url->domain = strdup(buf)) == NULL) - { - fclose(fp); - goto load_imagefile_error; - } - - /* split domain into components */ - *url = dsplit(b->url->domain); - b->url->dbuf = url->dbuf; - b->url->dcnt = url->dcnt; - b->url->dvec = url->dvec; - } -#ifndef SPLIT_PROXY_ARGS - if (!suppress_blocklists) - fs->proxy_args = strsav(fs->proxy_args, ""); -#endif /* ndef SPLIT_PROXY_ARGS */ - - fclose(fp); - -#ifndef SPLIT_PROXY_ARGS - if (!suppress_blocklists) - { - fs->proxy_args = strsav(fs->proxy_args, ""); - } -#endif /* ndef SPLIT_PROXY_ARGS */ - - /* the old one is now obsolete */ - if (current_imagefile) - { - current_imagefile->unloader = unload_imagefile; - } - - fs->next = files->next; - files->next = fs; - current_imagefile = fs; - - if (csp) - { - csp->ilist = fs; - } - - return(0); - -load_imagefile_error: - log_error(LOG_LEVEL_ERROR, "can't load imagefile '%s': %E", imagefile); - return(-1); - -} -#endif /* def USE_IMAGE_LIST */ - - -/********************************************************************* - * - * Function : load_cookiefile - * - * Description : Read and parse a cookiefile and add to files list. - * - * Parameters : - * 1 : csp = Current client state (buffers, headers, etc...) - * - * Returns : 0 => Ok, everything else is an error. - * - *********************************************************************/ -int load_cookiefile(struct client_state *csp) -{ - FILE *fp; - - struct cookie_spec *b, *bl; - char buf[BUFSIZ], *p, *q; - int port, user_cookie, server_cookie; - struct file_list *fs; - struct url_spec url[1]; - - if (!check_file_changed(current_cookiefile, cookiefile, &fs)) - { - /* No need to load */ - if (csp) - { - csp->clist = current_cookiefile; - } - return(0); - } - if (!fs) - { - goto load_cookie_error; - } - - fs->f = bl = (struct cookie_spec *)zalloc(sizeof(*bl)); - if (bl == NULL) - { - goto load_cookie_error; - } - - if ((fp = fopen(cookiefile, "r")) == NULL) - { - goto load_cookie_error; - } - - while (read_config_line(buf, sizeof(buf), fp, fs) != NULL) - { - p = buf; - - switch ((int)*p) - { - case '>': - server_cookie = 0; - user_cookie = 1; - p++; - break; - - case '<': - server_cookie = 1; - user_cookie = 0; - p++; - break; - case '~': - server_cookie = 0; - user_cookie = 0; - p++; - break; + /* Eat any the whitespace before the '=' */ + end--; + while ((*end == ' ') || (*end == '\t')) + { + /* + * we already know we must have at least 1 non-ws char + * at start of buf - no need to check + */ + end--; + } + end[1] = '\0'; - default: - server_cookie = 1; - user_cookie = 1; - break; - } + new_alias->name = strdup(buf); - /* - * Elide any of the "special" chars from the - * front of the pattern - */ - q = buf; - if (p > q) while ((*q++ = *p++)) - { - /* nop */ - } + curmask = PERMIT_MASK_ALL; + curadd = 0; - /* skip lines containing only "special" chars */ - if (*buf == '\0') - { - continue; - } + while (more) + { + const struct permission_alias * alias = standard_aliases; + char * option = start; + while ((*start != '\0') && (*start != ' ') && (*start != '\t')) + { + start++; + } - /* allocate a new node */ - if (((b = zalloc(sizeof(*b))) == NULL) -#ifdef REGEX - || ((b->url->preg = zalloc(sizeof(*b->url->preg))) == NULL) -#endif - ) - { - fclose(fp); - goto load_cookie_error; - } + more = (*start != 0); + if (more) + { + *start++ = '\0'; - /* add it to the list */ - b->next = bl->next; - bl->next = b; + /* Eat all the whitespace between the options */ + while ((*start == ' ') || (*start == '\t')) + { + start++; + } + } - /* save a copy of the orignal specification */ - if ((b->url->spec = strdup(buf)) == NULL) - { - fclose(fp); - goto load_cookie_error; - } + /* handle option in 'option' */ - b->send_user_cookie = user_cookie; - b->accept_server_cookie = server_cookie; + /* Check for standard permission name */ + while ( (alias->name != NULL) && (0 != strcmpic(alias->name, option)) ) + { + alias++; + } + if (alias->name == NULL) + { + /* try user aliases. */ + alias = alias_list; + while ( (alias != NULL) && (0 != strcmpic(alias->name, option)) ) + { + alias = alias->next; + } + } + if (alias == NULL) + { + /* Bad permission name */ + fclose(fp); + log_error(LOG_LEVEL_FATAL, + "can't load permissions file '%s': invalid permission name: %s", + csp->config->permissions_file, option); + return 1; /* never get here */ + } + curmask &= alias->mask; + curadd &= alias->mask; + curadd |= alias->add; + } - if ((p = strchr(buf, '/'))) - { - b->url->path = strdup(p); - b->url->pathlen = strlen(b->url->path); - *p = '\0'; + /* save alias permissions */ + new_alias->mask = curmask; + new_alias->add = curadd; + + /* add to list */ + new_alias->next = alias_list; + alias_list = new_alias; } - else + else if (mode == MODE_PERMISSIONS) { - b->url->path = NULL; - b->url->pathlen = 0; - } -#ifdef REGEX - if (b->url->path) - { - int errcode; - char rebuf[BUFSIZ]; - - sprintf(rebuf, "^(%s)", b->url->path); + /* it's a URL pattern */ - errcode = regcomp(b->url->preg, rebuf, - (REG_EXTENDED|REG_NOSUB|REG_ICASE)); - if (errcode) + /* allocate a new node */ + if ((perm = zalloc(sizeof(*perm))) == NULL) { - size_t errlen = - regerror(errcode, - b->url->preg, buf, sizeof(buf)); + fclose(fp); + log_error(LOG_LEVEL_FATAL, + "can't load permissions file '%s': out of memory!", + csp->config->permissions_file); + return 1; /* never get here */ + } - buf[errlen] = '\0'; + /* Save flags */ + perm->mask = curmask; + perm->add = curadd; - log_error(LOG_LEVEL_ERROR, "error compiling %s: %s", - b->url->spec, buf); + /* Save the URL pattern */ + if (create_url_spec(perm->url, buf)) + { fclose(fp); - goto load_cookie_error; + log_error(LOG_LEVEL_FATAL, + "can't load permissions file '%s': cannot create URL permission from: %s", + csp->config->permissions_file, buf); + return 1; /* never get here */ } + + /* add it to the list */ + last_perm->next = perm; + last_perm = perm; } - else - { - freez(b->url->preg); - } -#endif - if ((p = strchr(buf, ':')) == NULL) + else if (mode == MODE_START_OF_FILE) { - port = 0; + /* oops - please have a {} line as 1st line in file. */ + fclose(fp); + log_error(LOG_LEVEL_FATAL, + "can't load permissions file '%s': first line is invalid: %s", + csp->config->permissions_file, buf); + return 1; /* never get here */ } else { - *p++ = '\0'; - port = atoi(p); - } - - b->url->port = port; - - if ((b->url->domain = strdup(buf)) == NULL) - { + /* How did we get here? This is impossible! */ fclose(fp); - goto load_cookie_error; + log_error(LOG_LEVEL_FATAL, + "can't load permissions file '%s': INTERNAL ERROR - mode = %d", + csp->config->permissions_file, mode); + return 1; /* never get here */ } - - /* split domain into components */ - - *url = dsplit(b->url->domain); - b->url->dbuf = url->dbuf; - b->url->dcnt = url->dcnt; - b->url->dvec = url->dvec; } fclose(fp); + + while (alias_list != NULL) + { + struct permission_alias * next = alias_list->next; + freez((char *)alias_list->name); + free(alias_list); + alias_list = next; + } #ifndef SPLIT_PROXY_ARGS if (!suppress_blocklists) @@ -1435,26 +1384,22 @@ int load_cookiefile(struct client_state *csp) #endif /* ndef SPLIT_PROXY_ARGS */ /* the old one is now obsolete */ - if (current_cookiefile) + if (current_permissions_file) { - current_cookiefile->unloader = unload_cookiefile; + current_permissions_file->unloader = unload_permissions_file; } fs->next = files->next; files->next = fs; - current_cookiefile = fs; + current_permissions_file = fs; if (csp) { - csp->clist = fs; + csp->permissions_list = fs; } return(0); -load_cookie_error: - log_error(LOG_LEVEL_ERROR, "can't load cookiefile '%s': %E", cookiefile); - return(-1); - } @@ -1479,11 +1424,10 @@ int load_trustfile(struct client_state *csp) struct url_spec **tl; char buf[BUFSIZ], *p, *q; - int port, reject, trusted; + int reject, trusted; struct file_list *fs; - struct url_spec url[1]; - if (!check_file_changed(current_trustfile, trustfile, &fs)) + if (!check_file_changed(current_trustfile, csp->config->trustfile, &fs)) { /* No need to load */ if (csp) @@ -1503,12 +1447,12 @@ int load_trustfile(struct client_state *csp) goto load_trustfile_error; } - if ((fp = fopen(trustfile, "r")) == NULL) + if ((fp = fopen(csp->config->trustfile, "r")) == NULL) { goto load_trustfile_error; } - tl = trust_list; + tl = csp->config->trust_list; while (read_config_line(buf, sizeof(buf), fp, fs) != NULL) { @@ -1539,11 +1483,7 @@ int load_trustfile(struct client_state *csp) } /* allocate a new node */ - if (((b = zalloc(sizeof(*b))) == NULL) -#ifdef REGEX - || ((b->url->preg = zalloc(sizeof(*b->url->preg))) == NULL) -#endif - ) + if ((b = zalloc(sizeof(*b))) == NULL) { fclose(fp); goto load_trustfile_error; @@ -1553,80 +1493,15 @@ int load_trustfile(struct client_state *csp) b->next = bl->next; bl->next = b; - /* save a copy of the orignal specification */ - if ((b->url->spec = strdup(buf)) == NULL) - { - fclose(fp); - goto load_trustfile_error; - } - b->reject = reject; - if ((p = strchr(buf, '/'))) - { - b->url->path = strdup(p); - b->url->pathlen = strlen(b->url->path); - *p = '\0'; - } - else - { - b->url->path = NULL; - b->url->pathlen = 0; - } -#ifdef REGEX - if (b->url->path) - { - int errcode; - char rebuf[BUFSIZ]; - - sprintf(rebuf, "^(%s)", b->url->path); - - errcode = regcomp(b->url->preg, rebuf, - (REG_EXTENDED|REG_NOSUB|REG_ICASE)); - - if (errcode) - { - size_t errlen = - regerror(errcode, - b->url->preg, buf, sizeof(buf)); - - buf[errlen] = '\0'; - - log_error(LOG_LEVEL_ERROR, "error compiling %s: %s", - b->url->spec, buf); - fclose(fp); - goto load_trustfile_error; - } - } - else - { - freez(b->url->preg); - } -#endif - if ((p = strchr(buf, ':')) == NULL) - { - port = 0; - } - else - { - *p++ = '\0'; - port = atoi(p); - } - - b->url->port = port; - - if ((b->url->domain = strdup(buf)) == NULL) + /* Save the URL pattern */ + if (create_url_spec(b->url, buf)) { fclose(fp); goto load_trustfile_error; } - /* split domain into components */ - *url = dsplit(b->url->domain); - b->url->dbuf = url->dbuf; - b->url->dcnt = url->dcnt; - b->url->dvec = url->dvec; - /* * save a pointer to URL's spec in the list of trusted URL's, too */ @@ -1665,7 +1540,8 @@ int load_trustfile(struct client_state *csp) return(0); load_trustfile_error: - log_error(LOG_LEVEL_ERROR, "can't load trustfile '%s': %E", trustfile); + log_error(LOG_LEVEL_FATAL, "can't load trustfile '%s': %E", + csp->config->trustfile); return(-1); } @@ -1689,14 +1565,14 @@ int load_forwardfile(struct client_state *csp) FILE *fp; struct forward_spec *b, *bl; - char buf[BUFSIZ], *p, *q, *tmp; - char *vec[4]; - int port, n, reject; + char buf[BUFSIZ]; + char *p, *tmp; + char *vec[4]; + int n; struct file_list *fs; const struct gateway *gw; - struct url_spec url[1]; - if (!check_file_changed(current_forwardfile, forwardfile, &fs)) + if (!check_file_changed(current_forwardfile, csp->config->forwardfile, &fs)) { /* No need to load */ if (csp) @@ -1717,7 +1593,7 @@ int load_forwardfile(struct client_state *csp) goto load_forwardfile_error; } - if ((fp = fopen(forwardfile, "r")) == NULL) + if ((fp = fopen(csp->config->forwardfile, "r")) == NULL) { goto load_forwardfile_error; } @@ -1740,19 +1616,6 @@ int load_forwardfile(struct client_state *csp) strcpy(buf, vec[0]); - reject = 1; - - if (*buf == '~') - { - reject = 0; - p = buf; - q = p+1; - while ((*p++ = *q++)) - { - /* nop */ - } - } - /* skip lines containing only ~ */ if (*buf == '\0') { @@ -1761,9 +1624,6 @@ int load_forwardfile(struct client_state *csp) /* allocate a new node */ if (((b = zalloc(sizeof(*b))) == NULL) -#ifdef REGEX - || ((b->url->preg = zalloc(sizeof(*b->url->preg))) == NULL) -#endif ) { fclose(fp); @@ -1774,78 +1634,13 @@ int load_forwardfile(struct client_state *csp) b->next = bl->next; bl->next = b; - /* save a copy of the orignal specification */ - if ((b->url->spec = strdup(buf)) == NULL) + /* Save the URL pattern */ + if (create_url_spec(b->url, buf)) { fclose(fp); goto load_forwardfile_error; } - b->reject = reject; - - if ((p = strchr(buf, '/'))) - { - b->url->path = strdup(p); - b->url->pathlen = strlen(b->url->path); - *p = '\0'; - } - else - { - b->url->path = NULL; - b->url->pathlen = 0; - } -#ifdef REGEX - if (b->url->path) - { - int errcode; - char rebuf[BUFSIZ]; - - sprintf(rebuf, "^(%s)", b->url->path); - - errcode = regcomp(b->url->preg, rebuf, - (REG_EXTENDED|REG_NOSUB|REG_ICASE)); - - if (errcode) - { - size_t errlen = regerror(errcode, b->url->preg, buf, sizeof(buf)); - - buf[errlen] = '\0'; - - log_error(LOG_LEVEL_ERROR, "error compiling %s: %s", - b->url->spec, buf); - fclose(fp); - goto load_forwardfile_error; - } - } - else - { - freez(b->url->preg); - } -#endif - if ((p = strchr(buf, ':')) == NULL) - { - port = 0; - } - else - { - *p++ = '\0'; - port = atoi(p); - } - - b->url->port = port; - - if ((b->url->domain = strdup(buf)) == NULL) - { - fclose(fp); - goto load_forwardfile_error; - } - - /* split domain into components */ - *url = dsplit(b->url->domain); - b->url->dbuf = url->dbuf; - b->url->dcnt = url->dcnt; - b->url->dvec = url->dvec; - /* now parse the gateway specs */ p = vec[2]; @@ -1934,7 +1729,8 @@ int load_forwardfile(struct client_state *csp) return(0); load_forwardfile_error: - log_error(LOG_LEVEL_ERROR, "can't load forwardfile '%s': %E", forwardfile); + log_error(LOG_LEVEL_FATAL, "can't load forwardfile '%s': %E", + csp->config->forwardfile); return(-1); } @@ -1966,10 +1762,7 @@ int load_re_filterfile(struct client_state *csp) int error; pcrs_job *dummy; -#ifndef SPLIT_PROXY_ARGS - char *p; -#endif /* ndef SPLIT_PROXY_ARGS */ - if (!check_file_changed(current_re_filterfile, re_filterfile, &fs)) + if (!check_file_changed(current_re_filterfile, csp->config->re_filterfile, &fs)) { /* No need to load */ if (csp) @@ -1990,7 +1783,7 @@ int load_re_filterfile(struct client_state *csp) } /* Open the file or fail */ - if ((fp = fopen(re_filterfile, "r")) == NULL) + if ((fp = fopen(csp->config->re_filterfile, "r")) == NULL) { goto load_re_filterfile_error; } @@ -2003,7 +1796,7 @@ int load_re_filterfile(struct client_state *csp) /* We have a meaningful line -> make it a job */ if ((dummy = pcrs_make_job(buf, &error)) == NULL) { - log_error(LOG_LEVEL_REF, + log_error(LOG_LEVEL_RE_FILTER, "Adding re_filter job %s failed with error %d.", buf, error); continue; } @@ -2011,7 +1804,7 @@ int load_re_filterfile(struct client_state *csp) { dummy->next = bl->joblist; bl->joblist = dummy; - log_error(LOG_LEVEL_REF, "Adding re_filter job %s succeeded.", buf); + log_error(LOG_LEVEL_RE_FILTER, "Adding re_filter job %s succeeded.", buf); } } @@ -2042,134 +1835,14 @@ int load_re_filterfile(struct client_state *csp) return( 0 ); load_re_filterfile_error: - log_error(LOG_LEVEL_ERROR, "can't load re_filterfile '%s': %E", re_filterfile); + log_error(LOG_LEVEL_FATAL, "can't load re_filterfile '%s': %E", + csp->config->re_filterfile); return(-1); } #endif /* def PCRS */ -#ifdef KILLPOPUPS -/********************************************************************* - * - * Function : load_popupfile - * - * Description : Load, and parse the popup blocklist. - * - * Parameters : - * 1 : csp = Current client state (buffers, headers, etc...) - * - * Returns : 0 => success, else there was an error. - * - *********************************************************************/ -int load_popupfile(struct client_state *csp) -{ - FILE *fp; - char buf[BUFSIZ], *p, *q; - struct popup_blocklist *entry = NULL; - struct popup_settings * data; - struct file_list *fs; - p = buf; - q = buf; - - if (!check_file_changed(current_popupfile, popupfile, &fs)) - { - /* No need to load */ - if (csp) - { - csp->plist = current_popupfile; - } - return(0); - } - if (!fs) - { - goto load_popupfile_error; - } - - fs->f = data = (struct popup_settings *)zalloc(sizeof(*data)); - if (data == NULL) - { - goto load_popupfile_error; - } - - if ((fp = fopen(popupfile, "r")) == NULL) - { - goto load_popupfile_error; - } - - while (read_config_line(buf, sizeof(buf), fp, fs) != NULL) - { - entry = (struct popup_blocklist*)zalloc(sizeof(struct popup_blocklist)); - if (!entry) - { - fclose( fp ); - goto load_popupfile_error; - } - - /* Handle allowed hosts. */ - if ( *buf == '~' ) - { - /* Rememeber: skip the tilde */ - entry->host_name = strdup( buf + 1 ); - if (!entry->host_name) - { - fclose( fp ); - goto load_popupfile_error; - } - - entry->next = data->allowed; - data->allowed = entry; - } - else - { - /* Blocked host */ - entry->host_name = strdup( buf ); - if (!entry->host_name) - { - fclose( fp ); - goto load_popupfile_error; - } - - entry->next = data->blocked; - data->blocked = entry; - } - } - - fclose( fp ); - -#ifndef SPLIT_PROXY_ARGS - if (!suppress_blocklists) - { - fs->proxy_args = strsav(fs->proxy_args, ""); - } -#endif /* ndef SPLIT_PROXY_ARGS */ - - /* the old one is now obsolete */ - if ( NULL != current_popupfile ) - { - current_popupfile->unloader = unload_popupfile; - } - - fs->next = files->next; - files->next = fs; - current_popupfile = fs; - - if (csp) - { - csp->plist = fs; - } - - return( 0 ); - -load_popupfile_error: - log_error(LOG_LEVEL_ERROR, "can't load popupfile '%s': %E", popupfile); - return(-1); - -} -#endif /* def KILLPOPUPS */ - - - /********************************************************************* * * Function : add_loader @@ -2180,19 +1853,21 @@ load_popupfile_error: * Parameters : * 1 : loader = pointer to a function that can parse and load * the appropriate config file. + * 2 : config = The configuration_spec to add the loader to. * * Returns : N/A * *********************************************************************/ -void add_loader(int (*loader)(struct client_state *)) +void add_loader(int (*loader)(struct client_state *), + struct configuration_spec * config) { int i; for (i=0; i < NLOADERS; i++) { - if (loaders[i] == NULL) + if (config->loaders[i] == NULL) { - loaders[i] = loader; + config->loaders[i] = loader; break; } } @@ -2211,6 +1886,8 @@ void add_loader(int (*loader)(struct client_state *)) * * Parameters : * 1 : csp = Current client state (buffers, headers, etc...) + * Must be non-null. Reads: "csp->config" + * Writes: various data members. * * Returns : 0 => Ok, everything else is an error. * @@ -2222,34 +1899,17 @@ int run_loader(struct client_state *csp) for (i=0; i < NLOADERS; i++) { - if (loaders[i] == NULL) + if (csp->config->loaders[i] == NULL) { break; } - ret |= (loaders[i])(csp); + ret |= (csp->config->loaders[i])(csp); } return(ret); } -/********************************************************************* - * - * Function : remove_all_loaders - * - * Description : Remove all loaders from the list. - * - * Parameters : N/A - * - * Returns : N/A - * - *********************************************************************/ -void remove_all_loaders(void) -{ - memset( loaders, 0, sizeof( loaders ) ); -} - - /* Local Variables: tab-width: 3