Do not pass rejected keep-alive timeouts to the server
[privoxy.git] / parsers.c
1 const char parsers_rcs[] = "$Id: parsers.c,v 1.283 2014/02/10 14:42:18 fabiankeil Exp $";
2 /*********************************************************************
3  *
4  * File        :  $Source: /cvsroot/ijbswa/current/parsers.c,v $
5  *
6  * Purpose     :  Declares functions to parse/crunch headers and pages.
7  *
8  * Copyright   :  Written by and Copyright (C) 2001-2012 the
9  *                Privoxy team. http://www.privoxy.org/
10  *
11  *                Based on the Internet Junkbuster originally written
12  *                by and Copyright (C) 1997 Anonymous Coders and
13  *                Junkbusters Corporation.  http://www.junkbusters.com
14  *
15  *                This program is free software; you can redistribute it
16  *                and/or modify it under the terms of the GNU General
17  *                Public License as published by the Free Software
18  *                Foundation; either version 2 of the License, or (at
19  *                your option) any later version.
20  *
21  *                This program is distributed in the hope that it will
22  *                be useful, but WITHOUT ANY WARRANTY; without even the
23  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
24  *                PARTICULAR PURPOSE.  See the GNU General Public
25  *                License for more details.
26  *
27  *                The GNU General Public License should be included with
28  *                this file.  If not, you can view it at
29  *                http://www.gnu.org/copyleft/gpl.html
30  *                or write to the Free Software Foundation, Inc., 59
31  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
32  *
33  *********************************************************************/
34
35
36 #include "config.h"
37
38 #ifndef _WIN32
39 #include <stdio.h>
40 #include <sys/types.h>
41 #endif
42
43 #include <stdlib.h>
44 #include <ctype.h>
45 #include <assert.h>
46 #include <string.h>
47
48 #ifdef __GLIBC__
49 /*
50  * Convince GNU's libc to provide a strptime prototype.
51  */
52 #define __USE_XOPEN
53 #endif /*__GLIBC__ */
54 #include <time.h>
55
56 #ifdef FEATURE_ZLIB
57 #include <zlib.h>
58
59 #define GZIP_IDENTIFIER_1       0x1f
60 #define GZIP_IDENTIFIER_2       0x8b
61
62 #define GZIP_FLAG_CHECKSUM      0x02
63 #define GZIP_FLAG_EXTRA_FIELDS  0x04
64 #define GZIP_FLAG_FILE_NAME     0x08
65 #define GZIP_FLAG_COMMENT       0x10
66 #define GZIP_FLAG_RESERVED_BITS 0xe0
67 #endif
68
69 #if !defined(_WIN32) && !defined(__OS2__)
70 #include <unistd.h>
71 #endif
72
73 #include "project.h"
74
75 #ifdef FEATURE_PTHREAD
76 #include "jcc.h"
77 /* jcc.h is for mutex semapores only */
78 #endif /* def FEATURE_PTHREAD */
79 #include "list.h"
80 #include "parsers.h"
81 #include "ssplit.h"
82 #include "errlog.h"
83 #include "jbsockets.h"
84 #include "miscutil.h"
85 #include "list.h"
86 #include "actions.h"
87 #include "filters.h"
88
89 #ifndef HAVE_STRPTIME
90 #include "strptime.h"
91 #endif
92
93 const char parsers_h_rcs[] = PARSERS_H_VERSION;
94
95 static char *get_header_line(struct iob *iob);
96 static jb_err scan_headers(struct client_state *csp);
97 static jb_err header_tagger(struct client_state *csp, char *header);
98 static jb_err parse_header_time(const char *header_time, time_t *result);
99
100 static jb_err crumble                   (struct client_state *csp, char **header);
101 static jb_err filter_header             (struct client_state *csp, char **header);
102 static jb_err client_connection         (struct client_state *csp, char **header);
103 static jb_err client_referrer           (struct client_state *csp, char **header);
104 static jb_err client_uagent             (struct client_state *csp, char **header);
105 static jb_err client_ua                 (struct client_state *csp, char **header);
106 static jb_err client_from               (struct client_state *csp, char **header);
107 static jb_err client_send_cookie        (struct client_state *csp, char **header);
108 static jb_err client_x_forwarded        (struct client_state *csp, char **header);
109 static jb_err client_accept_encoding    (struct client_state *csp, char **header);
110 static jb_err client_te                 (struct client_state *csp, char **header);
111 static jb_err client_max_forwards       (struct client_state *csp, char **header);
112 static jb_err client_host               (struct client_state *csp, char **header);
113 static jb_err client_if_modified_since  (struct client_state *csp, char **header);
114 static jb_err client_accept_language    (struct client_state *csp, char **header);
115 static jb_err client_if_none_match      (struct client_state *csp, char **header);
116 static jb_err crunch_client_header      (struct client_state *csp, char **header);
117 static jb_err client_x_filter           (struct client_state *csp, char **header);
118 static jb_err client_range              (struct client_state *csp, char **header);
119 static jb_err server_set_cookie         (struct client_state *csp, char **header);
120 static jb_err server_connection         (struct client_state *csp, char **header);
121 static jb_err server_content_type       (struct client_state *csp, char **header);
122 static jb_err server_adjust_content_length(struct client_state *csp, char **header);
123 static jb_err server_content_md5        (struct client_state *csp, char **header);
124 static jb_err server_content_encoding   (struct client_state *csp, char **header);
125 static jb_err server_transfer_coding    (struct client_state *csp, char **header);
126 static jb_err server_http               (struct client_state *csp, char **header);
127 static jb_err crunch_server_header      (struct client_state *csp, char **header);
128 static jb_err server_last_modified      (struct client_state *csp, char **header);
129 static jb_err server_content_disposition(struct client_state *csp, char **header);
130 #ifdef FEATURE_ZLIB
131 static jb_err server_adjust_content_encoding(struct client_state *csp, char **header);
132 #endif
133
134 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
135 static jb_err server_save_content_length(struct client_state *csp, char **header);
136 static jb_err server_keep_alive(struct client_state *csp, char **header);
137 static jb_err server_proxy_connection(struct client_state *csp, char **header);
138 static jb_err client_keep_alive(struct client_state *csp, char **header);
139 static jb_err client_save_content_length(struct client_state *csp, char **header);
140 static jb_err client_proxy_connection(struct client_state *csp, char **header);
141 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
142
143 static jb_err client_host_adder       (struct client_state *csp);
144 static jb_err client_xtra_adder       (struct client_state *csp);
145 static jb_err client_x_forwarded_for_adder(struct client_state *csp);
146 static jb_err client_connection_header_adder(struct client_state *csp);
147 static jb_err server_connection_adder(struct client_state *csp);
148 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
149 static jb_err server_proxy_connection_adder(struct client_state *csp);
150 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
151 static jb_err proxy_authentication(struct client_state *csp, char **header);
152
153 static jb_err create_forged_referrer(char **header, const char *hostport);
154 static jb_err create_fake_referrer(char **header, const char *fake_referrer);
155 static jb_err handle_conditional_hide_referrer_parameter(char **header,
156    const char *host, const int parameter_conditional_block);
157 static void create_content_length_header(unsigned long long content_length,
158                                          char *header, size_t buffer_length);
159
160 /*
161  * List of functions to run on a list of headers.
162  */
163 struct parsers
164 {
165    /** The header prefix to match */
166    const char *str;
167
168    /** The length of the prefix to match */
169    const size_t len;
170
171    /** The function to apply to this line */
172    const parser_func_ptr parser;
173 };
174
175 static const struct parsers client_patterns[] = {
176    { "referer:",                  8,   client_referrer },
177    { "user-agent:",              11,   client_uagent },
178    { "ua-",                       3,   client_ua },
179    { "from:",                     5,   client_from },
180    { "cookie:",                   7,   client_send_cookie },
181    { "x-forwarded-for:",         16,   client_x_forwarded },
182    { "Accept-Encoding:",         16,   client_accept_encoding },
183    { "TE:",                       3,   client_te },
184    { "Host:",                     5,   client_host },
185    { "if-modified-since:",       18,   client_if_modified_since },
186 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
187    { "Keep-Alive:",              11,   client_keep_alive },
188    { "Content-Length:",          15,   client_save_content_length },
189    { "Proxy-Connection:",        17,   client_proxy_connection },
190 #else
191    { "Keep-Alive:",              11,   crumble },
192    { "Proxy-Connection:",        17,   crumble },
193 #endif
194    { "connection:",              11,   client_connection },
195    { "max-forwards:",            13,   client_max_forwards },
196    { "Accept-Language:",         16,   client_accept_language },
197    { "if-none-match:",           14,   client_if_none_match },
198    { "Range:",                    6,   client_range },
199    { "Request-Range:",           14,   client_range },
200    { "If-Range:",                 9,   client_range },
201    { "X-Filter:",                 9,   client_x_filter },
202    { "Proxy-Authorization:",     20,   proxy_authentication },
203 #if 0
204    { "Transfer-Encoding:",       18,   client_transfer_encoding },
205 #endif
206    { "*",                         0,   crunch_client_header },
207    { "*",                         0,   filter_header },
208    { NULL,                        0,   NULL }
209 };
210
211 static const struct parsers server_patterns[] = {
212    { "HTTP/",                     5, server_http },
213    { "set-cookie:",              11, server_set_cookie },
214    { "connection:",              11, server_connection },
215    { "Content-Type:",            13, server_content_type },
216    { "Content-MD5:",             12, server_content_md5 },
217    { "Content-Encoding:",        17, server_content_encoding },
218 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
219    { "Content-Length:",          15, server_save_content_length },
220    { "Keep-Alive:",              11, server_keep_alive },
221    { "Proxy-Connection:",        17, server_proxy_connection },
222 #else
223    { "Keep-Alive:",              11, crumble },
224 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
225    { "Transfer-Encoding:",       18, server_transfer_coding },
226    { "content-disposition:",     20, server_content_disposition },
227    { "Last-Modified:",           14, server_last_modified },
228    { "Proxy-Authenticate:",      19, proxy_authentication },
229    { "*",                         0, crunch_server_header },
230    { "*",                         0, filter_header },
231    { NULL,                        0, NULL }
232 };
233
234 static const add_header_func_ptr add_client_headers[] = {
235    client_host_adder,
236    client_x_forwarded_for_adder,
237    client_xtra_adder,
238    client_connection_header_adder,
239    NULL
240 };
241
242 static const add_header_func_ptr add_server_headers[] = {
243    server_connection_adder,
244 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
245    server_proxy_connection_adder,
246 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
247    NULL
248 };
249
250 /*********************************************************************
251  *
252  * Function    :  flush_socket
253  *
254  * Description :  Write any pending "buffered" content.
255  *
256  * Parameters  :
257  *          1  :  fd = file descriptor of the socket to read
258  *          2  :  iob = The I/O buffer to flush, usually csp->iob.
259  *
260  * Returns     :  On success, the number of bytes written are returned (zero
261  *                indicates nothing was written).  On error, -1 is returned,
262  *                and errno is set appropriately.  If count is zero and the
263  *                file descriptor refers to a regular file, 0 will be
264  *                returned without causing any other effect.  For a special
265  *                file, the results are not portable.
266  *
267  *********************************************************************/
268 long flush_socket(jb_socket fd, struct iob *iob)
269 {
270    long len = iob->eod - iob->cur;
271
272    if (len <= 0)
273    {
274       return(0);
275    }
276
277    if (write_socket(fd, iob->cur, (size_t)len))
278    {
279       return(-1);
280    }
281    iob->eod = iob->cur = iob->buf;
282    return(len);
283
284 }
285
286
287 /*********************************************************************
288  *
289  * Function    :  add_to_iob
290  *
291  * Description :  Add content to the buffer, expanding the
292  *                buffer if necessary.
293  *
294  * Parameters  :
295  *          1  :  iob = Destination buffer.
296  *          2  :  buffer_limit = Limit to which the destination may grow
297  *          3  :  src = holds the content to be added
298  *          4  :  n = number of bytes to be added
299  *
300  * Returns     :  JB_ERR_OK on success, JB_ERR_MEMORY if out-of-memory
301  *                or buffer limit reached.
302  *
303  *********************************************************************/
304 jb_err add_to_iob(struct iob *iob, const size_t buffer_limit, char *src, long n)
305 {
306    size_t used, offset, need;
307    char *p;
308
309    if (n <= 0) return JB_ERR_OK;
310
311    used   = (size_t)(iob->eod - iob->buf);
312    offset = (size_t)(iob->cur - iob->buf);
313    need   = used + (size_t)n + 1;
314
315    /*
316     * If the buffer can't hold the new data, extend it first.
317     * Use the next power of two if possible, else use the actual need.
318     */
319    if (need > buffer_limit)
320    {
321       log_error(LOG_LEVEL_INFO,
322          "Buffer limit reached while extending the buffer (iob). Needed: %d. Limit: %d",
323          need, buffer_limit);
324       return JB_ERR_MEMORY;
325    }
326
327    if (need > iob->size)
328    {
329       size_t want = iob->size ? iob->size : 512;
330
331       while (want <= need)
332       {
333          want *= 2;
334       }
335
336       if (want <= buffer_limit && NULL != (p = (char *)realloc(iob->buf, want)))
337       {
338          iob->size = want;
339       }
340       else if (NULL != (p = (char *)realloc(iob->buf, need)))
341       {
342          iob->size = need;
343       }
344       else
345       {
346          log_error(LOG_LEVEL_ERROR, "Extending the buffer (iob) failed: %E");
347          return JB_ERR_MEMORY;
348       }
349
350       /* Update the iob pointers */
351       iob->cur = p + offset;
352       iob->eod = p + used;
353       iob->buf = p;
354    }
355
356    /* copy the new data into the iob buffer */
357    memcpy(iob->eod, src, (size_t)n);
358
359    /* point to the end of the data */
360    iob->eod += n;
361
362    /* null terminate == cheap insurance */
363    *iob->eod = '\0';
364
365    return JB_ERR_OK;
366
367 }
368
369
370 /*********************************************************************
371  *
372  * Function    :  clear_iob
373  *
374  * Description :  Frees the memory allocated for an I/O buffer and
375  *                resets the structure.
376  *
377  * Parameters  :
378  *          1  :  iob = I/O buffer to clear.
379  *
380  * Returns     :  JB_ERR_OK on success, JB_ERR_MEMORY if out-of-memory
381  *                or buffer limit reached.
382  *
383  *********************************************************************/
384 void clear_iob(struct iob *iob)
385 {
386    free(iob->buf);
387    memset(iob, '\0', sizeof(*iob));;
388 }
389
390
391 #ifdef FEATURE_ZLIB
392 /*********************************************************************
393  *
394  * Function    :  decompress_iob
395  *
396  * Description :  Decompress buffered page, expanding the
397  *                buffer as necessary.  csp->iob->cur
398  *                should point to the the beginning of the
399  *                compressed data block.
400  *
401  * Parameters  :
402  *          1  :  csp = Current client state (buffers, headers, etc...)
403  *
404  * Returns     :  JB_ERR_OK on success,
405  *                JB_ERR_MEMORY if out-of-memory limit reached, and
406  *                JB_ERR_COMPRESS if error decompressing buffer.
407  *
408  *********************************************************************/
409 jb_err decompress_iob(struct client_state *csp)
410 {
411    char  *buf;       /* new, uncompressed buffer */
412    char  *cur;       /* Current iob position (to keep the original
413                       * iob->cur unmodified if we return early) */
414    size_t bufsize;   /* allocated size of the new buffer */
415    size_t old_size;  /* Content size before decompression */
416    size_t skip_size; /* Number of bytes at the beginning of the iob
417                         that we should NOT decompress. */
418    int status;       /* return status of the inflate() call */
419    z_stream zstr;    /* used by calls to zlib */
420
421    assert(csp->iob->cur - csp->iob->buf > 0);
422    assert(csp->iob->eod - csp->iob->cur > 0);
423
424    bufsize = csp->iob->size;
425    skip_size = (size_t)(csp->iob->cur - csp->iob->buf);
426    old_size = (size_t)(csp->iob->eod - csp->iob->cur);
427
428    cur = csp->iob->cur;
429
430    if (bufsize < (size_t)10)
431    {
432       /*
433        * This is to protect the parsing of gzipped data,
434        * but it should(?) be valid for deflated data also.
435        */
436       log_error(LOG_LEVEL_ERROR, "Buffer too small decompressing iob");
437       return JB_ERR_COMPRESS;
438    }
439
440    if (csp->content_type & CT_GZIP)
441    {
442       /*
443        * Our task is slightly complicated by the facts that data
444        * compressed by gzip does not include a zlib header, and
445        * that there is no easily accessible interface in zlib to
446        * handle a gzip header. We strip off the gzip header by
447        * hand, and later inform zlib not to expect a header.
448        */
449
450       /*
451        * Strip off the gzip header. Please see RFC 1952 for more
452        * explanation of the appropriate fields.
453        */
454       if (((*cur++ & 0xff) != GZIP_IDENTIFIER_1)
455        || ((*cur++ & 0xff) != GZIP_IDENTIFIER_2)
456        || (*cur++ != Z_DEFLATED))
457       {
458          log_error(LOG_LEVEL_ERROR, "Invalid gzip header when decompressing");
459          return JB_ERR_COMPRESS;
460       }
461       else
462       {
463          int flags = *cur++;
464          if (flags & GZIP_FLAG_RESERVED_BITS)
465          {
466             /* The gzip header has reserved bits set; bail out. */
467             log_error(LOG_LEVEL_ERROR, "Invalid gzip header flags when decompressing");
468             return JB_ERR_COMPRESS;
469          }
470
471          /*
472           * Skip mtime (4 bytes), extra flags (1 byte)
473           * and OS type (1 byte).
474           */
475          cur += 6;
476
477          /* Skip extra fields if necessary. */
478          if (flags & GZIP_FLAG_EXTRA_FIELDS)
479          {
480             /*
481              * Skip a given number of bytes, specified
482              * as a 16-bit little-endian value.
483              *
484              * XXX: this code is untested and should probably be removed.
485              */
486             int skip_bytes;
487             skip_bytes = *cur++;
488             skip_bytes += *cur++ << 8;
489
490             /*
491              * The number of bytes to skip should be positive
492              * and we'd like to stay in the buffer.
493              */
494             if ((skip_bytes < 0) || (skip_bytes >= (csp->iob->eod - cur)))
495             {
496                log_error(LOG_LEVEL_ERROR,
497                   "Unreasonable amount of bytes to skip (%d). Stopping decompression",
498                   skip_bytes);
499                return JB_ERR_COMPRESS;
500             }
501             log_error(LOG_LEVEL_INFO,
502                "Skipping %d bytes for gzip compression. Does this sound right?",
503                skip_bytes);
504             cur += skip_bytes;
505          }
506
507          /* Skip the filename if necessary. */
508          if (flags & GZIP_FLAG_FILE_NAME)
509          {
510             /* A null-terminated string is supposed to follow. */
511             while (*cur++ && (cur < csp->iob->eod));
512          }
513
514          /* Skip the comment if necessary. */
515          if (flags & GZIP_FLAG_COMMENT)
516          {
517             /* A null-terminated string is supposed to follow. */
518             while (*cur++ && (cur < csp->iob->eod));
519          }
520
521          /* Skip the CRC if necessary. */
522          if (flags & GZIP_FLAG_CHECKSUM)
523          {
524             cur += 2;
525          }
526
527          if (cur >= csp->iob->eod)
528          {
529             /*
530              * If the current position pointer reached or passed
531              * the buffer end, we were obviously tricked to skip
532              * too much.
533              */
534             log_error(LOG_LEVEL_ERROR,
535                "Malformed gzip header detected. Aborting decompression.");
536             return JB_ERR_COMPRESS;
537          }
538       }
539    }
540    else if (csp->content_type & CT_DEFLATE)
541    {
542       /*
543        * In theory (that is, according to RFC 1950), deflate-compressed
544        * data should begin with a two-byte zlib header and have an
545        * adler32 checksum at the end. It seems that in practice only
546        * the raw compressed data is sent. Note that this means that
547        * we are not RFC 1950-compliant here, but the advantage is that
548        * this actually works. :)
549        *
550        * We add a dummy null byte to tell zlib where the data ends,
551        * and later inform it not to expect a header.
552        *
553        * Fortunately, add_to_iob() has thoughtfully null-terminated
554        * the buffer; we can just increment the end pointer to include
555        * the dummy byte.
556        */
557       csp->iob->eod++;
558    }
559    else
560    {
561       log_error(LOG_LEVEL_ERROR,
562          "Unable to determine compression format for decompression");
563       return JB_ERR_COMPRESS;
564    }
565
566    /* Set up the fields required by zlib. */
567    zstr.next_in  = (Bytef *)cur;
568    zstr.avail_in = (unsigned int)(csp->iob->eod - cur);
569    zstr.zalloc   = Z_NULL;
570    zstr.zfree    = Z_NULL;
571    zstr.opaque   = Z_NULL;
572
573    /*
574     * Passing -MAX_WBITS to inflateInit2 tells the library
575     * that there is no zlib header.
576     */
577    if (inflateInit2(&zstr, -MAX_WBITS) != Z_OK)
578    {
579       log_error(LOG_LEVEL_ERROR, "Error initializing decompression");
580       return JB_ERR_COMPRESS;
581    }
582
583    /*
584     * Next, we allocate new storage for the inflated data.
585     * We don't modify the existing iob yet, so in case there
586     * is error in decompression we can recover gracefully.
587     */
588    buf = zalloc(bufsize);
589    if (NULL == buf)
590    {
591       log_error(LOG_LEVEL_ERROR, "Out of memory decompressing iob");
592       return JB_ERR_MEMORY;
593    }
594
595    assert(bufsize >= skip_size);
596    memcpy(buf, csp->iob->buf, skip_size);
597    zstr.avail_out = (uInt)(bufsize - skip_size);
598    zstr.next_out  = (Bytef *)buf + skip_size;
599
600    /* Try to decompress the whole stream in one shot. */
601    while (Z_BUF_ERROR == (status = inflate(&zstr, Z_FINISH)))
602    {
603       /* We need to allocate more memory for the output buffer. */
604
605       char *tmpbuf;                /* used for realloc'ing the buffer */
606       size_t oldbufsize = bufsize; /* keep track of the old bufsize */
607
608       if (0 == zstr.avail_in)
609       {
610          /*
611           * If zlib wants more data then there's a problem, because
612           * the complete compressed file should have been buffered.
613           */
614          log_error(LOG_LEVEL_ERROR,
615             "Unexpected end of compressed iob. Using what we got so far.");
616          break;
617       }
618
619       /*
620        * If we reached the buffer limit and still didn't have enough
621        * memory, just give up. Due to the ceiling enforced by the next
622        * if block we could actually check for equality here, but as it
623        * can be easily mistaken for a bug we don't.
624        */
625       if (bufsize >= csp->config->buffer_limit)
626       {
627          log_error(LOG_LEVEL_ERROR, "Buffer limit reached while decompressing iob");
628          return JB_ERR_MEMORY;
629       }
630
631       /* Try doubling the buffer size each time. */
632       bufsize *= 2;
633
634       /* Don't exceed the buffer limit. */
635       if (bufsize > csp->config->buffer_limit)
636       {
637          bufsize = csp->config->buffer_limit;
638       }
639
640       /* Try to allocate the new buffer. */
641       tmpbuf = realloc(buf, bufsize);
642       if (NULL == tmpbuf)
643       {
644          log_error(LOG_LEVEL_ERROR, "Out of memory decompressing iob");
645          freez(buf);
646          return JB_ERR_MEMORY;
647       }
648       else
649       {
650          char *oldnext_out = (char *)zstr.next_out;
651
652          /*
653           * Update the fields for inflate() to use the new
654           * buffer, which may be in a location different from
655           * the old one.
656           */
657          zstr.avail_out += (uInt)(bufsize - oldbufsize);
658          zstr.next_out   = (Bytef *)tmpbuf + bufsize - zstr.avail_out;
659
660          /*
661           * Compare with an uglier method of calculating these values
662           * that doesn't require the extra oldbufsize variable.
663           */
664          assert(zstr.avail_out == tmpbuf + bufsize - (char *)zstr.next_out);
665          assert((char *)zstr.next_out == tmpbuf + ((char *)oldnext_out - buf));
666
667          buf = tmpbuf;
668       }
669    }
670
671    if (Z_STREAM_ERROR == inflateEnd(&zstr))
672    {
673       log_error(LOG_LEVEL_ERROR,
674          "Inconsistent stream state after decompression: %s", zstr.msg);
675       /*
676        * XXX: Intentionally no return.
677        *
678        * According to zlib.h, Z_STREAM_ERROR is returned
679        * "if the stream state was inconsistent".
680        *
681        * I assume in this case inflate()'s status
682        * would also be something different than Z_STREAM_END
683        * so this check should be redundant, but lets see.
684        */
685    }
686
687    if ((status != Z_STREAM_END) && (0 != zstr.avail_in))
688    {
689       /*
690        * We failed to decompress the stream and it's
691        * not simply because of missing data.
692        */
693       log_error(LOG_LEVEL_ERROR,
694          "Unexpected error while decompressing to the buffer (iob): %s",
695          zstr.msg);
696       return JB_ERR_COMPRESS;
697    }
698
699    /*
700     * Finally, we can actually update the iob, since the
701     * decompression was successful. First, free the old
702     * buffer.
703     */
704    freez(csp->iob->buf);
705
706    /* Now, update the iob to use the new buffer. */
707    csp->iob->buf  = buf;
708    csp->iob->cur  = csp->iob->buf + skip_size;
709    csp->iob->eod  = (char *)zstr.next_out;
710    csp->iob->size = bufsize;
711
712    /*
713     * Make sure the new uncompressed iob obeys some minimal
714     * consistency conditions.
715     */
716    if ((csp->iob->buf <  csp->iob->cur)
717     && (csp->iob->cur <= csp->iob->eod)
718     && (csp->iob->eod <= csp->iob->buf + csp->iob->size))
719    {
720       const size_t new_size = (size_t)(csp->iob->eod - csp->iob->cur);
721       if (new_size > (size_t)0)
722       {
723          log_error(LOG_LEVEL_RE_FILTER,
724             "Decompression successful. Old size: %d, new size: %d.",
725             old_size, new_size);
726       }
727       else
728       {
729          /* zlib thinks this is OK, so lets do the same. */
730          log_error(LOG_LEVEL_INFO, "Decompression didn't result in any content.");
731       }
732    }
733    else
734    {
735       /* It seems that zlib did something weird. */
736       log_error(LOG_LEVEL_ERROR,
737          "Unexpected error decompressing the buffer (iob): %d==%d, %d>%d, %d<%d",
738          csp->iob->cur, csp->iob->buf + skip_size, csp->iob->eod, csp->iob->buf,
739          csp->iob->eod, csp->iob->buf + csp->iob->size);
740       return JB_ERR_COMPRESS;
741    }
742
743    return JB_ERR_OK;
744
745 }
746 #endif /* defined(FEATURE_ZLIB) */
747
748
749 /*********************************************************************
750  *
751  * Function    :  normalize_lws
752  *
753  * Description :  Reduces unquoted linear white space in headers
754  *                to a single space in accordance with RFC 2616 2.2.
755  *                This simplifies parsing and filtering later on.
756  *
757  *                XXX: Remove log messages before
758  *                     the next stable release?
759  *
760  * Parameters  :
761  *          1  :  header = A header with linear white space to reduce.
762  *
763  * Returns     :  N/A
764  *
765  *********************************************************************/
766 static void normalize_lws(char *header)
767 {
768    char *p = header;
769
770    while (*p != '\0')
771    {
772       if (privoxy_isspace(*p) && privoxy_isspace(*(p+1)))
773       {
774          char *q = p+1;
775
776          while (privoxy_isspace(*q))
777          {
778             q++;
779          }
780          log_error(LOG_LEVEL_HEADER, "Reducing white space in '%s'", header);
781          string_move(p+1, q);
782       }
783
784       if (*p == '\t')
785       {
786          log_error(LOG_LEVEL_HEADER,
787             "Converting tab to space in '%s'", header);
788          *p = ' ';
789       }
790       else if (*p == '"')
791       {
792          char *end_of_token = strstr(p+1, "\"");
793
794          if (NULL != end_of_token)
795          {
796             /* Don't mess with quoted text. */
797             p = end_of_token;
798          }
799          else
800          {
801             log_error(LOG_LEVEL_HEADER,
802                "Ignoring single quote in '%s'", header);
803          }
804       }
805       p++;
806    }
807
808    p = strchr(header, ':');
809    if ((p != NULL) && (p != header) && privoxy_isspace(*(p-1)))
810    {
811       /*
812        * There's still space before the colon.
813        * We don't want it.
814        */
815       string_move(p-1, p);
816    }
817 }
818
819
820 /*********************************************************************
821  *
822  * Function    :  get_header
823  *
824  * Description :  This (odd) routine will parse the csp->iob
825  *                to get the next complete header.
826  *
827  * Parameters  :
828  *          1  :  iob = The I/O buffer to parse, usually csp->iob.
829  *
830  * Returns     :  Any one of the following:
831  *
832  * 1) a pointer to a dynamically allocated string that contains a header line
833  * 2) NULL  indicating that the end of the header was reached
834  * 3) ""    indicating that the end of the iob was reached before finding
835  *          a complete header line.
836  *
837  *********************************************************************/
838 char *get_header(struct iob *iob)
839 {
840    char *header;
841
842    header = get_header_line(iob);
843
844    if ((header == NULL) || (*header == '\0'))
845    {
846       /*
847        * No complete header read yet, tell the client.
848        */
849       return header;
850    }
851
852    while ((iob->cur[0] == ' ') || (iob->cur[0] == '\t'))
853    {
854       /*
855        * Header spans multiple lines, append the next one.
856        */
857       char *continued_header;
858
859       continued_header = get_header_line(iob);
860       if ((continued_header == NULL) || (*continued_header == '\0'))
861       {
862          /*
863           * No complete header read yet, return what we got.
864           * XXX: Should "unread" header instead.
865           */
866          log_error(LOG_LEVEL_INFO,
867             "Failed to read a multi-line header properly: '%s'",
868             header);
869          break;
870       }
871
872       if (JB_ERR_OK != string_join(&header, continued_header))
873       {
874          log_error(LOG_LEVEL_FATAL,
875             "Out of memory while appending multiple headers.");
876       }
877       else
878       {
879          /* XXX: remove before next stable release. */
880          log_error(LOG_LEVEL_HEADER,
881             "Merged multiple header lines to: '%s'",
882             header);
883       }
884    }
885
886    normalize_lws(header);
887
888    return header;
889
890 }
891
892
893 /*********************************************************************
894  *
895  * Function    :  get_header_line
896  *
897  * Description :  This (odd) routine will parse the csp->iob
898  *                to get the next header line.
899  *
900  * Parameters  :
901  *          1  :  iob = The I/O buffer to parse, usually csp->iob.
902  *
903  * Returns     :  Any one of the following:
904  *
905  * 1) a pointer to a dynamically allocated string that contains a header line
906  * 2) NULL  indicating that the end of the header was reached
907  * 3) ""    indicating that the end of the iob was reached before finding
908  *          a complete header line.
909  *
910  *********************************************************************/
911 static char *get_header_line(struct iob *iob)
912 {
913    char *p, *q, *ret;
914
915    if ((iob->cur == NULL)
916       || ((p = strchr(iob->cur, '\n')) == NULL))
917    {
918       return(""); /* couldn't find a complete header */
919    }
920
921    *p = '\0';
922
923    ret = strdup(iob->cur);
924    if (ret == NULL)
925    {
926       /* FIXME No way to handle error properly */
927       log_error(LOG_LEVEL_FATAL, "Out of memory in get_header_line()");
928    }
929    assert(ret != NULL);
930
931    iob->cur = p+1;
932
933    if ((q = strchr(ret, '\r')) != NULL) *q = '\0';
934
935    /* is this a blank line (i.e. the end of the header) ? */
936    if (*ret == '\0')
937    {
938       freez(ret);
939       return NULL;
940    }
941
942    return ret;
943
944 }
945
946
947 /*********************************************************************
948  *
949  * Function    :  get_header_value
950  *
951  * Description :  Get the value of a given header from a chained list
952  *                of header lines or return NULL if no such header is
953  *                present in the list.
954  *
955  * Parameters  :
956  *          1  :  header_list = pointer to list
957  *          2  :  header_name = string with name of header to look for.
958  *                              Trailing colon required, capitalization
959  *                              doesn't matter.
960  *
961  * Returns     :  NULL if not found, else value of header
962  *
963  *********************************************************************/
964 char *get_header_value(const struct list *header_list, const char *header_name)
965 {
966    struct list_entry *cur_entry;
967    char *ret = NULL;
968    size_t length = 0;
969
970    assert(header_list);
971    assert(header_name);
972    length = strlen(header_name);
973
974    for (cur_entry = header_list->first; cur_entry ; cur_entry = cur_entry->next)
975    {
976       if (cur_entry->str)
977       {
978          if (!strncmpic(cur_entry->str, header_name, length))
979          {
980             /*
981              * Found: return pointer to start of value
982              */
983             ret = cur_entry->str + length;
984             while (*ret && privoxy_isspace(*ret)) ret++;
985             return ret;
986          }
987       }
988    }
989
990    /*
991     * Not found
992     */
993    return NULL;
994
995 }
996
997
998 /*********************************************************************
999  *
1000  * Function    :  scan_headers
1001  *
1002  * Description :  Scans headers, applies tags and updates action bits.
1003  *
1004  * Parameters  :
1005  *          1  :  csp = Current client state (buffers, headers, etc...)
1006  *
1007  * Returns     :  JB_ERR_OK
1008  *
1009  *********************************************************************/
1010 static jb_err scan_headers(struct client_state *csp)
1011 {
1012    struct list_entry *h; /* Header */
1013    jb_err err = JB_ERR_OK;
1014
1015    for (h = csp->headers->first; (err == JB_ERR_OK) && (h != NULL) ; h = h->next)
1016    {
1017       /* Header crunch()ed in previous run? -> ignore */
1018       if (h->str == NULL) continue;
1019       log_error(LOG_LEVEL_HEADER, "scan: %s", h->str);
1020       err = header_tagger(csp, h->str);
1021    }
1022
1023    return err;
1024 }
1025
1026
1027 /*********************************************************************
1028  *
1029  * Function    :  enforce_header_order
1030  *
1031  * Description :  Enforces a given header order.
1032  *
1033  * Parameters  :
1034  *          1  :  headers         = List of headers to order.
1035  *          2  :  ordered_headers = List of ordered header names.
1036  *
1037  * Returns     :  N/A
1038  *
1039  *********************************************************************/
1040 static void enforce_header_order(struct list *headers, const struct list *ordered_headers)
1041 {
1042    struct list_entry *sorted_header;
1043    struct list new_headers[1];
1044    struct list_entry *header;
1045
1046    init_list(new_headers);
1047
1048    /* The request line is always the first "header" */
1049
1050    assert(NULL != headers->first->str);
1051    enlist(new_headers, headers->first->str);
1052    freez(headers->first->str)
1053
1054    /* Enlist the specified headers in the given order */
1055
1056    for (sorted_header = ordered_headers->first; sorted_header != NULL;
1057         sorted_header = sorted_header->next)
1058    {
1059       const size_t sorted_header_length = strlen(sorted_header->str);
1060       for (header = headers->first; header != NULL; header = header->next)
1061       {
1062          /* Header enlisted in previous run? -> ignore */
1063          if (header->str == NULL) continue;
1064
1065          if (0 == strncmpic(sorted_header->str, header->str, sorted_header_length)
1066             && (header->str[sorted_header_length] == ':'))
1067          {
1068             log_error(LOG_LEVEL_HEADER, "Enlisting sorted header %s", header->str);
1069             if (JB_ERR_OK != enlist(new_headers, header->str))
1070             {
1071                log_error(LOG_LEVEL_HEADER, "Failed to enlist %s", header->str);
1072             }
1073             freez(header->str);
1074          }
1075       }
1076    }
1077
1078    /* Enlist the rest of the headers behind the ordered ones */
1079    for (header = headers->first; header != NULL; header = header->next)
1080    {
1081       /* Header enlisted in previous run? -> ignore */
1082       if (header->str == NULL) continue;
1083
1084       log_error(LOG_LEVEL_HEADER,
1085          "Enlisting left-over header %s", header->str);
1086       if (JB_ERR_OK != enlist(new_headers, header->str))
1087       {
1088          log_error(LOG_LEVEL_HEADER, "Failed to enlist %s", header->str);
1089       }
1090       freez(header->str);
1091    }
1092
1093    list_remove_all(headers);
1094    list_duplicate(headers, new_headers);
1095    list_remove_all(new_headers);
1096
1097    return;
1098 }
1099
1100
1101 /*********************************************************************
1102  *
1103  * Function    :  sed
1104  *
1105  * Description :  add, delete or modify lines in the HTTP header streams.
1106  *                On entry, it receives a linked list of headers space
1107  *                that was allocated dynamically (both the list nodes
1108  *                and the header contents).
1109  *
1110  *                As a side effect it frees the space used by the original
1111  *                header lines.
1112  *
1113  * Parameters  :
1114  *          1  :  csp = Current client state (buffers, headers, etc...)
1115  *          2  :  filter_server_headers = Boolean to switch between
1116  *                                        server and header filtering.
1117  *
1118  * Returns     :  JB_ERR_OK in case off success, or
1119  *                JB_ERR_MEMORY on out-of-memory error.
1120  *
1121  *********************************************************************/
1122 jb_err sed(struct client_state *csp, int filter_server_headers)
1123 {
1124    /* XXX: use more descriptive names. */
1125    struct list_entry *p;
1126    const struct parsers *v;
1127    const add_header_func_ptr *f;
1128    jb_err err = JB_ERR_OK;
1129
1130    scan_headers(csp);
1131
1132    if (filter_server_headers)
1133    {
1134       v = server_patterns;
1135       f = add_server_headers;
1136       check_negative_tag_patterns(csp, PATTERN_SPEC_NO_RESPONSE_TAG_PATTERN);
1137    }
1138    else
1139    {
1140       v = client_patterns;
1141       f = add_client_headers;
1142       check_negative_tag_patterns(csp, PATTERN_SPEC_NO_REQUEST_TAG_PATTERN);
1143    }
1144
1145    while ((err == JB_ERR_OK) && (v->str != NULL))
1146    {
1147       for (p = csp->headers->first; (err == JB_ERR_OK) && (p != NULL); p = p->next)
1148       {
1149          /* Header crunch()ed in previous run? -> ignore */
1150          if (p->str == NULL) continue;
1151
1152          /* Does the current parser handle this header? */
1153          if ((strncmpic(p->str, v->str, v->len) == 0) ||
1154              (v->len == CHECK_EVERY_HEADER_REMAINING))
1155          {
1156             err = v->parser(csp, &(p->str));
1157          }
1158       }
1159       v++;
1160    }
1161
1162    /* place additional headers on the csp->headers list */
1163    while ((err == JB_ERR_OK) && (*f))
1164    {
1165       err = (*f)(csp);
1166       f++;
1167    }
1168
1169    if (!filter_server_headers && !list_is_empty(csp->config->ordered_client_headers))
1170    {
1171       enforce_header_order(csp->headers, csp->config->ordered_client_headers);
1172    }
1173
1174    return err;
1175 }
1176
1177
1178 /*********************************************************************
1179  *
1180  * Function    :  update_server_headers
1181  *
1182  * Description :  Updates server headers after the body has been modified.
1183  *
1184  * Parameters  :
1185  *          1  :  csp = Current client state (buffers, headers, etc...)
1186  *
1187  * Returns     :  JB_ERR_OK in case off success, or
1188  *                JB_ERR_MEMORY on out-of-memory error.
1189  *
1190  *********************************************************************/
1191 jb_err update_server_headers(struct client_state *csp)
1192 {
1193    jb_err err = JB_ERR_OK;
1194
1195    static const struct parsers server_patterns_light[] = {
1196       { "Content-Length:",    15, server_adjust_content_length },
1197       { "Transfer-Encoding:", 18, server_transfer_coding },
1198 #ifdef FEATURE_ZLIB
1199       { "Content-Encoding:",  17, server_adjust_content_encoding },
1200 #endif /* def FEATURE_ZLIB */
1201       { NULL,                  0, NULL }
1202    };
1203
1204    if (strncmpic(csp->http->cmd, "HEAD", 4))
1205    {
1206       const struct parsers *v;
1207       struct list_entry *p;
1208
1209       for (v = server_patterns_light; (err == JB_ERR_OK) && (v->str != NULL); v++)
1210       {
1211          for (p = csp->headers->first; (err == JB_ERR_OK) && (p != NULL); p = p->next)
1212          {
1213             /* Header crunch()ed in previous run? -> ignore */
1214             if (p->str == NULL) continue;
1215
1216             /* Does the current parser handle this header? */
1217             if (strncmpic(p->str, v->str, v->len) == 0)
1218             {
1219                err = v->parser(csp, (char **)&(p->str));
1220             }
1221          }
1222       }
1223    }
1224
1225 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1226    if ((JB_ERR_OK == err)
1227     && (csp->flags & CSP_FLAG_MODIFIED)
1228     && (csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE)
1229     && !(csp->flags & CSP_FLAG_SERVER_CONTENT_LENGTH_SET))
1230    {
1231       char header[50];
1232
1233       create_content_length_header(csp->content_length, header, sizeof(header));
1234       err = enlist(csp->headers, header);
1235       if (JB_ERR_OK == err)
1236       {
1237          log_error(LOG_LEVEL_HEADER,
1238             "Content modified with no Content-Length header set. "
1239             "Created: %s.", header);
1240          csp->flags |= CSP_FLAG_SERVER_CONTENT_LENGTH_SET;
1241       }
1242    }
1243 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
1244
1245 #ifdef FEATURE_COMPRESSION
1246    if ((JB_ERR_OK == err)
1247       && (csp->flags & CSP_FLAG_BUFFERED_CONTENT_DEFLATED))
1248    {
1249       err = enlist_unique_header(csp->headers, "Content-Encoding", "deflate");
1250       if (JB_ERR_OK == err)
1251       {
1252          log_error(LOG_LEVEL_HEADER, "Added header: Content-Encoding: deflate");
1253       }
1254    }
1255 #endif
1256
1257    return err;
1258 }
1259
1260
1261 /*********************************************************************
1262  *
1263  * Function    :  header_tagger
1264  *
1265  * Description :  Executes all text substitutions from applying
1266  *                tag actions and saves the result as tag.
1267  *
1268  *                XXX: Shares enough code with filter_header() and
1269  *                pcrs_filter_response() to warrant some helper functions.
1270  *
1271  * Parameters  :
1272  *          1  :  csp = Current client state (buffers, headers, etc...)
1273  *          2  :  header = Header that is used as tagger input
1274  *
1275  * Returns     :  JB_ERR_OK on success and always succeeds
1276  *
1277  *********************************************************************/
1278 static jb_err header_tagger(struct client_state *csp, char *header)
1279 {
1280    int wanted_filter_type;
1281    int multi_action_index;
1282    pcrs_job *job;
1283
1284    struct re_filterfile_spec *b;
1285    struct list_entry *tag_name;
1286
1287    const size_t header_length = strlen(header);
1288
1289    if (csp->flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
1290    {
1291       wanted_filter_type = FT_SERVER_HEADER_TAGGER;
1292       multi_action_index = ACTION_MULTI_SERVER_HEADER_TAGGER;
1293    }
1294    else
1295    {
1296       wanted_filter_type = FT_CLIENT_HEADER_TAGGER;
1297       multi_action_index = ACTION_MULTI_CLIENT_HEADER_TAGGER;
1298    }
1299
1300    if (list_is_empty(csp->action->multi[multi_action_index])
1301       || filters_available(csp) == FALSE)
1302    {
1303       /* Return early if no taggers apply or if none are available. */
1304       return JB_ERR_OK;
1305    }
1306
1307    /* Execute all applying taggers */
1308    for (tag_name = csp->action->multi[multi_action_index]->first;
1309         NULL != tag_name; tag_name = tag_name->next)
1310    {
1311       char *modified_tag = NULL;
1312       char *tag = header;
1313       size_t size = header_length;
1314       pcrs_job *joblist;
1315
1316       b = get_filter(csp, tag_name->str, wanted_filter_type);
1317       if (b == NULL)
1318       {
1319          continue;
1320       }
1321
1322       joblist = b->joblist;
1323
1324       if (b->dynamic) joblist = compile_dynamic_pcrs_job_list(csp, b);
1325
1326       if (NULL == joblist)
1327       {
1328          log_error(LOG_LEVEL_RE_FILTER,
1329             "Tagger %s has empty joblist. Nothing to do.", b->name);
1330          continue;
1331       }
1332
1333       /* execute their pcrs_joblist on the header. */
1334       for (job = joblist; NULL != job; job = job->next)
1335       {
1336          const int hits = pcrs_execute(job, tag, size, &modified_tag, &size);
1337
1338          if (0 < hits)
1339          {
1340             /* Success, continue with the modified version. */
1341             if (tag != header)
1342             {
1343                freez(tag);
1344             }
1345             tag = modified_tag;
1346          }
1347          else
1348          {
1349             /* Tagger doesn't match */
1350             if (0 > hits)
1351             {
1352                /* Regex failure, log it but continue anyway. */
1353                assert(NULL != header);
1354                log_error(LOG_LEVEL_ERROR,
1355                   "Problems with tagger \'%s\' and header \'%s\': %s",
1356                   b->name, *header, pcrs_strerror(hits));
1357             }
1358             freez(modified_tag);
1359          }
1360       }
1361
1362       if (b->dynamic) pcrs_free_joblist(joblist);
1363
1364       /* If this tagger matched */
1365       if (tag != header)
1366       {
1367          if (0 == size)
1368          {
1369             /*
1370              * There is no technical limitation which makes
1371              * it impossible to use empty tags, but I assume
1372              * no one would do it intentionally.
1373              */
1374             freez(tag);
1375             log_error(LOG_LEVEL_INFO,
1376                "Tagger \'%s\' created an empty tag. Ignored.", b->name);
1377             continue;
1378          }
1379
1380          if (!list_contains_item(csp->tags, tag))
1381          {
1382             if (JB_ERR_OK != enlist(csp->tags, tag))
1383             {
1384                log_error(LOG_LEVEL_ERROR,
1385                   "Insufficient memory to add tag \'%s\', "
1386                   "based on tagger \'%s\' and header \'%s\'",
1387                   tag, b->name, *header);
1388             }
1389             else
1390             {
1391                char *action_message;
1392                /*
1393                 * update the action bits right away, to make
1394                 * tagging based on tags set by earlier taggers
1395                 * of the same kind possible.
1396                 */
1397                if (update_action_bits_for_tag(csp, tag))
1398                {
1399                   action_message = "Action bits updated accordingly.";
1400                }
1401                else
1402                {
1403                   action_message = "No action bits update necessary.";
1404                }
1405
1406                log_error(LOG_LEVEL_HEADER,
1407                   "Tagger \'%s\' added tag \'%s\'. %s",
1408                   b->name, tag, action_message);
1409             }
1410          }
1411          else
1412          {
1413             /* XXX: Is this log-worthy? */
1414             log_error(LOG_LEVEL_HEADER,
1415                "Tagger \'%s\' didn't add tag \'%s\'. Tag already present",
1416                b->name, tag);
1417          }
1418          freez(tag);
1419       }
1420    }
1421
1422    return JB_ERR_OK;
1423 }
1424
1425 /* here begins the family of parser functions that reformat header lines */
1426
1427 /*********************************************************************
1428  *
1429  * Function    :  filter_header
1430  *
1431  * Description :  Executes all text substitutions from all applying
1432  *                +(server|client)-header-filter actions on the header.
1433  *                Most of the code was copied from pcrs_filter_response,
1434  *                including the rather short variable names
1435  *
1436  * Parameters  :
1437  *          1  :  csp = Current client state (buffers, headers, etc...)
1438  *          2  :  header = On input, pointer to header to modify.
1439  *                On output, pointer to the modified header, or NULL
1440  *                to remove the header.  This function frees the
1441  *                original string if necessary.
1442  *
1443  * Returns     :  JB_ERR_OK on success and always succeeds
1444  *
1445  *********************************************************************/
1446 static jb_err filter_header(struct client_state *csp, char **header)
1447 {
1448    int hits=0;
1449    int matches;
1450    size_t size = strlen(*header);
1451
1452    char *newheader = NULL;
1453    pcrs_job *job;
1454
1455    struct re_filterfile_spec *b;
1456    struct list_entry *filtername;
1457
1458    int wanted_filter_type;
1459    int multi_action_index;
1460
1461    if (csp->flags & CSP_FLAG_NO_FILTERING)
1462    {
1463       return JB_ERR_OK;
1464    }
1465
1466    if (csp->flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
1467    {
1468       wanted_filter_type = FT_SERVER_HEADER_FILTER;
1469       multi_action_index = ACTION_MULTI_SERVER_HEADER_FILTER;
1470    }
1471    else
1472    {
1473       wanted_filter_type = FT_CLIENT_HEADER_FILTER;
1474       multi_action_index = ACTION_MULTI_CLIENT_HEADER_FILTER;
1475    }
1476
1477    if (list_is_empty(csp->action->multi[multi_action_index])
1478       || filters_available(csp) == FALSE)
1479    {
1480       /* Return early if no filters apply or if none are available. */
1481       return JB_ERR_OK;
1482    }
1483
1484    /* Execute all applying header filters */
1485    for (filtername = csp->action->multi[multi_action_index]->first;
1486         filtername != NULL; filtername = filtername->next)
1487    {
1488       int current_hits = 0;
1489       pcrs_job *joblist;
1490
1491       b = get_filter(csp, filtername->str, wanted_filter_type);
1492       if (b == NULL)
1493       {
1494          continue;
1495       }
1496
1497       joblist = b->joblist;
1498
1499       if (b->dynamic) joblist = compile_dynamic_pcrs_job_list(csp, b);
1500
1501       if (NULL == joblist)
1502       {
1503          log_error(LOG_LEVEL_RE_FILTER, "Filter %s has empty joblist. Nothing to do.", b->name);
1504          continue;
1505       }
1506
1507       log_error(LOG_LEVEL_RE_FILTER, "filtering \'%s\' (size %d) with \'%s\' ...",
1508          *header, size, b->name);
1509
1510       /* Apply all jobs from the joblist */
1511       for (job = joblist; NULL != job; job = job->next)
1512       {
1513          matches = pcrs_execute(job, *header, size, &newheader, &size);
1514          if (0 < matches)
1515          {
1516             current_hits += matches;
1517             log_error(LOG_LEVEL_HEADER, "Transforming \"%s\" to \"%s\"", *header, newheader);
1518             freez(*header);
1519             *header = newheader;
1520          }
1521          else if (0 == matches)
1522          {
1523             /* Filter doesn't change header */
1524             freez(newheader);
1525          }
1526          else
1527          {
1528             /* RegEx failure */
1529             log_error(LOG_LEVEL_ERROR, "Filtering \'%s\' with \'%s\' didn't work out: %s",
1530                *header, b->name, pcrs_strerror(matches));
1531             if (newheader != NULL)
1532             {
1533                log_error(LOG_LEVEL_ERROR, "Freeing what's left: %s", newheader);
1534                freez(newheader);
1535             }
1536          }
1537       }
1538
1539       if (b->dynamic) pcrs_free_joblist(joblist);
1540
1541       log_error(LOG_LEVEL_RE_FILTER, "... produced %d hits (new size %d).", current_hits, size);
1542       hits += current_hits;
1543    }
1544
1545    /*
1546     * Additionally checking for hits is important because if
1547     * the continue hack is triggered, server headers can
1548     * arrive empty to separate multiple heads from each other.
1549     */
1550    if ((0 == size) && hits)
1551    {
1552       log_error(LOG_LEVEL_HEADER, "Removing empty header %s", *header);
1553       freez(*header);
1554    }
1555
1556    return JB_ERR_OK;
1557 }
1558
1559
1560 /*********************************************************************
1561  *
1562  * Function    :  server_connection
1563  *
1564  * Description :  Makes sure a proper "Connection:" header is
1565  *                set and signals connection_header_adder to
1566  *                do nothing.
1567  *
1568  * Parameters  :
1569  *          1  :  csp = Current client state (buffers, headers, etc...)
1570  *          2  :  header = On input, pointer to header to modify.
1571  *                On output, pointer to the modified header, or NULL
1572  *                to remove the header.  This function frees the
1573  *                original string if necessary.
1574  *
1575  * Returns     :  JB_ERR_OK on success.
1576  *
1577  *********************************************************************/
1578 static jb_err server_connection(struct client_state *csp, char **header)
1579 {
1580    if (!strcmpic(*header, "Connection: keep-alive")
1581 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1582     && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
1583 #endif
1584      )
1585    {
1586 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1587       if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE))
1588       {
1589          csp->flags |= CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE;
1590       }
1591
1592       if ((csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE))
1593       {
1594          log_error(LOG_LEVEL_HEADER,
1595             "Keeping the server header '%s' around.", *header);
1596       }
1597       else
1598 #endif /* FEATURE_CONNECTION_KEEP_ALIVE */
1599       {
1600          char *old_header = *header;
1601
1602          *header = strdup_or_die("Connection: close");
1603          log_error(LOG_LEVEL_HEADER, "Replaced: \'%s\' with \'%s\'", old_header, *header);
1604          freez(old_header);
1605       }
1606    }
1607
1608    /* Signal server_connection_adder() to return early. */
1609    csp->flags |= CSP_FLAG_SERVER_CONNECTION_HEADER_SET;
1610
1611    return JB_ERR_OK;
1612 }
1613
1614
1615 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1616 /*********************************************************************
1617  *
1618  * Function    :  server_keep_alive
1619  *
1620  * Description :  Stores the server's keep alive timeout.
1621  *
1622  * Parameters  :
1623  *          1  :  csp = Current client state (buffers, headers, etc...)
1624  *          2  :  header = On input, pointer to header to modify.
1625  *                On output, pointer to the modified header, or NULL
1626  *                to remove the header.  This function frees the
1627  *                original string if necessary.
1628  *
1629  * Returns     :  JB_ERR_OK.
1630  *
1631  *********************************************************************/
1632 static jb_err server_keep_alive(struct client_state *csp, char **header)
1633 {
1634    unsigned int keep_alive_timeout;
1635    const char *timeout_position = strstr(*header, "timeout=");
1636
1637    if ((NULL == timeout_position)
1638     || (1 != sscanf(timeout_position, "timeout=%u", &keep_alive_timeout)))
1639    {
1640       log_error(LOG_LEVEL_ERROR, "Couldn't parse: %s", *header);
1641    }
1642    else
1643    {
1644       if (keep_alive_timeout < csp->server_connection.keep_alive_timeout)
1645       {
1646          log_error(LOG_LEVEL_HEADER,
1647             "Reducing keep-alive timeout from %u to %u.",
1648             csp->server_connection.keep_alive_timeout, keep_alive_timeout);
1649          csp->server_connection.keep_alive_timeout = keep_alive_timeout;
1650       }
1651       else
1652       {
1653          /* XXX: Is this log worthy? */
1654          log_error(LOG_LEVEL_HEADER,
1655             "Server keep-alive timeout is %u. Sticking with %u.",
1656             keep_alive_timeout, csp->server_connection.keep_alive_timeout);
1657       }
1658       csp->flags |= CSP_FLAG_SERVER_KEEP_ALIVE_TIMEOUT_SET;
1659    }
1660
1661    return JB_ERR_OK;
1662 }
1663
1664
1665 /*********************************************************************
1666  *
1667  * Function    :  server_proxy_connection
1668  *
1669  * Description :  Figures out whether or not we should add a
1670  *                Proxy-Connection header.
1671  *
1672  * Parameters  :
1673  *          1  :  csp = Current client state (buffers, headers, etc...)
1674  *          2  :  header = On input, pointer to header to modify.
1675  *                On output, pointer to the modified header, or NULL
1676  *                to remove the header.  This function frees the
1677  *                original string if necessary.
1678  *
1679  * Returns     :  JB_ERR_OK.
1680  *
1681  *********************************************************************/
1682 static jb_err server_proxy_connection(struct client_state *csp, char **header)
1683 {
1684    csp->flags |= CSP_FLAG_SERVER_PROXY_CONNECTION_HEADER_SET;
1685    return JB_ERR_OK;
1686 }
1687
1688
1689 /*********************************************************************
1690  *
1691  * Function    :  proxy_authentication
1692  *
1693  * Description :  Removes headers that are relevant for proxy
1694  *                authentication unless forwarding them has
1695  *                been explicitly requested.
1696  *
1697  * Parameters  :
1698  *          1  :  csp = Current client state (buffers, headers, etc...)
1699  *          2  :  header = On input, pointer to header to modify.
1700  *                On output, pointer to the modified header, or NULL
1701  *                to remove the header.  This function frees the
1702  *                original string if necessary.
1703  *
1704  * Returns     :  JB_ERR_OK.
1705  *
1706  *********************************************************************/
1707 static jb_err proxy_authentication(struct client_state *csp, char **header)
1708 {
1709    if ((csp->config->feature_flags &
1710       RUNTIME_FEATURE_FORWARD_PROXY_AUTHENTICATION_HEADERS) == 0) {
1711       log_error(LOG_LEVEL_HEADER,
1712          "Forwarding proxy authentication headers is disabled. Crunching: %s", *header);
1713       freez(*header);
1714    }
1715    return JB_ERR_OK;
1716 }
1717
1718
1719 /*********************************************************************
1720  *
1721  * Function    :  client_keep_alive
1722  *
1723  * Description :  Stores the client's keep alive timeout.
1724  *
1725  * Parameters  :
1726  *          1  :  csp = Current client state (buffers, headers, etc...)
1727  *          2  :  header = On input, pointer to header to modify.
1728  *                On output, pointer to the modified header, or NULL
1729  *                to remove the header.  This function frees the
1730  *                original string if necessary.
1731  *
1732  * Returns     :  JB_ERR_OK.
1733  *
1734  *********************************************************************/
1735 static jb_err client_keep_alive(struct client_state *csp, char **header)
1736 {
1737    unsigned int keep_alive_timeout;
1738    char *timeout_position;
1739
1740    if (!(csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE))
1741    {
1742       log_error(LOG_LEVEL_HEADER,
1743          "keep-alive support is disabled. Crunching: %s.", *header);
1744       freez(*header);
1745       return JB_ERR_OK;
1746    }
1747
1748    /* Check for parameter-less format "Keep-Alive: 100" */
1749    timeout_position = strstr(*header, ": ");
1750    if ((NULL == timeout_position)
1751     || (1 != sscanf(timeout_position, ": %u", &keep_alive_timeout)))
1752    {
1753       /* Assume parameter format "Keep-Alive: timeout=100" */
1754       timeout_position = strstr(*header, "timeout=");
1755       if ((NULL == timeout_position)
1756          || (1 != sscanf(timeout_position, "timeout=%u", &keep_alive_timeout)))
1757       {
1758          log_error(LOG_LEVEL_HEADER,
1759             "Couldn't parse: '%s'. Using default timeout %u",
1760             *header, csp->config->keep_alive_timeout);
1761          freez(*header);
1762
1763          return JB_ERR_OK;
1764       }
1765    }
1766
1767    if (keep_alive_timeout < csp->config->keep_alive_timeout)
1768    {
1769       log_error(LOG_LEVEL_HEADER,
1770          "Reducing keep-alive timeout from %u to %u.",
1771          csp->config->keep_alive_timeout, keep_alive_timeout);
1772       csp->server_connection.keep_alive_timeout = keep_alive_timeout;
1773    }
1774    else
1775    {
1776       /* XXX: Is this log worthy? */
1777       log_error(LOG_LEVEL_HEADER,
1778          "Client keep-alive timeout is %u. Sticking with %u.",
1779          keep_alive_timeout, csp->config->keep_alive_timeout);
1780       freez(*header);
1781    }
1782
1783    return JB_ERR_OK;
1784 }
1785
1786
1787 /*********************************************************************
1788  *
1789  * Function    :  get_content_length
1790  *
1791  * Description :  Gets the content length specified in a
1792  *                Content-Length header.
1793  *
1794  * Parameters  :
1795  *          1  :  header_value = The Content-Length header value.
1796  *          2  :  length = Storage to return the value.
1797  *
1798  * Returns     :  JB_ERR_OK on success, or
1799  *                JB_ERR_PARSE if no value is recognized.
1800  *
1801  *********************************************************************/
1802 static jb_err get_content_length(const char *header_value, unsigned long long *length)
1803 {
1804 #ifdef _WIN32
1805    assert(sizeof(unsigned long long) > 4);
1806    if (1 != sscanf(header_value, "%I64u", length))
1807 #else
1808    if (1 != sscanf(header_value, "%llu", length))
1809 #endif
1810    {
1811       return JB_ERR_PARSE;
1812    }
1813
1814    return JB_ERR_OK;
1815 }
1816
1817
1818 /*********************************************************************
1819  *
1820  * Function    :  client_save_content_length
1821  *
1822  * Description :  Save the Content-Length sent by the client.
1823  *
1824  * Parameters  :
1825  *          1  :  csp = Current client state (buffers, headers, etc...)
1826  *          2  :  header = On input, pointer to header to modify.
1827  *                On output, pointer to the modified header, or NULL
1828  *                to remove the header.  This function frees the
1829  *                original string if necessary.
1830  *
1831  * Returns     :  JB_ERR_OK on success, or
1832  *                JB_ERR_MEMORY on out-of-memory error.
1833  *
1834  *********************************************************************/
1835 static jb_err client_save_content_length(struct client_state *csp, char **header)
1836 {
1837    unsigned long long content_length = 0;
1838    const char *header_value;
1839
1840    assert(*(*header+14) == ':');
1841
1842    header_value = *header + 15;
1843    if (JB_ERR_OK != get_content_length(header_value, &content_length))
1844    {
1845       log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header);
1846       freez(*header);
1847    }
1848    else
1849    {
1850       csp->expected_client_content_length = content_length;
1851    }
1852
1853    return JB_ERR_OK;
1854 }
1855 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
1856
1857
1858
1859 /*********************************************************************
1860  *
1861  * Function    :  client_connection
1862  *
1863  * Description :  Makes sure a proper "Connection:" header is
1864  *                set and signals connection_header_adder
1865  *                to do nothing.
1866  *
1867  * Parameters  :
1868  *          1  :  csp = Current client state (buffers, headers, etc...)
1869  *          2  :  header = On input, pointer to header to modify.
1870  *                On output, pointer to the modified header, or NULL
1871  *                to remove the header.  This function frees the
1872  *                original string if necessary.
1873  *
1874  * Returns     :  JB_ERR_OK on success.
1875  *
1876  *********************************************************************/
1877 static jb_err client_connection(struct client_state *csp, char **header)
1878 {
1879    static const char connection_close[] = "Connection: close";
1880
1881    if (!strcmpic(*header, connection_close))
1882    {
1883 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1884       if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_SHARING)
1885         && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED))
1886       {
1887           if (!strcmpic(csp->http->ver, "HTTP/1.1"))
1888           {
1889              log_error(LOG_LEVEL_HEADER,
1890                 "Removing \'%s\' to imply keep-alive.", *header);
1891              freez(*header);
1892              /*
1893               * While we imply keep-alive to the server,
1894               * we have to remember that the client didn't.
1895               */
1896              csp->flags &= ~CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
1897           }
1898           else
1899           {
1900              char *old_header = *header;
1901
1902              *header = strdup_or_die("Connection: keep-alive");
1903              log_error(LOG_LEVEL_HEADER,
1904                 "Replaced: \'%s\' with \'%s\'", old_header, *header);
1905              freez(old_header);
1906           }
1907       }
1908       else
1909       {
1910          log_error(LOG_LEVEL_HEADER,
1911             "Keeping the client header '%s' around. "
1912             "The connection will not be kept alive.",
1913             *header);
1914          csp->flags &= ~CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
1915       }
1916    }
1917    else if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
1918         && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED))
1919    {
1920       log_error(LOG_LEVEL_HEADER,
1921          "Keeping the client header '%s' around. "
1922          "The server connection will be kept alive if possible.",
1923          *header);
1924       csp->flags |= CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
1925 #endif  /* def FEATURE_CONNECTION_KEEP_ALIVE */
1926    }
1927    else
1928    {
1929       char *old_header = *header;
1930
1931       *header = strdup_or_die(connection_close);
1932       log_error(LOG_LEVEL_HEADER,
1933          "Replaced: \'%s\' with \'%s\'", old_header, *header);
1934       freez(old_header);
1935    }
1936
1937    /* Signal client_connection_header_adder() to return early. */
1938    csp->flags |= CSP_FLAG_CLIENT_CONNECTION_HEADER_SET;
1939
1940    return JB_ERR_OK;
1941 }
1942
1943
1944 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1945 /*********************************************************************
1946  *
1947  * Function    :  client_proxy_connection
1948  *
1949  * Description :  Sets the CLIENT_CONNECTION_KEEP_ALIVE flag when
1950  *                appropriate and removes the Proxy-Connection
1951  *                header.
1952  *
1953  * Parameters  :
1954  *          1  :  csp = Current client state (buffers, headers, etc...)
1955  *          2  :  header = On input, pointer to header to modify.
1956  *                On output, pointer to the modified header, or NULL
1957  *                to remove the header.  This function frees the
1958  *                original string if necessary.
1959  *
1960  * Returns     :  JB_ERR_OK
1961  *
1962  *********************************************************************/
1963 static jb_err client_proxy_connection(struct client_state *csp, char **header)
1964 {
1965    if (0 == (csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE)
1966       && (csp->http->ssl == 0)
1967       && (NULL == strstr(*header, "close")))
1968    {
1969       log_error(LOG_LEVEL_HEADER,
1970          "The client connection can be kept alive due to: %s", *header);
1971       csp->flags |= CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
1972    }
1973    crumble(csp, header);
1974
1975    return JB_ERR_OK;
1976 }
1977 #endif  /* def FEATURE_CONNECTION_KEEP_ALIVE */
1978
1979
1980 /*********************************************************************
1981  *
1982  * Function    :  client_transfer_encoding
1983  *
1984  * Description :  Raise the CSP_FLAG_CHUNKED_CLIENT_BODY flag if
1985  *                the request body is "chunked"
1986  *
1987  *                XXX: Currently not called through sed() as we
1988  *                     need the flag earlier on. Should be fixed.
1989  *
1990  * Parameters  :
1991  *          1  :  csp = Current client state (buffers, headers, etc...)
1992  *          2  :  header = On input, pointer to header to modify.
1993  *                On output, pointer to the modified header, or NULL
1994  *                to remove the header.  This function frees the
1995  *                original string if necessary.
1996  *
1997  * Returns     :  JB_ERR_OK on success, or
1998  *
1999  *********************************************************************/
2000 jb_err client_transfer_encoding(struct client_state *csp, char **header)
2001 {
2002    if (strstr(*header, "chunked"))
2003    {
2004       csp->flags |= CSP_FLAG_CHUNKED_CLIENT_BODY;
2005       log_error(LOG_LEVEL_HEADER, "Expecting chunked client body");
2006    }
2007
2008    return JB_ERR_OK;
2009 }
2010
2011
2012 /*********************************************************************
2013  *
2014  * Function    :  crumble
2015  *
2016  * Description :  This is called if a header matches a pattern to "crunch"
2017  *
2018  * Parameters  :
2019  *          1  :  csp = Current client state (buffers, headers, etc...)
2020  *          2  :  header = On input, pointer to header to modify.
2021  *                On output, pointer to the modified header, or NULL
2022  *                to remove the header.  This function frees the
2023  *                original string if necessary.
2024  *
2025  * Returns     :  JB_ERR_OK on success, or
2026  *                JB_ERR_MEMORY on out-of-memory error.
2027  *
2028  *********************************************************************/
2029 static jb_err crumble(struct client_state *csp, char **header)
2030 {
2031    (void)csp;
2032    log_error(LOG_LEVEL_HEADER, "crumble crunched: %s!", *header);
2033    freez(*header);
2034    return JB_ERR_OK;
2035 }
2036
2037
2038 /*********************************************************************
2039  *
2040  * Function    :  crunch_server_header
2041  *
2042  * Description :  Crunch server header if it matches a string supplied by the
2043  *                user. Called from `sed'.
2044  *
2045  * Parameters  :
2046  *          1  :  csp = Current client state (buffers, headers, etc...)
2047  *          2  :  header = On input, pointer to header to modify.
2048  *                On output, pointer to the modified header, or NULL
2049  *                to remove the header.  This function frees the
2050  *                original string if necessary.
2051  *
2052  * Returns     :  JB_ERR_OK on success and always succeeds
2053  *
2054  *********************************************************************/
2055 static jb_err crunch_server_header(struct client_state *csp, char **header)
2056 {
2057    const char *crunch_pattern;
2058
2059    /* Do we feel like crunching? */
2060    if ((csp->action->flags & ACTION_CRUNCH_SERVER_HEADER))
2061    {
2062       crunch_pattern = csp->action->string[ACTION_STRING_SERVER_HEADER];
2063
2064       /* Is the current header the lucky one? */
2065       if (strstr(*header, crunch_pattern))
2066       {
2067          log_error(LOG_LEVEL_HEADER, "Crunching server header: %s (contains: %s)", *header, crunch_pattern);
2068          freez(*header);
2069       }
2070    }
2071
2072    return JB_ERR_OK;
2073 }
2074
2075
2076 /*********************************************************************
2077  *
2078  * Function    :  server_content_type
2079  *
2080  * Description :  Set the content-type for filterable types (text/.*,
2081  *                .*xml.*, .*script.* and image/gif) unless filtering has been
2082  *                forbidden (CT_TABOO) while parsing earlier headers.
2083  *                NOTE: Since text/plain is commonly used by web servers
2084  *                      for files whose correct type is unknown, we don't
2085  *                      set CT_TEXT for it.
2086  *
2087  * Parameters  :
2088  *          1  :  csp = Current client state (buffers, headers, etc...)
2089  *          2  :  header = On input, pointer to header to modify.
2090  *                On output, pointer to the modified header, or NULL
2091  *                to remove the header.  This function frees the
2092  *                original string if necessary.
2093  *
2094  * Returns     :  JB_ERR_OK on success, or
2095  *                JB_ERR_MEMORY on out-of-memory error.
2096  *
2097  *********************************************************************/
2098 static jb_err server_content_type(struct client_state *csp, char **header)
2099 {
2100    /* Remove header if it isn't the first Content-Type header */
2101    if ((csp->content_type & CT_DECLARED))
2102    {
2103       if (content_filters_enabled(csp->action))
2104       {
2105          /*
2106           * Making sure the client interprets the content the same way
2107           * Privoxy did is only relevant if Privoxy modified it.
2108           *
2109           * Checking for this is "hard" as it's not yet known when
2110           * this function is called, thus go shopping and and just
2111           * check if Privoxy could filter it.
2112           *
2113           * The main thing is that we don't mess with the headers
2114           * unless the user signalled that it's acceptable.
2115           */
2116          log_error(LOG_LEVEL_HEADER,
2117             "Multiple Content-Type headers detected. "
2118             "Removing and ignoring: %s",
2119             *header);
2120          freez(*header);
2121       }
2122       return JB_ERR_OK;
2123    }
2124
2125    /*
2126     * Signal that the Content-Type has been set.
2127     */
2128    csp->content_type |= CT_DECLARED;
2129
2130    if (!(csp->content_type & CT_TABOO))
2131    {
2132       /*
2133        * XXX: The assumption that text/plain is a sign of
2134        * binary data seems to be somewhat unreasonable nowadays
2135        * and should be dropped after 3.0.8 is out.
2136        */
2137       if ((strstr(*header, "text/") && !strstr(*header, "plain"))
2138         || strstr(*header, "xml")
2139         || strstr(*header, "script"))
2140       {
2141          csp->content_type |= CT_TEXT;
2142       }
2143       else if (strstr(*header, "image/gif"))
2144       {
2145          csp->content_type |= CT_GIF;
2146       }
2147    }
2148
2149    /*
2150     * Are we messing with the content type?
2151     */
2152    if (csp->action->flags & ACTION_CONTENT_TYPE_OVERWRITE)
2153    {
2154       /*
2155        * Make sure the user doesn't accidentally
2156        * change the content type of binary documents.
2157        */
2158       if ((csp->content_type & CT_TEXT) || (csp->action->flags & ACTION_FORCE_TEXT_MODE))
2159       {
2160          freez(*header);
2161          *header = strdup_or_die("Content-Type: ");
2162          string_append(header, csp->action->string[ACTION_STRING_CONTENT_TYPE]);
2163
2164          if (header == NULL)
2165          {
2166             log_error(LOG_LEVEL_HEADER, "Insufficient memory to replace Content-Type!");
2167             return JB_ERR_MEMORY;
2168          }
2169          log_error(LOG_LEVEL_HEADER, "Modified: %s!", *header);
2170       }
2171       else
2172       {
2173          log_error(LOG_LEVEL_HEADER, "%s not replaced. "
2174             "It doesn't look like a content type that should be filtered. "
2175             "Enable force-text-mode if you know what you're doing.", *header);
2176       }
2177    }
2178
2179    return JB_ERR_OK;
2180 }
2181
2182
2183 /*********************************************************************
2184  *
2185  * Function    :  server_transfer_coding
2186  *
2187  * Description :  - Prohibit filtering (CT_TABOO) if transfer coding compresses
2188  *                - Raise the CSP_FLAG_CHUNKED flag if coding is "chunked"
2189  *                - Remove header if body was chunked but has been
2190  *                  de-chunked for filtering.
2191  *
2192  * Parameters  :
2193  *          1  :  csp = Current client state (buffers, headers, etc...)
2194  *          2  :  header = On input, pointer to header to modify.
2195  *                On output, pointer to the modified header, or NULL
2196  *                to remove the header.  This function frees the
2197  *                original string if necessary.
2198  *
2199  * Returns     :  JB_ERR_OK on success, or
2200  *                JB_ERR_MEMORY on out-of-memory error.
2201  *
2202  *********************************************************************/
2203 static jb_err server_transfer_coding(struct client_state *csp, char **header)
2204 {
2205    /*
2206     * Turn off pcrs and gif filtering if body compressed
2207     */
2208    if (strstr(*header, "gzip") || strstr(*header, "compress") || strstr(*header, "deflate"))
2209    {
2210 #ifdef FEATURE_ZLIB
2211       /*
2212        * XXX: Added to test if we could use CT_GZIP and CT_DEFLATE here.
2213        */
2214       log_error(LOG_LEVEL_INFO, "Marking content type for %s as CT_TABOO because of %s.",
2215          csp->http->cmd, *header);
2216 #endif /* def FEATURE_ZLIB */
2217       csp->content_type = CT_TABOO;
2218    }
2219
2220    /*
2221     * Raise flag if body chunked
2222     */
2223    if (strstr(*header, "chunked"))
2224    {
2225       csp->flags |= CSP_FLAG_CHUNKED;
2226
2227       /*
2228        * If the body was modified, it has been de-chunked first
2229        * and the header must be removed.
2230        *
2231        * FIXME: If there is more than one transfer encoding,
2232        * only the "chunked" part should be removed here.
2233        */
2234       if (csp->flags & CSP_FLAG_MODIFIED)
2235       {
2236          log_error(LOG_LEVEL_HEADER, "Removing: %s", *header);
2237          freez(*header);
2238       }
2239    }
2240
2241    return JB_ERR_OK;
2242 }
2243
2244
2245 /*********************************************************************
2246  *
2247  * Function    :  server_content_encoding
2248  *
2249  * Description :  Used to check if the content is compressed, and if
2250  *                FEATURE_ZLIB is disabled, filtering is disabled as
2251  *                well.
2252  *
2253  *                If FEATURE_ZLIB is enabled and the compression type
2254  *                supported, the content is marked for decompression.
2255  *
2256  *                XXX: Doesn't properly deal with multiple or with
2257  *                     unsupported but unknown encodings.
2258  *                     Is case-sensitive but shouldn't be.
2259  *
2260  * Parameters  :
2261  *          1  :  csp = Current client state (buffers, headers, etc...)
2262  *          2  :  header = On input, pointer to header to modify.
2263  *                On output, pointer to the modified header, or NULL
2264  *                to remove the header.  This function frees the
2265  *                original string if necessary.
2266  *
2267  * Returns     :  JB_ERR_OK on success, or
2268  *                JB_ERR_MEMORY on out-of-memory error.
2269  *
2270  *********************************************************************/
2271 static jb_err server_content_encoding(struct client_state *csp, char **header)
2272 {
2273 #ifdef FEATURE_ZLIB
2274    if (strstr(*header, "sdch"))
2275    {
2276       /*
2277        * Shared Dictionary Compression over HTTP isn't supported,
2278        * filtering it anyway is pretty much guaranteed to mess up
2279        * the encoding.
2280        */
2281       csp->content_type |= CT_TABOO;
2282
2283       /*
2284        * Log a warning if the user expects the content to be filtered.
2285        */
2286       if ((csp->rlist != NULL) &&
2287          (!list_is_empty(csp->action->multi[ACTION_MULTI_FILTER])))
2288       {
2289          log_error(LOG_LEVEL_INFO,
2290             "SDCH-compressed content detected, content filtering disabled. "
2291             "Consider suppressing SDCH offers made by the client.");
2292       }
2293    }
2294    else if (strstr(*header, "gzip"))
2295    {
2296       /* Mark for gzip decompression */
2297       csp->content_type |= CT_GZIP;
2298    }
2299    else if (strstr(*header, "deflate"))
2300    {
2301       /* Mark for zlib decompression */
2302       csp->content_type |= CT_DEFLATE;
2303    }
2304    else if (strstr(*header, "compress"))
2305    {
2306       /*
2307        * We can't decompress this; therefore we can't filter
2308        * it either.
2309        */
2310       csp->content_type |= CT_TABOO;
2311    }
2312 #else /* !defined(FEATURE_ZLIB) */
2313    /*
2314     * XXX: Using a black list here isn't the right approach.
2315     *
2316     *      In case of SDCH, building with zlib support isn't
2317     *      going to help.
2318     */
2319    if (strstr(*header, "gzip") ||
2320        strstr(*header, "compress") ||
2321        strstr(*header, "deflate") ||
2322        strstr(*header, "sdch"))
2323    {
2324       /*
2325        * Body is compressed, turn off pcrs and gif filtering.
2326        */
2327       csp->content_type |= CT_TABOO;
2328
2329       /*
2330        * Log a warning if the user expects the content to be filtered.
2331        */
2332       if ((csp->rlist != NULL) &&
2333          (!list_is_empty(csp->action->multi[ACTION_MULTI_FILTER])))
2334       {
2335          log_error(LOG_LEVEL_INFO,
2336             "Compressed content detected, content filtering disabled. "
2337             "Consider recompiling Privoxy with zlib support or "
2338             "enable the prevent-compression action.");
2339       }
2340    }
2341 #endif /* defined(FEATURE_ZLIB) */
2342
2343    return JB_ERR_OK;
2344
2345 }
2346
2347
2348 #ifdef FEATURE_ZLIB
2349 /*********************************************************************
2350  *
2351  * Function    :  server_adjust_content_encoding
2352  *
2353  * Description :  Remove the Content-Encoding header if the
2354  *                decompression was successful and the content
2355  *                has been modifed.
2356  *
2357  * Parameters  :
2358  *          1  :  csp = Current client state (buffers, headers, etc...)
2359  *          2  :  header = On input, pointer to header to modify.
2360  *                On output, pointer to the modified header, or NULL
2361  *                to remove the header.  This function frees the
2362  *                original string if necessary.
2363  *
2364  * Returns     :  JB_ERR_OK on success, or
2365  *                JB_ERR_MEMORY on out-of-memory error.
2366  *
2367  *********************************************************************/
2368 static jb_err server_adjust_content_encoding(struct client_state *csp, char **header)
2369 {
2370    if ((csp->flags & CSP_FLAG_MODIFIED)
2371     && (csp->content_type & (CT_GZIP | CT_DEFLATE)))
2372    {
2373       /*
2374        * We successfully decompressed the content,
2375        * and have to clean the header now, so the
2376        * client no longer expects compressed data.
2377        *
2378        * XXX: There is a difference between cleaning
2379        * and removing it completely.
2380        */
2381       log_error(LOG_LEVEL_HEADER, "Crunching: %s", *header);
2382       freez(*header);
2383    }
2384
2385    return JB_ERR_OK;
2386
2387 }
2388 #endif /* defined(FEATURE_ZLIB) */
2389
2390
2391 /*********************************************************************
2392  *
2393  * Function    :  server_adjust_content_length
2394  *
2395  * Description :  Adjust Content-Length header if we modified
2396  *                the body.
2397  *
2398  * Parameters  :
2399  *          1  :  csp = Current client state (buffers, headers, etc...)
2400  *          2  :  header = On input, pointer to header to modify.
2401  *                On output, pointer to the modified header, or NULL
2402  *                to remove the header.  This function frees the
2403  *                original string if necessary.
2404  *
2405  * Returns     :  JB_ERR_OK on success, or
2406  *                JB_ERR_MEMORY on out-of-memory error.
2407  *
2408  *********************************************************************/
2409 static jb_err server_adjust_content_length(struct client_state *csp, char **header)
2410 {
2411    /* Regenerate header if the content was modified. */
2412    if (csp->flags & CSP_FLAG_MODIFIED)
2413    {
2414       const size_t header_length = 50;
2415       freez(*header);
2416       *header = malloc(header_length);
2417       if (*header == NULL)
2418       {
2419          return JB_ERR_MEMORY;
2420       }
2421       create_content_length_header(csp->content_length, *header, header_length);
2422       log_error(LOG_LEVEL_HEADER,
2423          "Adjusted Content-Length to %llu", csp->content_length);
2424    }
2425
2426    return JB_ERR_OK;
2427 }
2428
2429
2430 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
2431 /*********************************************************************
2432  *
2433  * Function    :  server_save_content_length
2434  *
2435  * Description :  Save the Content-Length sent by the server.
2436  *
2437  * Parameters  :
2438  *          1  :  csp = Current client state (buffers, headers, etc...)
2439  *          2  :  header = On input, pointer to header to modify.
2440  *                On output, pointer to the modified header, or NULL
2441  *                to remove the header.  This function frees the
2442  *                original string if necessary.
2443  *
2444  * Returns     :  JB_ERR_OK on success, or
2445  *                JB_ERR_MEMORY on out-of-memory error.
2446  *
2447  *********************************************************************/
2448 static jb_err server_save_content_length(struct client_state *csp, char **header)
2449 {
2450    unsigned long long content_length = 0;
2451    const char *header_value;
2452
2453    assert(*(*header+14) == ':');
2454
2455    header_value = *header + 15;
2456    if (JB_ERR_OK != get_content_length(header_value, &content_length))
2457    {
2458       log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header);
2459       freez(*header);
2460    }
2461    else
2462    {
2463       csp->expected_content_length = content_length;
2464       csp->flags |= CSP_FLAG_SERVER_CONTENT_LENGTH_SET;
2465       csp->flags |= CSP_FLAG_CONTENT_LENGTH_SET;
2466    }
2467
2468    return JB_ERR_OK;
2469 }
2470 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
2471
2472
2473 /*********************************************************************
2474  *
2475  * Function    :  server_content_md5
2476  *
2477  * Description :  Crumble any Content-MD5 headers if the document was
2478  *                modified. FIXME: Should we re-compute instead?
2479  *
2480  * Parameters  :
2481  *          1  :  csp = Current client state (buffers, headers, etc...)
2482  *          2  :  header = On input, pointer to header to modify.
2483  *                On output, pointer to the modified header, or NULL
2484  *                to remove the header.  This function frees the
2485  *                original string if necessary.
2486  *
2487  * Returns     :  JB_ERR_OK on success, or
2488  *                JB_ERR_MEMORY on out-of-memory error.
2489  *
2490  *********************************************************************/
2491 static jb_err server_content_md5(struct client_state *csp, char **header)
2492 {
2493    if (csp->flags & CSP_FLAG_MODIFIED)
2494    {
2495       log_error(LOG_LEVEL_HEADER, "Crunching Content-MD5");
2496       freez(*header);
2497    }
2498
2499    return JB_ERR_OK;
2500 }
2501
2502
2503 /*********************************************************************
2504  *
2505  * Function    :  server_content_disposition
2506  *
2507  * Description :  If enabled, blocks or modifies the "Content-Disposition" header.
2508  *                Called from `sed'.
2509  *
2510  * Parameters  :
2511  *          1  :  csp = Current client state (buffers, headers, etc...)
2512  *          2  :  header = On input, pointer to header to modify.
2513  *                On output, pointer to the modified header, or NULL
2514  *                to remove the header.  This function frees the
2515  *                original string if necessary.
2516  *
2517  * Returns     :  JB_ERR_OK on success, or
2518  *                JB_ERR_MEMORY on out-of-memory error.
2519  *
2520  *********************************************************************/
2521 static jb_err server_content_disposition(struct client_state *csp, char **header)
2522 {
2523    const char *newval;
2524
2525    /*
2526     * Are we messing with the Content-Disposition header?
2527     */
2528    if ((csp->action->flags & ACTION_HIDE_CONTENT_DISPOSITION) == 0)
2529    {
2530       /* Me tinks not */
2531       return JB_ERR_OK;
2532    }
2533
2534    newval = csp->action->string[ACTION_STRING_CONTENT_DISPOSITION];
2535
2536    if ((newval == NULL) || (0 == strcmpic(newval, "block")))
2537    {
2538       /*
2539        * Blocking content-disposition header
2540        */
2541       log_error(LOG_LEVEL_HEADER, "Crunching %s!", *header);
2542       freez(*header);
2543       return JB_ERR_OK;
2544    }
2545    else
2546    {
2547       /*
2548        * Replacing Content-Disposition header
2549        */
2550       freez(*header);
2551       *header = strdup("Content-Disposition: ");
2552       string_append(header, newval);
2553
2554       if (*header != NULL)
2555       {
2556          log_error(LOG_LEVEL_HEADER,
2557             "Content-Disposition header crunched and replaced with: %s", *header);
2558       }
2559    }
2560    return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
2561 }
2562
2563
2564 /*********************************************************************
2565  *
2566  * Function    :  server_last_modified
2567  *
2568  * Description :  Changes Last-Modified header to the actual date
2569  *                to help hide-if-modified-since.
2570  *                Called from `sed'.
2571  *
2572  * Parameters  :
2573  *          1  :  csp = Current client state (buffers, headers, etc...)
2574  *          2  :  header = On input, pointer to header to modify.
2575  *                On output, pointer to the modified header, or NULL
2576  *                to remove the header.  This function frees the
2577  *                original string if necessary.
2578  *
2579  * Returns     :  JB_ERR_OK on success, or
2580  *                JB_ERR_MEMORY on out-of-memory error.
2581  *
2582  *********************************************************************/
2583 static jb_err server_last_modified(struct client_state *csp, char **header)
2584 {
2585    const char *newval;
2586    time_t last_modified;
2587    char newheader[50];
2588
2589    /*
2590     * Are we messing with the Last-Modified header?
2591     */
2592    if ((csp->action->flags & ACTION_OVERWRITE_LAST_MODIFIED) == 0)
2593    {
2594       /*Nope*/
2595       return JB_ERR_OK;
2596    }
2597
2598    newval = csp->action->string[ACTION_STRING_LAST_MODIFIED];
2599
2600    if (0 == strcmpic(newval, "block"))
2601    {
2602       /*
2603        * Blocking Last-Modified header. Useless but why not.
2604        */
2605       log_error(LOG_LEVEL_HEADER, "Crunching %s!", *header);
2606       freez(*header);
2607       return JB_ERR_OK;
2608    }
2609    else if (0 == strcmpic(newval, "reset-to-request-time"))
2610    {
2611       /*
2612        * Setting Last-Modified Header to now.
2613        */
2614       char buf[30];
2615       get_http_time(0, buf, sizeof(buf));
2616       freez(*header);
2617       *header = strdup("Last-Modified: ");
2618       string_append(header, buf);
2619
2620       if (*header == NULL)
2621       {
2622          log_error(LOG_LEVEL_HEADER, "Insufficient memory. Last-Modified header got lost, boohoo.");
2623       }
2624       else
2625       {
2626          log_error(LOG_LEVEL_HEADER, "Reset to present time: %s", *header);
2627       }
2628    }
2629    else if (0 == strcmpic(newval, "randomize"))
2630    {
2631       const char *header_time = *header + sizeof("Last-Modified:");
2632
2633       log_error(LOG_LEVEL_HEADER, "Randomizing: %s", *header);
2634
2635       if (JB_ERR_OK != parse_header_time(header_time, &last_modified))
2636       {
2637          log_error(LOG_LEVEL_HEADER, "Couldn't parse: %s in %s (crunching!)", header_time, *header);
2638          freez(*header);
2639       }
2640       else
2641       {
2642          time_t now;
2643          struct tm *timeptr = NULL;
2644          long int rtime;
2645 #ifdef HAVE_GMTIME_R
2646          struct tm gmt;
2647 #endif
2648          now = time(NULL);
2649          rtime = (long int)difftime(now, last_modified);
2650          if (rtime)
2651          {
2652             long int days, hours, minutes, seconds;
2653             const int negative_delta = (rtime < 0);
2654
2655             if (negative_delta)
2656             {
2657                rtime *= -1;
2658                log_error(LOG_LEVEL_HEADER, "Server time in the future.");
2659             }
2660             rtime = pick_from_range(rtime);
2661             if (negative_delta)
2662             {
2663                rtime *= -1;
2664             }
2665             last_modified += rtime;
2666 #ifdef HAVE_GMTIME_R
2667             timeptr = gmtime_r(&last_modified, &gmt);
2668 #elif defined(MUTEX_LOCKS_AVAILABLE)
2669             privoxy_mutex_lock(&gmtime_mutex);
2670             timeptr = gmtime(&last_modified);
2671             privoxy_mutex_unlock(&gmtime_mutex);
2672 #else
2673             timeptr = gmtime(&last_modified);
2674 #endif
2675             if ((NULL == timeptr) || !strftime(newheader,
2676                   sizeof(newheader), "%a, %d %b %Y %H:%M:%S GMT", timeptr))
2677             {
2678                log_error(LOG_LEVEL_ERROR,
2679                   "Randomizing '%s' failed. Crunching the header without replacement.",
2680                   *header);
2681                freez(*header);
2682                return JB_ERR_OK;
2683             }
2684
2685             freez(*header);
2686             *header = strdup("Last-Modified: ");
2687             string_append(header, newheader);
2688
2689             if (*header == NULL)
2690             {
2691                log_error(LOG_LEVEL_ERROR, "Insufficient memory, header crunched without replacement.");
2692                return JB_ERR_MEMORY;
2693             }
2694
2695             days    = rtime / (3600 * 24);
2696             hours   = rtime / 3600 % 24;
2697             minutes = rtime / 60 % 60;
2698             seconds = rtime % 60;
2699
2700             log_error(LOG_LEVEL_HEADER,
2701                "Randomized:  %s (added %d da%s %d hou%s %d minut%s %d second%s",
2702                *header, days, (days == 1) ? "y" : "ys", hours, (hours == 1) ? "r" : "rs",
2703                minutes, (minutes == 1) ? "e" : "es", seconds, (seconds == 1) ? ")" : "s)");
2704          }
2705          else
2706          {
2707             log_error(LOG_LEVEL_HEADER, "Randomized ... or not. No time difference to work with.");
2708          }
2709       }
2710    }
2711
2712    return JB_ERR_OK;
2713 }
2714
2715
2716 /*********************************************************************
2717  *
2718  * Function    :  client_accept_encoding
2719  *
2720  * Description :  Rewrite the client's Accept-Encoding header so that
2721  *                if doesn't allow compression, if the action applies.
2722  *                Note: For HTTP/1.0 the absence of the header is enough.
2723  *
2724  * Parameters  :
2725  *          1  :  csp = Current client state (buffers, headers, etc...)
2726  *          2  :  header = On input, pointer to header to modify.
2727  *                On output, pointer to the modified header, or NULL
2728  *                to remove the header.  This function frees the
2729  *                original string if necessary.
2730  *
2731  * Returns     :  JB_ERR_OK on success, or
2732  *                JB_ERR_MEMORY on out-of-memory error.
2733  *
2734  *********************************************************************/
2735 static jb_err client_accept_encoding(struct client_state *csp, char **header)
2736 {
2737 #ifdef FEATURE_COMPRESSION
2738    if ((csp->config->feature_flags & RUNTIME_FEATURE_COMPRESSION)
2739       && strstr(*header, "deflate"))
2740    {
2741       csp->flags |= CSP_FLAG_CLIENT_SUPPORTS_DEFLATE;
2742    }
2743 #endif
2744    if ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
2745    {
2746       log_error(LOG_LEVEL_HEADER, "Suppressed offer to compress content");
2747       freez(*header);
2748    }
2749
2750    return JB_ERR_OK;
2751 }
2752
2753
2754 /*********************************************************************
2755  *
2756  * Function    :  client_te
2757  *
2758  * Description :  Rewrite the client's TE header so that
2759  *                if doesn't allow compression, if the action applies.
2760  *
2761  * Parameters  :
2762  *          1  :  csp = Current client state (buffers, headers, etc...)
2763  *          2  :  header = On input, pointer to header to modify.
2764  *                On output, pointer to the modified header, or NULL
2765  *                to remove the header.  This function frees the
2766  *                original string if necessary.
2767  *
2768  * Returns     :  JB_ERR_OK on success, or
2769  *                JB_ERR_MEMORY on out-of-memory error.
2770  *
2771  *********************************************************************/
2772 static jb_err client_te(struct client_state *csp, char **header)
2773 {
2774    if ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
2775    {
2776       freez(*header);
2777       log_error(LOG_LEVEL_HEADER, "Suppressed offer to compress transfer");
2778    }
2779
2780    return JB_ERR_OK;
2781 }
2782
2783
2784 /*********************************************************************
2785  *
2786  * Function    :  client_referrer
2787  *
2788  * Description :  Handle the "referer" config setting properly.
2789  *                Called from `sed'.
2790  *
2791  * Parameters  :
2792  *          1  :  csp = Current client state (buffers, headers, etc...)
2793  *          2  :  header = On input, pointer to header to modify.
2794  *                On output, pointer to the modified header, or NULL
2795  *                to remove the header.  This function frees the
2796  *                original string if necessary.
2797  *
2798  * Returns     :  JB_ERR_OK on success, or
2799  *                JB_ERR_MEMORY on out-of-memory error.
2800  *
2801  *********************************************************************/
2802 static jb_err client_referrer(struct client_state *csp, char **header)
2803 {
2804    const char *parameter;
2805    /* booleans for parameters we have to check multiple times */
2806    int parameter_conditional_block;
2807    int parameter_conditional_forge;
2808
2809 #ifdef FEATURE_FORCE_LOAD
2810    /*
2811     * Since the referrer can include the prefix even
2812     * if the request itself is non-forced, we must
2813     * clean it unconditionally.
2814     *
2815     * XXX: strclean is too broad
2816     */
2817    strclean(*header, FORCE_PREFIX);
2818 #endif /* def FEATURE_FORCE_LOAD */
2819
2820    if ((csp->action->flags & ACTION_HIDE_REFERER) == 0)
2821    {
2822       /* Nothing left to do */
2823       return JB_ERR_OK;
2824    }
2825
2826    parameter = csp->action->string[ACTION_STRING_REFERER];
2827    assert(parameter != NULL);
2828    parameter_conditional_block = (0 == strcmpic(parameter, "conditional-block"));
2829    parameter_conditional_forge = (0 == strcmpic(parameter, "conditional-forge"));
2830
2831    if (!parameter_conditional_block && !parameter_conditional_forge)
2832    {
2833       /*
2834        * As conditional-block and conditional-forge are the only
2835        * parameters that rely on the original referrer, we can
2836        * remove it now for all the others.
2837        */
2838       freez(*header);
2839    }
2840
2841    if (0 == strcmpic(parameter, "block"))
2842    {
2843       log_error(LOG_LEVEL_HEADER, "Referer crunched!");
2844       return JB_ERR_OK;
2845    }
2846    else if (parameter_conditional_block || parameter_conditional_forge)
2847    {
2848       return handle_conditional_hide_referrer_parameter(header,
2849          csp->http->hostport, parameter_conditional_block);
2850    }
2851    else if (0 == strcmpic(parameter, "forge"))
2852    {
2853       return create_forged_referrer(header, csp->http->hostport);
2854    }
2855    else
2856    {
2857       /* interpret parameter as user-supplied referer to fake */
2858       return create_fake_referrer(header, parameter);
2859    }
2860 }
2861
2862
2863 /*********************************************************************
2864  *
2865  * Function    :  client_accept_language
2866  *
2867  * Description :  Handle the "Accept-Language" config setting properly.
2868  *                Called from `sed'.
2869  *
2870  * Parameters  :
2871  *          1  :  csp = Current client state (buffers, headers, etc...)
2872  *          2  :  header = On input, pointer to header to modify.
2873  *                On output, pointer to the modified header, or NULL
2874  *                to remove the header.  This function frees the
2875  *                original string if necessary.
2876  *
2877  * Returns     :  JB_ERR_OK on success, or
2878  *                JB_ERR_MEMORY on out-of-memory error.
2879  *
2880  *********************************************************************/
2881 static jb_err client_accept_language(struct client_state *csp, char **header)
2882 {
2883    const char *newval;
2884
2885    /*
2886     * Are we messing with the Accept-Language?
2887     */
2888    if ((csp->action->flags & ACTION_HIDE_ACCEPT_LANGUAGE) == 0)
2889    {
2890       /*I don't think so*/
2891       return JB_ERR_OK;
2892    }
2893
2894    newval = csp->action->string[ACTION_STRING_LANGUAGE];
2895
2896    if ((newval == NULL) || (0 == strcmpic(newval, "block")))
2897    {
2898       /*
2899        * Blocking Accept-Language header
2900        */
2901       log_error(LOG_LEVEL_HEADER, "Crunching Accept-Language!");
2902       freez(*header);
2903       return JB_ERR_OK;
2904    }
2905    else
2906    {
2907       /*
2908        * Replacing Accept-Language header
2909        */
2910       freez(*header);
2911       *header = strdup("Accept-Language: ");
2912       string_append(header, newval);
2913
2914       if (*header == NULL)
2915       {
2916          log_error(LOG_LEVEL_ERROR,
2917             "Insufficient memory. Accept-Language header crunched without replacement.");
2918       }
2919       else
2920       {
2921          log_error(LOG_LEVEL_HEADER,
2922             "Accept-Language header crunched and replaced with: %s", *header);
2923       }
2924    }
2925    return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
2926 }
2927
2928
2929 /*********************************************************************
2930  *
2931  * Function    :  crunch_client_header
2932  *
2933  * Description :  Crunch client header if it matches a string supplied by the
2934  *                user. Called from `sed'.
2935  *
2936  * Parameters  :
2937  *          1  :  csp = Current client state (buffers, headers, etc...)
2938  *          2  :  header = On input, pointer to header to modify.
2939  *                On output, pointer to the modified header, or NULL
2940  *                to remove the header.  This function frees the
2941  *                original string if necessary.
2942  *
2943  * Returns     :  JB_ERR_OK on success and always succeeds
2944  *
2945  *********************************************************************/
2946 static jb_err crunch_client_header(struct client_state *csp, char **header)
2947 {
2948    const char *crunch_pattern;
2949
2950    /* Do we feel like crunching? */
2951    if ((csp->action->flags & ACTION_CRUNCH_CLIENT_HEADER))
2952    {
2953       crunch_pattern = csp->action->string[ACTION_STRING_CLIENT_HEADER];
2954
2955       /* Is the current header the lucky one? */
2956       if (strstr(*header, crunch_pattern))
2957       {
2958          log_error(LOG_LEVEL_HEADER, "Crunching client header: %s (contains: %s)", *header, crunch_pattern);
2959          freez(*header);
2960       }
2961    }
2962    return JB_ERR_OK;
2963 }
2964
2965
2966 /*********************************************************************
2967  *
2968  * Function    :  client_uagent
2969  *
2970  * Description :  Handle the "user-agent" config setting properly
2971  *                and remember its original value to enable browser
2972  *                bug workarounds. Called from `sed'.
2973  *
2974  * Parameters  :
2975  *          1  :  csp = Current client state (buffers, headers, etc...)
2976  *          2  :  header = On input, pointer to header to modify.
2977  *                On output, pointer to the modified header, or NULL
2978  *                to remove the header.  This function frees the
2979  *                original string if necessary.
2980  *
2981  * Returns     :  JB_ERR_OK on success, or
2982  *                JB_ERR_MEMORY on out-of-memory error.
2983  *
2984  *********************************************************************/
2985 static jb_err client_uagent(struct client_state *csp, char **header)
2986 {
2987    const char *newval;
2988
2989    if ((csp->action->flags & ACTION_HIDE_USER_AGENT) == 0)
2990    {
2991       return JB_ERR_OK;
2992    }
2993
2994    newval = csp->action->string[ACTION_STRING_USER_AGENT];
2995    if (newval == NULL)
2996    {
2997       return JB_ERR_OK;
2998    }
2999
3000    freez(*header);
3001    *header = strdup("User-Agent: ");
3002    string_append(header, newval);
3003
3004    log_error(LOG_LEVEL_HEADER, "Modified: %s", *header);
3005
3006    return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
3007 }
3008
3009
3010 /*********************************************************************
3011  *
3012  * Function    :  client_ua
3013  *
3014  * Description :  Handle "ua-" headers properly.  Called from `sed'.
3015  *
3016  * Parameters  :
3017  *          1  :  csp = Current client state (buffers, headers, etc...)
3018  *          2  :  header = On input, pointer to header to modify.
3019  *                On output, pointer to the modified header, or NULL
3020  *                to remove the header.  This function frees the
3021  *                original string if necessary.
3022  *
3023  * Returns     :  JB_ERR_OK on success, or
3024  *                JB_ERR_MEMORY on out-of-memory error.
3025  *
3026  *********************************************************************/
3027 static jb_err client_ua(struct client_state *csp, char **header)
3028 {
3029    if ((csp->action->flags & ACTION_HIDE_USER_AGENT) != 0)
3030    {
3031       log_error(LOG_LEVEL_HEADER, "crunched User-Agent!");
3032       freez(*header);
3033    }
3034
3035    return JB_ERR_OK;
3036 }
3037
3038
3039 /*********************************************************************
3040  *
3041  * Function    :  client_from
3042  *
3043  * Description :  Handle the "from" config setting properly.
3044  *                Called from `sed'.
3045  *
3046  * Parameters  :
3047  *          1  :  csp = Current client state (buffers, headers, etc...)
3048  *          2  :  header = On input, pointer to header to modify.
3049  *                On output, pointer to the modified header, or NULL
3050  *                to remove the header.  This function frees the
3051  *                original string if necessary.
3052  *
3053  * Returns     :  JB_ERR_OK on success, or
3054  *                JB_ERR_MEMORY on out-of-memory error.
3055  *
3056  *********************************************************************/
3057 static jb_err client_from(struct client_state *csp, char **header)
3058 {
3059    const char *newval;
3060
3061    if ((csp->action->flags & ACTION_HIDE_FROM) == 0)
3062    {
3063       return JB_ERR_OK;
3064    }
3065
3066    freez(*header);
3067
3068    newval = csp->action->string[ACTION_STRING_FROM];
3069
3070    /*
3071     * Are we blocking the e-mail address?
3072     */
3073    if ((newval == NULL) || (0 == strcmpic(newval, "block")))
3074    {
3075       log_error(LOG_LEVEL_HEADER, "crunched From!");
3076       return JB_ERR_OK;
3077    }
3078
3079    log_error(LOG_LEVEL_HEADER, " modified");
3080
3081    *header = strdup("From: ");
3082    string_append(header, newval);
3083
3084    return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
3085 }
3086
3087
3088 /*********************************************************************
3089  *
3090  * Function    :  client_send_cookie
3091  *
3092  * Description :  Crunches the "cookie" header if necessary.
3093  *                Called from `sed'.
3094  *
3095  *                XXX: Stupid name, doesn't send squat.
3096  *
3097  * Parameters  :
3098  *          1  :  csp = Current client state (buffers, headers, etc...)
3099  *          2  :  header = On input, pointer to header to modify.
3100  *                On output, pointer to the modified header, or NULL
3101  *                to remove the header.  This function frees the
3102  *                original string if necessary.
3103  *
3104  * Returns     :  JB_ERR_OK on success, or
3105  *                JB_ERR_MEMORY on out-of-memory error.
3106  *
3107  *********************************************************************/
3108 static jb_err client_send_cookie(struct client_state *csp, char **header)
3109 {
3110    if (csp->action->flags & ACTION_CRUNCH_OUTGOING_COOKIES)
3111    {
3112       log_error(LOG_LEVEL_HEADER, "Crunched outgoing cookie: %s", *header);
3113       freez(*header);
3114    }
3115
3116    return JB_ERR_OK;
3117 }
3118
3119
3120 /*********************************************************************
3121  *
3122  * Function    :  client_x_forwarded
3123  *
3124  * Description :  Handle the "x-forwarded-for" config setting properly,
3125  *                also used in the add_client_headers list.  Called from `sed'.
3126  *
3127  * Parameters  :
3128  *          1  :  csp = Current client state (buffers, headers, etc...)
3129  *          2  :  header = On input, pointer to header to modify.
3130  *                On output, pointer to the modified header, or NULL
3131  *                to remove the header.  This function frees the
3132  *                original string if necessary.
3133  *
3134  * Returns     :  JB_ERR_OK on success, or
3135  *                JB_ERR_MEMORY on out-of-memory error.
3136  *
3137  *********************************************************************/
3138 jb_err client_x_forwarded(struct client_state *csp, char **header)
3139 {
3140    if (0 != (csp->action->flags & ACTION_CHANGE_X_FORWARDED_FOR))
3141    {
3142       const char *parameter = csp->action->string[ACTION_STRING_CHANGE_X_FORWARDED_FOR];
3143
3144       if (0 == strcmpic(parameter, "block"))
3145       {
3146          freez(*header);
3147          log_error(LOG_LEVEL_HEADER, "crunched x-forwarded-for!");
3148       }
3149       else if (0 == strcmpic(parameter, "add"))
3150       {
3151          string_append(header, ", ");
3152          string_append(header, csp->ip_addr_str);
3153
3154          if (*header == NULL)
3155          {
3156             return JB_ERR_MEMORY;
3157          }
3158          log_error(LOG_LEVEL_HEADER,
3159             "Appended client IP address to %s", *header);
3160          csp->flags |= CSP_FLAG_X_FORWARDED_FOR_APPENDED;
3161       }
3162       else
3163       {
3164          log_error(LOG_LEVEL_FATAL,
3165             "Invalid change-x-forwarded-for parameter: '%s'", parameter);
3166       }
3167    }
3168
3169    return JB_ERR_OK;
3170 }
3171
3172
3173 /*********************************************************************
3174  *
3175  * Function    :  client_max_forwards
3176  *
3177  * Description :  If the HTTP method is OPTIONS or TRACE, subtract one
3178  *                from the value of the Max-Forwards header field.
3179  *
3180  * Parameters  :
3181  *          1  :  csp = Current client state (buffers, headers, etc...)
3182  *          2  :  header = On input, pointer to header to modify.
3183  *                On output, pointer to the modified header, or NULL
3184  *                to remove the header.  This function frees the
3185  *                original string if necessary.
3186  *
3187  * Returns     :  JB_ERR_OK on success, or
3188  *                JB_ERR_MEMORY on out-of-memory error.
3189  *
3190  *********************************************************************/
3191 static jb_err client_max_forwards(struct client_state *csp, char **header)
3192 {
3193    int max_forwards;
3194
3195    if ((0 == strcmpic(csp->http->gpc, "trace")) ||
3196        (0 == strcmpic(csp->http->gpc, "options")))
3197    {
3198       assert(*(*header+12) == ':');
3199       if (1 == sscanf(*header+12, ": %d", &max_forwards))
3200       {
3201          if (max_forwards > 0)
3202          {
3203             snprintf(*header, strlen(*header)+1, "Max-Forwards: %d", --max_forwards);
3204             log_error(LOG_LEVEL_HEADER,
3205                "Max-Forwards value for %s request reduced to %d.",
3206                csp->http->gpc, max_forwards);
3207          }
3208          else if (max_forwards < 0)
3209          {
3210             log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header);
3211             freez(*header);
3212          }
3213       }
3214       else
3215       {
3216          log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header);
3217          freez(*header);
3218       }
3219    }
3220
3221    return JB_ERR_OK;
3222 }
3223
3224
3225 /*********************************************************************
3226  *
3227  * Function    :  client_host
3228  *
3229  * Description :  If the request URI did not contain host and
3230  *                port information, parse and evaluate the Host
3231  *                header field.
3232  *
3233  * Parameters  :
3234  *          1  :  csp = Current client state (buffers, headers, etc...)
3235  *          2  :  header = On input, pointer to header to modify.
3236  *                On output, pointer to the modified header, or NULL
3237  *                to remove the header.  This function frees the
3238  *                original string if necessary.
3239  *
3240  * Returns     :  JB_ERR_OK on success, or
3241  *                JB_ERR_MEMORY on out-of-memory error.
3242  *
3243  *********************************************************************/
3244 static jb_err client_host(struct client_state *csp, char **header)
3245 {
3246    char *p, *q;
3247
3248    if (!csp->http->hostport || (*csp->http->hostport == '*') ||
3249        *csp->http->hostport == ' ' || *csp->http->hostport == '\0')
3250    {
3251
3252       p = strdup_or_die((*header)+6);
3253       chomp(p);
3254       q = strdup_or_die(p);
3255
3256       freez(csp->http->hostport);
3257       csp->http->hostport = p;
3258       freez(csp->http->host);
3259       csp->http->host = q;
3260       q = strchr(csp->http->host, ':');
3261       if (q != NULL)
3262       {
3263          /* Terminate hostname and evaluate port string */
3264          *q++ = '\0';
3265          csp->http->port = atoi(q);
3266       }
3267       else
3268       {
3269          csp->http->port = csp->http->ssl ? 443 : 80;
3270       }
3271
3272       log_error(LOG_LEVEL_HEADER, "New host and port from Host field: %s = %s:%d",
3273                 csp->http->hostport, csp->http->host, csp->http->port);
3274    }
3275
3276    /* Signal client_host_adder() to return right away */
3277    csp->flags |= CSP_FLAG_HOST_HEADER_IS_SET;
3278
3279    return JB_ERR_OK;
3280 }
3281
3282
3283 /*********************************************************************
3284  *
3285  * Function    :  client_if_modified_since
3286  *
3287  * Description :  Remove or modify the If-Modified-Since header.
3288  *
3289  * Parameters  :
3290  *          1  :  csp = Current client state (buffers, headers, etc...)
3291  *          2  :  header = On input, pointer to header to modify.
3292  *                On output, pointer to the modified header, or NULL
3293  *                to remove the header.  This function frees the
3294  *                original string if necessary.
3295  *
3296  * Returns     :  JB_ERR_OK on success, or
3297  *                JB_ERR_MEMORY on out-of-memory error.
3298  *
3299  *********************************************************************/
3300 static jb_err client_if_modified_since(struct client_state *csp, char **header)
3301 {
3302    char newheader[50];
3303 #ifdef HAVE_GMTIME_R
3304    struct tm gmt;
3305 #endif
3306    struct tm *timeptr = NULL;
3307    time_t tm = 0;
3308    const char *newval;
3309    char * endptr;
3310
3311    if (0 == strcmpic(*header, "If-Modified-Since: Wed, 08 Jun 1955 12:00:00 GMT"))
3312    {
3313       /*
3314        * The client got an error message because of a temporary problem,
3315        * the problem is gone and the client now tries to revalidate our
3316        * error message on the real server. The revalidation would always
3317        * end with the transmission of the whole document and there is
3318        * no need to expose the bogus If-Modified-Since header.
3319        */
3320       log_error(LOG_LEVEL_HEADER, "Crunching useless If-Modified-Since header.");
3321       freez(*header);
3322    }
3323    else if (csp->action->flags & ACTION_HIDE_IF_MODIFIED_SINCE)
3324    {
3325       newval = csp->action->string[ACTION_STRING_IF_MODIFIED_SINCE];
3326
3327       if ((0 == strcmpic(newval, "block")))
3328       {
3329          log_error(LOG_LEVEL_HEADER, "Crunching %s", *header);
3330          freez(*header);
3331       }
3332       else /* add random value */
3333       {
3334          const char *header_time = *header + sizeof("If-Modified-Since:");
3335
3336          if (JB_ERR_OK != parse_header_time(header_time, &tm))
3337          {
3338             log_error(LOG_LEVEL_HEADER, "Couldn't parse: %s in %s (crunching!)", header_time, *header);
3339             freez(*header);
3340          }
3341          else
3342          {
3343             long int hours, minutes, seconds;
3344             long int rtime = strtol(newval, &endptr, 0);
3345             const int negative_range = (rtime < 0);
3346
3347             if (rtime)
3348             {
3349                log_error(LOG_LEVEL_HEADER, "Randomizing: %s (random range: %d minut%s)",
3350                   *header, rtime, (rtime == 1 || rtime == -1) ? "e": "es");
3351                if (negative_range)
3352                {
3353                   rtime *= -1;
3354                }
3355                rtime *= 60;
3356                rtime = pick_from_range(rtime);
3357             }
3358             else
3359             {
3360                log_error(LOG_LEVEL_ERROR, "Random range is 0. Assuming time transformation test.",
3361                   *header);
3362             }
3363             tm += rtime * (negative_range ? -1 : 1);
3364 #ifdef HAVE_GMTIME_R
3365             timeptr = gmtime_r(&tm, &gmt);
3366 #elif defined(MUTEX_LOCKS_AVAILABLE)
3367             privoxy_mutex_lock(&gmtime_mutex);
3368             timeptr = gmtime(&tm);
3369             privoxy_mutex_unlock(&gmtime_mutex);
3370 #else
3371             timeptr = gmtime(&tm);
3372 #endif
3373             if ((NULL == timeptr) || !strftime(newheader,
3374                   sizeof(newheader), "%a, %d %b %Y %H:%M:%S GMT", timeptr))
3375             {
3376                log_error(LOG_LEVEL_ERROR,
3377                   "Randomizing '%s' failed. Crunching the header without replacement.",
3378                   *header);
3379                freez(*header);
3380                return JB_ERR_OK;
3381             }
3382
3383             freez(*header);
3384             *header = strdup("If-Modified-Since: ");
3385             string_append(header, newheader);
3386
3387             if (*header == NULL)
3388             {
3389                log_error(LOG_LEVEL_HEADER, "Insufficient memory, header crunched without replacement.");
3390                return JB_ERR_MEMORY;
3391             }
3392
3393             hours   = rtime / 3600;
3394             minutes = rtime / 60 % 60;
3395             seconds = rtime % 60;
3396
3397             log_error(LOG_LEVEL_HEADER,
3398                "Randomized:  %s (%s %d hou%s %d minut%s %d second%s",
3399                *header, (negative_range) ? "subtracted" : "added", hours,
3400                (hours == 1) ? "r" : "rs", minutes, (minutes == 1) ? "e" : "es",
3401                seconds, (seconds == 1) ? ")" : "s)");
3402          }
3403       }
3404    }
3405
3406    return JB_ERR_OK;
3407 }
3408
3409
3410 /*********************************************************************
3411  *
3412  * Function    :  client_if_none_match
3413  *
3414  * Description :  Remove the If-None-Match header.
3415  *
3416  * Parameters  :
3417  *          1  :  csp = Current client state (buffers, headers, etc...)
3418  *          2  :  header = On input, pointer to header to modify.
3419  *                On output, pointer to the modified header, or NULL
3420  *                to remove the header.  This function frees the
3421  *                original string if necessary.
3422  *
3423  * Returns     :  JB_ERR_OK on success, or
3424  *                JB_ERR_MEMORY on out-of-memory error.
3425  *
3426  *********************************************************************/
3427 static jb_err client_if_none_match(struct client_state *csp, char **header)
3428 {
3429    if (csp->action->flags & ACTION_CRUNCH_IF_NONE_MATCH)
3430    {
3431       log_error(LOG_LEVEL_HEADER, "Crunching %s", *header);
3432       freez(*header);
3433    }
3434
3435    return JB_ERR_OK;
3436 }
3437
3438
3439 /*********************************************************************
3440  *
3441  * Function    :  client_x_filter
3442  *
3443  * Description :  Disables filtering if the client set "X-Filter: No".
3444  *                Called from `sed'.
3445  *
3446  * Parameters  :
3447  *          1  :  csp = Current client state (buffers, headers, etc...)
3448  *          2  :  header = On input, pointer to header to modify.
3449  *                On output, pointer to the modified header, or NULL
3450  *                to remove the header.  This function frees the
3451  *                original string if necessary.
3452  *
3453  * Returns     :  JB_ERR_OK on success
3454  *
3455  *********************************************************************/
3456 jb_err client_x_filter(struct client_state *csp, char **header)
3457 {
3458    if (0 == strcmpic(*header, "X-Filter: No"))
3459    {
3460       if (!(csp->config->feature_flags & RUNTIME_FEATURE_HTTP_TOGGLE))
3461       {
3462          log_error(LOG_LEVEL_INFO, "Ignored the client's request to fetch without filtering.");
3463       }
3464       else
3465       {
3466          if (csp->action->flags & ACTION_FORCE_TEXT_MODE)
3467          {
3468             log_error(LOG_LEVEL_HEADER,
3469                "force-text-mode overruled the client's request to fetch without filtering!");
3470          }
3471          else
3472          {
3473             csp->content_type = CT_TABOO; /* XXX: This hack shouldn't be necessary */
3474             csp->flags |= CSP_FLAG_NO_FILTERING;
3475             log_error(LOG_LEVEL_HEADER, "Accepted the client's request to fetch without filtering.");
3476          }
3477          log_error(LOG_LEVEL_HEADER, "Crunching %s", *header);
3478          freez(*header);
3479       }
3480    }
3481    return JB_ERR_OK;
3482 }
3483
3484
3485 /*********************************************************************
3486  *
3487  * Function    :  client_range
3488  *
3489  * Description :  Removes Range, Request-Range and If-Range headers if
3490  *                content filtering is enabled and the range doesn't
3491  *                start at byte 0.
3492  *
3493  *                If the client's version of the document has been
3494  *                altered by Privoxy, the server could interpret the
3495  *                range differently than the client intended in which
3496  *                case the user could end up with corrupted content.
3497  *
3498  *                If the range starts at byte 0 this isn't an issue
3499  *                so the header can pass. Partial requests like this
3500  *                are used to render preview images for videos without
3501  *                downloading the whole video.
3502  *
3503  *                While HTTP doesn't require that range requests are
3504  *                honoured and the client could simply abort the download
3505  *                after receiving a sufficient amount of data, various
3506  *                clients don't handle complete responses to range
3507  *                requests gracefully and emit misleading error messages
3508  *                instead.
3509  *
3510  * Parameters  :
3511  *          1  :  csp = Current client state (buffers, headers, etc...)
3512  *          2  :  header = On input, pointer to header to modify.
3513  *                On output, pointer to the modified header, or NULL
3514  *                to remove the header.  This function frees the
3515  *                original string if necessary.
3516  *
3517  * Returns     :  JB_ERR_OK
3518  *
3519  *********************************************************************/
3520 static jb_err client_range(struct client_state *csp, char **header)
3521 {
3522    if (content_filters_enabled(csp->action)
3523       && (0 != strncmpic(strstr(*header, ":"), ": bytes=0-", 10)))
3524    {
3525       log_error(LOG_LEVEL_HEADER, "Content filtering is enabled."
3526          " Crunching: \'%s\' to prevent range-mismatch problems.", *header);
3527       freez(*header);
3528    }
3529
3530    return JB_ERR_OK;
3531 }
3532
3533 /* the following functions add headers directly to the header list */
3534
3535 /*********************************************************************
3536  *
3537  * Function    :  client_host_adder
3538  *
3539  * Description :  Adds the Host: header field if it is missing.
3540  *                Called from `sed'.
3541  *
3542  * Parameters  :
3543  *          1  :  csp = Current client state (buffers, headers, etc...)
3544  *
3545  * Returns     :  JB_ERR_OK on success, or
3546  *                JB_ERR_MEMORY on out-of-memory error.
3547  *
3548  *********************************************************************/
3549 static jb_err client_host_adder(struct client_state *csp)
3550 {
3551    char *p;
3552    jb_err err;
3553
3554    if (csp->flags & CSP_FLAG_HOST_HEADER_IS_SET)
3555    {
3556       /* Header already set by the client, nothing to do. */
3557       return JB_ERR_OK;
3558    }
3559
3560    if (!csp->http->hostport || !*(csp->http->hostport))
3561    {
3562       /* XXX: When does this happen and why is it OK? */
3563       log_error(LOG_LEVEL_INFO, "Weirdness in client_host_adder detected and ignored.");
3564       return JB_ERR_OK;
3565    }
3566
3567    /*
3568     * remove 'user:pass@' from 'proto://user:pass@host'
3569     */
3570    if ((p = strchr( csp->http->hostport, '@')) != NULL)
3571    {
3572       p++;
3573    }
3574    else
3575    {
3576       p = csp->http->hostport;
3577    }
3578
3579    /* XXX: Just add it, we already made sure that it will be unique */
3580    log_error(LOG_LEVEL_HEADER, "addh-unique: Host: %s", p);
3581    err = enlist_unique_header(csp->headers, "Host", p);
3582    return err;
3583
3584 }
3585
3586
3587 /*********************************************************************
3588  *
3589  * Function    :  client_xtra_adder
3590  *
3591  * Description :  Used in the add_client_headers list.  Called from `sed'.
3592  *
3593  * Parameters  :
3594  *          1  :  csp = Current client state (buffers, headers, etc...)
3595  *
3596  * Returns     :  JB_ERR_OK on success, or
3597  *                JB_ERR_MEMORY on out-of-memory error.
3598  *
3599  *********************************************************************/
3600 static jb_err client_xtra_adder(struct client_state *csp)
3601 {
3602    struct list_entry *lst;
3603    jb_err err;
3604
3605    for (lst = csp->action->multi[ACTION_MULTI_ADD_HEADER]->first;
3606         lst ; lst = lst->next)
3607    {
3608       log_error(LOG_LEVEL_HEADER, "addh: %s", lst->str);
3609       err = enlist(csp->headers, lst->str);
3610       if (err)
3611       {
3612          return err;
3613       }
3614
3615    }
3616
3617    return JB_ERR_OK;
3618 }
3619
3620
3621 /*********************************************************************
3622  *
3623  * Function    :  client_x_forwarded_for_adder
3624  *
3625  * Description :  Used in the add_client_headers list.  Called from `sed'.
3626  *
3627  * Parameters  :
3628  *          1  :  csp = Current client state (buffers, headers, etc...)
3629  *
3630  * Returns     :  JB_ERR_OK on success, or
3631  *                JB_ERR_MEMORY on out-of-memory error.
3632  *
3633  *********************************************************************/
3634 static jb_err client_x_forwarded_for_adder(struct client_state *csp)
3635 {
3636    char *header = NULL;
3637    jb_err err;
3638
3639    if (!((csp->action->flags & ACTION_CHANGE_X_FORWARDED_FOR)
3640          && (0 == strcmpic(csp->action->string[ACTION_STRING_CHANGE_X_FORWARDED_FOR], "add")))
3641       || (csp->flags & CSP_FLAG_X_FORWARDED_FOR_APPENDED))
3642    {
3643       /*
3644        * If we aren't adding X-Forwarded-For headers,
3645        * or we already appended an existing X-Forwarded-For
3646        * header, there's nothing left to do here.
3647        */
3648       return JB_ERR_OK;
3649    }
3650
3651    header = strdup("X-Forwarded-For: ");
3652    string_append(&header, csp->ip_addr_str);
3653
3654    if (header == NULL)
3655    {
3656       return JB_ERR_MEMORY;
3657    }
3658
3659    log_error(LOG_LEVEL_HEADER, "addh: %s", header);
3660    err = enlist(csp->headers, header);
3661    freez(header);
3662
3663    return err;
3664 }
3665
3666
3667 /*********************************************************************
3668  *
3669  * Function    :  server_connection_adder
3670  *
3671  * Description :  Adds an appropriate "Connection:" header to csp->headers
3672  *                unless the header was already present. Called from `sed'.
3673  *
3674  * Parameters  :
3675  *          1  :  csp = Current client state (buffers, headers, etc...)
3676  *
3677  * Returns     :  JB_ERR_OK on success, or
3678  *                JB_ERR_MEMORY on out-of-memory error.
3679  *
3680  *********************************************************************/
3681 static jb_err server_connection_adder(struct client_state *csp)
3682 {
3683    const unsigned int flags = csp->flags;
3684    const char *response_status_line = csp->headers->first->str;
3685    static const char connection_close[] = "Connection: close";
3686
3687    if ((flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
3688     && (flags & CSP_FLAG_SERVER_CONNECTION_HEADER_SET))
3689    {
3690       return JB_ERR_OK;
3691    }
3692
3693    /*
3694     * XXX: if we downgraded the response, this check will fail.
3695     */
3696    if ((csp->config->feature_flags &
3697         RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
3698     && (NULL != response_status_line)
3699     && !strncmpic(response_status_line, "HTTP/1.1", 8)
3700 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
3701     && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
3702 #endif
3703       )
3704    {
3705       log_error(LOG_LEVEL_HEADER, "A HTTP/1.1 response "
3706          "without Connection header implies keep-alive.");
3707       csp->flags |= CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE;
3708       return JB_ERR_OK;
3709    }
3710
3711    log_error(LOG_LEVEL_HEADER, "Adding: %s", connection_close);
3712
3713    return enlist(csp->headers, connection_close);
3714 }
3715
3716
3717 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
3718 /*********************************************************************
3719  *
3720  * Function    :  server_proxy_connection_adder
3721  *
3722  * Description :  Adds a "Proxy-Connection: keep-alive" header to
3723  *                csp->headers when appropriate.
3724  *
3725  * Parameters  :
3726  *          1  :  csp = Current client state (buffers, headers, etc...)
3727  *
3728  * Returns     :  JB_ERR_OK on success, or
3729  *                JB_ERR_MEMORY on out-of-memory error.
3730  *
3731  *********************************************************************/
3732 static jb_err server_proxy_connection_adder(struct client_state *csp)
3733 {
3734    static const char proxy_connection_header[] = "Proxy-Connection: keep-alive";
3735    jb_err err = JB_ERR_OK;
3736
3737    if ((csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE)
3738     && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
3739     && !(csp->flags & CSP_FLAG_SERVER_PROXY_CONNECTION_HEADER_SET)
3740     && ((csp->flags & CSP_FLAG_SERVER_CONTENT_LENGTH_SET)
3741        || (csp->flags & CSP_FLAG_CHUNKED)))
3742    {
3743       log_error(LOG_LEVEL_HEADER, "Adding: %s", proxy_connection_header);
3744       err = enlist(csp->headers, proxy_connection_header);
3745    }
3746
3747    return err;
3748 }
3749 #endif /* FEATURE_CONNECTION_KEEP_ALIVE */
3750
3751
3752 /*********************************************************************
3753  *
3754  * Function    :  client_connection_header_adder
3755  *
3756  * Description :  Adds a proper "Connection:" header to csp->headers
3757  *                unless the header was already present. Called from `sed'.
3758  *
3759  * Parameters  :
3760  *          1  :  csp = Current client state (buffers, headers, etc...)
3761  *
3762  * Returns     :  JB_ERR_OK on success, or
3763  *                JB_ERR_MEMORY on out-of-memory error.
3764  *
3765  *********************************************************************/
3766 static jb_err client_connection_header_adder(struct client_state *csp)
3767 {
3768    static const char connection_close[] = "Connection: close";
3769
3770    if (!(csp->flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
3771      && (csp->flags & CSP_FLAG_CLIENT_CONNECTION_HEADER_SET))
3772    {
3773       return JB_ERR_OK;
3774    }
3775
3776 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
3777    if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
3778       && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
3779       && (csp->http->ssl == 0)
3780       && !strcmpic(csp->http->ver, "HTTP/1.1"))
3781    {
3782       csp->flags |= CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
3783       return JB_ERR_OK;
3784    }
3785 #endif /* FEATURE_CONNECTION_KEEP_ALIVE */
3786
3787    log_error(LOG_LEVEL_HEADER, "Adding: %s", connection_close);
3788
3789    return enlist(csp->headers, connection_close);
3790 }
3791
3792
3793 /*********************************************************************
3794  *
3795  * Function    :  server_http
3796  *
3797  * Description :  - Save the HTTP Status into csp->http->status
3798  *                - Set CT_TABOO to prevent filtering if the answer
3799  *                  is a partial range (HTTP status 206)
3800  *                - Rewrite HTTP/1.1 answers to HTTP/1.0 if +downgrade
3801  *                  action applies.
3802  *
3803  * Parameters  :
3804  *          1  :  csp = Current client state (buffers, headers, etc...)
3805  *          2  :  header = On input, pointer to header to modify.
3806  *                On output, pointer to the modified header, or NULL
3807  *                to remove the header.  This function frees the
3808  *                original string if necessary.
3809  *
3810  * Returns     :  JB_ERR_OK on success, or
3811  *                JB_ERR_MEMORY on out-of-memory error.
3812  *
3813  *********************************************************************/
3814 static jb_err server_http(struct client_state *csp, char **header)
3815 {
3816    sscanf(*header, "HTTP/%*d.%*d %d", &(csp->http->status));
3817    if (csp->http->status == 206)
3818    {
3819       csp->content_type = CT_TABOO;
3820    }
3821
3822    if ((csp->action->flags & ACTION_DOWNGRADE) != 0)
3823    {
3824       /* XXX: Should we do a real validity check here? */
3825       if (strlen(*header) > 8)
3826       {
3827          (*header)[7] = '0';
3828          log_error(LOG_LEVEL_HEADER, "Downgraded answer to HTTP/1.0");
3829       }
3830       else
3831       {
3832          /*
3833           * XXX: Should we block the request or
3834           * enlist a valid status code line here?
3835           */
3836          log_error(LOG_LEVEL_INFO, "Malformed server response detected. "
3837             "Downgrading to HTTP/1.0 impossible.");
3838       }
3839    }
3840
3841    return JB_ERR_OK;
3842 }
3843
3844 /*********************************************************************
3845  *
3846  * Function    :  add_cooky_expiry_date
3847  *
3848  * Description :  Adds a cookie expiry date to a string.
3849  *
3850  * Parameters  :
3851  *          1  :  cookie = On input, pointer to cookie to modify.
3852  *                         On output, pointer to the modified header.
3853  *                         The original string is freed.
3854  *          2  :  lifetime = Seconds the cookie should be valid
3855  *
3856  * Returns     :  N/A
3857  *
3858  *********************************************************************/
3859 static void add_cookie_expiry_date(char **cookie, time_t lifetime)
3860 {
3861    char tmp[50];
3862    struct tm *timeptr = NULL;
3863    time_t expiry_date = time(NULL) + lifetime;
3864 #ifdef HAVE_GMTIME_R
3865    struct tm gmt;
3866
3867    timeptr = gmtime_r(&expiry_date, &gmt);
3868 #elif defined(MUTEX_LOCKS_AVAILABLE)
3869    privoxy_mutex_lock(&gmtime_mutex);
3870    timeptr = gmtime(&expiry_date);
3871    privoxy_mutex_unlock(&gmtime_mutex);
3872 #else
3873    timeptr = gmtime(&expiry_date);
3874 #endif
3875
3876    if (NULL == timeptr)
3877    {
3878       log_error(LOG_LEVEL_FATAL,
3879          "Failed to get the time in add_cooky_expiry_date()");
3880    }
3881    strftime(tmp, sizeof(tmp), "; expires=%a, %d-%b-%Y %H:%M:%S GMT", timeptr);
3882    if (JB_ERR_OK != string_append(cookie, tmp))
3883    {
3884       log_error(LOG_LEVEL_FATAL, "Out of memory in add_cooky_expiry()");
3885    }
3886 }
3887
3888
3889 /*********************************************************************
3890  *
3891  * Function    :  server_set_cookie
3892  *
3893  * Description :  Handle the server "cookie" header properly.
3894  *                Crunch, accept or rewrite it to a session cookie.
3895  *                Called from `sed'.
3896  *
3897  * Parameters  :
3898  *          1  :  csp = Current client state (buffers, headers, etc...)
3899  *          2  :  header = On input, pointer to header to modify.
3900  *                On output, pointer to the modified header, or NULL
3901  *                to remove the header.  This function frees the
3902  *                original string if necessary.
3903  *
3904  * Returns     :  JB_ERR_OK on success, or
3905  *                JB_ERR_MEMORY on out-of-memory error.
3906  *
3907  *********************************************************************/
3908 static jb_err server_set_cookie(struct client_state *csp, char **header)
3909 {
3910    if ((csp->action->flags & ACTION_CRUNCH_INCOMING_COOKIES) != 0)
3911    {
3912       log_error(LOG_LEVEL_HEADER, "Crunching incoming cookie: %s", *header);
3913       freez(*header);
3914    }
3915    else if ((0 != (csp->action->flags & ACTION_SESSION_COOKIES_ONLY))
3916          || (0 != (csp->action->flags & ACTION_LIMIT_COOKIE_LIFETIME)))
3917    {
3918       time_t now;
3919       time_t cookie_time;
3920       long cookie_lifetime = 0;
3921       enum
3922       {
3923          NO_EXPIRY_DATE_SPECIFIED,
3924          EXPIRY_DATE_ACCEPTABLE,
3925          EXPIRY_DATE_UNACCEPTABLE
3926       } expiry_date_status = NO_EXPIRY_DATE_SPECIFIED;
3927
3928       /* A variable to store the tag we're working on */
3929       char *cur_tag;
3930
3931       /* Skip "Set-Cookie:" (11 characters) in header */
3932       cur_tag = *header + 11;
3933
3934       /* skip whitespace between "Set-Cookie:" and value */
3935       while (*cur_tag && privoxy_isspace(*cur_tag))
3936       {
3937          cur_tag++;
3938       }
3939
3940       time(&now);
3941
3942       if ((csp->action->flags & ACTION_LIMIT_COOKIE_LIFETIME) != 0)
3943       {
3944          const char *param = csp->action->string[ACTION_STRING_LIMIT_COOKIE_LIFETIME];
3945
3946          cookie_lifetime = strtol(param, NULL, 0);
3947          if (cookie_lifetime < 0)
3948          {
3949             log_error(LOG_LEVEL_FATAL, "Invalid cookie lifetime limit: %s", param);
3950          }
3951          cookie_lifetime *= 60;
3952       }
3953
3954       /* Loop through each tag in the cookie */
3955       while (*cur_tag)
3956       {
3957          /* Find next tag */
3958          char *next_tag = strchr(cur_tag, ';');
3959          if (next_tag != NULL)
3960          {
3961             /* Skip the ';' character itself */
3962             next_tag++;
3963
3964             /* skip whitespace ";" and start of tag */
3965             while (*next_tag && privoxy_isspace(*next_tag))
3966             {
3967                next_tag++;
3968             }
3969          }
3970          else
3971          {
3972             /* "Next tag" is the end of the string */
3973             next_tag = cur_tag + strlen(cur_tag);
3974          }
3975
3976          /*
3977           * Check the expiration date to see
3978           * if the cookie is still valid, if yes,
3979           * rewrite it to a session cookie.
3980           */
3981          if ((strncmpic(cur_tag, "expires=", 8) == 0) && *(cur_tag + 8))
3982          {
3983             char *expiration_date = cur_tag + 8; /* Skip "[Ee]xpires=" */
3984
3985             if ((expiration_date[0] == '"')
3986              && (expiration_date[1] != '\0'))
3987             {
3988                /*
3989                 * Skip quotation mark. RFC 2109 10.1.2 seems to hint
3990                 * that the expiration date isn't supposed to be quoted,
3991                 * but some servers do it anyway.
3992                 */
3993                expiration_date++;
3994             }
3995
3996             /* Did we detect the date properly? */
3997             if (JB_ERR_OK != parse_header_time(expiration_date, &cookie_time))
3998             {
3999                /*
4000                 * Nope, treat it as if it was still valid.
4001                 *
4002                 * XXX: Should we remove the whole cookie instead?
4003                 */
4004                log_error(LOG_LEVEL_ERROR,
4005                   "Can't parse \'%s\', send by %s. Unsupported time format?", cur_tag, csp->http->url);
4006                string_move(cur_tag, next_tag);
4007                expiry_date_status = EXPIRY_DATE_UNACCEPTABLE;
4008             }
4009             else
4010             {
4011                /*
4012                 * Yes. Check if the cookie is still valid.
4013                 *
4014                 * If the cookie is already expired it's probably
4015                 * a delete cookie and even if it isn't, the browser
4016                 * will discard it anyway.
4017                 */
4018
4019                /*
4020                 * XXX: timegm() isn't available on some AmigaOS
4021                 * versions and our replacement doesn't work.
4022                 *
4023                 * Our options are to either:
4024                 *
4025                 * - disable session-cookies-only completely if timegm
4026                 *   is missing,
4027                 *
4028                 * - to simply remove all expired tags, like it has
4029                 *   been done until Privoxy 3.0.6 and to live with
4030                 *    the consequence that it can cause login/logout
4031                 *   problems on servers that don't validate their
4032                 *   input properly, or
4033                 *
4034                 * - to replace it with mktime in which
4035                 *   case there is a slight chance of valid cookies
4036                 *   passing as already expired.
4037                 *
4038                 *   This is the way it's currently done and it's not
4039                 *   as bad as it sounds. If the missing GMT offset is
4040                 *   enough to change the result of the expiration check
4041                 *   the cookie will be only valid for a few hours
4042                 *   anyway, which in many cases will be shorter
4043                 *   than a browser session.
4044                 */
4045                if (cookie_time < now)
4046                {
4047                   log_error(LOG_LEVEL_HEADER,
4048                      "Cookie \'%s\' is already expired and can pass unmodified.", *header);
4049                   /* Just in case some clown sets more then one expiration date */
4050                   cur_tag = next_tag;
4051                   expiry_date_status = EXPIRY_DATE_ACCEPTABLE;
4052                }
4053                else if ((cookie_lifetime != 0) && (cookie_time < (now + cookie_lifetime)))
4054                {
4055                   log_error(LOG_LEVEL_HEADER, "Cookie \'%s\' can pass unmodified. "
4056                      "Its lifetime is below the limit.", *header);
4057                   /* Just in case some clown sets more then one expiration date */
4058                   cur_tag = next_tag;
4059                   expiry_date_status = EXPIRY_DATE_ACCEPTABLE;
4060                }
4061                else
4062                {
4063                   /*
4064                    * Still valid, delete expiration date by copying
4065                    * the rest of the string over it.
4066                    */
4067                   string_move(cur_tag, next_tag);
4068
4069                   /* That changed the header, need to issue a log message */
4070                   expiry_date_status = EXPIRY_DATE_UNACCEPTABLE;
4071
4072                   /*
4073                    * Note that the next tag has now been moved to *cur_tag,
4074                    * so we do not need to update the cur_tag pointer.
4075                    */
4076                }
4077             }
4078
4079          }
4080          else
4081          {
4082             /* Move on to next cookie tag */
4083             cur_tag = next_tag;
4084          }
4085       }
4086
4087       if (expiry_date_status != EXPIRY_DATE_ACCEPTABLE)
4088       {
4089          assert(NULL != *header);
4090          if (cookie_lifetime != 0)
4091          {
4092             add_cookie_expiry_date(header, cookie_lifetime);
4093             log_error(LOG_LEVEL_HEADER, "Cookie rewritten to: %s", *header);
4094          }
4095          else if (expiry_date_status != NO_EXPIRY_DATE_SPECIFIED)
4096          {
4097             log_error(LOG_LEVEL_HEADER,
4098                "Cookie rewritten to a temporary one: %s", *header);
4099          }
4100       }
4101    }
4102
4103    return JB_ERR_OK;
4104 }
4105
4106
4107 #ifdef FEATURE_FORCE_LOAD
4108 /*********************************************************************
4109  *
4110  * Function    :  strclean
4111  *
4112  * Description :  In-Situ-Eliminate all occurrences of substring in
4113  *                string
4114  *
4115  * Parameters  :
4116  *          1  :  string = string to clean
4117  *          2  :  substring = substring to eliminate
4118  *
4119  * Returns     :  Number of eliminations
4120  *
4121  *********************************************************************/
4122 int strclean(char *string, const char *substring)
4123 {
4124    int hits = 0;
4125    size_t len;
4126    char *pos, *p;
4127
4128    len = strlen(substring);
4129
4130    while((pos = strstr(string, substring)) != NULL)
4131    {
4132       p = pos + len;
4133       do
4134       {
4135          *(p - len) = *p;
4136       }
4137       while (*p++ != '\0');
4138
4139       hits++;
4140    }
4141
4142    return(hits);
4143 }
4144 #endif /* def FEATURE_FORCE_LOAD */
4145
4146
4147 /*********************************************************************
4148  *
4149  * Function    :  parse_header_time
4150  *
4151  * Description :  Parses time formats used in HTTP header strings
4152  *                to get the numerical respresentation.
4153  *
4154  * Parameters  :
4155  *          1  :  header_time = HTTP header time as string.
4156  *          2  :  result = storage for header_time in seconds
4157  *
4158  * Returns     :  JB_ERR_OK if the time format was recognized, or
4159  *                JB_ERR_PARSE otherwise.
4160  *
4161  *********************************************************************/
4162 static jb_err parse_header_time(const char *header_time, time_t *result)
4163 {
4164    struct tm gmt;
4165    /*
4166     * Checking for two-digit years first in an
4167     * attempt to work around GNU libc's strptime()
4168     * reporting negative year values when using %Y.
4169     */
4170    static const char time_formats[][22] = {
4171       /* Tue, 02-Jun-37 20:00:00 */
4172       "%a, %d-%b-%y %H:%M:%S",
4173       /* Tue, 02 Jun 2037 20:00:00 */
4174       "%a, %d %b %Y %H:%M:%S",
4175       /* Tue, 02-Jun-2037 20:00:00 */
4176       "%a, %d-%b-%Y %H:%M:%S",
4177       /* Tuesday, 02-Jun-2037 20:00:00 */
4178       "%A, %d-%b-%Y %H:%M:%S",
4179       /* Tuesday Jun 02 20:00:00 2037 */
4180       "%A %b %d %H:%M:%S %Y"
4181    };
4182    unsigned int i;
4183
4184    for (i = 0; i < SZ(time_formats); i++)
4185    {
4186       /*
4187        * Zero out gmt to prevent time zone offsets.
4188        * Documented to be required for GNU libc.
4189        */
4190       memset(&gmt, 0, sizeof(gmt));
4191
4192       if (NULL != strptime(header_time, time_formats[i], &gmt))
4193       {
4194          /* Sanity check for GNU libc. */
4195          if (gmt.tm_year < 0)
4196          {
4197             log_error(LOG_LEVEL_HEADER,
4198                "Failed to parse '%s' using '%s'. Moving on.",
4199                header_time, time_formats[i]);
4200             continue;
4201          }
4202          *result = timegm(&gmt);
4203
4204 #ifdef FEATURE_STRPTIME_SANITY_CHECKS
4205          /*
4206           * Verify that parsing the date recreated from the first
4207           * parse operation gets the previous result. If it doesn't,
4208           * either strptime() or strftime() are malfunctioning.
4209           *
4210           * We could string-compare the recreated date with the original
4211           * header date, but this leads to false positives as strptime()
4212           * may let %a accept all day formats while strftime() will only
4213           * create one.
4214           */
4215          {
4216             char recreated_date[100];
4217             struct tm *tm;
4218             time_t result2;
4219
4220             tm = gmtime(result);
4221             strftime(recreated_date, sizeof(recreated_date), time_formats[i], tm);
4222             memset(&gmt, 0, sizeof(gmt));
4223             if (NULL == strptime(recreated_date, time_formats[i], &gmt))
4224             {
4225                log_error(LOG_LEVEL_ERROR,
4226                   "Failed to parse '%s' generated with '%s' to recreate '%s'.",
4227                   recreated_date, time_formats[i], header_time);
4228                continue;
4229             }
4230             result2 = timegm(&gmt);
4231             if (*result != result2)
4232             {
4233                log_error(LOG_LEVEL_ERROR, "strftime() and strptime() disagree. "
4234                   "Format: '%s'. In: '%s', out: '%s'. %d != %d. Rejecting.",
4235                   time_formats[i], header_time, recreated_date, *result, result2);
4236                continue;
4237             }
4238          }
4239 #endif
4240
4241          return JB_ERR_OK;
4242       }
4243    }
4244
4245    return JB_ERR_PARSE;
4246
4247 }
4248
4249
4250 /*********************************************************************
4251  *
4252  * Function    :  get_destination_from_headers
4253  *
4254  * Description :  Parse the "Host:" header to get the request's destination.
4255  *                Only needed if the client's request was forcefully
4256  *                redirected into Privoxy.
4257  *
4258  *                Code mainly copied from client_host() which is currently
4259  *                run too late for this purpose.
4260  *
4261  * Parameters  :
4262  *          1  :  headers = List of headers (one of them hopefully being
4263  *                the "Host:" header)
4264  *          2  :  http = storage for the result (host, port and hostport).
4265  *
4266  * Returns     :  JB_ERR_MEMORY (or terminates) in case of memory problems,
4267  *                JB_ERR_PARSE if the host header couldn't be found,
4268  *                JB_ERR_OK otherwise.
4269  *
4270  *********************************************************************/
4271 jb_err get_destination_from_headers(const struct list *headers, struct http_request *http)
4272 {
4273    char *q;
4274    char *p;
4275    char *host;
4276
4277    host = get_header_value(headers, "Host:");
4278
4279    if (NULL == host)
4280    {
4281       log_error(LOG_LEVEL_ERROR, "No \"Host:\" header found.");
4282       return JB_ERR_PARSE;
4283    }
4284
4285    p = strdup_or_die(host);
4286    chomp(p);
4287    q = strdup_or_die(p);
4288
4289    freez(http->hostport);
4290    http->hostport = p;
4291    freez(http->host);
4292    http->host = q;
4293    q = strchr(http->host, ':');
4294    if (q != NULL)
4295    {
4296       /* Terminate hostname and evaluate port string */
4297       *q++ = '\0';
4298       http->port = atoi(q);
4299    }
4300    else
4301    {
4302       http->port = http->ssl ? 443 : 80;
4303    }
4304
4305    /* Rebuild request URL */
4306    freez(http->url);
4307    http->url = strdup(http->ssl ? "https://" : "http://");
4308    string_append(&http->url, http->hostport);
4309    string_append(&http->url, http->path);
4310    if (http->url == NULL)
4311    {
4312       return JB_ERR_MEMORY;
4313    }
4314
4315    log_error(LOG_LEVEL_HEADER, "Destination extracted from \"Host:\" header. New request URL: %s",
4316       http->url);
4317
4318    return JB_ERR_OK;
4319
4320 }
4321
4322
4323 /*********************************************************************
4324  *
4325  * Function    :  create_forged_referrer
4326  *
4327  * Description :  Helper for client_referrer to forge a referer as
4328  *                'http://hostname[:port]/' to fool stupid
4329  *                checks for in-site links
4330  *
4331  * Parameters  :
4332  *          1  :  header   = Pointer to header pointer
4333  *          2  :  hostport = Host and optionally port as string
4334  *
4335  * Returns     :  JB_ERR_OK in case of success, or
4336  *                JB_ERR_MEMORY in case of memory problems.
4337  *
4338  *********************************************************************/
4339 static jb_err create_forged_referrer(char **header, const char *hostport)
4340 {
4341     assert(NULL == *header);
4342
4343     *header = strdup("Referer: http://");
4344     string_append(header, hostport);
4345     string_append(header, "/");
4346
4347     if (NULL == *header)
4348     {
4349        return JB_ERR_MEMORY;
4350     }
4351
4352     log_error(LOG_LEVEL_HEADER, "Referer forged to: %s", *header);
4353
4354     return JB_ERR_OK;
4355
4356 }
4357
4358
4359 /*********************************************************************
4360  *
4361  * Function    :  create_fake_referrer
4362  *
4363  * Description :  Helper for client_referrer to create a fake referrer
4364  *                based on a string supplied by the user.
4365  *
4366  * Parameters  :
4367  *          1  :  header   = Pointer to header pointer
4368  *          2  :  hosthost = Referrer to fake
4369  *
4370  * Returns     :  JB_ERR_OK in case of success, or
4371  *                JB_ERR_MEMORY in case of memory problems.
4372  *
4373  *********************************************************************/
4374 static jb_err create_fake_referrer(char **header, const char *fake_referrer)
4375 {
4376    assert(NULL == *header);
4377
4378    if ((0 != strncmpic(fake_referrer, "http://", 7)) && (0 != strncmpic(fake_referrer, "https://", 8)))
4379    {
4380       log_error(LOG_LEVEL_HEADER,
4381          "Parameter: +hide-referrer{%s} is a bad idea, but I don't care.", fake_referrer);
4382    }
4383    *header = strdup("Referer: ");
4384    string_append(header, fake_referrer);
4385
4386    if (NULL == *header)
4387    {
4388       return JB_ERR_MEMORY;
4389    }
4390
4391    log_error(LOG_LEVEL_HEADER, "Referer replaced with: %s", *header);
4392
4393    return JB_ERR_OK;
4394
4395 }
4396
4397
4398 /*********************************************************************
4399  *
4400  * Function    :  handle_conditional_hide_referrer_parameter
4401  *
4402  * Description :  Helper for client_referrer to crunch or forge
4403  *                the referrer header if the host has changed.
4404  *
4405  * Parameters  :
4406  *          1  :  header = Pointer to header pointer
4407  *          2  :  host   = The target host (may include the port)
4408  *          3  :  parameter_conditional_block = Boolean to signal
4409  *                if we're in conditional-block mode. If not set,
4410  *                we're in conditional-forge mode.
4411  *
4412  * Returns     :  JB_ERR_OK in case of success, or
4413  *                JB_ERR_MEMORY in case of memory problems.
4414  *
4415  *********************************************************************/
4416 static jb_err handle_conditional_hide_referrer_parameter(char **header,
4417    const char *host, const int parameter_conditional_block)
4418 {
4419    char *referer = strdup_or_die(*header);
4420    const size_t hostlength = strlen(host);
4421    const char *referer_url = NULL;
4422
4423    /* referer begins with 'Referer: http[s]://' */
4424    if ((hostlength+17) < strlen(referer))
4425    {
4426       /*
4427        * Shorten referer to make sure the referer is blocked
4428        * if www.example.org/www.example.com-shall-see-the-referer/
4429        * links to www.example.com/
4430        */
4431       referer[hostlength+17] = '\0';
4432    }
4433    referer_url = strstr(referer, "http://");
4434    if ((NULL == referer_url) || (NULL == strstr(referer_url, host)))
4435    {
4436       /* Host has changed, Referer is invalid or a https URL. */
4437       if (parameter_conditional_block)
4438       {
4439          log_error(LOG_LEVEL_HEADER, "New host is: %s. Crunching %s!", host, *header);
4440          freez(*header);
4441       }
4442       else
4443       {
4444          freez(*header)