From: Fabian Keil Date: Mon, 1 Jan 2007 19:36:37 +0000 (+0000) Subject: Integrate a modified version of Wil Mahan's X-Git-Tag: v_3_0_7~409 X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=commitdiff_plain;h=dfd5a3ced69851300f203f904334d3e44b004176 Integrate a modified version of Wil Mahan's zlib patch (PR #895531). --- diff --git a/AUTHORS b/AUTHORS index 9a99db84..5ce2a216 100644 --- a/AUTHORS +++ b/AUTHORS @@ -58,12 +58,14 @@ alphabetical order): Don Libes Paul Lieverse Toby Lyward + Wil Mahan Jindrich Makovicka David Mediavilla Raphael Moll Roberto Ragusa Félix Rauch Maynard Riley + Chung-chieh Shan Spinor S Bart Schelstraete Oliver Stoeneberg diff --git a/configure.in b/configure.in index 85a2283d..c90dd825 100644 --- a/configure.in +++ b/configure.in @@ -1,6 +1,6 @@ dnl Process this file with autoconf to produce a configure script. dnl -dnl $Id: configure.in,v 1.97 2006/11/21 18:32:46 hal9 Exp $ +dnl $Id: configure.in,v 1.98 2006/12/17 19:15:26 fabiankeil Exp $ dnl dnl Written by and Copyright (C) 2001 - 2004 the SourceForge dnl Privoxy team. http://www.privoxy.org/ @@ -28,6 +28,9 @@ dnl or write to the Free Software Foundation, Inc., 59 dnl Temple Place - Suite 330, Boston, MA 02111-1307, USA. dnl dnl $Log: configure.in,v $ +dnl Revision 1.98 2006/12/17 19:15:26 fabiankeil +dnl Added ./configure switch for FEATURE_GRACEFUL_TERMINATION. +dnl dnl Revision 1.97 2006/11/21 18:32:46 hal9 dnl Setting version to 3.0.7 UNRELEASED for lack of a better setting. dnl @@ -467,7 +470,7 @@ dnl ================================================================= dnl AutoConf Initialization dnl ================================================================= -AC_REVISION($Revision: 1.97 $) +AC_REVISION($Revision: 1.98 $) AC_INIT(jcc.c) if test ! -f config.h.in; then @@ -1274,6 +1277,22 @@ AC_ARG_ENABLE(dynamic-pcrs, [ if test $enableval = "no"; then have_pcrs=no; fi ]) +# This check is incomplete. mingw32's zlib is found but the build fails. +AC_ARG_ENABLE(zlib, +[ --enable-zlib Use an external zlib library to allow decompressing + data on the fly.], +[enableval2=$enableval], +[enableval2=no]) +if test $enableval2 = yes; then + AC_CHECK_LIB(z, zlibVersion, , [ + AC_MSG_ERROR([Unable to find a copy of zlib. The zlib library +is necessary to enable compresion support. ]) + ]) + AC_DEFINE(FEATURE_ZLIB,1, + [ Define to 1 to use compression through the zlib library. ]) +fi + + # If we have libpcre and either we also have pcreposix or # we don't need pcreposix, then link pcre dynamically; else # build it and link statically diff --git a/filters.c b/filters.c index 84ea1d5b..e69952e1 100644 --- a/filters.c +++ b/filters.c @@ -1,4 +1,4 @@ -const char filters_rcs[] = "$Id: filters.c,v 1.74 2006/12/24 17:37:38 fabiankeil Exp $"; +const char filters_rcs[] = "$Id: filters.c,v 1.75 2006/12/29 18:30:46 fabiankeil Exp $"; /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/filters.c,v $ @@ -40,6 +40,10 @@ const char filters_rcs[] = "$Id: filters.c,v 1.74 2006/12/24 17:37:38 fabiankeil * * Revisions : * $Log: filters.c,v $ + * Revision 1.75 2006/12/29 18:30:46 fabiankeil + * Fixed gcc43 conversion warnings, + * changed sprintf calls to snprintf. + * * Revision 1.74 2006/12/24 17:37:38 fabiankeil * Adjust comment in pcrs_filter_response() * to recent pcrs changes. Hohoho. @@ -934,7 +938,6 @@ struct http_response *block_url(struct client_state *csp) return cgi_error_memory(); } } - } else #endif /* def FEATURE_IMAGE_BLOCKING */ @@ -1660,6 +1663,11 @@ int is_untrusted_url(struct client_state *csp) * csp->content_length to the modified size and raise the * CSP_FLAG_MODIFIED flag. * + * XXX: Currently pcrs_filter_response is also responsible + * for dechunking and decompressing. Both should be + * done in separate functions so other content modifiers + * profit as well, even if pcrs filtering is disabled. + * * Parameters : * 1 : csp = Current client state (buffers, headers, etc...) * @@ -1709,7 +1717,7 @@ char *pcrs_filter_response(struct client_state *csp) if (0 == found_filters) { log_error(LOG_LEVEL_ERROR, "Unable to get current state of regexp filtering."); - return(NULL); + return(NULL); } /* @@ -1727,6 +1735,41 @@ char *pcrs_filter_response(struct client_state *csp) csp->flags |= CSP_FLAG_MODIFIED; } +#ifdef FEATURE_ZLIB + /* + * If the body has a compressed transfer-encoding, + * uncompress it first, adjusting size and iob->eod. + * Note that decompression occurs after de-chunking. + */ + if (csp->content_type & CT_GZIP || csp->content_type & CT_DEFLATE) + { + /* Notice that we at least tried to decompress. */ + if (JB_ERR_OK != decompress_iob(csp)) + { + /* + * We failed to decompress the data; there's no point + * in continuing since we can't filter. This is + * slightly tricky because we need to remember not to + * modify the Content-Encoding header later; using + * CT_TABOO flag is a kludge for this purpose. + */ + csp->content_type |= CT_TABOO; + return(NULL); + } + log_error(LOG_LEVEL_RE_FILTER, "Decompressing successful"); + + /* + * Decompression gives us a completely new iob, + * so we need to update. + */ + size = (size_t)(csp->iob->eod - csp->iob->cur); + old = csp->iob->cur; + + csp->flags |= CSP_FLAG_MODIFIED; + csp->content_type &= ~CT_TABOO; + } +#endif + for (i = 0; i < MAX_AF_FILES; i++) { fl = csp->rlist[i]; diff --git a/parsers.c b/parsers.c index 032dc833..fd62f9d7 100644 --- a/parsers.c +++ b/parsers.c @@ -1,4 +1,4 @@ -const char parsers_rcs[] = "$Id: parsers.c,v 1.80 2006/12/29 19:08:22 fabiankeil Exp $"; +const char parsers_rcs[] = "$Id: parsers.c,v 1.81 2006/12/31 22:21:33 fabiankeil Exp $"; /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/parsers.c,v $ @@ -45,6 +45,11 @@ const char parsers_rcs[] = "$Id: parsers.c,v 1.80 2006/12/29 19:08:22 fabiankeil * * Revisions : * $Log: parsers.c,v $ + * Revision 1.81 2006/12/31 22:21:33 fabiankeil + * Skip empty filter files in filter_header() + * but don't ignore the ones that come afterwards. + * Fixes BR 1619208, this time for real. + * * Revision 1.80 2006/12/29 19:08:22 fabiankeil * Reverted parts of my last commit * to keep error handling working. @@ -568,6 +573,10 @@ const char parsers_rcs[] = "$Id: parsers.c,v 1.80 2006/12/29 19:08:22 fabiankeil #include #include +#ifdef FEATURE_ZLIB +#include +#endif + #if !defined(_WIN32) && !defined(__OS2__) #include #endif @@ -650,6 +659,9 @@ const struct parsers server_patterns[] = { const struct parsers server_patterns_light[] = { { "Content-Length:", 15, server_content_length }, { "Transfer-Encoding:", 18, server_transfer_coding }, +#ifdef FEATURE_ZLIB + { "Content-Encoding:", 17, server_content_encoding }, +#endif /* def FEATURE_ZLIB */ { NULL, 0, NULL } }; @@ -783,6 +795,296 @@ jb_err add_to_iob(struct client_state *csp, char *buf, int n) } +#ifdef FEATURE_ZLIB +/********************************************************************* + * + * Function : decompress_iob + * + * Description : Decompress buffered page, expanding the + * buffer as necessary. csp->iob->cur + * should point to the the beginning of the + * compressed data block. + * + * Parameters : + * 1 : csp = Current client state (buffers, headers, etc...) + * + * Returns : JB_ERR_OK on success, + * JB_ERR_MEMORY if out-of-memory limit reached, and + * JB_ERR_COMPRESS if error decompressing buffer. + * + *********************************************************************/ +jb_err decompress_iob(struct client_state *csp) +{ + char *buf; /* new, uncompressed buffer */ + size_t bufsize; /* allocated size of the new buffer */ + size_t skip_size; /* Number of bytes at the beginning of the iob + that we should NOT decompress. */ + int status; /* return status of the inflate() call */ + z_stream zstr; /* used by calls to zlib */ + + bufsize = csp->iob->size; + skip_size = (size_t)(csp->iob->cur - csp->iob->buf); + + if (bufsize < 10) + { + /* + * This is to protect the parsing of gzipped data, + * but it should(?) be valid for deflated data also. + */ + log_error (LOG_LEVEL_ERROR, "Buffer too small decompressing iob"); + return JB_ERR_COMPRESS; + } + + if (csp->content_type & CT_GZIP) + { + /* + * Our task is slightly complicated by the facts that data + * compressed by gzip does not include a zlib header, and + * that there is no easily accessible interface in zlib to + * handle a gzip header. We strip off the gzip header by + * hand, and later inform zlib not to expect a header. + */ + + /* + * Strip off the gzip header. Please see RFC 1952 for more + * explanation of the appropriate fields. + */ + if ((*csp->iob->cur++ != (char)0x1f) + || (*csp->iob->cur++ != (char)0x8b) + || (*csp->iob->cur++ != Z_DEFLATED)) + { + log_error (LOG_LEVEL_ERROR, "Invalid gzip header when decompressing"); + return JB_ERR_COMPRESS; + } + else + { + int flags = *csp->iob->cur++; + /* + * XXX: These magic numbers should be replaced + * with macros to give a better idea what they do. + */ + if (flags & 0xe0) + { + /* The gzip header has reserved bits set; bail out. */ + log_error (LOG_LEVEL_ERROR, "Invalid gzip header when decompressing"); + return JB_ERR_COMPRESS; + } + csp->iob->cur += 6; + + /* Skip extra fields if necessary. */ + if (flags & 0x04) + { + /* + * Skip a given number of bytes, specified + * as a 16-bit little-endian value. + */ + csp->iob->cur += *csp->iob->cur++ + (*csp->iob->cur++ << 8); + } + + /* Skip the filename if necessary. */ + if (flags & 0x08) + { + /* A null-terminated string follows. */ + while (*csp->iob->cur++); + } + + /* Skip the comment if necessary. */ + if (flags & 0x10) + { + while (*csp->iob->cur++); + } + + /* Skip the CRC if necessary. */ + if (flags & 0x02) + { + csp->iob->cur += 2; + } + } + } + else if (csp->content_type & CT_DEFLATE) + { + log_error (LOG_LEVEL_INFO, "Decompressing deflated iob: %d", *csp->iob->cur); + /* + * In theory (that is, according to RFC 1950), deflate-compressed + * data should begin with a two-byte zlib header and have an + * adler32 checksum at the end. It seems that in practice only + * the raw compressed data is sent. Note that this means that + * we are not RFC 1950-compliant here, but the advantage is that + * this actually works. :) + * + * We add a dummy null byte to tell zlib where the data ends, + * and later inform it not to expect a header. + * + * Fortunately, add_to_iob() has thoughtfully null-terminated + * the buffer; we can just increment the end pointer to include + * the dummy byte. + */ + csp->iob->eod++; + } + else + { + log_error (LOG_LEVEL_ERROR, + "Unable to determine compression format for decompression"); + return JB_ERR_COMPRESS; + } + + /* Set up the fields required by zlib. */ + zstr.next_in = (Bytef *)csp->iob->cur; + zstr.avail_in = (unsigned long)(csp->iob->eod - csp->iob->cur); + zstr.zalloc = Z_NULL; + zstr.zfree = Z_NULL; + zstr.opaque = Z_NULL; + + /* + * Passing -MAX_WBITS to inflateInit2 tells the library + * that there is no zlib header. + */ + if (inflateInit2 (&zstr, -MAX_WBITS) != Z_OK) + { + log_error (LOG_LEVEL_ERROR, "Error initializing decompression"); + return JB_ERR_COMPRESS; + } + + /* + * Next, we allocate new storage for the inflated data. + * We don't modify the existing iob yet, so in case there + * is error in decompression we can recover gracefully. + */ + buf = zalloc (bufsize); + if (NULL == buf) + { + log_error (LOG_LEVEL_ERROR, "Out of memory decompressing iob"); + return JB_ERR_MEMORY; + } + + assert(bufsize >= skip_size); + memcpy(buf, csp->iob->buf, skip_size); + zstr.avail_out = bufsize - skip_size; + zstr.next_out = (Bytef *)buf + skip_size; + + /* Try to decompress the whole stream in one shot. */ + while (Z_BUF_ERROR == (status = inflate(&zstr, Z_FINISH))) + { + /* We need to allocate more memory for the output buffer. */ + + char *tmpbuf; /* used for realloc'ing the buffer */ + size_t oldbufsize = bufsize; /* keep track of the old bufsize */ + + /* + * If zlib wants more data then there's a problem, because + * the complete compressed file should have been buffered. + */ + if (0 == zstr.avail_in) + { + log_error(LOG_LEVEL_ERROR, "Unexpected end of compressed iob"); + return JB_ERR_COMPRESS; + } + + /* + * If we tried the limit and still didn't have enough + * memory, just give up. + */ + if (bufsize == csp->config->buffer_limit) + { + log_error(LOG_LEVEL_ERROR, "Buffer limit reached while decompressing iob"); + return JB_ERR_MEMORY; + } + + /* Try doubling the buffer size each time. */ + bufsize *= 2; + + /* Don't exceed the buffer limit. */ + if (bufsize > csp->config->buffer_limit) + { + bufsize = csp->config->buffer_limit; + } + + /* Try to allocate the new buffer. */ + tmpbuf = realloc(buf, bufsize); + if (NULL == tmpbuf) + { + log_error(LOG_LEVEL_ERROR, "Out of memory decompressing iob"); + freez(buf); + return JB_ERR_MEMORY; + } + else + { + char *oldnext_out = (char *)zstr.next_out; + + /* + * Update the fields for inflate() to use the new + * buffer, which may be in a location different from + * the old one. + */ + zstr.avail_out += bufsize - oldbufsize; + zstr.next_out = (Bytef *)tmpbuf + bufsize - zstr.avail_out; + + /* + * Compare with an uglier method of calculating these values + * that doesn't require the extra oldbufsize variable. + */ + assert(zstr.avail_out == tmpbuf + bufsize - (char *)zstr.next_out); + assert((char *)zstr.next_out == tmpbuf + ((char *)oldnext_out - buf)); + assert(zstr.avail_out > 0); + + buf = tmpbuf; + } + } + + inflateEnd(&zstr); + if (status != Z_STREAM_END) + { + /* We failed to decompress the stream. */ + log_error(LOG_LEVEL_ERROR, + "Error in decompressing to the buffer (iob): %s", zstr.msg); + return JB_ERR_COMPRESS; + } + + /* + * Finally, we can actually update the iob, since the + * decompression was successful. First, free the old + * buffer. + */ + freez(csp->iob->buf); + + /* Now, update the iob to use the new buffer. */ + csp->iob->buf = buf; + csp->iob->cur = csp->iob->buf + skip_size; + csp->iob->eod = (char *)zstr.next_out; + csp->iob->size = bufsize; + + /* + * Make sure the new uncompressed iob obeys some minimal + * consistency conditions. + */ + if ((csp->iob->buf < csp->iob->cur) + && (csp->iob->cur <= csp->iob->eod) + && (csp->iob->eod <= csp->iob->buf + csp->iob->size)) + { + char t = csp->iob->cur[100]; + csp->iob->cur[100] = '\0'; + /* + * XXX: The debug level should be lowered + * before the next stable release. + */ + log_error(LOG_LEVEL_INFO, "Sucessfully decompressed: %s", csp->iob->cur); + csp->iob->cur[100] = t; + return JB_ERR_OK; + } + else + { + /* It seems that zlib did something weird. */ + log_error(LOG_LEVEL_ERROR, + "Unexpected error decompressing the buffer (iob): %d==%d, %d>%d, %d<%d", + csp->iob->cur, csp->iob->buf + skip_size, csp->iob->eod, csp->iob->buf, + csp->iob->eod, csp->iob->buf + csp->iob->size); + return JB_ERR_COMPRESS; + } + +} +#endif /* defined(FEATURE_ZLIB) */ + + /********************************************************************* * * Function : get_header @@ -957,7 +1259,7 @@ char *sed(const struct parsers pats[], */ if (strncmpic(csp->http->cmd, "HEAD", 4)) { - /*XXX: Code duplication*/ + /*XXX: Code duplication */ for (v = pats; (err == JB_ERR_OK) && (v->str != NULL) ; v++) { for (p = csp->headers->first; (err == JB_ERR_OK) && (p != NULL) ; p = p->next) @@ -1266,34 +1568,44 @@ jb_err server_content_type(struct client_state *csp, char **header) newval = csp->action->string[ACTION_STRING_CONTENT_TYPE]; - if (csp->content_type != CT_TABOO) + assert(!csp->content_type || (csp->content_type == CT_TABOO)); + + if (!(csp->content_type & CT_TABOO)) { if ((strstr(*header, " text/") && !strstr(*header, "plain")) - || strstr(*header, "xml") - || strstr(*header, "application/x-javascript")) - csp->content_type = CT_TEXT; + || strstr(*header, "xml") + || strstr(*header, "application/x-javascript")) + { + csp->content_type |= CT_TEXT; + } else if (strstr(*header, " image/gif")) - csp->content_type = CT_GIF; + { + csp->content_type |= CT_GIF; + } else if (strstr(*header, " image/jpeg")) - csp->content_type = CT_JPEG; + { + csp->content_type |= CT_JPEG; + } else + { csp->content_type = 0; + } } /* * Are we enabling text mode by force? */ if (csp->action->flags & ACTION_FORCE_TEXT_MODE) { - /* - * Do we really have to? - */ - if (csp->content_type == CT_TEXT) + /* + * Do we really have to? + */ + if (csp->content_type & CT_TEXT) { log_error(LOG_LEVEL_HEADER, "Text mode is already enabled."); } else { - csp->content_type = CT_TEXT; + csp->content_type |= CT_TEXT; log_error(LOG_LEVEL_HEADER, "Text mode enabled by force. Take cover!"); } } @@ -1302,28 +1614,29 @@ jb_err server_content_type(struct client_state *csp, char **header) */ if (csp->action->flags & ACTION_CONTENT_TYPE_OVERWRITE) { - /* - * Make sure the user doesn't accidently - * change the content type of binary documents. - */ - if (csp->content_type == CT_TEXT) - { - freez(*header); - *header = strdup("Content-Type: "); - string_append(header, newval); - - if (header == NULL) - { - log_error(LOG_LEVEL_HEADER, "Insufficient memory. Conten-Type crunched without replacement!"); - return JB_ERR_MEMORY; - } - log_error(LOG_LEVEL_HEADER, "Modified: %s!", *header); - } - else - { - log_error(LOG_LEVEL_HEADER, "%s not replaced. It doesn't look like text. " - "Enable force-text-mode if you know what you're doing.", *header); - } + /* + * Make sure the user doesn't accidently + * change the content type of binary documents. + */ + if (csp->content_type & CT_TEXT) + { + freez(*header); + *header = strdup("Content-Type: "); + string_append(header, newval); + + if (header == NULL) + { + log_error(LOG_LEVEL_HEADER, + "Insufficient memory. Content-Type crunched without replacement!"); + return JB_ERR_MEMORY; + } + log_error(LOG_LEVEL_HEADER, "Modified: %s!", *header); + } + else + { + log_error(LOG_LEVEL_HEADER, "%s not replaced. It doesn't look like text. " + "Enable force-text-mode if you know what you're doing.", *header); + } } return JB_ERR_OK; } @@ -1356,6 +1669,13 @@ jb_err server_transfer_coding(struct client_state *csp, char **header) */ if (strstr(*header, "gzip") || strstr(*header, "compress") || strstr(*header, "deflate")) { +#ifdef FEATURE_ZLIB + /* + * XXX: Added to test if we could use CT_GZIP and CT_DEFLATE here. + */ + log_error(LOG_LEVEL_INFO, "Marking content type for %s as CT_TABOO because of %s.", + csp->http->cmd, *header); +#endif /* def FEATURE_ZLIB */ csp->content_type = CT_TABOO; } @@ -1368,7 +1688,10 @@ jb_err server_transfer_coding(struct client_state *csp, char **header) /* * If the body was modified, it has been de-chunked first - * and the header must be removed. + * and the header must be removed. + * + * FIXME: If there is more than one transfer encoding, + * only the "chunked" part should be removed here. */ if (csp->flags & CSP_FLAG_MODIFIED) { @@ -1385,7 +1708,16 @@ jb_err server_transfer_coding(struct client_state *csp, char **header) * * Function : server_content_encoding * - * Description : Prohibit filtering (CT_TABOO) if content encoding compresses + * Description : This function is run twice for each request, + * unless FEATURE_ZLIB and filtering are disabled. + * + * The first run is used to check if the content + * is compressed, if FEATURE_ZLIB is disabled + * filtering is then disabled as well, if FEATURE_ZLIB + * is enabled the content is marked for decompression. + * + * The second run is used to remove the Content-Encoding + * header if the decompression was successful. * * Parameters : * 1 : csp = Current client state (buffers, headers, etc...) @@ -1400,13 +1732,48 @@ jb_err server_transfer_coding(struct client_state *csp, char **header) *********************************************************************/ jb_err server_content_encoding(struct client_state *csp, char **header) { - /* - * Turn off pcrs and gif filtering if body compressed - */ +#ifdef FEATURE_ZLIB + /* XXX: Why would we modify the content if it was taboo? */ + if ((csp->flags & CSP_FLAG_MODIFIED) && !(csp->content_type & CT_TABOO)) + { + /* + * We successfully decompressed the content, + * and have to clean the header now, so the + * client no longer expects compressed data.. + * + * XXX: There is a difference between cleaning + * and removing it completely. + */ + log_error(LOG_LEVEL_HEADER, "Crunching: %s", *header); + freez(*header); + } + else if (strstr(*header, "gzip")) + { + /* Mark for gzip decompression */ + csp->content_type |= CT_GZIP; + } + else if (strstr(*header, "deflate")) + { + /* Mark for zlib decompression */ + csp->content_type |= CT_DEFLATE; + } + else if (strstr(*header, "compress")) + { + /* + * We can't decompress this; therefore we can't filter + * it either. + */ + csp->content_type |= CT_TABOO; + } +#else /* !defined(FEATURE_ZLIB) */ if (strstr(*header, "gzip") || strstr(*header, "compress") || strstr(*header, "deflate")) { - csp->content_type = CT_TABOO; + /* + * Body is compressed, turn off pcrs and gif filtering. + */ + csp->content_type |= CT_TABOO; } +#endif /* !defined(FEATURE_ZLIB) */ return JB_ERR_OK; diff --git a/parsers.h b/parsers.h index 0fface19..3267c582 100644 --- a/parsers.h +++ b/parsers.h @@ -1,6 +1,6 @@ #ifndef PARSERS_H_INCLUDED #define PARSERS_H_INCLUDED -#define PARSERS_H_VERSION "$Id: parsers.h,v 1.33 2006/12/29 18:04:40 fabiankeil Exp $" +#define PARSERS_H_VERSION "$Id: parsers.h,v 1.34 2006/12/29 19:08:22 fabiankeil Exp $" /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/parsers.h,v $ @@ -43,6 +43,10 @@ * * Revisions : * $Log: parsers.h,v $ + * Revision 1.34 2006/12/29 19:08:22 fabiankeil + * Reverted parts of my last commit + * to keep error handling working. + * * Revision 1.33 2006/12/29 18:04:40 fabiankeil * Fixed gcc43 conversion warnings. * @@ -230,6 +234,7 @@ extern const add_header_func_ptr add_server_headers[]; extern int flush_socket(jb_socket fd, struct client_state *csp); extern jb_err add_to_iob(struct client_state *csp, char *buf, int n); +extern jb_err decompress_iob(struct client_state *csp); extern char *get_header(struct client_state *csp); extern char *get_header_value(const struct list *header_list, const char *header_name); extern char *sed(const struct parsers pats[], const add_header_func_ptr more_headers[], struct client_state *csp); diff --git a/project.h b/project.h index dedd2d91..b021c62d 100644 --- a/project.h +++ b/project.h @@ -1,7 +1,7 @@ #ifndef PROJECT_H_INCLUDED #define PROJECT_H_INCLUDED /** Version string. */ -#define PROJECT_H_VERSION "$Id: project.h,v 1.85 2006/12/31 15:03:31 fabiankeil Exp $" +#define PROJECT_H_VERSION "$Id: project.h,v 1.86 2006/12/31 17:56:37 fabiankeil Exp $" /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/project.h,v $ @@ -37,6 +37,10 @@ * * Revisions : * $Log: project.h,v $ + * Revision 1.86 2006/12/31 17:56:37 fabiankeil + * Added config option accept-intercepted-requests + * and disabled it by default. + * * Revision 1.85 2006/12/31 15:03:31 fabiankeil * Fix gcc43 compiler warnings and a comment. * @@ -633,7 +637,7 @@ typedef int jb_err; #define JB_ERR_PARSE 4 /**< Error parsing file */ #define JB_ERR_MODIFIED 5 /**< File has been modified outside of the CGI actions editor. */ - +#define JB_ERR_COMPRESS 6 /**< Error on decompression */ /** * This macro is used to free a pointer that may be NULL. @@ -885,15 +889,18 @@ struct iob */ #define IOB_RESET(CSP) if(CSP->iob->buf) free(CSP->iob->buf); memset(CSP->iob, '\0', sizeof(CSP->iob)); -/* Bits for csp->content_type */ -#define CT_TEXT 1U /**< csp->content_type bitmask: - Suitable for pcrs filtering. */ -#define CT_GIF 2U /**< csp->content_type bitmask: - Suitable for GIF filtering. */ -#define CT_TABOO 4U /**< csp->content_type bitmask: - DO NOT filter, irrespective of other flags. */ -#define CT_JPEG 8U /**< csp->content_type bitmask: - Suitable for JPEG filtering. */ +/* Bits for csp->content_type bitmask: */ +#define CT_TEXT 0x0001U /**< Suitable for pcrs filtering. */ +#define CT_GIF 0x0002U /**< Suitable for GIF filtering. */ +#define CT_TABOO 0x0004U /**< DO NOT filter, irrespective of other flags. */ +#define CT_JPEG 0x0008U /**< Suitable for JPEG filtering. */ + +/* Although these are not, strictly speaking, content types + * (they are content encodings), it is simple to handle them + * as such. + */ +#define CT_GZIP 0x0010U /**< gzip-compressed data. */ +#define CT_DEFLATE 0x0020U /**< zlib-compressed data. */ /** * The mask which includes all actions.