X-Git-Url: http://www.privoxy.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=parsers.c;h=e89a64345b3dd77896e595212e589792bb4ef457;hb=363febbbf9f54bcd3fc7ecc8eae6eaa18f9d587a;hp=a0dfb06e58479c586413ada4969a8680bac49f4a;hpb=5c3ba00266dd995872f0eb2c48f2486c98762506;p=privoxy.git

diff --git a/parsers.c b/parsers.c
index a0dfb06e..e89a6434 100644
--- a/parsers.c
+++ b/parsers.c
@@ -1,4 +1,4 @@
-const char parsers_rcs[] = "$Id: parsers.c,v 1.97 2007/04/15 16:39:21 fabiankeil Exp $";
+const char parsers_rcs[] = "$Id: parsers.c,v 1.114 2007/10/19 16:56:26 fabiankeil Exp $";
 /*********************************************************************
  *
  * File        :  $Source: /cvsroot/ijbswa/current/parsers.c,v $
@@ -44,6 +44,71 @@ const char parsers_rcs[] = "$Id: parsers.c,v 1.97 2007/04/15 16:39:21 fabiankeil
  *
  * Revisions   :
  *    $Log: parsers.c,v $
+ *    Revision 1.114  2007/10/19 16:56:26  fabiankeil
+ *    - Downgrade "Buffer limit reached" message to LOG_LEVEL_INFO.
+ *    - Use shiny new content_filters_enabled() in client_range().
+ *
+ *    Revision 1.113  2007/10/10 17:29:57  fabiankeil
+ *    I forgot about Poland.
+ *
+ *    Revision 1.112  2007/10/09 16:38:40  fabiankeil
+ *    Remove Range and If-Range headers if content filtering is enabled.
+ *
+ *    Revision 1.111  2007/10/04 18:07:00  fabiankeil
+ *    Move ACTION_VANILLA_WAFER handling from jcc's chat() into
+ *    client_cookie_adder() to make sure send-vanilla-wafer can be
+ *    controlled through tags (and thus regression-tested).
+ *
+ *    Revision 1.110  2007/09/29 10:42:37  fabiankeil
+ *    - Remove "scanning headers for" log message again.
+ *    - Some more whitespace fixes.
+ *
+ *    Revision 1.109  2007/09/08 14:25:48  fabiankeil
+ *    Refactor client_referrer() and add conditional-forge parameter.
+ *
+ *    Revision 1.108  2007/08/28 18:21:03  fabiankeil
+ *    A bunch of whitespace fixes, pointy hat to me.
+ *
+ *    Revision 1.107  2007/08/28 18:16:32  fabiankeil
+ *    Fix possible memory corruption in server_http, make sure it's not
+ *    executed for ordinary server headers and mark some problems for later.
+ *
+ *    Revision 1.106  2007/08/18 14:30:32  fabiankeil
+ *    Let content-type-overwrite{} honour force-text-mode again.
+ *
+ *    Revision 1.105  2007/08/11 14:49:49  fabiankeil
+ *    - Add prototpyes for the header parsers and make them static.
+ *    - Comment out client_accept_encoding_adder() which isn't used right now.
+ *
+ *    Revision 1.104  2007/07/14 07:38:19  fabiankeil
+ *    Move the ACTION_FORCE_TEXT_MODE check out of
+ *    server_content_type(). Signal other functions
+ *    whether or not a content type has been declared.
+ *    Part of the fix for BR#1750917.
+ *
+ *    Revision 1.103  2007/06/01 16:31:54  fabiankeil
+ *    Change sed() to return a jb_err in preparation for forward-override{}.
+ *
+ *    Revision 1.102  2007/05/27 12:39:32  fabiankeil
+ *    Adjust "X-Filter: No" to disable dedicated header filters.
+ *
+ *    Revision 1.101  2007/05/14 10:16:41  fabiankeil
+ *    Streamline client_cookie_adder().
+ *
+ *    Revision 1.100  2007/04/30 15:53:11  fabiankeil
+ *    Make sure filters with dynamic jobs actually use them.
+ *
+ *    Revision 1.99  2007/04/30 15:06:26  fabiankeil
+ *    - Introduce dynamic pcrs jobs that can resolve variables.
+ *    - Remove unnecessary update_action_bits_for_all_tags() call.
+ *
+ *    Revision 1.98  2007/04/17 18:32:10  fabiankeil
+ *    - Make tagging based on tags set by earlier taggers
+ *      of the same kind possible.
+ *    - Log whether or not new tags cause action bits updates
+ *      (in which case a matching tag-pattern section exists).
+ *    - Log if the user tries to set a tag that is already set.
+ *
  *    Revision 1.97  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
@@ -699,6 +764,7 @@ const char parsers_rcs[] = "$Id: parsers.c,v 1.97 2007/04/15 16:39:21 fabiankeil
 #include "miscutil.h"
 #include "list.h"
 #include "actions.h"
+#include "filters.h"
 
 #ifndef HAVE_STRPTIME
 #include "strptime.h"
@@ -719,8 +785,50 @@ const char parsers_h_rcs[] = PARSERS_H_VERSION;
 #define ijb_isupper(__X) isupper((int)(unsigned char)(__X))
 #define ijb_tolower(__X) tolower((int)(unsigned char)(__X))
 
-jb_err header_tagger(struct client_state *csp, char *header);
-jb_err scan_headers(struct client_state *csp);
+static jb_err scan_headers(struct client_state *csp);
+static jb_err header_tagger(struct client_state *csp, char *header);
+static jb_err parse_header_time(const char *header_time, time_t *result);
+
+static jb_err crumble                   (struct client_state *csp, char **header);
+static jb_err connection                (struct client_state *csp, char **header);
+static jb_err filter_header             (struct client_state *csp, char **header);
+static jb_err client_referrer           (struct client_state *csp, char **header);
+static jb_err client_uagent             (struct client_state *csp, char **header);
+static jb_err client_ua                 (struct client_state *csp, char **header);
+static jb_err client_from               (struct client_state *csp, char **header);
+static jb_err client_send_cookie        (struct client_state *csp, char **header);
+static jb_err client_x_forwarded        (struct client_state *csp, char **header);
+static jb_err client_accept_encoding    (struct client_state *csp, char **header);
+static jb_err client_te                 (struct client_state *csp, char **header);
+static jb_err client_max_forwards       (struct client_state *csp, char **header);
+static jb_err client_host               (struct client_state *csp, char **header);
+static jb_err client_if_modified_since  (struct client_state *csp, char **header);
+static jb_err client_accept_language    (struct client_state *csp, char **header);
+static jb_err client_if_none_match      (struct client_state *csp, char **header);
+static jb_err crunch_client_header      (struct client_state *csp, char **header);
+static jb_err client_x_filter           (struct client_state *csp, char **header);
+static jb_err client_range              (struct client_state *csp, char **header);
+static jb_err server_set_cookie         (struct client_state *csp, char **header);
+static jb_err server_content_type       (struct client_state *csp, char **header);
+static jb_err server_content_length     (struct client_state *csp, char **header);
+static jb_err server_content_md5        (struct client_state *csp, char **header);
+static jb_err server_content_encoding   (struct client_state *csp, char **header);
+static jb_err server_transfer_coding    (struct client_state *csp, char **header);
+static jb_err server_http               (struct client_state *csp, char **header);
+static jb_err crunch_server_header      (struct client_state *csp, char **header);
+static jb_err server_last_modified      (struct client_state *csp, char **header);
+static jb_err server_content_disposition(struct client_state *csp, char **header);
+
+static jb_err client_host_adder       (struct client_state *csp);
+static jb_err client_cookie_adder     (struct client_state *csp);
+static jb_err client_xtra_adder       (struct client_state *csp);
+static jb_err client_x_forwarded_adder(struct client_state *csp);
+static jb_err connection_close_adder  (struct client_state *csp); 
+
+static jb_err create_forged_referrer(char **header, const char *hostport);
+static jb_err create_fake_referrer(char **header, const char *fake_referrer);
+static jb_err handle_conditional_hide_referrer_parameter(char **header,
+   const char *host, const int parameter_conditional_block);
 
 const struct parsers client_patterns[] = {
    { "referer:",                  8,   client_referrer },
@@ -739,6 +847,8 @@ const struct parsers client_patterns[] = {
    { "max-forwards:",            13,   client_max_forwards },
    { "Accept-Language:",         16,   client_accept_language },
    { "if-none-match:",           14,   client_if_none_match },
+   { "Range:",                    6,   client_range },
+   { "If-Range:",                 9,   client_range },
    { "X-Filter:",                 9,   client_x_filter },
    { "*",                         0,   crunch_client_header },
    { "*",                         0,   filter_header },
@@ -746,7 +856,7 @@ const struct parsers client_patterns[] = {
 };
 
 const struct parsers server_patterns[] = {
-   { "HTTP",                      4, server_http },
+   { "HTTP/",                     5, server_http },
    { "set-cookie:",              11, server_set_cookie },
    { "connection:",              11, connection },
    { "Content-Type:",            13, server_content_type },
@@ -780,12 +890,21 @@ const add_header_func_ptr add_client_headers[] = {
    NULL
 };
 
-
 const add_header_func_ptr add_server_headers[] = {
    connection_close_adder,
    NULL
 };
 
+/* The vanilla wafer. */
+static const char VANILLA_WAFER[] =
+   "NOTICE=TO_WHOM_IT_MAY_CONCERN_"
+   "Do_not_send_me_any_copyrighted_information_other_than_the_"
+   "document_that_I_am_requesting_or_any_of_its_necessary_components._"
+   "In_particular_do_not_send_me_any_cookies_that_"
+   "are_subject_to_a_claim_of_copyright_by_anybody._"
+   "Take_notice_that_I_refuse_to_be_bound_by_any_license_condition_"
+   "(copyright_or_otherwise)_applying_to_any_cookie._";
+
 /*********************************************************************
  *
  * Function    :  flush_socket
@@ -858,7 +977,7 @@ jb_err add_to_iob(struct client_state *csp, char *buf, int n)
     */
    if (need > csp->config->buffer_limit)
    {
-      log_error(LOG_LEVEL_ERROR, "Buffer limit reached while extending the buffer (iob)");
+      log_error(LOG_LEVEL_INFO, "Buffer limit reached while extending the buffer (iob)");
       return JB_ERR_MEMORY;
    }
 
@@ -945,7 +1064,7 @@ jb_err decompress_iob(struct client_state *csp)
        * 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");
+      log_error(LOG_LEVEL_ERROR, "Buffer too small decompressing iob");
       return JB_ERR_COMPRESS;
    }
 
@@ -967,7 +1086,7 @@ jb_err decompress_iob(struct client_state *csp)
        || (*cur++ != (char)0x8b)
        || (*cur++ != Z_DEFLATED))
       {
-         log_error (LOG_LEVEL_ERROR, "Invalid gzip header when decompressing");
+         log_error(LOG_LEVEL_ERROR, "Invalid gzip header when decompressing");
          return JB_ERR_COMPRESS;
       }
       else
@@ -980,7 +1099,7 @@ jb_err decompress_iob(struct client_state *csp)
          if (flags & 0xe0)
          {
             /* The gzip header has reserved bits set; bail out. */
-            log_error (LOG_LEVEL_ERROR, "Invalid gzip header flags when decompressing");
+            log_error(LOG_LEVEL_ERROR, "Invalid gzip header flags when decompressing");
             return JB_ERR_COMPRESS;
          }
          cur += 6;
@@ -1019,14 +1138,14 @@ jb_err decompress_iob(struct client_state *csp)
              * The number of bytes to skip should be positive
              * and we'd like to stay in the buffer.
              */
-            if((skip_bytes < 0) || (skip_bytes >= (csp->iob->eod - cur)))
+            if ((skip_bytes < 0) || (skip_bytes >= (csp->iob->eod - cur)))
             {
-               log_error (LOG_LEVEL_ERROR,
+               log_error(LOG_LEVEL_ERROR,
                   "Unreasonable amount of bytes to skip (%d). Stopping decompression",
                   skip_bytes);
                return JB_ERR_COMPRESS;
             }
-            log_error (LOG_LEVEL_INFO,
+            log_error(LOG_LEVEL_INFO,
                "Skipping %d bytes for gzip compression. Does this sound right?",
                skip_bytes);
             cur += skip_bytes;
@@ -1060,7 +1179,7 @@ jb_err decompress_iob(struct client_state *csp)
              * the buffer end, we were obviously tricked to skip
              * too much.
              */
-            log_error (LOG_LEVEL_ERROR,
+            log_error(LOG_LEVEL_ERROR,
                "Malformed gzip header detected. Aborting decompression.");
             return JB_ERR_COMPRESS;
          }
@@ -1072,7 +1191,7 @@ jb_err decompress_iob(struct client_state *csp)
        * XXX: The debug level should be lowered
        * before the next stable release.
        */
-      log_error (LOG_LEVEL_INFO, "Decompressing deflated iob: %d", *cur);
+      log_error(LOG_LEVEL_INFO, "Decompressing deflated iob: %d", *cur);
       /*
        * In theory (that is, according to RFC 1950), deflate-compressed
        * data should begin with a two-byte zlib header and have an
@@ -1092,7 +1211,7 @@ jb_err decompress_iob(struct client_state *csp)
    }
    else
    {
-      log_error (LOG_LEVEL_ERROR,
+      log_error(LOG_LEVEL_ERROR,
          "Unable to determine compression format for decompression");
       return JB_ERR_COMPRESS;
    }
@@ -1110,7 +1229,7 @@ jb_err decompress_iob(struct client_state *csp)
     */
    if (inflateInit2 (&zstr, -MAX_WBITS) != Z_OK)
    {
-      log_error (LOG_LEVEL_ERROR, "Error initializing decompression");
+      log_error(LOG_LEVEL_ERROR, "Error initializing decompression");
       return JB_ERR_COMPRESS;
    }
 
@@ -1119,10 +1238,10 @@ jb_err decompress_iob(struct client_state *csp)
     * We don't modify the existing iob yet, so in case there
     * is error in decompression we can recover gracefully.
     */
-   buf = zalloc (bufsize);
+   buf = zalloc(bufsize);
    if (NULL == buf)
    {
-      log_error (LOG_LEVEL_ERROR, "Out of memory decompressing iob");
+      log_error(LOG_LEVEL_ERROR, "Out of memory decompressing iob");
       return JB_ERR_MEMORY;
    }
 
@@ -1391,13 +1510,11 @@ char *get_header_value(const struct list *header_list, const char *header_name)
  * Returns     :  JB_ERR_OK
  *
  *********************************************************************/
-jb_err scan_headers(struct client_state *csp)
+static jb_err scan_headers(struct client_state *csp)
 {
    struct list_entry *h; /* Header */
    jb_err err = JB_ERR_OK;
 
-   log_error(LOG_LEVEL_HEADER, "scanning headers for: %s", csp->http->url);
-
    for (h = csp->headers->first; (err == JB_ERR_OK) && (h != NULL) ; h = h->next)
    {
       /* Header crunch()ed in previous run? -> ignore */
@@ -1406,17 +1523,6 @@ jb_err scan_headers(struct client_state *csp)
       err = header_tagger(csp, h->str);
    }
 
-   /*
-    * header_tagger already updated the action bits
-    * for every new tag, but unless I'm confused,
-    * updating them again after all tags are collected,
-    * should give us another level of indirection when
-    * it comes to tagging based on tags which were set
-    * by tag sections which were active because of other
-    * tag sections themselves (or something like this).
-    */
-   update_action_bits_for_all_tags(csp);
-
    return err;
 }
 
@@ -1433,19 +1539,21 @@ jb_err scan_headers(struct client_state *csp)
  *                As a side effect it frees the space used by the original
  *                header lines.
  *
+ *                XXX: should be split to remove the first_run hack.
+ *
  * Parameters  :
  *          1  :  pats = list of patterns to match against headers
  *          2  :  more_headers = list of functions to add more
  *                headers (client or server)
  *          3  :  csp = Current client state (buffers, headers, etc...)
  *
- * Returns     :  Single pointer to a fully formed header, or NULL
- *                on out-of-memory error.
+ * Returns     :  JB_ERR_OK in case off success, or
+ *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-char *sed(const struct parsers pats[],
-          const add_header_func_ptr more_headers[],
-          struct client_state *csp)
+jb_err sed(const struct parsers pats[],
+           const add_header_func_ptr more_headers[],
+           struct client_state *csp)
 {
    struct list_entry *p;
    const struct parsers *v;
@@ -1509,12 +1617,7 @@ char *sed(const struct parsers pats[],
       }
    }
 
-   if (err != JB_ERR_OK)
-   {
-      return NULL;
-   }
-
-   return list_to_text(csp->headers);
+   return err;
 }
 
 
@@ -1536,7 +1639,7 @@ char *sed(const struct parsers pats[],
  * Returns     :  JB_ERR_OK on success and always succeeds
  *
  *********************************************************************/
-jb_err header_tagger(struct client_state *csp, char *header)
+static jb_err header_tagger(struct client_state *csp, char *header)
 {
    int wanted_filter_type;
    int multi_action_index;
@@ -1616,8 +1719,11 @@ jb_err header_tagger(struct client_state *csp, char *header)
                char *modified_tag = NULL;
                char *tag = header;
                size_t size = header_length;
+               pcrs_job *joblist = b->joblist;
 
-               if (NULL == b->joblist)
+               if (b->dynamic) joblist = compile_dynamic_pcrs_job_list(csp, b);
+
+               if (NULL == joblist)
                {
                   log_error(LOG_LEVEL_RE_FILTER,
                      "Tagger %s has empty joblist. Nothing to do.", b->name);
@@ -1625,7 +1731,7 @@ jb_err header_tagger(struct client_state *csp, char *header)
                }
 
                /* execute their pcrs_joblist on the header. */
-               for (job = b->joblist; NULL != job; job = job->next)
+               for (job = joblist; NULL != job; job = job->next)
                {
                   const int hits = pcrs_execute(job, tag, size, &modified_tag, &size);
 
@@ -1652,6 +1758,8 @@ jb_err header_tagger(struct client_state *csp, char *header)
                   }
                }
 
+               if (b->dynamic) pcrs_free_joblist(joblist);
+
                /* If this tagger matched */
                if (tag != header)
                {
@@ -1738,7 +1846,7 @@ jb_err header_tagger(struct client_state *csp, char *header)
  * Returns     :  JB_ERR_OK on success and always succeeds
  *
  *********************************************************************/
-jb_err filter_header(struct client_state *csp, char **header)
+static jb_err filter_header(struct client_state *csp, char **header)
 {
    int hits=0;
    int matches;
@@ -1755,6 +1863,11 @@ jb_err filter_header(struct client_state *csp, char **header)
    int wanted_filter_type;
    int multi_action_index;
 
+   if (csp->flags & CSP_FLAG_NO_FILTERING)
+   {
+      return JB_ERR_OK;
+   }
+
    if (csp->flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
    {
       wanted_filter_type = FT_SERVER_HEADER_FILTER;
@@ -1823,8 +1936,11 @@ jb_err filter_header(struct client_state *csp, char **header)
             if (strcmp(b->name, filtername->str) == 0)
             {
                int current_hits = 0;
+               pcrs_job *joblist = b->joblist;
 
-               if ( NULL == b->joblist )
+               if (b->dynamic) joblist = compile_dynamic_pcrs_job_list(csp, b);
+
+               if (NULL == joblist)
                {
                   log_error(LOG_LEVEL_RE_FILTER, "Filter %s has empty joblist. Nothing to do.", b->name);
                   continue;
@@ -1834,7 +1950,7 @@ jb_err filter_header(struct client_state *csp, char **header)
                          *header, size, b->name);
 
                /* Apply all jobs from the joblist */
-               for (job = b->joblist; NULL != job; job = job->next)
+               for (job = joblist; NULL != job; job = job->next)
                {
                   matches = pcrs_execute(job, *header, size, &newheader, &size);
                   if ( 0 < matches )
@@ -1854,13 +1970,16 @@ jb_err filter_header(struct client_state *csp, char **header)
                      /* RegEx failure */
                      log_error(LOG_LEVEL_ERROR, "Filtering \'%s\' with \'%s\' didn't work out: %s",
                         *header, b->name, pcrs_strerror(matches));
-                     if( newheader != NULL)
+                     if (newheader != NULL)
                      {
                         log_error(LOG_LEVEL_ERROR, "Freeing what's left: %s", newheader);
                         freez(newheader);
                      }
                   }
                }
+
+               if (b->dynamic) pcrs_free_joblist(joblist);
+
                log_error(LOG_LEVEL_RE_FILTER, "... produced %d hits (new size %d).", current_hits, size);
                hits += current_hits;
             }
@@ -1902,7 +2021,7 @@ jb_err filter_header(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err connection(struct client_state *csp, char **header)
+static jb_err connection(struct client_state *csp, char **header)
 {
    char *old_header = *header;
 
@@ -1950,13 +2069,14 @@ jb_err connection(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err crumble(struct client_state *csp, char **header)
+static jb_err crumble(struct client_state *csp, char **header)
 {
    log_error(LOG_LEVEL_HEADER, "crumble crunched: %s!", *header);
    freez(*header);
    return JB_ERR_OK;
 }
 
+
 /*********************************************************************
  *
  * Function    :  crunch_server_header
@@ -1974,7 +2094,7 @@ jb_err crumble(struct client_state *csp, char **header)
  * Returns     :  JB_ERR_OK on success and always succeeds
  *
  *********************************************************************/
-jb_err crunch_server_header(struct client_state *csp, char **header)
+static jb_err crunch_server_header(struct client_state *csp, char **header)
 {
    const char *crunch_pattern;
 
@@ -2017,10 +2137,10 @@ jb_err crunch_server_header(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err server_content_type(struct client_state *csp, char **header)
+static jb_err server_content_type(struct client_state *csp, char **header)
 {
    /* Remove header if it isn't the first Content-Type header */
-   if(csp->content_type && (csp->content_type != CT_TABOO))
+   if ((csp->content_type & CT_DECLARED))
    {
      /*
       * Another, slightly slower, way to see if
@@ -2036,6 +2156,11 @@ jb_err server_content_type(struct client_state *csp, char **header)
       return JB_ERR_OK;
    }
 
+   /*
+    * Signal that the Content-Type has been set.
+    */
+   csp->content_type |= CT_DECLARED;
+
    if (!(csp->content_type & CT_TABOO))
    {
       if ((strstr(*header, " text/") && !strstr(*header, "plain"))
@@ -2052,29 +2177,8 @@ jb_err server_content_type(struct client_state *csp, char **header)
       {
          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)
-      {
-         log_error(LOG_LEVEL_HEADER, "Text mode is already enabled.");   
-      }
-      else
-      {
-         csp->content_type |= CT_TEXT;
-         log_error(LOG_LEVEL_HEADER, "Text mode enabled by force. Take cover!");   
-      }
    }
+
    /*
     * Are we messing with the content type?
     */ 
@@ -2084,7 +2188,7 @@ jb_err server_content_type(struct client_state *csp, char **header)
        * Make sure the user doesn't accidently
        * change the content type of binary documents. 
        */ 
-      if (csp->content_type & CT_TEXT)
+      if ((csp->content_type & CT_TEXT) || (csp->action->flags & ACTION_FORCE_TEXT_MODE))
       { 
          freez(*header);
          *header = strdup("Content-Type: ");
@@ -2103,6 +2207,7 @@ jb_err server_content_type(struct client_state *csp, char **header)
             "Enable force-text-mode if you know what you're doing.", *header);   
       }
    }  
+
    return JB_ERR_OK;
 }
 
@@ -2127,7 +2232,7 @@ jb_err server_content_type(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err server_transfer_coding(struct client_state *csp, char **header)
+static jb_err server_transfer_coding(struct client_state *csp, char **header)
 {
    /*
     * Turn off pcrs and gif filtering if body compressed
@@ -2195,7 +2300,7 @@ jb_err server_transfer_coding(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err server_content_encoding(struct client_state *csp, char **header)
+static jb_err server_content_encoding(struct client_state *csp, char **header)
 {
 #ifdef FEATURE_ZLIB
    if ((csp->flags & CSP_FLAG_MODIFIED)
@@ -2275,7 +2380,7 @@ jb_err server_content_encoding(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err server_content_length(struct client_state *csp, char **header)
+static jb_err server_content_length(struct client_state *csp, char **header)
 {
    const size_t max_header_length = 80;
 
@@ -2317,7 +2422,7 @@ jb_err server_content_length(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err server_content_md5(struct client_state *csp, char **header)
+static jb_err server_content_md5(struct client_state *csp, char **header)
 {
    if (csp->flags & CSP_FLAG_MODIFIED)
    {
@@ -2328,6 +2433,7 @@ jb_err server_content_md5(struct client_state *csp, char **header)
    return JB_ERR_OK;
 }
 
+
 /*********************************************************************
  *
  * Function    :  server_content_disposition
@@ -2346,7 +2452,7 @@ jb_err server_content_md5(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err server_content_disposition(struct client_state *csp, char **header)
+static jb_err server_content_disposition(struct client_state *csp, char **header)
 {
    const char *newval;
 
@@ -2391,6 +2497,7 @@ jb_err server_content_disposition(struct client_state *csp, char **header)
    return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
 }
 
+
 /*********************************************************************
  *
  * Function    :  server_last_modified
@@ -2410,7 +2517,7 @@ jb_err server_content_disposition(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err server_last_modified(struct client_state *csp, char **header)
+static jb_err server_last_modified(struct client_state *csp, char **header)
 {
    const char *newval;
    char buf[BUFFER_SIZE];
@@ -2510,7 +2617,7 @@ jb_err server_last_modified(struct client_state *csp, char **header)
                return JB_ERR_MEMORY;  
             }
 
-            if(LOG_LEVEL_HEADER & debug) /* Save cycles if the user isn't interested. */
+            if (LOG_LEVEL_HEADER & debug) /* Save cycles if the user isn't interested. */
             {
                days    = rtime / (3600 * 24);
                hours   = rtime / 3600 % 24;
@@ -2552,7 +2659,7 @@ jb_err server_last_modified(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_accept_encoding(struct client_state *csp, char **header)
+static jb_err client_accept_encoding(struct client_state *csp, char **header)
 {
    if ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
    {
@@ -2597,7 +2704,7 @@ jb_err client_accept_encoding(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_te(struct client_state *csp, char **header)
+static jb_err client_te(struct client_state *csp, char **header)
 {
    if ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
    {
@@ -2608,6 +2715,7 @@ jb_err client_te(struct client_state *csp, char **header)
    return JB_ERR_OK;
 }
 
+
 /*********************************************************************
  *
  * Function    :  client_referrer
@@ -2626,115 +2734,67 @@ jb_err client_te(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_referrer(struct client_state *csp, char **header)
+static jb_err client_referrer(struct client_state *csp, char **header)
 {
-   const char *newval;
-   const char *host;
-   char *referer;
-   size_t hostlenght;
+   const char *parameter;
+   /* booleans for parameters we have to check multiple times */
+   int parameter_conditional_block;
+   int parameter_conditional_forge;
  
 #ifdef FEATURE_FORCE_LOAD
-   /* Since the referrer can include the prefix even
+   /*
+    * Since the referrer can include the prefix even
     * if the request itself is non-forced, we must
-    * clean it unconditionally
+    * clean it unconditionally.
+    *
+    * XXX: strclean is too broad
     */
    strclean(*header, FORCE_PREFIX);
 #endif /* def FEATURE_FORCE_LOAD */
 
-   /*
-    * Are we sending referer?
-    */
    if ((csp->action->flags & ACTION_HIDE_REFERER) == 0)
    {
+      /* Nothing left to do */
       return JB_ERR_OK;
    }
 
-   newval = csp->action->string[ACTION_STRING_REFERER];
+   parameter = csp->action->string[ACTION_STRING_REFERER];
+   assert(parameter != NULL);
+   parameter_conditional_block = (0 == strcmpic(parameter, "conditional-block"));
+   parameter_conditional_forge = (0 == strcmpic(parameter, "conditional-forge"));
 
-   if ((0 != strcmpic(newval, "conditional-block")))
-   {  
-      freez(*header);
-   }
-   if ((newval == NULL) || (0 == strcmpic(newval, "block")) )
+   if (!parameter_conditional_block && !parameter_conditional_forge)
    {
       /*
-       * Blocking referer
+       * As conditional-block and conditional-forge are the only
+       * parameters that rely on the original referrer, we can
+       * remove it now for all the others.
        */
+      freez(*header);
+   }
+
+   if (0 == strcmpic(parameter, "block"))
+   {
       log_error(LOG_LEVEL_HEADER, "Referer crunched!");
       return JB_ERR_OK;
    }
-   else if (0 == strcmpic(newval, "conditional-block"))
+   else if (parameter_conditional_block || parameter_conditional_forge)
    {
-      /*
-       * Block referer if host has changed.
-       */
-
-      if (NULL == (host = strdup(csp->http->hostport)))
-      {
-         freez(*header);
-         log_error(LOG_LEVEL_HEADER, "Referer crunched! Couldn't allocate memory for temporary host copy.");
-         return JB_ERR_MEMORY;
-      }
-      if (NULL == (referer = strdup(*header)))
-      {
-         freez(*header);
-         freez(host);
-         log_error(LOG_LEVEL_HEADER, "Referer crunched! Couldn't allocate memory for temporary referer copy.");
-         return JB_ERR_MEMORY;
-      }
-      hostlenght = strlen(host);
-      if ( hostlenght < (strlen(referer)-17) ) /*referer begins with 'Referer: http[s]://'*/
-      {
-         /*Shorten referer to make sure the referer is blocked
-          *if www.example.org/www.example.com-shall-see-the-referer/
-          *links to www.example.com/
-          */
-         referer[hostlenght+17] = '\0';
-      }
-      if ( 0 == strstr(referer, host)) /*Host has changed*/
-      {
-         log_error(LOG_LEVEL_HEADER, "New host is: %s. Crunching %s!", host, *header);
-         freez(*header);
-      }
-      else
-      {
-         log_error(LOG_LEVEL_HEADER, "%s (not modified, still on %s)", *header, host);
-      }
-      freez(referer);
-      freez(host);
-      return JB_ERR_OK;    
+      return handle_conditional_hide_referrer_parameter(header,
+         csp->http->hostport, parameter_conditional_block);
    }
-   else if (0 != strcmpic(newval, "forge"))
+   else if (0 == strcmpic(parameter, "forge"))
    {
-      /*
-       * We have a specific (fixed) referer we want to send.
-       */
-      if ((0 != strncmpic(newval, "http://", 7)) && (0 != strncmpic(newval, "https://", 8)))
-      {
-         log_error(LOG_LEVEL_HEADER, "Parameter: +referrer{%s} is a bad idea, but I don't care.", newval);
-      }
-      *header = strdup("Referer: ");
-      string_append(header, newval);
-      log_error(LOG_LEVEL_HEADER, "Referer overwritten with: %s", *header);
-
-      return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
+      return create_forged_referrer(header, csp->http->hostport);
    }
    else
    {
-      /*
-       * Forge a referer as http://[hostname:port of REQUEST]/
-       * to fool stupid checks for in-site links
-       */
-
-      *header = strdup("Referer: http://");
-      string_append(header, csp->http->hostport);
-      string_append(header, "/");
-      log_error(LOG_LEVEL_HEADER, "Referer forged to: %s", *header);
-      
-      return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
+      /* interpret parameter as user-supplied referer to fake */
+      return create_fake_referrer(header, parameter);
    }
 }
 
+
 /*********************************************************************
  *
  * Function    :  client_accept_language
@@ -2753,7 +2813,7 @@ jb_err client_referrer(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_accept_language(struct client_state *csp, char **header)
+static jb_err client_accept_language(struct client_state *csp, char **header)
 {
    const char *newval;
 
@@ -2800,6 +2860,7 @@ jb_err client_accept_language(struct client_state *csp, char **header)
    return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
 }
 
+
 /*********************************************************************
  *
  * Function    :  crunch_client_header
@@ -2817,7 +2878,7 @@ jb_err client_accept_language(struct client_state *csp, char **header)
  * Returns     :  JB_ERR_OK on success and always succeeds
  *
  *********************************************************************/
-jb_err crunch_client_header(struct client_state *csp, char **header)
+static jb_err crunch_client_header(struct client_state *csp, char **header)
 {
    const char *crunch_pattern;
 
@@ -2856,7 +2917,7 @@ jb_err crunch_client_header(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_uagent(struct client_state *csp, char **header)
+static jb_err client_uagent(struct client_state *csp, char **header)
 {
    const char *newval;
 
@@ -2880,6 +2941,7 @@ jb_err client_uagent(struct client_state *csp, char **header)
    return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
 }
 
+
 /*********************************************************************
  *
  * Function    :  client_ua
@@ -2897,7 +2959,7 @@ jb_err client_uagent(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_ua(struct client_state *csp, char **header)
+static jb_err client_ua(struct client_state *csp, char **header)
 {
    if ((csp->action->flags & ACTION_HIDE_USER_AGENT) != 0)
    {
@@ -2927,7 +2989,7 @@ jb_err client_ua(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_from(struct client_state *csp, char **header)
+static jb_err client_from(struct client_state *csp, char **header)
 {
    const char *newval;
 
@@ -2978,7 +3040,7 @@ jb_err client_from(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_send_cookie(struct client_state *csp, char **header)
+static jb_err client_send_cookie(struct client_state *csp, char **header)
 {
    if (csp->action->flags & ACTION_NO_COOKIE_READ)
    {
@@ -3050,7 +3112,7 @@ jb_err client_x_forwarded(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_max_forwards(struct client_state *csp, char **header)
+static jb_err client_max_forwards(struct client_state *csp, char **header)
 {
    int max_forwards;
 
@@ -3071,17 +3133,6 @@ jb_err client_max_forwards(struct client_state *csp, char **header)
             log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header);
             freez(*header);
          }
-         else
-         {
-            /*
-             * Not supposed to be reached. direct_response() which
-             * was already called earlier in chat() should have
-             * intercepted the request.
-             */
-            log_error(LOG_LEVEL_ERROR,
-               "Non-intercepted %s request with Max-Forwards zero!", csp->http->gpc);
-            assert(max_forwards != 0);
-         }
       }
       else
       {
@@ -3116,7 +3167,7 @@ jb_err client_max_forwards(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_host(struct client_state *csp, char **header)
+static jb_err client_host(struct client_state *csp, char **header)
 {
    char *p, *q;
 
@@ -3173,6 +3224,7 @@ jb_err client_host(struct client_state *csp, char **header)
    return JB_ERR_OK;
 }
 
+
 /*********************************************************************
  *
  * Function    :  client_if_modified_since
@@ -3190,7 +3242,7 @@ jb_err client_host(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_if_modified_since(struct client_state *csp, char **header)
+static jb_err client_if_modified_since(struct client_state *csp, char **header)
 {
    char newheader[50];
 #ifdef HAVE_GMTIME_R
@@ -3237,11 +3289,11 @@ jb_err client_if_modified_since(struct client_state *csp, char **header)
          else
          {
             rtime = strtol(newval, &endptr, 0);
-            if(rtime)
+            if (rtime)
             {
                log_error(LOG_LEVEL_HEADER, "Randomizing: %s (random range: %d minut%s)",
                   *header, rtime, (rtime == 1 || rtime == -1) ? "e": "es");
-               if(rtime < 0)
+               if (rtime < 0)
                {
                   rtime *= -1; 
                   negative = 1;
@@ -3276,7 +3328,7 @@ jb_err client_if_modified_since(struct client_state *csp, char **header)
                return JB_ERR_MEMORY;  
             }
 
-            if(LOG_LEVEL_HEADER & debug) /* Save cycles if the user isn't interested. */
+            if (LOG_LEVEL_HEADER & debug) /* Save cycles if the user isn't interested. */
             {
                hours   = rtime / 3600;
                minutes = rtime / 60 % 60;
@@ -3293,6 +3345,7 @@ jb_err client_if_modified_since(struct client_state *csp, char **header)
    return JB_ERR_OK;
 }
 
+
 /*********************************************************************
  *
  * Function    :  client_if_none_match
@@ -3310,7 +3363,7 @@ jb_err client_if_modified_since(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_if_none_match(struct client_state *csp, char **header)
+static jb_err client_if_none_match(struct client_state *csp, char **header)
 {
    if (csp->action->flags & ACTION_CRUNCH_IF_NONE_MATCH)
    {  
@@ -3321,6 +3374,7 @@ jb_err client_if_none_match(struct client_state *csp, char **header)
    return JB_ERR_OK;
 }
 
+
 /*********************************************************************
  *
  * Function    :  client_x_filter
@@ -3355,9 +3409,8 @@ jb_err client_x_filter(struct client_state *csp, char **header)
          }
          else
          {  
-            csp->content_type = CT_TABOO;
-            csp->action->flags &= ~ACTION_FILTER_SERVER_HEADERS;
-            csp->action->flags &= ~ACTION_FILTER_CLIENT_HEADERS;
+            csp->content_type = CT_TABOO; /* XXX: This hack shouldn't be necessary */
+            csp->flags |= CSP_FLAG_NO_FILTERING;
             log_error(LOG_LEVEL_HEADER, "Accepted the client's request to fetch without filtering.");
          }
          log_error(LOG_LEVEL_HEADER, "Crunching %s", *header);
@@ -3367,6 +3420,40 @@ jb_err client_x_filter(struct client_state *csp, char **header)
    return JB_ERR_OK; 
 }
 
+
+/*********************************************************************
+ *
+ * Function    :  client_range
+ *
+ * Description :  Removes Range and If-Range headers if content
+ *                filtering is enabled. If the client's version of
+ *                the document has been altered by Privoxy, the server
+ *                could interpret the range differently than the client
+ *                intended in which case the user could end up with
+ *                corrupted content.
+ *
+ * Parameters  :
+ *          1  :  csp = Current client state (buffers, headers, etc...)
+ *          2  :  header = On input, pointer to header to modify.
+ *                On output, pointer to the modified header, or NULL
+ *                to remove the header.  This function frees the
+ *                original string if necessary.
+ *
+ * Returns     :  JB_ERR_OK
+ *
+ *********************************************************************/
+static jb_err client_range(struct client_state *csp, char **header)
+{
+   if (content_filters_enabled(csp))
+   {
+      log_error(LOG_LEVEL_HEADER, "Content filtering is enabled."
+         " Crunching: \'%s\' to prevent range-mismatch problems.", *header);
+      freez(*header);
+   }
+
+   return JB_ERR_OK; 
+}
+
 /* the following functions add headers directly to the header list */
 
 /*********************************************************************
@@ -3383,7 +3470,7 @@ jb_err client_x_filter(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_host_adder(struct client_state *csp)
+static jb_err client_host_adder(struct client_state *csp)
 {
    char *p;
    jb_err err;
@@ -3425,9 +3512,8 @@ jb_err client_host_adder(struct client_state *csp)
  *
  * Function    :  client_cookie_adder
  *
- * Description :  Used in the add_client_headers list.  Called from `sed'.
- *
- *                XXX: Remove csp->cookie_list which is no longer used.
+ * Description :  Used in the add_client_headers list to add "wafers".
+ *                Called from `sed'.
  *
  * Parameters  :
  *          1  :  csp = Current client state (buffers, headers, etc...)
@@ -3438,45 +3524,39 @@ jb_err client_host_adder(struct client_state *csp)
  *********************************************************************/
 jb_err client_cookie_adder(struct client_state *csp)
 {
-   struct list_entry *lst;
    char *tmp;
-   struct list_entry *list1 = csp->cookie_list->first;
-   struct list_entry *list2 = csp->action->multi[ACTION_MULTI_WAFER]->first;
-   int first_cookie = 1;
+   struct list_entry *wafer;
+   struct list_entry *wafer_list;
    jb_err err;
 
-   if ((list1 == NULL) && (list2 == NULL))
+   /*
+    * If the user has not supplied any wafers, and the user has not
+    * told us to suppress the vanilla wafer, then send the vanilla wafer.
+    */
+   if ((0 != (csp->action->flags & ACTION_VANILLA_WAFER))
+      && list_is_empty(csp->action->multi[ACTION_MULTI_WAFER]))
    {
-      /* Nothing to do */
-      return JB_ERR_OK;
+      enlist(csp->action->multi[ACTION_MULTI_WAFER], VANILLA_WAFER);
    }
 
-   tmp = strdup("Cookie: ");
+   wafer_list = csp->action->multi[ACTION_MULTI_WAFER]->first;
 
-   for (lst = list1; lst ; lst = lst->next)
+   if (NULL == wafer_list)
    {
-      if (first_cookie)
-      {
-         first_cookie = 0;
-      }
-      else
-      {
-         string_append(&tmp, "; ");
-      }
-      string_append(&tmp, lst->str);
+      /* Nothing to do */
+      return JB_ERR_OK;
    }
 
-   for (lst = list2;  lst ; lst = lst->next)
+   tmp = strdup("Cookie: ");
+
+   for (wafer = wafer_list; (NULL != tmp) && (NULL != wafer); wafer = wafer->next)
    {
-      if (first_cookie)
-      {
-         first_cookie = 0;
-      }
-      else
+      if (wafer != wafer_list)
       {
+         /* As this isn't the first wafer, we need a delimiter. */
          string_append(&tmp, "; ");
       }
-      string_join(&tmp, cookie_encode(lst->str));
+      string_join(&tmp, cookie_encode(wafer->str));
    }
 
    if (tmp == NULL)
@@ -3491,6 +3571,7 @@ jb_err client_cookie_adder(struct client_state *csp)
 }
 
 
+#if 0
 /*********************************************************************
  *
  * Function    :  client_accept_encoding_adder
@@ -3507,10 +3588,8 @@ jb_err client_cookie_adder(struct client_state *csp)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_accept_encoding_adder(struct client_state *csp)
+static jb_err client_accept_encoding_adder(struct client_state *csp)
 {
-   assert(0); /* Not in use */
-
    if (   ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
        && (!strcmpic(csp->http->ver, "HTTP/1.1")) )
    {
@@ -3519,6 +3598,7 @@ jb_err client_accept_encoding_adder(struct client_state *csp)
 
    return JB_ERR_OK;
 }
+#endif
 
 
 /*********************************************************************
@@ -3534,7 +3614,7 @@ jb_err client_accept_encoding_adder(struct client_state *csp)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_xtra_adder(struct client_state *csp)
+static jb_err client_xtra_adder(struct client_state *csp)
 {
    struct list_entry *lst;
    jb_err err;
@@ -3568,7 +3648,7 @@ jb_err client_xtra_adder(struct client_state *csp)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err client_x_forwarded_adder(struct client_state *csp)
+static jb_err client_x_forwarded_adder(struct client_state *csp)
 {
    char *p = NULL;
    jb_err err;
@@ -3619,7 +3699,7 @@ jb_err client_x_forwarded_adder(struct client_state *csp)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err connection_close_adder(struct client_state *csp)
+static jb_err connection_close_adder(struct client_state *csp)
 {
    const unsigned int flags = csp->flags;
 
@@ -3667,7 +3747,7 @@ jb_err connection_close_adder(struct client_state *csp)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err server_http(struct client_state *csp, char **header)
+static jb_err server_http(struct client_state *csp, char **header)
 {
    sscanf(*header, "HTTP/%*d.%*d %d", &(csp->http->status));
    if (csp->http->status == 206)
@@ -3677,8 +3757,21 @@ jb_err server_http(struct client_state *csp, char **header)
 
    if ((csp->action->flags & ACTION_DOWNGRADE) != 0)
    {
-      (*header)[7] = '0';
-      log_error(LOG_LEVEL_HEADER, "Downgraded answer to HTTP/1.0");
+      /* XXX: Should we do a real validity check here? */
+      if (strlen(*header) > 8)
+      {
+         (*header)[7] = '0';
+         log_error(LOG_LEVEL_HEADER, "Downgraded answer to HTTP/1.0");
+      }
+      else
+      {
+         /*
+          * XXX: Should we block the request or
+          * enlist a valid status code line here?
+          */
+         log_error(LOG_LEVEL_INFO, "Malformed server response detected. "
+            "Downgrading to HTTP/1.0 impossible.");
+      }
    }
 
    return JB_ERR_OK;
@@ -3709,7 +3802,7 @@ jb_err server_http(struct client_state *csp, char **header)
  *                JB_ERR_MEMORY on out-of-memory error.
  *
  *********************************************************************/
-jb_err server_set_cookie(struct client_state *csp, char **header)
+static jb_err server_set_cookie(struct client_state *csp, char **header)
 {
    time_t now;
    time_t cookie_time; 
@@ -3933,6 +4026,7 @@ int strclean(const char *string, const char *substring)
 }
 #endif /* def FEATURE_FORCE_LOAD */
 
+
 /*********************************************************************
  *
  * Function    :  parse_header_time
@@ -3948,7 +4042,7 @@ int strclean(const char *string, const char *substring)
  *                JB_ERR_PARSE otherwise.
  *
  *********************************************************************/
-jb_err parse_header_time(const char *header_time, time_t *result)
+static jb_err parse_header_time(const char *header_time, time_t *result)
 {
    struct tm gmt;
 
@@ -3982,6 +4076,7 @@ jb_err parse_header_time(const char *header_time, time_t *result)
 
 }
 
+
 /*********************************************************************
  *
  * Function    :  get_destination_from_headers
@@ -4064,6 +4159,142 @@ jb_err get_destination_from_headers(const struct list *headers, struct http_requ
 }
 
 
+/*********************************************************************
+ *
+ * Function    :  create_forged_referrer
+ *
+ * Description :  Helper for client_referrer to forge a referer as
+ *                'http://[hostname:port/' to fool stupid
+ *                checks for in-site links 
+ *
+ * Parameters  :
+ *          1  :  header   = Pointer to header pointer
+ *          2  :  hostport = Host and optionally port as string
+ *
+ * Returns     :  JB_ERR_OK in case of success, or
+ *                JB_ERR_MEMORY in case of memory problems.
+ *
+ *********************************************************************/
+static jb_err create_forged_referrer(char **header, const char *hostport)
+{
+    assert(NULL == *header);
+
+    *header = strdup("Referer: http://");
+    string_append(header, hostport);
+    string_append(header, "/");
+
+    if (NULL == *header)
+    {
+       return JB_ERR_MEMORY;
+    }
+
+    log_error(LOG_LEVEL_HEADER, "Referer forged to: %s", *header);
+
+    return JB_ERR_OK;
+
+}
+
+
+/*********************************************************************
+ *
+ * Function    :  create_fake_referrer
+ *
+ * Description :  Helper for client_referrer to create a fake referrer
+ *                based on a string supplied by the user.
+ *
+ * Parameters  :
+ *          1  :  header   = Pointer to header pointer
+ *          2  :  hosthost = Referrer to fake
+ *
+ * Returns     :  JB_ERR_OK in case of success, or
+ *                JB_ERR_MEMORY in case of memory problems.
+ *
+ *********************************************************************/
+static jb_err create_fake_referrer(char **header, const char *fake_referrer)
+{
+   assert(NULL == *header);
+
+   if ((0 != strncmpic(fake_referrer, "http://", 7)) && (0 != strncmpic(fake_referrer, "https://", 8)))
+   {
+      log_error(LOG_LEVEL_HEADER,
+         "Parameter: +hide-referrer{%s} is a bad idea, but I don't care.", fake_referrer);
+   }
+   *header = strdup("Referer: ");
+   string_append(header, fake_referrer);
+
+   if (NULL == *header)
+   {
+      return JB_ERR_MEMORY;
+   }
+
+   log_error(LOG_LEVEL_HEADER, "Referer replaced with: %s", *header);
+
+   return JB_ERR_OK;
+
+}
+
+
+/*********************************************************************
+ *
+ * Function    :  handle_conditional_hide_referrer_parameter
+ *
+ * Description :  Helper for client_referrer to crunch or forge
+ *                the referrer header if the host has changed.
+ *
+ * Parameters  :
+ *          1  :  header = Pointer to header pointer
+ *          2  :  host   = The target host (may include the port)
+ *          3  :  parameter_conditional_block = Boolean to signal
+ *                if we're in conditional-block mode. If not set,
+ *                we're in conditional-forge mode.
+ *
+ * Returns     :  JB_ERR_OK in case of success, or
+ *                JB_ERR_MEMORY in case of memory problems.
+ *
+ *********************************************************************/
+static jb_err handle_conditional_hide_referrer_parameter(char **header,
+   const char *host, const int parameter_conditional_block)
+{
+   char *referer = strdup(*header);
+   const size_t hostlenght = strlen(host);
+
+   if (NULL == referer)
+   {
+      freez(*header);
+      return JB_ERR_MEMORY;
+   }
+
+   /* referer begins with 'Referer: http[s]://' */
+   if (hostlenght < (strlen(referer)-17))
+   {
+      /*
+       * Shorten referer to make sure the referer is blocked
+       * if www.example.org/www.example.com-shall-see-the-referer/
+       * links to www.example.com/
+       */
+      referer[hostlenght+17] = '\0';
+   }
+   if (NULL == strstr(referer, host))
+   {
+      /* Host has changed */
+      if (parameter_conditional_block)
+      {
+         log_error(LOG_LEVEL_HEADER, "New host is: %s. Crunching %s!", host, *header);
+         freez(*header);
+      }
+      else
+      {
+         freez(*header);
+         freez(referer);
+         return create_forged_referrer(header, host);
+      }
+   }
+   freez(referer);
+
+   return JB_ERR_OK;
+
+}
+
 /*
   Local Variables:
   tab-width: 3