X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=loaders.c;h=5a81363c72d8e6c62cdd03ae7e89b01348e77ecf;hp=0dd8ebb294c39a263f4d2d84100b9432b47d5373;hb=4067b267ce3335f422c9f2b5b1ecc3e1123048b4;hpb=e7f33c16b512f119f65800e85ba0beecfd3a1545 diff --git a/loaders.c b/loaders.c index 0dd8ebb2..5a81363c 100644 --- a/loaders.c +++ b/loaders.c @@ -1,4 +1,4 @@ -const char loaders_rcs[] = "$Id: loaders.c,v 1.33 2001/11/13 00:16:38 jongfoster Exp $"; +const char loaders_rcs[] = "$Id: loaders.c,v 1.43 2002/03/16 20:28:34 oes Exp $"; /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/loaders.c,v $ @@ -35,6 +35,50 @@ const char loaders_rcs[] = "$Id: loaders.c,v 1.33 2001/11/13 00:16:38 jongfoster * * Revisions : * $Log: loaders.c,v $ + * Revision 1.43 2002/03/16 20:28:34 oes + * Added descriptions to the filters so users will know what they select in the cgi editor + * + * Revision 1.42 2002/03/13 00:27:05 jongfoster + * Killing warnings + * + * Revision 1.41 2002/03/12 01:42:50 oes + * Introduced modular filters + * + * Revision 1.40 2002/03/08 17:46:04 jongfoster + * Fixing int/size_t warnings + * + * Revision 1.39 2002/03/07 03:46:17 oes + * Fixed compiler warnings + * + * Revision 1.38 2002/03/06 22:54:35 jongfoster + * Automated function-comment nitpicking. + * + * Revision 1.37 2002/03/03 15:07:49 oes + * Re-enabled automatic config reloading + * + * Revision 1.36 2002/01/22 23:46:18 jongfoster + * Moving edit_read_line() and simple_read_line() to loaders.c, and + * extending them to support reading MS-DOS, Mac and UNIX style files + * on all platforms. + * + * Modifying read_config_line() (without changing it's prototype) to + * be a trivial wrapper for edit_read_line(). This means that we have + * one function to read a line and handle comments, which is common + * between the initialization code and the edit interface. + * + * Revision 1.35 2002/01/17 21:03:08 jongfoster + * Moving all our URL and URL pattern parsing code to urlmatch.c. + * + * Renaming free_url to free_url_spec, since it frees a struct url_spec. + * + * Revision 1.34 2001/12/30 14:07:32 steudten + * - Add signal handling (unix) + * - Add SIGHUP handler (unix) + * - Add creation of pidfile (unix) + * - Add action 'top' in rc file (RH) + * - Add entry 'SIGNALS' to manpage + * - Add exit message to logfile (unix) + * * Revision 1.33 2001/11/13 00:16:38 jongfoster * Replacing references to malloc.h with the standard stdlib.h * (See ANSI or K&R 2nd Ed) @@ -223,6 +267,7 @@ const char loaders_rcs[] = "$Id: loaders.c,v 1.33 2001/11/13 00:16:38 jongfoster #include "miscutil.h" #include "errlog.h" #include "actions.h" +#include "urlmatch.h" const char loaders_h_rcs[] = LOADERS_H_VERSION; @@ -274,7 +319,7 @@ void sweep(void) fl->active = 0; } - for (csp = clients; csp && (ncsp = csp->next) ; csp = csp->next) + for (csp = clients; csp && (NULL != (ncsp = csp->next)) ; csp = csp->next) { if (ncsp->flags & CSP_FLAG_ACTIVE) { @@ -340,13 +385,13 @@ void sweep(void) freez(ncsp); /* are there any more in sequence after it? */ - if( !(ncsp = csp->next) ) + if( (ncsp = csp->next) == NULL) break; } } } - for (fl = files; fl && (nfl = fl->next) ; fl = fl->next) + for (fl = files; fl && ((nfl = fl->next) != NULL) ; fl = fl->next) { if ( ( 0 == nfl->active ) && ( NULL != nfl->unloader ) ) { @@ -363,174 +408,6 @@ 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 : JB_ERR_OK - Success - * JB_ERR_MEMORY - Out of memory - * JB_ERR_PARSE - Cannot parse regex (Detailed message - * written to system log) - * - *********************************************************************/ -jb_err create_url_spec(struct url_spec * url, char * buf) -{ - char *p; - struct url_spec tmp_url[1]; - - assert(url); - assert(buf); - - /* save a copy of the orignal specification */ - if ((url->spec = strdup(buf)) == NULL) - { - return JB_ERR_MEMORY; - } - - if ((p = strchr(buf, '/'))) - { - if (NULL == (url->path = strdup(p))) - { - freez(url->spec); - return JB_ERR_MEMORY; - } - url->pathlen = strlen(url->path); - *p = '\0'; - } - else - { - url->path = NULL; - url->pathlen = 0; - } -#ifdef REGEX - if (url->path) - { - int errcode; - char rebuf[BUFFER_SIZE]; - - if (NULL == (url->preg = zalloc(sizeof(*url->preg)))) - { - freez(url->spec); - freez(url->path); - return JB_ERR_MEMORY; - } - - 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, rebuf, sizeof(rebuf)); - - if (errlen > (sizeof(rebuf) - (size_t)1)) - { - errlen = sizeof(rebuf) - (size_t)1; - } - rebuf[errlen] = '\0'; - - log_error(LOG_LEVEL_ERROR, "error compiling %s: %s", - url->spec, rebuf); - - freez(url->spec); - freez(url->path); - freez(url->preg); - - return JB_ERR_PARSE; - } - } -#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 JB_ERR_MEMORY; - } - - /* split domain into components */ - - *tmp_url = dsplit(url->domain); - if (tmp_url->dbuf == NULL) - { - freez(url->spec); - freez(url->path); - freez(url->domain); -#ifdef REGEX - freez(url->preg); -#endif /* def REGEX */ - return JB_ERR_MEMORY; - } - - url->dbuf = tmp_url->dbuf; - url->dcnt = tmp_url->dcnt; - url->dvec = tmp_url->dvec; - url->unanchored = tmp_url->unanchored; - - return JB_ERR_OK; - -} - - -/********************************************************************* - * - * Function : free_url - * - * Description : Called from the "unloaders". Freez the url - * structure elements. - * - * Parameters : - * 1 : url = pointer to a url_spec structure. - * - * Returns : N/A - * - *********************************************************************/ -void free_url(struct url_spec *url) -{ - if (url == NULL) return; - - freez(url->spec); - freez(url->domain); - freez(url->dbuf); - freez(url->dvec); - freez(url->path); -#ifdef REGEX - if (url->preg) - { - regfree(url->preg); - freez(url->preg); - } -#endif - -} - - /********************************************************************* * * Function : check_file_changed @@ -576,8 +453,7 @@ int check_file_changed(const struct file_list * current, && (current->lastmodified == statbuf->st_mtime) && (0 == strcmp(current->filename, filename))) { - /* force reload of configfile and all the logs */ - if ( !MustReload ) return 0; + return 0; } fs = (struct file_list *)zalloc(sizeof(struct file_list)); @@ -603,99 +479,457 @@ int check_file_changed(const struct file_list * current, /********************************************************************* * - * Function : read_config_line + * Function : simple_read_line + * + * Description : Read a single line from a file and return it. + * This is basically a version of fgets() that malloc()s + * it's own line buffer. Note that the buffer will + * always be a multiple of BUFFER_SIZE bytes long. + * Therefore if you are going to keep the string for + * an extended period of time, you should probably + * strdup() it and free() the original, to save memory. + * + * + * Parameters : + * 1 : dest = destination for newly malloc'd pointer to + * line data. Will be set to NULL on error. + * 2 : fp = File to read from + * 3 : newline = Standard for newlines in the file. + * Will be unchanged if it's value on input is not + * NEWLINE_UNKNOWN. + * On output, may be changed from NEWLINE_UNKNOWN to + * actual convention in file. + * + * Returns : JB_ERR_OK on success + * JB_ERR_MEMORY on out-of-memory + * JB_ERR_FILE on EOF. + * + *********************************************************************/ +jb_err simple_read_line(FILE *fp, char **dest, int *newline) +{ + size_t len = 0; + size_t buflen = BUFFER_SIZE; + char * buf; + char * p; + int ch; + int realnewline = NEWLINE_UNKNOWN; + + if (NULL == (buf = malloc(buflen))) + { + return JB_ERR_MEMORY; + } + + p = buf; + +/* + * Character codes. If you have a wierd compiler and the following are + * incorrect, you also need to fix NEWLINE() in loaders.h + */ +#define CHAR_CR '\r' /* ASCII 13 */ +#define CHAR_LF '\n' /* ASCII 10 */ + + for (;;) + { + ch = fgetc(fp); + if (ch == EOF) + { + if (len > 0) + { + *p = '\0'; + *dest = buf; + return JB_ERR_OK; + } + else + { + free(buf); + *dest = NULL; + return JB_ERR_FILE; + } + } + else if (ch == CHAR_CR) + { + ch = getc(fp); + if (ch == CHAR_LF) + { + if (*newline == NEWLINE_UNKNOWN) + { + *newline = NEWLINE_DOS; + } + } + else + { + if (ch != EOF) + { + ungetc(ch, fp); + } + if (*newline == NEWLINE_UNKNOWN) + { + *newline = NEWLINE_MAC; + } + } + *p = '\0'; + *dest = buf; + if (*newline == NEWLINE_UNKNOWN) + { + *newline = realnewline; + } + return JB_ERR_OK; + } + else if (ch == CHAR_LF) + { + *p = '\0'; + *dest = buf; + if (*newline == NEWLINE_UNKNOWN) + { + *newline = NEWLINE_UNIX; + } + return JB_ERR_OK; + } + else if (ch == 0) + { + *p = '\0'; + *dest = buf; + return JB_ERR_OK; + } + + *p++ = ch; + + if (++len >= buflen) + { + buflen += BUFFER_SIZE; + if (NULL == (p = realloc(buf, buflen))); + { + free(buf); + return JB_ERR_MEMORY; + } + buf = p; + p = buf + len; + } + } +} + + +/********************************************************************* + * + * Function : edit_read_line * * Description : Read a single non-empty line from a file and return * it. Trims comments, leading and trailing whitespace * and respects escaping of newline and comment char. + * Provides the line in 2 alternative forms: raw and + * preprocessed. + * - raw is the raw data read from the file. If the + * line is not modified, then this should be written + * to the new file. + * - prefix is any comments and blank lines that were + * read from the file. If the line is modified, then + * this should be written out to the file followed + * by the modified data. (If this string is non-empty + * then it will have a newline at the end). + * - data is the actual data that will be parsed + * further by appropriate routines. + * On EOF, the 3 strings will all be set to NULL and + * 0 will be returned. * * Parameters : - * 1 : buf = Buffer to use. - * 2 : buflen = Size of buffer in bytes. - * 3 : fp = File to read from - * 4 : linenum = linenumber in file - * - * Returns : NULL on EOF or error - * Otherwise, returns buf. + * 1 : fp = File to read from + * 2 : raw_out = destination for newly malloc'd pointer to + * raw line data. May be NULL if you don't want it. + * 3 : prefix_out = destination for newly malloc'd pointer to + * comments. May be NULL if you don't want it. + * 4 : data_out = destination for newly malloc'd pointer to + * line data with comments and leading/trailing spaces + * removed, and line continuation performed. May be + * NULL if you don't want it. + * 5 : newline = Standard for newlines in the file. + * On input, set to value to use or NEWLINE_UNKNOWN. + * On output, may be changed from NEWLINE_UNKNOWN to + * actual convention in file. May be NULL if you + * don't want it. + * 6 : line_number = Line number in file. In "lines" as + * reported by a text editor, not lines containing data. + * + * Returns : JB_ERR_OK on success + * JB_ERR_MEMORY on out-of-memory + * JB_ERR_FILE on EOF. * *********************************************************************/ -char *read_config_line(char *buf, int buflen, FILE *fp, unsigned long *linenum) +jb_err edit_read_line(FILE *fp, + char **raw_out, + char **prefix_out, + char **data_out, + int *newline, + unsigned long *line_number) { - char *p; - char *src; - char *dest; - char linebuf[BUFFER_SIZE]; - int contflag = 0; + char *p; /* Temporary pointer */ + char *linebuf; /* Line read from file */ + char *linestart; /* Start of linebuf, usually first non-whitespace char */ + int contflag = 0; /* Nonzero for line continuation - i.e. line ends '\' */ + int is_empty = 1; /* Flag if not got any data yet */ + char *raw = NULL; /* String to be stored in raw_out */ + char *prefix = NULL; /* String to be stored in prefix_out */ + char *data = NULL; /* String to be stored in data_out */ + int scrapnewline; /* Used for (*newline) if newline==NULL */ + jb_err rval = JB_ERR_OK; + + assert(fp); + assert(raw_out || data_out); + assert(newline == NULL + || *newline == NEWLINE_UNKNOWN + || *newline == NEWLINE_UNIX + || *newline == NEWLINE_DOS + || *newline == NEWLINE_MAC); + + if (newline == NULL) + { + scrapnewline = NEWLINE_UNKNOWN; + newline = &scrapnewline; + } - *buf = '\0'; + /* Set output parameters to NULL */ + if (raw_out) + { + *raw_out = NULL; + } + if (prefix_out) + { + *prefix_out = NULL; + } + if (data_out) + { + *data_out = NULL; + } - while (fgets(linebuf, sizeof(linebuf), fp)) + /* Set string variables to new, empty strings. */ + + if (raw_out) { - (*linenum)++; - /* Trim off newline */ - if ((p = strpbrk(linebuf, "\r\n")) != NULL) + if ((raw = malloc(1)) == NULL) { - *p = '\0'; + return JB_ERR_MEMORY; } - else + *raw = '\0'; + } + if (prefix_out) + { + if ((prefix = malloc(1)) == NULL) { - p = linebuf + strlen(linebuf); + freez(raw); + return JB_ERR_MEMORY; + } + *prefix = '\0'; + } + if (data_out) + { + if ((data = malloc(1)) == NULL) + { + freez(raw); + freez(prefix); + return JB_ERR_MEMORY; + } + *data = '\0'; + } + + /* Main loop. Loop while we need more data & it's not EOF. */ + + while ( (contflag || is_empty) + && (JB_ERR_OK == (rval = simple_read_line(fp, &linebuf, newline)))) + { + if (line_number) + { + (*line_number)++; + } + if (raw) + { + string_append(&raw,linebuf); + if (string_append(&raw,NEWLINE(*newline))) + { + freez(prefix); + freez(data); + free(linebuf); + return JB_ERR_MEMORY; + } } /* Line continuation? Trim escape and set flag. */ - if ((p != linebuf) && (*--p == '\\')) + p = linebuf + strlen(linebuf) - 1; + contflag = ((*linebuf != '\0') && (*p == '\\')); + if (contflag) { - contflag = 1; *p = '\0'; } - /* If there's a comment char.. */ - p = linebuf; + /* Trim leading spaces if we're at the start of the line */ + linestart = linebuf; + if (*data == '\0') + { + /* Trim leading spaces */ + while (*linestart && isspace((int)(unsigned char)*linestart)) + { + linestart++; + } + } + + /* Handle comment characters. */ + p = linestart; while ((p = strchr(p, '#')) != NULL) { - /* ..and it's escaped, left-shift the line over the escape. */ + /* Found a comment char.. */ if ((p != linebuf) && (*(p-1) == '\\')) { - src = p; - dest = p - 1; - while ((*dest++ = *src++) != '\0') + /* ..and it's escaped, left-shift the line over the escape. */ + char *q = p - 1; + while ((*q = *(q + 1)) != '\0') { - /* nop */ + q++; } /* Now scan from just after the "#". */ } - /* Else, chop off the rest of the line */ else { + /* Real comment. Save it... */ + if (p == linestart) + { + /* Special case: Line only contains a comment, so all the + * previous whitespace is considered part of the comment. + * Undo the whitespace skipping, if any. + */ + linestart = linebuf; + p = linestart; + } + if (prefix) + { + string_append(&prefix,p); + if (string_append(&prefix, NEWLINE(*newline))) + { + freez(raw); + freez(data); + free(linebuf); + return JB_ERR_MEMORY; + } + } + + /* ... and chop off the rest of the line */ *p = '\0'; } - } + } /* END while (there's a # character) */ /* Write to the buffer */ - if (*linebuf) + if (*linestart) { - strncat(buf, linebuf, buflen - strlen(buf)); + is_empty = 0; + if (data) + { + if (string_append(&data, linestart)) + { + freez(raw); + freez(prefix); + free(linebuf); + return JB_ERR_MEMORY; + } + } } - /* Continue? */ - if (contflag) - { - contflag = 0; - continue; - } + free(linebuf); + } /* END while(we need more data) */ - /* Remove leading and trailing whitespace */ - chomp(buf); + /* Handle simple_read_line() errors - ignore EOF */ + if ((rval != JB_ERR_OK) && (rval != JB_ERR_FILE)) + { + freez(raw); + freez(prefix); + freez(data); + return rval; + } - if (*buf) + if (raw ? (*raw == '\0') : is_empty) + { + /* EOF and no data there. (Definition of "data" depends on whether + * the caller cares about "raw" or just "data"). + */ + + freez(raw); + freez(prefix); + freez(data); + + return JB_ERR_FILE; + } + else + { + /* Got at least some data */ + + /* Remove trailing whitespace */ + chomp(data); + + if (raw_out) { - return buf; + *raw_out = raw; } + else + { + freez(raw); + } + if (prefix_out) + { + *prefix_out = prefix; + } + else + { + freez(prefix); + } + if (data_out) + { + *data_out = data; + } + else + { + freez(data); + } + return JB_ERR_OK; } +} - /* EOF */ - return NULL; +/********************************************************************* + * + * Function : read_config_line + * + * Description : Read a single non-empty line from a file and return + * it. Trims comments, leading and trailing whitespace + * and respects escaping of newline and comment char. + * + * Parameters : + * 1 : buf = Buffer to use. + * 2 : buflen = Size of buffer in bytes. + * 3 : fp = File to read from + * 4 : linenum = linenumber in file + * + * Returns : NULL on EOF or error + * Otherwise, returns buf. + * + *********************************************************************/ +char *read_config_line(char *buf, size_t buflen, FILE *fp, unsigned long *linenum) +{ + jb_err err; + char *buf2 = NULL; + err = edit_read_line(fp, NULL, NULL, &buf2, NULL, linenum); + if (err) + { + if (err == JB_ERR_MEMORY) + { + log_error(LOG_LEVEL_FATAL, "Out of memory loading a config file"); + } + return NULL; + } + else + { + assert(buf2); + assert(strlen(buf2) + 1U < buflen); + strncpy(buf, buf2, buflen - 1); + free(buf2); + buf[buflen - 1] = '\0'; + return buf; + } } @@ -719,7 +953,7 @@ static void unload_trustfile(void *f) unload_trustfile(b->next); /* Stack is cheap, isn't it? */ - free_url(b->url); + free_url_spec(b->url); freez(b); @@ -793,7 +1027,7 @@ int load_trustfile(struct client_state *csp) reject = 0; p = buf; q = p+1; - while ((*p++ = *q++)) + while ((*p++ = *q++) != '\0') { /* nop */ } @@ -831,6 +1065,7 @@ int load_trustfile(struct client_state *csp) if (trusted) { *tl++ = b->url; + /* FIXME BUFFER OVERFLOW if >=64 entries */ } } @@ -868,7 +1103,8 @@ load_trustfile_error: * * Function : unload_re_filterfile * - * Description : Unload the re_filter list. + * Description : Unload the re_filter list by freeing all chained + * re_filterfile specs and their data. * * Parameters : * 1 : f = the data structure associated with the filterfile. @@ -878,27 +1114,33 @@ load_trustfile_error: *********************************************************************/ static void unload_re_filterfile(void *f) { - struct re_filterfile_spec *b = (struct re_filterfile_spec *)f; + struct re_filterfile_spec *a, *b = (struct re_filterfile_spec *)f; - if (b == NULL) + while (b != NULL) { - return; - } + a = b->next; - destroy_list(b->patterns); - pcrs_free_joblist(b->joblist); - freez(b); + destroy_list(b->patterns); + pcrs_free_joblist(b->joblist); + freez(b->name); + freez(b->description); + freez(b); + + b = a; + } return; } + /********************************************************************* * * Function : load_re_filterfile * - * Description : Load the re_filterfile. Each non-comment, non-empty - * line is instantly added to the joblist, which is - * a chained list of pcrs_job structs. + * Description : Load the re_filterfile. + * Generate a chained list of re_filterfile_spec's from + * the "FILTER: " blocks, compiling all their substitutions + * into chained lists of pcrs_job structs. * * Parameters : * 1 : csp = Current client state (buffers, headers, etc...) @@ -910,7 +1152,7 @@ int load_re_filterfile(struct client_state *csp) { FILE *fp; - struct re_filterfile_spec *bl; + struct re_filterfile_spec *new_bl, *bl = NULL; struct file_list *fs; char buf[BUFFER_SIZE]; @@ -918,9 +1160,11 @@ int load_re_filterfile(struct client_state *csp) unsigned long linenum = 0; pcrs_job *dummy; + /* + * No need to reload if unchanged + */ if (!check_file_changed(current_re_filterfile, csp->config->re_filterfile, &fs)) { - /* No need to load */ if (csp) { csp->rlist = current_re_filterfile; @@ -932,46 +1176,105 @@ int load_re_filterfile(struct client_state *csp) goto load_re_filterfile_error; } - fs->f = bl = (struct re_filterfile_spec *)zalloc(sizeof(*bl)); - if (bl == NULL) - { - goto load_re_filterfile_error; - } - - /* Open the file or fail */ + /* + * Open the file or fail + */ if ((fp = fopen(csp->config->re_filterfile, "r")) == NULL) { goto load_re_filterfile_error; } - /* Read line by line */ + /* + * Read line by line + */ while (read_config_line(buf, sizeof(buf), fp, &linenum) != NULL) { - enlist( bl->patterns, buf ); - - /* We have a meaningful line -> make it a job */ - if ((dummy = pcrs_compile_command(buf, &error)) == NULL) + /* + * If this is the head of a new filter block, make it a + * re_filterfile spec of its own and chain it to the list: + */ + if (strncmp(buf, "FILTER:", 7) == 0) { - log_error(LOG_LEVEL_RE_FILTER, - "Adding re_filter job %s failed with error %d.", buf, error); + new_bl = (struct re_filterfile_spec *)zalloc(sizeof(*bl)); + if (new_bl == NULL) + { + goto load_re_filterfile_error; + } + + new_bl->name = chomp(buf + 7); + + if (NULL != (new_bl->description = strchr(new_bl->name, ' '))) + { + *new_bl->description++ = '\0'; + new_bl->description = strdup(chomp(new_bl->description)); + } + else + { + new_bl->description = strdup("No description available for this filter"); + } + + new_bl->name = strdup(chomp(new_bl->name)); + + /* + * If this is the first filter block, chain it + * to the file_list rather than its (nonexistant) + * predecessor + */ + if (fs->f == NULL) + { + fs->f = new_bl; + } + else + { + bl->next = new_bl; + } + bl = new_bl; + + log_error(LOG_LEVEL_RE_FILTER, "Reading in filter \"%s\" (\"%s\")", bl->name, bl->description); + continue; } + + /* + * Else, save the expression, make it a pcrs_job + * and chain it into the current filter's joblist + */ + if (bl != NULL) + { + enlist(bl->patterns, buf); + + if ((dummy = pcrs_compile_command(buf, &error)) == NULL) + { + log_error(LOG_LEVEL_RE_FILTER, + "Adding re_filter job %s to filter %s failed with error %d.", buf, bl->name, error); + continue; + } + else + { + dummy->next = bl->joblist; + bl->joblist = dummy; + log_error(LOG_LEVEL_RE_FILTER, "Adding re_filter job %s to filter %s succeeded.", buf, bl->name); + } + } else { - dummy->next = bl->joblist; - bl->joblist = dummy; - log_error(LOG_LEVEL_RE_FILTER, "Adding re_filter job %s succeeded.", buf); + log_error(LOG_LEVEL_ERROR, "Ignoring job %s outside filter block in %s, line %d", buf, csp->config->re_filterfile, linenum); } } fclose(fp); - /* the old one is now obsolete */ + /* + * Schedule the now-obsolete old data for unloading + */ if ( NULL != current_re_filterfile ) { current_re_filterfile->unloader = unload_re_filterfile; } + /* + * Chain this file into the global list of loaded files + */ fs->next = files->next; files->next = fs; current_re_filterfile = fs;