path: root/net-proxy/privoxy/files/privoxy-zlib.patch

diff -Nru privoxy-3.0.3-stable.orig/actionlist.h privoxy-3.0.3-stable/actionlist.h
--- privoxy-3.0.3-stable.orig/actionlist.h	2002-09-25 18:25:25.000000000 +0300
+++ privoxy-3.0.3-stable/actionlist.h	2005-02-27 01:01:23.072737744 +0200
@@ -116,6 +116,7 @@
 DEFINE_ACTION_STRING     ("deanimate-gifs",             ACTION_DEANIMATE,       ACTION_STRING_DEANIMATE)
 DEFINE_CGI_PARAM_RADIO   ("deanimate-gifs",             ACTION_DEANIMATE,       ACTION_STRING_DEANIMATE,     "first", 0)
 DEFINE_CGI_PARAM_RADIO   ("deanimate-gifs",             ACTION_DEANIMATE,       ACTION_STRING_DEANIMATE,     "last",  1)
+DEFINE_ACTION_BOOL       ("decompress-from-server",     ACTION_DECOMPRESS_IN)
 DEFINE_ACTION_BOOL       ("downgrade-http-version",     ACTION_DOWNGRADE)
 DEFINE_ACTION_BOOL       ("fast-redirects",             ACTION_FAST_REDIRECTS)
 DEFINE_ACTION_MULTI      ("filter",                     ACTION_MULTI_FILTER)
diff -Nru privoxy-3.0.3-stable.orig/configure.in privoxy-3.0.3-stable/configure.in
--- privoxy-3.0.3-stable.orig/configure.in	2004-01-30 11:26:03.000000000 +0200
+++ privoxy-3.0.3-stable/configure.in	2005-02-27 00:59:01.813373408 +0200
@@ -1234,6 +1234,20 @@
                                 libpcrs is available],
 [ if test $enableval = "no"; then have_pcrs=no; fi ])
 
+AC_ARG_ENABLE(zlib,
+[  --enable-zlib            Use the zlib library to allow compressing or
+                             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
diff -Nru privoxy-3.0.3-stable.orig/default.action.master privoxy-3.0.3-stable/default.action.master
--- privoxy-3.0.3-stable.orig/default.action.master	2004-01-30 17:28:45.000000000 +0200
+++ privoxy-3.0.3-stable/default.action.master	2005-02-27 00:59:01.815373104 +0200
@@ -452,7 +452,7 @@
 -hide-user-agent \
 -kill-popups \
 -limit-connect \
-+prevent-compression \
+-prevent-compression \
 -send-vanilla-wafer \
 -send-wafer \
 +session-cookies-only \
diff -Nru privoxy-3.0.3-stable.orig/filters.c privoxy-3.0.3-stable/filters.c
--- privoxy-3.0.3-stable.orig/filters.c	2003-11-11 15:10:31.000000000 +0200
+++ privoxy-3.0.3-stable/filters.c	2005-02-27 01:01:23.073737592 +0200
@@ -1320,6 +1320,38 @@
       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 = csp->iob->eod - csp->iob->cur;
+      old_buf  = csp->iob->cur;
+
+      csp->flags |= CSP_FLAG_MODIFIED;
+   }
+#endif
+
+
    /*
     * For all applying +filter actions, look if a filter by that
     * name exists and if yes, execute it's pcrs_joblist on the
diff -Nru privoxy-3.0.3-stable.orig/jcc.c privoxy-3.0.3-stable/jcc.c
--- privoxy-3.0.3-stable.orig/jcc.c	2003-12-12 14:52:53.000000000 +0200
+++ privoxy-3.0.3-stable/jcc.c	2005-02-27 01:06:08.737310128 +0200
@@ -659,6 +659,10 @@
 #  include <select.h>
 # endif
 
+#ifdef FEATURE_ZLIB
+#include <zlib.h>
+#endif
+
 #endif
 
 #include "project.h"
@@ -1605,6 +1609,8 @@
 
             if ((csp->content_type & CT_TEXT) &&  /* It's a text / * MIME-Type */
                 !http->ssl    &&                  /* We talk plaintext */
+				!(csp->content_type & CT_GZIP)    && 
+				!(csp->content_type & CT_DEFLATE) && 
                 block_popups)                     /* Policy allows */
             {
                block_popups_now = 1;
diff -Nru privoxy-3.0.3-stable.orig/parsers.c privoxy-3.0.3-stable/parsers.c
--- privoxy-3.0.3-stable.orig/parsers.c	2003-07-11 16:21:25.000000000 +0300
+++ privoxy-3.0.3-stable/parsers.c	2005-02-27 01:01:23.078736832 +0200
@@ -433,6 +433,10 @@
 #include <assert.h>
 #include <string.h>
 
+#ifdef FEATURE_ZLIB
+#include <zlib.h>
+#endif
+
 #if !defined(_WIN32) && !defined(__OS2__)
 #include <unistd.h>
 #endif
@@ -632,6 +636,281 @@
 }
 
 
+#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, JB_ERR_GENERIC if error decompressing
+ *                buffer.
+ *
+ *********************************************************************/
+jb_err decompress_iob(struct client_state *csp)
+{
+   char *buf;                    /* new, uncompressed buffer */
+   int bufsize = csp->iob->size; /* allocated size of the new buffer */
+                                 /* Number of bytes at the beginning
+				  * of the iob that we should NOT
+				  * decompress.
+				  */
+   int skip_size = csp->iob->cur - csp->iob->buf;
+   int status;                   /* return status of the inflate() call */
+   z_stream zstr;           /* used by calls to zlib */
+
+   /* This is to protect the parsing of gzipped data, but it should(?)
+    * be valid for deflated data also.
+    */
+   if (bufsize < 10)
+   {
+      log_error (LOG_LEVEL_ERROR, "Buffer too small decompressing iob");
+      return JB_ERR_GENERIC;
+   }
+
+   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_GENERIC;
+      }
+      else {
+         int flags = *csp->iob->cur++;
+         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_GENERIC;
+         }
+         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 the
+       * 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_GENERIC;
+   }
+
+   /* Set up the fields required by zlib. */
+   zstr.next_in  = csp->iob->cur;
+   zstr.avail_in = 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_GENERIC;
+   }
+
+   /* 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  = 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 */
+      int 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_GENERIC;
+      }
+
+      /* 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, "Out of memory 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 = zstr.next_out;
+
+         /* Update the fields for inflate() to use the new
+	  * buffer, which may be in a different location from
+	  * the old one.
+	  */
+         zstr.avail_out += bufsize - oldbufsize;
+	 zstr.next_out = 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_GENERIC;
+   }
+
+   /* 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  = 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;
+      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_GENERIC;
+   }
+
+}
+#endif /* defined(FEATURE_ZLIB) */
+
+
 /*********************************************************************
  *
  * Function    :  get_header
@@ -937,13 +1216,59 @@
  *********************************************************************/
 jb_err server_content_encoding(struct client_state *csp, char **header)
 {
+#ifdef FEATURE_ZLIB
+   if (strstr(*header, "gzip"))
+   {
+      /*
+       * If the body was modified, we have tried to
+       * decompress it, so adjust the header if necessary.
+       */
+      if ((csp->flags & CSP_FLAG_MODIFIED) /* we attempted to decompress   */
+      && !(csp->content_type & CT_TABOO))  /* decompression was successful */
+      {
+         freez(*header);
+         *header = strdup("Content-Encoding: identity");
+         return (header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
+      }
+      else
+      {
+        csp->content_type |= CT_GZIP;
+      }
+   }
+   else if (strstr(*header, "deflate"))
+   {
+      /*
+       * If the body was modified, we have tried to
+       * decompress it, so adjust the header if necessary.
+       */
+      if ((csp->flags & CSP_FLAG_MODIFIED) /* we attempted to decompress   */
+      && !(csp->content_type & CT_TABOO))  /* decompression was successful */
+      {
+         freez(*header);
+         *header = strdup("Content-Encoding: identity");
+         return (header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
+      }
+      else
+      {
+        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_GZIP) */
    /*
     * Turn off pcrs and gif filtering if body compressed
     */
    if (strstr(*header, "gzip") || strstr(*header, "compress") || strstr(*header, "deflate"))
    {
-      csp->content_type = CT_TABOO;
+      csp->content_type |= CT_TABOO;
    }
+#endif /* !defined(FEATURE_GZIP) */
 
    return JB_ERR_OK;
 
diff -Nru privoxy-3.0.3-stable.orig/parsers.h privoxy-3.0.3-stable/parsers.h
--- privoxy-3.0.3-stable.orig/parsers.h	2002-09-25 17:52:46.000000000 +0300
+++ privoxy-3.0.3-stable/parsers.h	2005-02-27 01:01:23.079736680 +0200
@@ -194,6 +194,7 @@
 
 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 -Nru privoxy-3.0.3-stable.orig/project.h privoxy-3.0.3-stable/project.h
--- privoxy-3.0.3-stable.orig/project.h	2004-01-30 17:29:29.000000000 +0200
+++ privoxy-3.0.3-stable/project.h	2005-02-27 01:01:23.081736376 +0200
@@ -818,6 +818,15 @@
 #define CT_TABOO  4 /**< csp->content_type bitmask:
                          DO NOT filter, irrespective of other flags. */
 
+/* Although these are not, strictly speaking, content types
+ * (they are content encodings), it is simple to handle
+ * them as such.
+ */
+#define CT_GZIP     8 /**< csp->content_type bitmask:
+                         gzip-compressed data. */
+#define CT_DEFLATE 16 /**< csp->content_type bitmask:
+                         zlib-compressed data. */
+
 /**
  * The mask which includes all actions.
  */
@@ -862,6 +871,8 @@
 #define ACTION_VANILLA_WAFER   0x00008000UL
 /** Action bitmap: Limit CONNECT requests to safe ports. */
 #define ACTION_LIMIT_CONNECT   0x00010000UL
+/** Action bitmap: Uncompress incoming text for filtering. */
+#define ACTION_DECOMPRESS_IN   0x00020000UL
 
 /** Action string index: How to deanimate GIFs */
 #define ACTION_STRING_DEANIMATE     0