X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=filters.c;h=e30a24c835110339f47831548b07972b853cf279;hp=d6965cb913d505ea891de75b43e8d84167553161;hb=9020dc00a095952008d4775f5fafc382e85022b9;hpb=d413f089844873c5d88bb1580357124b45fab66c diff --git a/filters.c b/filters.c index d6965cb9..e30a24c8 100644 --- a/filters.c +++ b/filters.c @@ -1,4 +1,4 @@ -const char filters_rcs[] = "$Id: filters.c,v 1.16 2001/06/07 23:10:26 jongfoster Exp $"; +const char filters_rcs[] = "$Id: filters.c,v 1.35 2001/10/07 15:41:23 oes Exp $"; /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/filters.c,v $ @@ -8,7 +8,7 @@ const char filters_rcs[] = "$Id: filters.c,v 1.16 2001/06/07 23:10:26 jongfoster * `acl_addr', `add_stats', `block_acl', `block_imageurl', * `block_url', `url_actions', `domaincmp', `dsplit', * `filter_popups', `forward_url', 'redirect_url', - * `ij_untrusted_url', `intercept_url', `re_process_buffer', + * `ij_untrusted_url', `intercept_url', `pcrs_filter_respose', * `show_proxy_args', 'ijb_send_banner', and `trust_url' * * Copyright : Written by and Copyright (C) 2001 the SourceForge @@ -38,6 +38,118 @@ const char filters_rcs[] = "$Id: filters.c,v 1.16 2001/06/07 23:10:26 jongfoster * * Revisions : * $Log: filters.c,v $ + * Revision 1.35 2001/10/07 15:41:23 oes + * Replaced 6 boolean members of csp with one bitmap (csp->flags) + * + * New function remove_chunked_transfer_coding that strips chunked + * transfer coding to plain and is called by pcrs_filter_response + * and gif_deanimate_response if neccessary + * + * Improved handling of zero-change re_filter runs + * + * pcrs_filter_response and gif_deanimate_response now remove + * chunked transfer codeing before processing the body. + * + * Revision 1.34 2001/09/20 15:49:36 steudten + * + * Fix BUG: Change int size to size_t size in pcrs_filter_response(). + * See cgi.c fill_template(). + * + * Revision 1.33 2001/09/16 17:05:14 jongfoster + * Removing unused #include showarg.h + * + * Revision 1.32 2001/09/16 13:21:27 jongfoster + * Changes to use new list functions. + * + * Revision 1.31 2001/09/16 11:38:02 jongfoster + * Splitting fill_template() into 2 functions: + * template_load() loads the file + * template_fill() performs the PCRS regexps. + * This is because the CGI edit interface has a "table row" + * template which is used many times in the page - this + * change means it's only loaded from disk once. + * + * Revision 1.30 2001/09/16 11:00:10 jongfoster + * New function alloc_http_response, for symmetry with free_http_response + * + * Revision 1.29 2001/09/13 23:32:40 jongfoster + * Moving image data to cgi.c rather than cgi.h + * Fixing a GPF under Win32 (and any other OS that protects global + * constants from being written to). + * + * Revision 1.28 2001/09/10 10:18:51 oes + * Silenced compiler warnings + * + * Revision 1.27 2001/08/05 16:06:20 jongfoster + * Modifiying "struct map" so that there are now separate header and + * "map_entry" structures. This means that functions which modify a + * map no longer need to return a pointer to the modified map. + * Also, it no longer reverses the order of the entries (which may be + * important with some advanced template substitutions). + * + * Revision 1.26 2001/07/30 22:08:36 jongfoster + * Tidying up #defines: + * - All feature #defines are now of the form FEATURE_xxx + * - Permanently turned off WIN_GUI_EDIT + * - Permanently turned on WEBDAV and SPLIT_PROXY_ARGS + * + * Revision 1.25 2001/07/26 10:09:46 oes + * Made browser detection a little less naive + * + * Revision 1.24 2001/07/25 17:22:51 oes + * Added workaround for Netscape bug that prevents display of page when loading a component fails. + * + * Revision 1.23 2001/07/23 13:40:12 oes + * Fixed bug that caused document body to be dropped when pcrs joblist was empty. + * + * Revision 1.22 2001/07/18 12:29:34 oes + * - Made gif_deanimate_response respect + * csp->action->string[ACTION_STRING_DEANIMATE] + * - Logging cosmetics + * + * Revision 1.21 2001/07/13 13:59:53 oes + * - Introduced gif_deanimate_response which shares the + * generic content modification interface of pcrs_filter_response + * and acts as a wrapper to deanimate.c:gif_deanimate() + * - Renamed re_process_buffer to pcrs_filter_response + * - pcrs_filter_response now returns NULL on failiure + * - Removed all #ifdef PCRS + * + * Revision 1.20 2001/07/01 17:01:04 oes + * Added comments and missing return statement in is_untrusted_url() + * + * Revision 1.19 2001/06/29 21:45:41 oes + * Indentation, CRLF->LF, Tab-> Space + * + * Revision 1.18 2001/06/29 13:27:38 oes + * - Cleaned up, renamed and reorderd functions + * and improved comments + * + * - block_url: + * - Ported to CGI platform. Now delivers + * http_response or NULL + * - Unified HTML and GIF generation (moved image detection + * and GIF generation here from jcc.c:chat()) + * - Fixed HTTP status to: + * - 403 (Forbidden) for the "blocked" HTML message + * - 200 (OK) for GIF answers + * - 302 (Redirect) for redirect to GIF + * + * - trust_url: + * - Ported to CGI platform. Now delivers + * http_response or NULL + * - Separated detection of untrusted URL into + * (bool)is_untrusted_url + * - Added enforcement of untrusted requests + * + * - Moved redirect_url() from cgi.c to here + * and ported it to the CGI platform + * + * - Removed logentry from cancelled commit + * + * Revision 1.17 2001/06/09 10:55:28 jongfoster + * Changing BUFSIZ ==> BUFFER_SIZE + * * Revision 1.16 2001/06/07 23:10:26 jongfoster * Allowing unanchored domain patterns to back off and retry * if they partially match. Optimized right-anchored patterns. @@ -47,60 +159,6 @@ const char filters_rcs[] = "$Id: filters.c,v 1.16 2001/06/07 23:10:26 jongfoster * Revision 1.15 2001/06/03 19:12:00 oes * extracted-CGI relevant stuff * - * Revision 1.15 2001/06/03 11:03:48 oes - * Makefile/in - * - * introduced cgi.c - * - * actions.c: - * - * adapted to new enlist_unique arg format - * - * conf loadcfg.c - * - * introduced confdir option - * - * filters.c filtrers.h - * - * extracted-CGI relevant stuff - * - * jbsockets.c - * - * filled comment - * - * jcc.c - * - * support for new cgi mechansim - * - * list.c list.h - * - * functions for new list type: "map" - * extended enlist_unique - * - * miscutil.c .h - * introduced bindup() - * - * parsers.c parsers.h - * - * deleted const struct interceptors - * - * pcrs.c - * added FIXME - * - * project.h - * - * added struct map - * added struct http_response - * changes struct interceptors to struct cgi_dispatcher - * moved HTML stuff to cgi.h - * - * re_filterfile: - * - * changed - * - * showargs.c - * NO TIME LEFT - * * Revision 1.14 2001/06/01 10:30:55 oes * Added optional left-anchoring to domaincmp * @@ -245,6 +303,7 @@ const char filters_rcs[] = "$Id: filters.c,v 1.16 2001/06/07 23:10:26 jongfoster #include #include #include +#include #ifndef _WIN32 #include @@ -256,17 +315,15 @@ const char filters_rcs[] = "$Id: filters.c,v 1.16 2001/06/07 23:10:26 jongfoster #include "project.h" #include "filters.h" #include "encode.h" -#include "jcc.h" -#include "showargs.h" #include "parsers.h" #include "ssplit.h" -#include "gateway.h" -#include "jbsockets.h" #include "errlog.h" #include "jbsockets.h" #include "miscutil.h" #include "actions.h" #include "cgi.h" +#include "list.h" +#include "deanimate.h" #ifdef _WIN32 #include "win32.h" @@ -284,7 +341,7 @@ const char filters_h_rcs[] = FILTERS_H_VERSION; #define ijb_isdigit(__X) isdigit((int)(unsigned char)(__X)) -#ifdef ACL_FILES +#ifdef FEATURE_ACL /********************************************************************* * * Function : block_acl @@ -301,8 +358,7 @@ const char filters_h_rcs[] = FILTERS_H_VERSION; * Returns : 0 = FALSE (don't block) and 1 = TRUE (do block) * *********************************************************************/ -int block_acl(struct access_control_addr *dst, - struct client_state *csp) +int block_acl(struct access_control_addr *dst, struct client_state *csp) { struct access_control_list *acl = csp->config->acl; @@ -419,7 +475,87 @@ int acl_addr(char *aspec, struct access_control_addr *aca) return(0); } -#endif /* def ACL_FILES */ +#endif /* def FEATURE_ACL */ + + +/********************************************************************* + * + * Function : match_portlist + * + * Description : Check if a given number is covered by a comma + * separated list of numbers and ranges (a,b-c,d,..) + * + * Parameters : + * 1 : portlist = String with list + * 2 : port = port to check + * + * Returns : 0 => no match + * 1 => match + * + *********************************************************************/ +int match_portlist(const char *portlist, int port) +{ + char *min, *max, *next, *portlist_copy; + + min = next = portlist_copy = strdup(portlist); + + /* + * Zero-terminate first item and remember offset for next + */ + if (NULL != (next = strchr(portlist_copy, (int) ','))) + { + *next++ = '\0'; + } + + /* + * Loop through all items, checking for match + */ + while(min) + { + if (NULL == (max = strchr(min, (int) '-'))) + { + /* + * No dash, check for equality + */ + if (port == atoi(min)) + { + free(portlist_copy); + return(1); + } + } + else + { + /* + * This is a range, so check if between min and max, + * or, if max was omitted, between min and 65K + */ + *max++ = '\0'; + if(port >= atoi(min) && port <= (atoi(max) ? atoi(max) : 65535)) + { + free(portlist_copy); + return(1); + } + + } + + /* + * Jump to next item + */ + min = next; + + /* + * Zero-terminate next item and remember offset for n+1 + */ + if ((NULL != next) && (NULL != (next = strchr(next, (int) ',')))) + { + *next++ = '\0'; + } + } + + free(portlist_copy); + return 0; + +} /********************************************************************* @@ -429,65 +565,300 @@ int acl_addr(char *aspec, struct access_control_addr *aca) * Description : Called from `chat'. Check to see if we need to block this. * * Parameters : - * 1 : http = http_request request to "check" for blocked - * 2 : csp = Current client state (buffers, headers, etc...) + * 1 : csp = Current client state (buffers, headers, etc...) * - * Returns : NULL => unblocked, else string to HTML block description. + * Returns : NULL => unblocked, else HTTP block response * *********************************************************************/ -char *block_url(struct http_request *http, struct client_state *csp) +struct http_response *block_url(struct client_state *csp) { +#ifdef FEATURE_IMAGE_BLOCKING char *p; - int n; - int factor = 2; +#endif /* def FEATURE_IMAGE_BLOCKING */ + struct http_response *rsp; + /* + * If it's not blocked, don't block it ;-) + */ if ((csp->action->flags & ACTION_BLOCK) == 0) { return(NULL); } + + /* + * Else, prepare a response + */ + if (NULL == (rsp = alloc_http_response())) + { + return NULL; + } + + /* + * If it's an image-url, send back an image or redirect + * as specified by the relevant +image action + */ +#ifdef FEATURE_IMAGE_BLOCKING + if (((csp->action->flags & ACTION_IMAGE_BLOCKER) != 0) + && is_imageurl(csp)) + { + /* determine HOW images should be blocked */ + p = csp->action->string[ACTION_STRING_IMAGE_BLOCKER]; + + /* and handle accordingly: */ + if ((p == NULL) || (0 == strcmpic(p, "logo"))) + { + rsp->body = bindup(image_junkbuster_gif_data, image_junkbuster_gif_length); + rsp->content_length = image_junkbuster_gif_length; + enlist_unique_header(rsp->headers, "Content-Type", "image/gif"); + } + + else if (0 == strcmpic(p, "blank")) + { + rsp->body = bindup(image_blank_gif_data, image_blank_gif_length); + rsp->content_length = image_blank_gif_length; + enlist_unique_header(rsp->headers, "Content-Type", "image/gif"); + } + + else + { + rsp->status = strdup("302 Local Redirect from Junkbuster"); + enlist_unique_header(rsp->headers, "Location", p); + } + } else +#endif /* def FEATURE_IMAGE_BLOCKING */ + + /* + * Else, generate an HTML "blocked" message: + */ { -#ifdef FORCE_LOAD - factor++; -#endif /* def FORCE_LOAD */ + struct map * exports = default_exports(csp, NULL); +#ifdef FEATURE_FORCE_LOAD + map(exports, "force-prefix", 1, FORCE_PREFIX, 1); +#else /* ifndef FEATURE_FORCE_LOAD */ + map_block_killer(exports, "force-support"); +#endif /* ndef FEATURE_FORCE_LOAD */ + + map(exports, "hostport", 1, csp->http->hostport, 1); + map(exports, "hostport-html", 1, html_encode(csp->http->hostport), 0); + map(exports, "path", 1, csp->http->path, 1); + map(exports, "path-html", 1, html_encode(csp->http->path), 0); + + rsp->body = template_load(csp, "blocked"); + template_fill(&rsp->body, exports); + free_map(exports); + + /* + * Workaround for stupid Netscape bug which prevents + * pages from being displayed if loading a referenced + * JavaScript or style sheet fails. So make it appear + * as if it succeeded. + */ + if (csp->http->user_agent + && !strncmpic(csp->http->user_agent, "mozilla", 7) + && !strstr(csp->http->user_agent, "compatible") + && !strstr(csp->http->user_agent, "Opera")) + { + rsp->status = strdup("200 Request for blocked URL"); + } + else + { + rsp->status = strdup("404 Request for blocked URL"); + } - n = strlen(CBLOCK); - n += factor * strlen(http->hostport); - n += factor * strlen(http->path); + } - p = (char *)malloc(n); + return(finish_http_response(rsp)); -#ifdef FORCE_LOAD - sprintf(p, CBLOCK, http->hostport, http->path, http->hostport, http->path, - http->hostport, http->path); -#else - sprintf(p, CBLOCK, http->hostport, http->path, http->hostport, http->path); -#endif /* def FORCE_LOAD */ +} - return(p); + +#ifdef FEATURE_TRUST +/********************************************************************* + * + * Function : trust_url FIXME: I should be called distrust_url + * + * Description : Calls is_untrusted_url to determine if the URL is trusted + * and if not, returns a HTTP 304 response with a reject message. + * + * Parameters : + * 1 : csp = Current client state (buffers, headers, etc...) + * + * Returns : NULL => trusted, else http_response. + * + *********************************************************************/ +struct http_response *trust_url(struct client_state *csp) +{ + struct http_response *rsp; + struct map * exports; + char buf[BUFFER_SIZE], *p = NULL; + struct url_spec **tl, *t; + + /* + * Don't bother to work on trusted URLs + */ + if (!is_untrusted_url(csp)) + { + return NULL; + } + + /* + * Else, prepare a response: + */ + if (NULL == (rsp = alloc_http_response())) + { + return NULL; } + + exports = default_exports(csp, NULL); + + /* + * Export the host, port, and referrer information + */ + map(exports, "hostport", 1, csp->http->hostport, 1); + map(exports, "path", 1, csp->http->path, 1); + map(exports, "hostport-html", 1, html_encode(csp->http->hostport), 0); + map(exports, "path-html", 1, html_encode(csp->http->path), 0); + + if (csp->referrer && strlen(csp->referrer) > 9) + { + map(exports, "referrer", 1, csp->referrer + 9, 1); + map(exports, "referrer-html", 1, html_encode(csp->referrer + 9), 0); + } + else + { + map(exports, "referrer", 1, "unknown", 1); + map(exports, "referrer-html", 1, "unknown", 1); + } + + /* + * Export the trust list + */ + for (tl = csp->config->trust_list; (t = *tl) ; tl++) + { + sprintf(buf, "
  • %s
    • \n", t->spec); + p = strsav(p, buf); + } + map(exports, "trusted-referrers", 1, p, 0); + p = NULL; + + /* + * Export the trust info, if available + */ + if (csp->config->trust_info->first) + { + struct list_entry *l; + + for (l = csp->config->trust_info->first; l ; l = l->next) + { + sprintf(buf, "
  • %s
    \n",l->str, l->str); + p = strsav(p, buf); + } + map(exports, "trust-info", 1, p, 0); + } + else + { + map_block_killer(exports, "have-trust-info"); + } + + /* + * Export the force prefix or the force conditional block killer + */ +#ifdef FEATURE_FORCE_LOAD + map(exports, "force-prefix", 1, FORCE_PREFIX, 1); +#else /* ifndef FEATURE_FORCE_LOAD */ + map_block_killer(exports, "force-support"); +#endif /* ndef FEATURE_FORCE_LOAD */ + + /* + * Build the response + */ + rsp->body = template_load(csp, "untrusted"); + template_fill(&rsp->body, exports); + free_map(exports); + + return(finish_http_response(rsp)); + } +#endif /* def FEATURE_TRUST */ -#ifdef IMAGE_BLOCKING +#ifdef FEATURE_FAST_REDIRECTS /********************************************************************* * - * Function : block_imageurl + * Function : redirect_url * - * Description : Given a URL which is blocked, decide whether to - * send the "blocked" image or HTML. + * Description : Checks for redirection URLs and returns a HTTP redirect + * to the destination URL, if necessary * * Parameters : - * 1 : http = URL to check. - * 2 : csp = Current client state (buffers, headers, etc...) + * 1 : csp = Current client state (buffers, headers, etc...) * - * Returns : True (nonzero) if URL is in image list, false (0) + * Returns : NULL if URL was clean, HTTP redirect otherwise. + * + *********************************************************************/ +struct http_response *redirect_url(struct client_state *csp) +{ + char *p, *q; + struct http_response *rsp; + + p = q = csp->http->path; + log_error(LOG_LEVEL_REDIRECTS, "checking path for redirects: %s", p); + + /* + * find the last URL encoded in the request + */ + while ((p = strstr(p, "http://"))) + { + q = p++; + } + + /* + * if there was any, generate and return a HTTP redirect + */ + if (q != csp->http->path) + { + log_error(LOG_LEVEL_REDIRECTS, "redirecting to: %s", q); + + if (NULL == (rsp = alloc_http_response())) + { + return NULL; + } + + rsp->status = strdup("302 Local Redirect from Junkbuster"); + enlist_unique_header(rsp->headers, "Location", q); + + return(finish_http_response(rsp)); + } + else + { + return(NULL); + } + +} +#endif /* def FEATURE_FAST_REDIRECTS */ + + +#ifdef FEATURE_IMAGE_BLOCKING +/********************************************************************* + * + * Function : is_imageurl + * + * Description : Given a URL, decide whether it is an image or not, + * using either the info from a previous +image action + * or, #ifdef FEATURE_IMAGE_DETECT_MSIE, the info from + * the browser's accept header. + * + * Parameters : + * 1 : csp = Current client state (buffers, headers, etc...) + * + * Returns : True (nonzero) if URL is an image, false (0) * otherwise * *********************************************************************/ -int block_imageurl(struct http_request *http, struct client_state *csp) +int is_imageurl(struct client_state *csp) { -#ifdef DETECT_MSIE_IMAGES +#ifdef FEATURE_IMAGE_DETECT_MSIE if ((csp->accept_types & (ACCEPT_TYPE_IS_MSIE|ACCEPT_TYPE_MSIE_IMAGE|ACCEPT_TYPE_MSIE_HTML)) == (ACCEPT_TYPE_IS_MSIE|ACCEPT_TYPE_MSIE_IMAGE)) @@ -500,94 +871,79 @@ int block_imageurl(struct http_request *http, struct client_state *csp) { return 0; } -#endif +#endif /* def FEATURE_IMAGE_DETECT_MSIE */ return ((csp->action->flags & ACTION_IMAGE) != 0); + } -#endif /* def IMAGE_BLOCKING */ +#endif /* def FEATURE_IMAGE_BLOCKING */ -#ifdef TRUST_FILES +#ifdef FEATURE_COOKIE_JAR /********************************************************************* * - * Function : trust_url + * Function : is_untrusted_url * - * Description : Should we "trust" this URL? See "trustfile" line in config. + * Description : Should we "distrust" this URL (and block it)? + * + * Yes if it matches a line in the trustfile, or if the + * referrer matches a line starting with "+" in the + * trustfile. + * No otherwise. * * Parameters : - * 1 : http = http_request request for requested URL - * 2 : csp = Current client state (buffers, headers, etc...) + * 1 : csp = Current client state (buffers, headers, etc...) * - * Returns : NULL => trusted, else string to HTML "untrusted" description. + * Returns : 0 => trusted, 1 => untrusted * *********************************************************************/ -char *trust_url(struct http_request *http, struct client_state *csp) +int is_untrusted_url(struct client_state *csp) { struct file_list *fl; struct block_spec *b; struct url_spec url[1], **tl, *t; - char *p, *h; - char *hostport, *path, *refer; struct http_request rhttp[1]; - int n; + char *p, *h; + /* + * If we don't have a trustlist, we trust everybody + */ if (((fl = csp->tlist) == NULL) || ((b = fl->f) == NULL)) { - return(NULL); + return(0); } - *url = dsplit(http->host); + + /* + * Do we trust the request URL itself? + */ + *url = dsplit(csp->http->host); /* if splitting the domain fails, punt */ - if (url->dbuf == NULL) return(NULL); + if (url->dbuf == NULL) return(0); memset(rhttp, '\0', sizeof(*rhttp)); for (b = b->next; b ; b = b->next) { - if ((b->url->port == 0) || (b->url->port == http->port)) + if ((b->url->port == 0) || (b->url->port == csp->http->port)) { if ((b->url->domain[0] == '\0') || (domaincmp(b->url, url) == 0)) { if ((b->url->path == NULL) || #ifdef REGEX - (regexec(b->url->preg, http->path, 0, NULL, 0) == 0) + (regexec(b->url->preg, csp->http->path, 0, NULL, 0) == 0) #else - (strncmp(b->url->path, http->path, b->url->pathlen) == 0) + (strncmp(b->url->path, csp->http->path, b->url->pathlen) == 0) #endif ) { freez(url->dbuf); freez(url->dvec); - if (b->reject == 0) return(NULL); + if (b->reject == 0) return(0); - hostport = url_encode(http->hostport); - path = url_encode(http->path); - - if (csp->referrer) - { - refer = url_encode(csp->referrer); - } - else - { - refer = url_encode("undefined"); - } - - n = strlen(CTRUST); - n += strlen(hostport); - n += strlen(path); - n += strlen(refer); - - p = (char *)malloc(n); - - sprintf(p, CTRUST, hostport, path, refer); - - freez(hostport); - freez(path); - freez(refer); - - return(p); + return(1); } } } @@ -599,7 +955,7 @@ char *trust_url(struct http_request *http, struct client_state *csp) if ((csp->referrer == NULL)|| (strlen(csp->referrer) <= 9)) { /* no referrer was supplied */ - goto trust_url_not_trusted; + return(1); } /* forge a URL from the referrer so we can use @@ -612,19 +968,21 @@ char *trust_url(struct http_request *http, struct client_state *csp) p = strsav(p, " HTTP/1.0"); parse_http_request(p, rhttp, csp); + freez(p); if (rhttp->cmd == NULL) { - freez(p); - goto trust_url_not_trusted; + return(1); } - freez(p); + /* + * If not, do we maybe trust its referrer? + */ *url = dsplit(rhttp->host); /* if splitting the domain fails, punt */ - if (url->dbuf == NULL) goto trust_url_not_trusted; + if (url->dbuf == NULL) return(1); for (tl = csp->config->trust_list; (t = *tl) ; tl++) { @@ -655,9 +1013,9 @@ char *trust_url(struct http_request *http, struct client_state *csp) h = NULL; h = strsav(h, "~"); - h = strsav(h, http->hostport); + h = strsav(h, csp->http->hostport); - p = http->path; + p = csp->http->path; if ((*p++ == '/') && (*p++ == '~')) { @@ -667,118 +1025,242 @@ char *trust_url(struct http_request *http, struct client_state *csp) if ((p = strchr(p, '/'))) { *p = '\0'; - h = strsav(h, http->path); + h = strsav(h, csp->http->path); /* FIXME: p?! */ h = strsav(h, "/"); } } - free_http_request(rhttp); - fprintf(fp, "%s\n", h); freez(h); fclose(fp); } - return(NULL); + return(0); } } } } - -trust_url_not_trusted: - free_http_request(rhttp); - - hostport = url_encode(http->hostport); - path = url_encode(http->path); - - if (csp->referrer) - { - refer = url_encode(csp->referrer); - } - else - { - refer = url_encode("undefined"); - } - - n = strlen(CTRUST); - n += strlen(hostport); - n += strlen(path); - n += strlen(refer); - - p = (char *)malloc(n); - sprintf(p, CTRUST, hostport, path, refer); - - freez(hostport); - freez(path); - freez(refer); - - return(p); - + return(1); } -#endif /* def TRUST_FILES */ +#endif /* def FEATURE_COOKIE_JAR */ -#ifdef PCRS /********************************************************************* * - * Function : re_process_buffer + * Function : pcrs_filter_response * - * Description : Apply all jobs from the joblist (aka. Perl regexp's) to - * the text buffer that's been accumulated in csp->iob->buf - * and set csp->content_length to the modified size. + * Description : Apply all the pcrs jobs from the joblist (re_filterfile) + * to the text buffer that's been accumulated in + * csp->iob->buf and set csp->content_length to the modified + * size and raise the CSP_FLAG_MODIFIED flag if appropriate. * * Parameters : * 1 : csp = Current client state (buffers, headers, etc...) * * Returns : a pointer to the (newly allocated) modified buffer. + * or NULL in case something went wrong * - * *********************************************************************/ -char *re_process_buffer(struct client_state *csp) +char *pcrs_filter_response(struct client_state *csp) { int hits=0; - int size = csp->iob->eod - csp->iob->cur; - char *old=csp->iob->cur, *new = NULL; - pcrs_job *job, *joblist; + size_t size; + + char *old = csp->iob->cur, *new = NULL; + pcrs_job *job; struct file_list *fl; struct re_filterfile_spec *b; - /* Sanity first ;-) */ - if (size <= 0) + /* Sanity first */ + if (csp->iob->cur >= csp->iob->eod) { - return(strdup("")); + return(NULL); + } + size = csp->iob->eod - csp->iob->cur; + + /* + * If the body has a "chunked" transfer-encoding, + * get rid of it first, adjusting size and iob->eod + */ + if (csp->flags & CSP_FLAG_CHUNKED) + { + log_error(LOG_LEVEL_RE_FILTER, "Need to de-chunk first"); + if (0 == (size = remove_chunked_transfer_coding(csp->iob->cur, size))) + { + return(NULL); + } + csp->iob->eod = csp->iob->cur + size; + csp->flags |= CSP_FLAG_MODIFIED; } if ( ( NULL == (fl = csp->rlist) ) || ( NULL == (b = fl->f) ) ) { log_error(LOG_LEVEL_ERROR, "Unable to get current state of regexp filtering."); - return(strdup("")); + return(NULL); } - joblist = b->joblist; - + if ( NULL == b->joblist ) + { + log_error(LOG_LEVEL_RE_FILTER, "Empty joblist. Nothing to do."); + return(NULL); + } log_error(LOG_LEVEL_RE_FILTER, "re_filtering %s%s (size %d) ...", csp->http->hostport, csp->http->path, size); /* Apply all jobs from the joblist */ - for (job = joblist; NULL != job; job = job->next) + for (job = b->joblist; NULL != job; job = job->next) { - hits += pcrs_exec_substitution(job, old, size, &new, &size); + hits += pcrs_execute(job, old, size, &new, &size); if (old != csp->iob->cur) free(old); old=new; } log_error(LOG_LEVEL_RE_FILTER, " produced %d hits (new size %d).", hits, size); - csp->content_length = size; + /* + * If there were no hits, destroy our copy and let + * chat() use the original in csp->iob + */ + if (!hits) + { + free(new); + return(NULL); + } - /* fwiw, reset the iob */ + csp->flags |= CSP_FLAG_MODIFIED; + csp->content_length = size; IOB_RESET(csp); + return(new); } -#endif /* def PCRS */ + + +/********************************************************************* + * + * Function : gif_deanimate_response + * + * Description : Deanimate the GIF image that has been accumulated in + * csp->iob->buf, set csp->content_length to the modified + * size and raise the CSP_FLAG_MODIFIED flag. + * + * Parameters : + * 1 : csp = Current client state (buffers, headers, etc...) + * + * Returns : a pointer to the (newly allocated) modified buffer. + * or NULL in case something went wrong. + * + *********************************************************************/ +char *gif_deanimate_response(struct client_state *csp) +{ + struct binbuffer *in, *out; + char *p; + int size = csp->iob->eod - csp->iob->cur; + + /* + * If the body has a "chunked" transfer-encoding, + * get rid of it first, adjusting size and iob->eod + */ + if (csp->flags & CSP_FLAG_CHUNKED) + { + log_error(LOG_LEVEL_DEANIMATE, "Need to de-chunk first"); + if (0 == (size = remove_chunked_transfer_coding(csp->iob->cur, size))) + { + return(NULL); + } + csp->iob->eod = csp->iob->cur + size; + csp->flags |= CSP_FLAG_MODIFIED; + } + + if ( (NULL == (in = (struct binbuffer *)zalloc(sizeof *in ))) + || (NULL == (out = (struct binbuffer *)zalloc(sizeof *out))) ) + { + log_error(LOG_LEVEL_DEANIMATE, "failed! (no mem)"); + return NULL; + } + + in->buffer = csp->iob->cur; + in->size = size; + + if (gif_deanimate(in, out, strncmp("last", csp->action->string[ACTION_STRING_DEANIMATE], 4))) + { + log_error(LOG_LEVEL_DEANIMATE, "failed! (gif parsing)"); + free(in); + buf_free(out); + return(NULL); + } + else + { + log_error(LOG_LEVEL_DEANIMATE, "Success! GIF shrunk from %d bytes to %d.", size, out->offset); + csp->content_length = out->offset; + csp->flags |= CSP_FLAG_MODIFIED; + p = out->buffer; + free(in); + free(out); + return(p); + } + +} + + +/********************************************************************* + * + * Function : remove_chunked_transfer_coding + * + * Description : In-situ remove the "chunked" transfer coding as defined + * in rfc2616 from a buffer. + * + * Parameters : + * 1 : buffer = Pointer to the text buffer + * 2 : size = Number of bytes to be processed + * + * Returns : The new size, i.e. the number of bytes from buffer which + * are occupied by the stripped body, or 0 in case something + * went wrong + * + *********************************************************************/ +int remove_chunked_transfer_coding(char *buffer, const size_t size) +{ + size_t newsize = 0; + unsigned int chunksize = 0; + char *from_p, *to_p; + + assert(buffer); + from_p = to_p = buffer; + + if (sscanf(buffer, "%x", &chunksize) != 1) + { + log_error(LOG_LEVEL_ERROR, "Invalid first chunksize while stripping \"chunked\" transfer coding"); + return(0); + } + + while (chunksize > 0) + { + if (NULL == (from_p = strstr(from_p, "\r\n"))) + { + log_error(LOG_LEVEL_ERROR, "Parse error while stripping \"chunked\" transfer coding"); + return(0); + } + newsize += chunksize; + from_p += 2; + + memmove(to_p, from_p, (size_t) chunksize); + to_p = buffer + newsize; + from_p += chunksize + 2; + + if (sscanf(from_p, "%x", &chunksize) != 1) + { + log_error(LOG_LEVEL_ERROR, "Parse error while stripping \"chunked\" transfer coding"); + return(0); + } + } + + /* FIXME: Should this get its own loglevel? */ + log_error(LOG_LEVEL_RE_FILTER, "De-chunking successful. Shrunk from %d to %d\n", size, newsize); + return(newsize); + +} /********************************************************************* @@ -808,6 +1290,7 @@ void url_actions(struct http_request *http, } apply_url_actions(csp->action, http, b); + } @@ -886,7 +1369,7 @@ void apply_url_actions(struct current_action_spec *action, const struct forward_spec * forward_url(struct http_request *http, struct client_state *csp) { - static const struct forward_spec fwd_default[1] = { 0 }; /* All zeroes */ + static const struct forward_spec fwd_default[1] = { FORWARD_SPEC_INITIALIZER }; struct forward_spec *fwd = csp->config->forward; struct url_spec url[1]; @@ -958,12 +1441,13 @@ struct url_spec dsplit(char *domain) if (domain[strlen(domain) - 1] == '.') { - ret->unanchored |= ANCHOR_RIGHT; - } - if (domain[0] == '.') + ret->unanchored |= ANCHOR_RIGHT; + } + + if (domain[0] == '.') { - ret->unanchored |= ANCHOR_LEFT; - } + ret->unanchored |= ANCHOR_LEFT; + } ret->dbuf = strdup(domain); @@ -987,7 +1471,6 @@ struct url_spec dsplit(char *domain) memcpy(ret->dvec, v, size); } - return(*ret); } @@ -999,7 +1482,7 @@ struct url_spec dsplit(char *domain) * * Description : Domain-wise Compare fqdn's. The comparison is * both left- and right-anchored. The individual - * domain names are compared with trivialmatch(). + * domain names are compared with simplematch(). * This is only used by domaincmp. * * Parameters : @@ -1025,6 +1508,7 @@ static int simple_domaincmp(char **pv, char **fv, int len) } return 0; + } @@ -1036,7 +1520,7 @@ static int simple_domaincmp(char **pv, char **fv, int len) * pattern->unachored, the comparison is un-, left-, * right-anchored, or both. * The individual domain names are compared with - * trivialmatch(). + * simplematch(). * * Parameters : * 1 : pattern = a domain that may contain a '*' as a wildcard. @@ -1107,8 +1591,8 @@ int domaincmp(struct url_spec *pattern, struct url_spec *fqdn) } return 1; } -} +} /*