X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=loaders.c;h=e7dbbe42228826675dd5a59af493e859cfbc9585;hp=f63b9168a9cb7ca04e89eeabc9e27ab957fb2337;hb=8cae7e3a5026ceac91afc7e1f0f30a2ebd5ec1bc;hpb=97110184221edacdb7d4dfc29de0e38d63f4d831 diff --git a/loaders.c b/loaders.c index f63b9168..e7dbbe42 100644 --- a/loaders.c +++ b/loaders.c @@ -1,4 +1,4 @@ -const char loaders_rcs[] = "$Id: loaders.c,v 1.46 2002/03/24 13:25:43 swa Exp $"; +const char loaders_rcs[] = "$Id: loaders.c,v 1.71 2009/03/04 18:24:47 fabiankeil Exp $"; /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/loaders.c,v $ @@ -8,7 +8,7 @@ const char loaders_rcs[] = "$Id: loaders.c,v 1.46 2002/03/24 13:25:43 swa Exp $" * the list of active loaders, and to automatically * unload files that are no longer in use. * - * Copyright : Written by and Copyright (C) 2001 the SourceForge + * Copyright : Written by and Copyright (C) 2001-2009 the * Privoxy team. http://www.privoxy.org/ * * Based on the Internet Junkbuster originally written @@ -35,6 +35,131 @@ const char loaders_rcs[] = "$Id: loaders.c,v 1.46 2002/03/24 13:25:43 swa Exp $" * * Revisions : * $Log: loaders.c,v $ + * Revision 1.71 2009/03/04 18:24:47 fabiankeil + * No need to create empty strings manually, strdup("") FTW. + * + * Revision 1.70 2009/03/01 18:34:24 fabiankeil + * Help clang understand that we aren't dereferencing + * NULL pointers here. + * + * Revision 1.69 2008/09/21 13:36:52 fabiankeil + * If change-x-forwarded-for{add} is used and the client + * sends multiple X-Forwarded-For headers, append the client's + * IP address to each one of them. "Traditionally" we would + * lose all but the last one. + * + * Revision 1.68 2008/09/19 15:26:28 fabiankeil + * Add change-x-forwarded-for{} action to block or add + * X-Forwarded-For headers. Mostly based on code removed + * before 3.0.7. + * + * Revision 1.67 2008/03/30 14:52:08 fabiankeil + * Rename load_actions_file() and load_re_filterfile() + * as they load multiple files "now". + * + * Revision 1.66 2008/03/21 11:16:30 fabiankeil + * Garbage-collect csp->my_ip_addr_str and csp->my_hostname. + * + * Revision 1.65 2007/12/07 18:29:23 fabiankeil + * Remove now-obsolete csp member x_forwarded. + * + * Revision 1.64 2007/06/01 14:12:38 fabiankeil + * Add unload_forward_spec() in preparation for forward-override{}. + * + * Revision 1.63 2007/05/14 10:41:15 fabiankeil + * Ditch the csp member cookie_list[] which isn't used anymore. + * + * Revision 1.62 2007/04/30 15:02:18 fabiankeil + * Introduce dynamic pcrs jobs that can resolve variables. + * + * Revision 1.61 2007/04/15 16:39:21 fabiankeil + * Introduce tags as alternative way to specify which + * actions apply to a request. At the moment tags can be + * created based on client and server headers. + * + * Revision 1.60 2007/03/20 15:16:34 fabiankeil + * Use dedicated header filter actions instead of abusing "filter". + * Replace "filter-client-headers" and "filter-client-headers" + * with "server-header-filter" and "client-header-filter". + * + * Revision 1.59 2007/01/25 13:38:20 fabiankeil + * Freez csp->error_message in sweep(). + * + * Revision 1.58 2006/12/31 14:25:20 fabiankeil + * Fix gcc43 compiler warnings. + * + * Revision 1.57 2006/12/21 12:22:22 fabiankeil + * html_encode filter descriptions. + * + * Have "Ignoring job ..." error messages + * print the filter file name correctly. + * + * Revision 1.56 2006/09/07 10:40:30 fabiankeil + * Turns out trusted referrers above our arbitrary + * limit are downgraded too ordinary trusted URLs. + * Adjusted error message. + * + * Revision 1.55 2006/09/07 10:25:39 fabiankeil + * Fix typo. + * + * Revision 1.54 2006/09/07 10:22:20 fabiankeil + * If too many trusted referrers are used, + * print only one error message instead of logging + * every single trusted referrer above the arbitrary + * limit. + * + * Revision 1.53 2006/08/31 16:25:06 fabiankeil + * Work around a buffer overflow that caused Privoxy to + * segfault if too many trusted referrers were used. Good + * enough for now, but should be replaced with a real + * solution after the next release. + * + * Revision 1.52 2006/07/18 14:48:46 david__schmidt + * Reorganizing the repository: swapping out what was HEAD (the old 3.1 branch) + * with what was really the latest development (the v_3_0_branch branch) + * + * Revision 1.50.2.8 2006/01/30 15:16:25 david__schmidt + * Remove a little residual debugging info + * + * Revision 1.50.2.7 2006/01/29 23:10:56 david__schmidt + * Multiple filter file support + * + * Revision 1.50.2.6 2003/10/24 10:17:54 oes + * Nit: Allowed tabs as separators in filter headings + * + * Revision 1.50.2.5 2003/05/08 15:19:15 oes + * sweep: Made loop structure of sweep step mirror that of mark step + * + * Revision 1.50.2.4 2003/05/06 15:57:12 oes + * Bugfix: Update last_active pointer in sweep() before + * leaving an active client. Closes bugs #724395, #727882 + * + * Revision 1.50.2.3 2002/11/20 17:12:30 oes + * Ooops, forgot one change. + * + * Revision 1.50.2.2 2002/11/20 14:38:15 oes + * Fixed delayed/incomplete freeing of client resources and + * simplified loop structure in sweep. + * Thanks to Oliver Stoeneberg for the hint. + * + * Revision 1.50.2.1 2002/07/26 15:19:24 oes + * - PCRS jobs now chained in order of appearance. Previous + * reverse chaining was counter-intuitive. + * - Changed loglevel of PCRS job compile errors to + * LOG_LEVEL_ERROR + * + * Revision 1.50 2002/04/24 02:12:16 oes + * Jon's multiple AF patch: Sweep now takes care of all AFs + * + * Revision 1.49 2002/04/19 16:53:25 jongfoster + * Optimize away a function call by using an equivalent macro + * + * Revision 1.48 2002/04/05 00:56:09 gliptak + * Correcting typo to clean up on realloc failure + * + * Revision 1.47 2002/03/26 22:29:55 swa + * we have a new homepage! + * * Revision 1.46 2002/03/24 13:25:43 swa * name change related issues * @@ -281,6 +406,7 @@ const char loaders_rcs[] = "$Id: loaders.c,v 1.46 2002/03/24 13:25:43 swa Exp $" #include "errlog.h" #include "actions.h" #include "urlmatch.h" +#include "encode.h" const char loaders_h_rcs[] = LOADERS_H_VERSION; @@ -293,8 +419,17 @@ const char loaders_h_rcs[] = LOADERS_H_VERSION; static struct file_list *current_trustfile = NULL; #endif /* def FEATURE_TRUST */ -static struct file_list *current_re_filterfile = NULL; +static int load_one_re_filterfile(struct client_state *csp, int fileid); +static struct file_list *current_re_filterfile[MAX_AF_FILES] = { + NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL +}; + +/* + * Pseudo filter type for load_one_re_filterfile + */ +#define NO_NEW_FILTER -1 /********************************************************************* @@ -318,13 +453,15 @@ static struct file_list *current_re_filterfile = NULL; * * Parameters : None * - * Returns : N/A + * Returns : The number of threads that are still active. * *********************************************************************/ -void sweep(void) +unsigned int sweep(void) { struct file_list *fl, *nfl; - struct client_state *csp, *ncsp; + struct client_state *csp, *last_active; + int i; + unsigned int active_threads = 0; /* clear all of the file's active flags */ for ( fl = files->next; NULL != fl; fl = fl->next ) @@ -332,92 +469,121 @@ void sweep(void) fl->active = 0; } - for (csp = clients; csp && (NULL != (ncsp = csp->next)) ; csp = csp->next) + last_active = clients; + csp = clients->next; + + while (NULL != csp) { - if (ncsp->flags & CSP_FLAG_ACTIVE) + if (csp->flags & CSP_FLAG_ACTIVE) { - /* mark this client's files as active */ + /* Mark this client's files as active */ /* * Always have a configuration file. * (Also note the slightly non-standard extra * indirection here.) */ - ncsp->config->config_file_list->active = 1; + csp->config->config_file_list->active = 1; - if (ncsp->actions_list) /* actions files */ + /* + * Actions files + */ + for (i = 0; i < MAX_AF_FILES; i++) { - ncsp->actions_list->active = 1; + if (csp->actions_list[i]) + { + csp->actions_list[i]->active = 1; + } } - if (ncsp->rlist) /* pcrsjob files */ + /* + * Filter files + */ + for (i = 0; i < MAX_AF_FILES; i++) { - ncsp->rlist->active = 1; + if (csp->rlist[i]) + { + csp->rlist[i]->active = 1; + } } + /* + * Trust file + */ #ifdef FEATURE_TRUST - if (ncsp->tlist) /* trust files */ + if (csp->tlist) { - ncsp->tlist->active = 1; + csp->tlist->active = 1; } #endif /* def FEATURE_TRUST */ + active_threads++; + + last_active = csp; + csp = csp->next; } - else + else /* - * this client is not active, release its resources - * and the ones of all inactive clients that might - * follow it + * This client is not active. Free its resources. */ { - while (!(ncsp->flags & CSP_FLAG_ACTIVE)) - { - csp->next = ncsp->next; + last_active->next = csp->next; - freez(ncsp->ip_addr_str); - freez(ncsp->my_ip_addr_str); - freez(ncsp->my_hostname); - freez(ncsp->x_forwarded); - freez(ncsp->iob->buf); + freez(csp->ip_addr_str); + freez(csp->iob->buf); + freez(csp->error_message); - free_http_request(ncsp->http); + if (csp->action->flags & ACTION_FORWARD_OVERRIDE && + NULL != csp->fwd) + { + unload_forward_spec(csp->fwd); + } + free_http_request(csp->http); - destroy_list(ncsp->headers); - destroy_list(ncsp->cookie_list); + destroy_list(csp->headers); + destroy_list(csp->tags); - free_current_action(ncsp->action); + free_current_action(csp->action); #ifdef FEATURE_STATISTICS - urls_read++; - if (ncsp->flags & CSP_FLAG_REJECTED) - { - urls_rejected++; - } + urls_read++; + if (csp->flags & CSP_FLAG_REJECTED) + { + urls_rejected++; + } #endif /* def FEATURE_STATISTICS */ - freez(ncsp); - - /* are there any more in sequence after it? */ - if( (ncsp = csp->next) == NULL) - break; - } + freez(csp); + + csp = last_active->next; } } - for (fl = files; fl && ((nfl = fl->next) != NULL) ; fl = fl->next) + nfl = files; + fl = files->next; + + while (fl != NULL) { - if ( ( 0 == nfl->active ) && ( NULL != nfl->unloader ) ) + if ( ( 0 == fl->active ) && ( NULL != fl->unloader ) ) { - fl->next = nfl->next; + nfl->next = fl->next; - (nfl->unloader)(nfl->f); + (fl->unloader)(fl->f); - freez(nfl->filename); + freez(fl->filename); + freez(fl); - freez(nfl); + fl = nfl->next; + } + else + { + nfl = fl; + fl = fl->next; } } + return active_threads; + } @@ -476,6 +642,7 @@ int check_file_changed(const struct file_list * current, return 1; } + fs->filename = strdup(filename); fs->lastmodified = statbuf->st_mtime; @@ -543,7 +710,7 @@ jb_err simple_read_line(FILE *fp, char **dest, int *newline) for (;;) { - ch = fgetc(fp); + ch = getc(fp); if (ch == EOF) { if (len > 0) @@ -605,12 +772,12 @@ jb_err simple_read_line(FILE *fp, char **dest, int *newline) return JB_ERR_OK; } - *p++ = ch; + *p++ = (char)ch; if (++len >= buflen) { buflen += BUFFER_SIZE; - if (NULL == (p = realloc(buf, buflen))); + if (NULL == (p = realloc(buf, buflen))) { free(buf); return JB_ERR_MEMORY; @@ -717,30 +884,30 @@ jb_err edit_read_line(FILE *fp, if (raw_out) { - if ((raw = malloc(1)) == NULL) + raw = strdup(""); + if (NULL == raw) { return JB_ERR_MEMORY; } - *raw = '\0'; } if (prefix_out) { - if ((prefix = malloc(1)) == NULL) + prefix = strdup(""); + if (NULL == prefix) { freez(raw); return JB_ERR_MEMORY; } - *prefix = '\0'; } if (data_out) { - if ((data = malloc(1)) == NULL) + data = strdup(""); + if (NULL == data) { freez(raw); freez(prefix); return JB_ERR_MEMORY; } - *data = '\0'; } /* Main loop. Loop while we need more data & it's not EOF. */ @@ -774,6 +941,7 @@ jb_err edit_read_line(FILE *fp, /* Trim leading spaces if we're at the start of the line */ linestart = linebuf; + assert(NULL != data); if (*data == '\0') { /* Trim leading spaces */ @@ -1024,6 +1192,7 @@ int load_trustfile(struct client_state *csp) int reject, trusted; struct file_list *fs; unsigned long linenum = 0; + int trusted_referrers = 0; if (!check_file_changed(current_trustfile, csp->config->trustfile, &fs)) { @@ -1105,11 +1274,24 @@ int load_trustfile(struct client_state *csp) */ if (trusted) { - *tl++ = b->url; - /* FIXME BUFFER OVERFLOW if >=64 entries */ + if(++trusted_referrers < MAX_TRUSTED_REFERRERS) + { + *tl++ = b->url; + } } } + if(trusted_referrers >= MAX_TRUSTED_REFERRERS) + { + /* + * FIXME: ... after Privoxy 3.0.4 is out. + */ + log_error(LOG_LEVEL_ERROR, "Too many trusted referrers. Current limit is %d, you are using %d.\n" + " Additional trusted referrers are treated like ordinary trusted URLs.\n" + " (You can increase this limit by changing MAX_TRUSTED_REFERRERS in project.h and recompiling).", + MAX_TRUSTED_REFERRERS, trusted_referrers); + } + *tl = NULL; fclose(fp); @@ -1173,6 +1355,30 @@ static void unload_re_filterfile(void *f) return; } +/********************************************************************* + * + * Function : unload_forward_spec + * + * Description : Unload the forward spec settings by freeing all + * memory referenced by members and the memory for + * the spec itself. + * + * Parameters : + * 1 : fwd = the forward spec. + * + * Returns : N/A + * + *********************************************************************/ +void unload_forward_spec(struct forward_spec *fwd) +{ + free_url_spec(fwd->url); + freez(fwd->gateway_host); + freez(fwd->forward_host); + free(fwd); + + return; +} + #ifdef FEATURE_GRACEFUL_TERMINATION /********************************************************************* @@ -1189,10 +1395,15 @@ static void unload_re_filterfile(void *f) *********************************************************************/ void unload_current_re_filterfile(void) { - if (current_re_filterfile) + int i; + + for (i = 0; i < MAX_AF_FILES; i++) { - current_re_filterfile->unloader = unload_re_filterfile; - current_re_filterfile = NULL; + if (current_re_filterfile[i]) + { + current_re_filterfile[i]->unloader = unload_re_filterfile; + current_re_filterfile[i] = NULL; + } } } #endif @@ -1200,9 +1411,50 @@ void unload_current_re_filterfile(void) /********************************************************************* * - * Function : load_re_filterfile + * Function : load_re_filterfiles + * + * Description : Loads all the filterfiles. + * 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...) + * + * Returns : 0 => Ok, everything else is an error. + * + *********************************************************************/ +int load_re_filterfiles(struct client_state *csp) +{ + int i; + int result; + + for (i = 0; i < MAX_AF_FILES; i++) + { + if (csp->config->re_filterfile[i]) + { + result = load_one_re_filterfile(csp, i); + if (result) + { + return result; + } + } + else if (current_re_filterfile[i]) + { + current_re_filterfile[i]->unloader = unload_re_filterfile; + current_re_filterfile[i] = NULL; + } + } + + return 0; +} + + +/********************************************************************* + * + * Function : load_one_re_filterfile * - * Description : Load the re_filterfile. + * Description : Load a 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. @@ -1213,7 +1465,7 @@ void unload_current_re_filterfile(void) * Returns : 0 => Ok, everything else is an error. * *********************************************************************/ -int load_re_filterfile(struct client_state *csp) +int load_one_re_filterfile(struct client_state *csp, int fileid) { FILE *fp; @@ -1223,16 +1475,16 @@ int load_re_filterfile(struct client_state *csp) char buf[BUFFER_SIZE]; int error; unsigned long linenum = 0; - pcrs_job *dummy; + pcrs_job *dummy, *lastjob = NULL; /* * No need to reload if unchanged */ - if (!check_file_changed(current_re_filterfile, csp->config->re_filterfile, &fs)) + if (!check_file_changed(current_re_filterfile[fileid], csp->config->re_filterfile[fileid], &fs)) { if (csp) { - csp->rlist = current_re_filterfile; + csp->rlist[fileid] = current_re_filterfile[fileid]; } return(0); } @@ -1244,7 +1496,7 @@ int load_re_filterfile(struct client_state *csp) /* * Open the file or fail */ - if ((fp = fopen(csp->config->re_filterfile, "r")) == NULL) + if ((fp = fopen(csp->config->re_filterfile[fileid], "r")) == NULL) { goto load_re_filterfile_error; } @@ -1254,24 +1506,62 @@ int load_re_filterfile(struct client_state *csp) */ while (read_config_line(buf, sizeof(buf), fp, &linenum) != NULL) { + int new_filter = NO_NEW_FILTER; + + if (strncmp(buf, "FILTER:", 7) == 0) + { + new_filter = FT_CONTENT_FILTER; + } + else if (strncmp(buf, "SERVER-HEADER-FILTER:", 21) == 0) + { + new_filter = FT_SERVER_HEADER_FILTER; + } + else if (strncmp(buf, "CLIENT-HEADER-FILTER:", 21) == 0) + { + new_filter = FT_CLIENT_HEADER_FILTER; + } + else if (strncmp(buf, "CLIENT-HEADER-TAGGER:", 21) == 0) + { + new_filter = FT_CLIENT_HEADER_TAGGER; + } + else if (strncmp(buf, "SERVER-HEADER-TAGGER:", 21) == 0) + { + new_filter = FT_SERVER_HEADER_TAGGER; + } + /* * 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) + if (new_filter != NO_NEW_FILTER) { new_bl = (struct re_filterfile_spec *)zalloc(sizeof(*bl)); if (new_bl == NULL) { goto load_re_filterfile_error; } + if (new_filter == FT_CONTENT_FILTER) + { + new_bl->name = chomp(buf + 7); + } + else + { + new_bl->name = chomp(buf + 21); + } + new_bl->type = new_filter; - new_bl->name = chomp(buf + 7); - - if (NULL != (new_bl->description = strchr(new_bl->name, ' '))) + /* + * If a filter description is available, + * encode it to HTML and save it. + */ + if (NULL != (new_bl->description = strpbrk(new_bl->name, " \t"))) { *new_bl->description++ = '\0'; - new_bl->description = strdup(chomp(new_bl->description)); + new_bl->description = html_encode(chomp(new_bl->description)); + if (NULL == new_bl->description) + { + new_bl->description = strdup("Out of memory while encoding this filter's description to HTML"); + } } else { @@ -1291,6 +1581,7 @@ int load_re_filterfile(struct client_state *csp) } else { + assert(NULL != bl); bl->next = new_bl; } bl = new_bl; @@ -1306,24 +1597,66 @@ int load_re_filterfile(struct client_state *csp) */ if (bl != NULL) { - enlist(bl->patterns, buf); + error = enlist(bl->patterns, buf); + if (JB_ERR_MEMORY == error) + { + log_error(LOG_LEVEL_FATAL, + "Out of memory while enlisting re_filter job \'%s\' for filter %s.", buf, bl->name); + } + assert(JB_ERR_OK == error); - if ((dummy = pcrs_compile_command(buf, &error)) == NULL) + if (pcrs_job_is_dynamic(buf)) + { + /* + * Dynamic pattern that might contain variables + * and has to be recompiled for every request + */ + if (bl->joblist != NULL) + { + pcrs_free_joblist(bl->joblist); + bl->joblist = NULL; + } + bl->dynamic = 1; + log_error(LOG_LEVEL_RE_FILTER, + "Adding dynamic re_filter job \'%s\' to filter %s succeeded.", buf, bl->name); + continue; + } + else if (bl->dynamic) { + /* + * A previous job was dynamic and as we + * recompile the whole filter anyway, it + * makes no sense to compile this job now. + */ log_error(LOG_LEVEL_RE_FILTER, - "Adding re_filter job %s to filter %s failed with error %d.", buf, bl->name, error); + "Adding static re_filter job \'%s\' to dynamic filter %s succeeded.", buf, bl->name); + continue; + } + + if ((dummy = pcrs_compile_command(buf, &error)) == NULL) + { + log_error(LOG_LEVEL_ERROR, + "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); + if (bl->joblist == NULL) + { + bl->joblist = dummy; + } + else if (NULL != lastjob) + { + lastjob->next = dummy; + } + lastjob = dummy; + log_error(LOG_LEVEL_RE_FILTER, "Adding re_filter job \'%s\' to filter %s succeeded.", buf, bl->name); } } else { - log_error(LOG_LEVEL_ERROR, "Ignoring job %s outside filter block in %s, line %d", buf, csp->config->re_filterfile, linenum); + log_error(LOG_LEVEL_ERROR, "Ignoring job %s outside filter block in %s, line %d", + buf, csp->config->re_filterfile[fileid], linenum); } } @@ -1332,9 +1665,9 @@ int load_re_filterfile(struct client_state *csp) /* * Schedule the now-obsolete old data for unloading */ - if ( NULL != current_re_filterfile ) + if ( NULL != current_re_filterfile[fileid] ) { - current_re_filterfile->unloader = unload_re_filterfile; + current_re_filterfile[fileid]->unloader = unload_re_filterfile; } /* @@ -1342,18 +1675,18 @@ int load_re_filterfile(struct client_state *csp) */ fs->next = files->next; files->next = fs; - current_re_filterfile = fs; + current_re_filterfile[fileid] = fs; if (csp) { - csp->rlist = fs; + csp->rlist[fileid] = fs; } return( 0 ); load_re_filterfile_error: log_error(LOG_LEVEL_FATAL, "can't load re_filterfile '%s': %E", - csp->config->re_filterfile); + csp->config->re_filterfile[fileid]); return(-1); }