Properly deal with Keep-Alive headers with timeout= parameters
[privoxy.git] / parsers.c
1 const char parsers_rcs[] = "$Id: parsers.c,v 1.282 2013/12/24 13:34:45 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
1762          return JB_ERR_OK;
1763       }
1764    }
1765
1766    if (keep_alive_timeout < csp->config->keep_alive_timeout)
1767    {
1768       log_error(LOG_LEVEL_HEADER,
1769          "Reducing keep-alive timeout from %u to %u.",
1770          csp->config->keep_alive_timeout, keep_alive_timeout);
1771       csp->server_connection.keep_alive_timeout = keep_alive_timeout;
1772    }
1773    else
1774    {
1775       /* XXX: Is this log worthy? */
1776       log_error(LOG_LEVEL_HEADER,
1777          "Client keep-alive timeout is %u. Sticking with %u.",
1778          keep_alive_timeout, csp->config->keep_alive_timeout);
1779    }
1780
1781    return JB_ERR_OK;
1782 }
1783
1784
1785 /*********************************************************************
1786  *
1787  * Function    :  get_content_length
1788  *
1789  * Description :  Gets the content length specified in a
1790  *                Content-Length header.
1791  *
1792  * Parameters  :
1793  *          1  :  header_value = The Content-Length header value.
1794  *          2  :  length = Storage to return the value.
1795  *
1796  * Returns     :  JB_ERR_OK on success, or
1797  *                JB_ERR_PARSE if no value is recognized.
1798  *
1799  *********************************************************************/
1800 static jb_err get_content_length(const char *header_value, unsigned long long *length)
1801 {
1802 #ifdef _WIN32
1803    assert(sizeof(unsigned long long) > 4);
1804    if (1 != sscanf(header_value, "%I64u", length))
1805 #else
1806    if (1 != sscanf(header_value, "%llu", length))
1807 #endif
1808    {
1809       return JB_ERR_PARSE;
1810    }
1811
1812    return JB_ERR_OK;
1813 }
1814
1815
1816 /*********************************************************************
1817  *
1818  * Function    :  client_save_content_length
1819  *
1820  * Description :  Save the Content-Length sent by the client.
1821  *
1822  * Parameters  :
1823  *          1  :  csp = Current client state (buffers, headers, etc...)
1824  *          2  :  header = On input, pointer to header to modify.
1825  *                On output, pointer to the modified header, or NULL
1826  *                to remove the header.  This function frees the
1827  *                original string if necessary.
1828  *
1829  * Returns     :  JB_ERR_OK on success, or
1830  *                JB_ERR_MEMORY on out-of-memory error.
1831  *
1832  *********************************************************************/
1833 static jb_err client_save_content_length(struct client_state *csp, char **header)
1834 {
1835    unsigned long long content_length = 0;
1836    const char *header_value;
1837
1838    assert(*(*header+14) == ':');
1839
1840    header_value = *header + 15;
1841    if (JB_ERR_OK != get_content_length(header_value, &content_length))
1842    {
1843       log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header);
1844       freez(*header);
1845    }
1846    else
1847    {
1848       csp->expected_client_content_length = content_length;
1849    }
1850
1851    return JB_ERR_OK;
1852 }
1853 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
1854
1855
1856
1857 /*********************************************************************
1858  *
1859  * Function    :  client_connection
1860  *
1861  * Description :  Makes sure a proper "Connection:" header is
1862  *                set and signals connection_header_adder
1863  *                to do nothing.
1864  *
1865  * Parameters  :
1866  *          1  :  csp = Current client state (buffers, headers, etc...)
1867  *          2  :  header = On input, pointer to header to modify.
1868  *                On output, pointer to the modified header, or NULL
1869  *                to remove the header.  This function frees the
1870  *                original string if necessary.
1871  *
1872  * Returns     :  JB_ERR_OK on success.
1873  *
1874  *********************************************************************/
1875 static jb_err client_connection(struct client_state *csp, char **header)
1876 {
1877    static const char connection_close[] = "Connection: close";
1878
1879    if (!strcmpic(*header, connection_close))
1880    {
1881 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1882       if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_SHARING)
1883         && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED))
1884       {
1885           if (!strcmpic(csp->http->ver, "HTTP/1.1"))
1886           {
1887              log_error(LOG_LEVEL_HEADER,
1888                 "Removing \'%s\' to imply keep-alive.", *header);
1889              freez(*header);
1890              /*
1891               * While we imply keep-alive to the server,
1892               * we have to remember that the client didn't.
1893               */
1894              csp->flags &= ~CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
1895           }
1896           else
1897           {
1898              char *old_header = *header;
1899
1900              *header = strdup_or_die("Connection: keep-alive");
1901              log_error(LOG_LEVEL_HEADER,
1902                 "Replaced: \'%s\' with \'%s\'", old_header, *header);
1903              freez(old_header);
1904           }
1905       }
1906       else
1907       {
1908          log_error(LOG_LEVEL_HEADER,
1909             "Keeping the client header '%s' around. "
1910             "The connection will not be kept alive.",
1911             *header);
1912          csp->flags &= ~CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
1913       }
1914    }
1915    else if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
1916         && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED))
1917    {
1918       log_error(LOG_LEVEL_HEADER,
1919          "Keeping the client header '%s' around. "
1920          "The server connection will be kept alive if possible.",
1921          *header);
1922       csp->flags |= CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
1923 #endif  /* def FEATURE_CONNECTION_KEEP_ALIVE */
1924    }
1925    else
1926    {
1927       char *old_header = *header;
1928
1929       *header = strdup_or_die(connection_close);
1930       log_error(LOG_LEVEL_HEADER,
1931          "Replaced: \'%s\' with \'%s\'", old_header, *header);
1932       freez(old_header);
1933    }
1934
1935    /* Signal client_connection_header_adder() to return early. */
1936    csp->flags |= CSP_FLAG_CLIENT_CONNECTION_HEADER_SET;
1937
1938    return JB_ERR_OK;
1939 }
1940
1941
1942 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1943 /*********************************************************************
1944  *
1945  * Function    :  client_proxy_connection
1946  *
1947  * Description :  Sets the CLIENT_CONNECTION_KEEP_ALIVE flag when
1948  *                appropriate and removes the Proxy-Connection
1949  *                header.
1950  *
1951  * Parameters  :
1952  *          1  :  csp = Current client state (buffers, headers, etc...)
1953  *          2  :  header = On input, pointer to header to modify.
1954  *                On output, pointer to the modified header, or NULL
1955  *                to remove the header.  This function frees the
1956  *                original string if necessary.
1957  *
1958  * Returns     :  JB_ERR_OK
1959  *
1960  *********************************************************************/
1961 static jb_err client_proxy_connection(struct client_state *csp, char **header)
1962 {
1963    if (0 == (csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE)
1964       && (csp->http->ssl == 0)
1965       && (NULL == strstr(*header, "close")))
1966    {
1967       log_error(LOG_LEVEL_HEADER,
1968          "The client connection can be kept alive due to: %s", *header);
1969       csp->flags |= CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
1970    }
1971    crumble(csp, header);
1972
1973    return JB_ERR_OK;
1974 }
1975 #endif  /* def FEATURE_CONNECTION_KEEP_ALIVE */
1976
1977
1978 /*********************************************************************
1979  *
1980  * Function    :  client_transfer_encoding
1981  *
1982  * Description :  Raise the CSP_FLAG_CHUNKED_CLIENT_BODY flag if
1983  *                the request body is "chunked"
1984  *
1985  *                XXX: Currently not called through sed() as we
1986  *                     need the flag earlier on. Should be fixed.
1987  *
1988  * Parameters  :
1989  *          1  :  csp = Current client state (buffers, headers, etc...)
1990  *          2  :  header = On input, pointer to header to modify.
1991  *                On output, pointer to the modified header, or NULL
1992  *                to remove the header.  This function frees the
1993  *                original string if necessary.
1994  *
1995  * Returns     :  JB_ERR_OK on success, or
1996  *
1997  *********************************************************************/
1998 jb_err client_transfer_encoding(struct client_state *csp, char **header)
1999 {
2000    if (strstr(*header, "chunked"))
2001    {
2002       csp->flags |= CSP_FLAG_CHUNKED_CLIENT_BODY;
2003       log_error(LOG_LEVEL_HEADER, "Expecting chunked client body");
2004    }
2005
2006    return JB_ERR_OK;
2007 }
2008
2009
2010 /*********************************************************************
2011  *
2012  * Function    :  crumble
2013  *
2014  * Description :  This is called if a header matches a pattern to "crunch"
2015  *
2016  * Parameters  :
2017  *          1  :  csp = Current client state (buffers, headers, etc...)
2018  *          2  :  header = On input, pointer to header to modify.
2019  *                On output, pointer to the modified header, or NULL
2020  *                to remove the header.  This function frees the
2021  *                original string if necessary.
2022  *
2023  * Returns     :  JB_ERR_OK on success, or
2024  *                JB_ERR_MEMORY on out-of-memory error.
2025  *
2026  *********************************************************************/
2027 static jb_err crumble(struct client_state *csp, char **header)
2028 {
2029    (void)csp;
2030    log_error(LOG_LEVEL_HEADER, "crumble crunched: %s!", *header);
2031    freez(*header);
2032    return JB_ERR_OK;
2033 }
2034
2035
2036 /*********************************************************************
2037  *
2038  * Function    :  crunch_server_header
2039  *
2040  * Description :  Crunch server header if it matches a string supplied by the
2041  *                user. Called from `sed'.
2042  *
2043  * Parameters  :
2044  *          1  :  csp = Current client state (buffers, headers, etc...)
2045  *          2  :  header = On input, pointer to header to modify.
2046  *                On output, pointer to the modified header, or NULL
2047  *                to remove the header.  This function frees the
2048  *                original string if necessary.
2049  *
2050  * Returns     :  JB_ERR_OK on success and always succeeds
2051  *
2052  *********************************************************************/
2053 static jb_err crunch_server_header(struct client_state *csp, char **header)
2054 {
2055    const char *crunch_pattern;
2056
2057    /* Do we feel like crunching? */
2058    if ((csp->action->flags & ACTION_CRUNCH_SERVER_HEADER))
2059    {
2060       crunch_pattern = csp->action->string[ACTION_STRING_SERVER_HEADER];
2061
2062       /* Is the current header the lucky one? */
2063       if (strstr(*header, crunch_pattern))
2064       {
2065          log_error(LOG_LEVEL_HEADER, "Crunching server header: %s (contains: %s)", *header, crunch_pattern);
2066          freez(*header);
2067       }
2068    }
2069
2070    return JB_ERR_OK;
2071 }
2072
2073
2074 /*********************************************************************
2075  *
2076  * Function    :  server_content_type
2077  *
2078  * Description :  Set the content-type for filterable types (text/.*,
2079  *                .*xml.*, .*script.* and image/gif) unless filtering has been
2080  *                forbidden (CT_TABOO) while parsing earlier headers.
2081  *                NOTE: Since text/plain is commonly used by web servers
2082  *                      for files whose correct type is unknown, we don't
2083  *                      set CT_TEXT for it.
2084  *
2085  * Parameters  :
2086  *          1  :  csp = Current client state (buffers, headers, etc...)
2087  *          2  :  header = On input, pointer to header to modify.
2088  *                On output, pointer to the modified header, or NULL
2089  *                to remove the header.  This function frees the
2090  *                original string if necessary.
2091  *
2092  * Returns     :  JB_ERR_OK on success, or
2093  *                JB_ERR_MEMORY on out-of-memory error.
2094  *
2095  *********************************************************************/
2096 static jb_err server_content_type(struct client_state *csp, char **header)
2097 {
2098    /* Remove header if it isn't the first Content-Type header */
2099    if ((csp->content_type & CT_DECLARED))
2100    {
2101       if (content_filters_enabled(csp->action))
2102       {
2103          /*
2104           * Making sure the client interprets the content the same way
2105           * Privoxy did is only relevant if Privoxy modified it.
2106           *
2107           * Checking for this is "hard" as it's not yet known when
2108           * this function is called, thus go shopping and and just
2109           * check if Privoxy could filter it.
2110           *
2111           * The main thing is that we don't mess with the headers
2112           * unless the user signalled that it's acceptable.
2113           */
2114          log_error(LOG_LEVEL_HEADER,
2115             "Multiple Content-Type headers detected. "
2116             "Removing and ignoring: %s",
2117             *header);
2118          freez(*header);
2119       }
2120       return JB_ERR_OK;
2121    }
2122
2123    /*
2124     * Signal that the Content-Type has been set.
2125     */
2126    csp->content_type |= CT_DECLARED;
2127
2128    if (!(csp->content_type & CT_TABOO))
2129    {
2130       /*
2131        * XXX: The assumption that text/plain is a sign of
2132        * binary data seems to be somewhat unreasonable nowadays
2133        * and should be dropped after 3.0.8 is out.
2134        */
2135       if ((strstr(*header, "text/") && !strstr(*header, "plain"))
2136         || strstr(*header, "xml")
2137         || strstr(*header, "script"))
2138       {
2139          csp->content_type |= CT_TEXT;
2140       }
2141       else if (strstr(*header, "image/gif"))
2142       {
2143          csp->content_type |= CT_GIF;
2144       }
2145    }
2146
2147    /*
2148     * Are we messing with the content type?
2149     */
2150    if (csp->action->flags & ACTION_CONTENT_TYPE_OVERWRITE)
2151    {
2152       /*
2153        * Make sure the user doesn't accidentally
2154        * change the content type of binary documents.
2155        */
2156       if ((csp->content_type & CT_TEXT) || (csp->action->flags & ACTION_FORCE_TEXT_MODE))
2157       {
2158          freez(*header);
2159          *header = strdup_or_die("Content-Type: ");
2160          string_append(header, csp->action->string[ACTION_STRING_CONTENT_TYPE]);
2161
2162          if (header == NULL)
2163          {
2164             log_error(LOG_LEVEL_HEADER, "Insufficient memory to replace Content-Type!");
2165             return JB_ERR_MEMORY;
2166          }
2167          log_error(LOG_LEVEL_HEADER, "Modified: %s!", *header);
2168       }
2169       else
2170       {
2171          log_error(LOG_LEVEL_HEADER, "%s not replaced. "
2172             "It doesn't look like a content type that should be filtered. "
2173             "Enable force-text-mode if you know what you're doing.", *header);
2174       }
2175    }
2176
2177    return JB_ERR_OK;
2178 }
2179
2180
2181 /*********************************************************************
2182  *
2183  * Function    :  server_transfer_coding
2184  *
2185  * Description :  - Prohibit filtering (CT_TABOO) if transfer coding compresses
2186  *                - Raise the CSP_FLAG_CHUNKED flag if coding is "chunked"
2187  *                - Remove header if body was chunked but has been
2188  *                  de-chunked for filtering.
2189  *
2190  * Parameters  :
2191  *          1  :  csp = Current client state (buffers, headers, etc...)
2192  *          2  :  header = On input, pointer to header to modify.
2193  *                On output, pointer to the modified header, or NULL
2194  *                to remove the header.  This function frees the
2195  *                original string if necessary.
2196  *
2197  * Returns     :  JB_ERR_OK on success, or
2198  *                JB_ERR_MEMORY on out-of-memory error.
2199  *
2200  *********************************************************************/
2201 static jb_err server_transfer_coding(struct client_state *csp, char **header)
2202 {
2203    /*
2204     * Turn off pcrs and gif filtering if body compressed
2205     */
2206    if (strstr(*header, "gzip") || strstr(*header, "compress") || strstr(*header, "deflate"))
2207    {
2208 #ifdef FEATURE_ZLIB
2209       /*
2210        * XXX: Added to test if we could use CT_GZIP and CT_DEFLATE here.
2211        */
2212       log_error(LOG_LEVEL_INFO, "Marking content type for %s as CT_TABOO because of %s.",
2213          csp->http->cmd, *header);
2214 #endif /* def FEATURE_ZLIB */
2215       csp->content_type = CT_TABOO;
2216    }
2217
2218    /*
2219     * Raise flag if body chunked
2220     */
2221    if (strstr(*header, "chunked"))
2222    {
2223       csp->flags |= CSP_FLAG_CHUNKED;
2224
2225       /*
2226        * If the body was modified, it has been de-chunked first
2227        * and the header must be removed.
2228        *
2229        * FIXME: If there is more than one transfer encoding,
2230        * only the "chunked" part should be removed here.
2231        */
2232       if (csp->flags & CSP_FLAG_MODIFIED)
2233       {
2234          log_error(LOG_LEVEL_HEADER, "Removing: %s", *header);
2235          freez(*header);
2236       }
2237    }
2238
2239    return JB_ERR_OK;
2240 }
2241
2242
2243 /*********************************************************************
2244  *
2245  * Function    :  server_content_encoding
2246  *
2247  * Description :  Used to check if the content is compressed, and if
2248  *                FEATURE_ZLIB is disabled, filtering is disabled as
2249  *                well.
2250  *
2251  *                If FEATURE_ZLIB is enabled and the compression type
2252  *                supported, the content is marked for decompression.
2253  *
2254  *                XXX: Doesn't properly deal with multiple or with
2255  *                     unsupported but unknown encodings.
2256  *                     Is case-sensitive but shouldn't be.
2257  *
2258  * Parameters  :
2259  *          1  :  csp = Current client state (buffers, headers, etc...)
2260  *          2  :  header = On input, pointer to header to modify.
2261  *                On output, pointer to the modified header, or NULL
2262  *                to remove the header.  This function frees the
2263  *                original string if necessary.
2264  *
2265  * Returns     :  JB_ERR_OK on success, or
2266  *                JB_ERR_MEMORY on out-of-memory error.
2267  *
2268  *********************************************************************/
2269 static jb_err server_content_encoding(struct client_state *csp, char **header)
2270 {
2271 #ifdef FEATURE_ZLIB
2272    if (strstr(*header, "sdch"))
2273    {
2274       /*
2275        * Shared Dictionary Compression over HTTP isn't supported,
2276        * filtering it anyway is pretty much guaranteed to mess up
2277        * the encoding.
2278        */
2279       csp->content_type |= CT_TABOO;
2280
2281       /*
2282        * Log a warning if the user expects the content to be filtered.
2283        */
2284       if ((csp->rlist != NULL) &&
2285          (!list_is_empty(csp->action->multi[ACTION_MULTI_FILTER])))
2286       {
2287          log_error(LOG_LEVEL_INFO,
2288             "SDCH-compressed content detected, content filtering disabled. "
2289             "Consider suppressing SDCH offers made by the client.");
2290       }
2291    }
2292    else if (strstr(*header, "gzip"))
2293    {
2294       /* Mark for gzip decompression */
2295       csp->content_type |= CT_GZIP;
2296    }
2297    else if (strstr(*header, "deflate"))
2298    {
2299       /* Mark for zlib decompression */
2300       csp->content_type |= CT_DEFLATE;
2301    }
2302    else if (strstr(*header, "compress"))
2303    {
2304       /*
2305        * We can't decompress this; therefore we can't filter
2306        * it either.
2307        */
2308       csp->content_type |= CT_TABOO;
2309    }
2310 #else /* !defined(FEATURE_ZLIB) */
2311    /*
2312     * XXX: Using a black list here isn't the right approach.
2313     *
2314     *      In case of SDCH, building with zlib support isn't
2315     *      going to help.
2316     */
2317    if (strstr(*header, "gzip") ||
2318        strstr(*header, "compress") ||
2319        strstr(*header, "deflate") ||
2320        strstr(*header, "sdch"))
2321    {
2322       /*
2323        * Body is compressed, turn off pcrs and gif filtering.
2324        */
2325       csp->content_type |= CT_TABOO;
2326
2327       /*
2328        * Log a warning if the user expects the content to be filtered.
2329        */
2330       if ((csp->rlist != NULL) &&
2331          (!list_is_empty(csp->action->multi[ACTION_MULTI_FILTER])))
2332       {
2333          log_error(LOG_LEVEL_INFO,
2334             "Compressed content detected, content filtering disabled. "
2335             "Consider recompiling Privoxy with zlib support or "
2336             "enable the prevent-compression action.");
2337       }
2338    }
2339 #endif /* defined(FEATURE_ZLIB) */
2340
2341    return JB_ERR_OK;
2342
2343 }
2344
2345
2346 #ifdef FEATURE_ZLIB
2347 /*********************************************************************
2348  *
2349  * Function    :  server_adjust_content_encoding
2350  *
2351  * Description :  Remove the Content-Encoding header if the
2352  *                decompression was successful and the content
2353  *                has been modifed.
2354  *
2355  * Parameters  :
2356  *          1  :  csp = Current client state (buffers, headers, etc...)
2357  *          2  :  header = On input, pointer to header to modify.
2358  *                On output, pointer to the modified header, or NULL
2359  *                to remove the header.  This function frees the
2360  *                original string if necessary.
2361  *
2362  * Returns     :  JB_ERR_OK on success, or
2363  *                JB_ERR_MEMORY on out-of-memory error.
2364  *
2365  *********************************************************************/
2366 static jb_err server_adjust_content_encoding(struct client_state *csp, char **header)
2367 {
2368    if ((csp->flags & CSP_FLAG_MODIFIED)
2369     && (csp->content_type & (CT_GZIP | CT_DEFLATE)))
2370    {
2371       /*
2372        * We successfully decompressed the content,
2373        * and have to clean the header now, so the
2374        * client no longer expects compressed data.
2375        *
2376        * XXX: There is a difference between cleaning
2377        * and removing it completely.
2378        */
2379       log_error(LOG_LEVEL_HEADER, "Crunching: %s", *header);
2380       freez(*header);
2381    }
2382
2383    return JB_ERR_OK;
2384
2385 }
2386 #endif /* defined(FEATURE_ZLIB) */
2387
2388
2389 /*********************************************************************
2390  *
2391  * Function    :  server_adjust_content_length
2392  *
2393  * Description :  Adjust Content-Length header if we modified
2394  *                the body.
2395  *
2396  * Parameters  :
2397  *          1  :  csp = Current client state (buffers, headers, etc...)
2398  *          2  :  header = On input, pointer to header to modify.
2399  *                On output, pointer to the modified header, or NULL
2400  *                to remove the header.  This function frees the
2401  *                original string if necessary.
2402  *
2403  * Returns     :  JB_ERR_OK on success, or
2404  *                JB_ERR_MEMORY on out-of-memory error.
2405  *
2406  *********************************************************************/
2407 static jb_err server_adjust_content_length(struct client_state *csp, char **header)
2408 {
2409    /* Regenerate header if the content was modified. */
2410    if (csp->flags & CSP_FLAG_MODIFIED)
2411    {
2412       const size_t header_length = 50;
2413       freez(*header);
2414       *header = malloc(header_length);
2415       if (*header == NULL)
2416       {
2417          return JB_ERR_MEMORY;
2418       }
2419       create_content_length_header(csp->content_length, *header, header_length);
2420       log_error(LOG_LEVEL_HEADER,
2421          "Adjusted Content-Length to %llu", csp->content_length);
2422    }
2423
2424    return JB_ERR_OK;
2425 }
2426
2427
2428 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
2429 /*********************************************************************
2430  *
2431  * Function    :  server_save_content_length
2432  *
2433  * Description :  Save the Content-Length sent by the server.
2434  *
2435  * Parameters  :
2436  *          1  :  csp = Current client state (buffers, headers, etc...)
2437  *          2  :  header = On input, pointer to header to modify.
2438  *                On output, pointer to the modified header, or NULL
2439  *                to remove the header.  This function frees the
2440  *                original string if necessary.
2441  *
2442  * Returns     :  JB_ERR_OK on success, or
2443  *                JB_ERR_MEMORY on out-of-memory error.
2444  *
2445  *********************************************************************/
2446 static jb_err server_save_content_length(struct client_state *csp, char **header)
2447 {
2448    unsigned long long content_length = 0;
2449    const char *header_value;
2450
2451    assert(*(*header+14) == ':');
2452
2453    header_value = *header + 15;
2454    if (JB_ERR_OK != get_content_length(header_value, &content_length))
2455    {
2456       log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header);
2457       freez(*header);
2458    }
2459    else
2460    {
2461       csp->expected_content_length = content_length;
2462       csp->flags |= CSP_FLAG_SERVER_CONTENT_LENGTH_SET;
2463       csp->flags |= CSP_FLAG_CONTENT_LENGTH_SET;
2464    }
2465
2466    return JB_ERR_OK;
2467 }
2468 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
2469
2470
2471 /*********************************************************************
2472  *
2473  * Function    :  server_content_md5
2474  *
2475  * Description :  Crumble any Content-MD5 headers if the document was
2476  *                modified. FIXME: Should we re-compute instead?
2477  *
2478  * Parameters  :
2479  *          1  :  csp = Current client state (buffers, headers, etc...)
2480  *          2  :  header = On input, pointer to header to modify.
2481  *                On output, pointer to the modified header, or NULL
2482  *                to remove the header.  This function frees the
2483  *                original string if necessary.
2484  *
2485  * Returns     :  JB_ERR_OK on success, or
2486  *                JB_ERR_MEMORY on out-of-memory error.
2487  *
2488  *********************************************************************/
2489 static jb_err server_content_md5(struct client_state *csp, char **header)
2490 {
2491    if (csp->flags & CSP_FLAG_MODIFIED)
2492    {
2493       log_error(LOG_LEVEL_HEADER, "Crunching Content-MD5");
2494       freez(*header);
2495    }
2496
2497    return JB_ERR_OK;
2498 }
2499
2500
2501 /*********************************************************************
2502  *
2503  * Function    :  server_content_disposition
2504  *
2505  * Description :  If enabled, blocks or modifies the "Content-Disposition" header.
2506  *                Called from `sed'.
2507  *
2508  * Parameters  :
2509  *          1  :  csp = Current client state (buffers, headers, etc...)
2510  *          2  :  header = On input, pointer to header to modify.
2511  *                On output, pointer to the modified header, or NULL
2512  *                to remove the header.  This function frees the
2513  *                original string if necessary.
2514  *
2515  * Returns     :  JB_ERR_OK on success, or
2516  *                JB_ERR_MEMORY on out-of-memory error.
2517  *
2518  *********************************************************************/
2519 static jb_err server_content_disposition(struct client_state *csp, char **header)
2520 {
2521    const char *newval;
2522
2523    /*
2524     * Are we messing with the Content-Disposition header?
2525     */
2526    if ((csp->action->flags & ACTION_HIDE_CONTENT_DISPOSITION) == 0)
2527    {
2528       /* Me tinks not */
2529       return JB_ERR_OK;
2530    }
2531
2532    newval = csp->action->string[ACTION_STRING_CONTENT_DISPOSITION];
2533
2534    if ((newval == NULL) || (0 == strcmpic(newval, "block")))
2535    {
2536       /*
2537        * Blocking content-disposition header
2538        */
2539       log_error(LOG_LEVEL_HEADER, "Crunching %s!", *header);
2540       freez(*header);
2541       return JB_ERR_OK;
2542    }
2543    else
2544    {
2545       /*
2546        * Replacing Content-Disposition header
2547        */
2548       freez(*header);
2549       *header = strdup("Content-Disposition: ");
2550       string_append(header, newval);
2551
2552       if (*header != NULL)
2553       {
2554          log_error(LOG_LEVEL_HEADER,
2555             "Content-Disposition header crunched and replaced with: %s", *header);
2556       }
2557    }
2558    return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
2559 }
2560
2561
2562 /*********************************************************************
2563  *
2564  * Function    :  server_last_modified
2565  *
2566  * Description :  Changes Last-Modified header to the actual date
2567  *                to help hide-if-modified-since.
2568  *                Called from `sed'.
2569  *
2570  * Parameters  :
2571  *          1  :  csp = Current client state (buffers, headers, etc...)
2572  *          2  :  header = On input, pointer to header to modify.
2573  *                On output, pointer to the modified header, or NULL
2574  *                to remove the header.  This function frees the
2575  *                original string if necessary.
2576  *
2577  * Returns     :  JB_ERR_OK on success, or
2578  *                JB_ERR_MEMORY on out-of-memory error.
2579  *
2580  *********************************************************************/
2581 static jb_err server_last_modified(struct client_state *csp, char **header)
2582 {
2583    const char *newval;
2584    time_t last_modified;
2585    char newheader[50];
2586
2587    /*
2588     * Are we messing with the Last-Modified header?
2589     */
2590    if ((csp->action->flags & ACTION_OVERWRITE_LAST_MODIFIED) == 0)
2591    {
2592       /*Nope*/
2593       return JB_ERR_OK;
2594    }
2595
2596    newval = csp->action->string[ACTION_STRING_LAST_MODIFIED];
2597
2598    if (0 == strcmpic(newval, "block"))
2599    {
2600       /*
2601        * Blocking Last-Modified header. Useless but why not.
2602        */
2603       log_error(LOG_LEVEL_HEADER, "Crunching %s!", *header);
2604       freez(*header);
2605       return JB_ERR_OK;
2606    }
2607    else if (0 == strcmpic(newval, "reset-to-request-time"))
2608    {
2609       /*
2610        * Setting Last-Modified Header to now.
2611        */
2612       char buf[30];
2613       get_http_time(0, buf, sizeof(buf));
2614       freez(*header);
2615       *header = strdup("Last-Modified: ");
2616       string_append(header, buf);
2617
2618       if (*header == NULL)
2619       {
2620          log_error(LOG_LEVEL_HEADER, "Insufficient memory. Last-Modified header got lost, boohoo.");
2621       }
2622       else
2623       {
2624          log_error(LOG_LEVEL_HEADER, "Reset to present time: %s", *header);
2625       }
2626    }
2627    else if (0 == strcmpic(newval, "randomize"))
2628    {
2629       const char *header_time = *header + sizeof("Last-Modified:");
2630
2631       log_error(LOG_LEVEL_HEADER, "Randomizing: %s", *header);
2632
2633       if (JB_ERR_OK != parse_header_time(header_time, &last_modified))
2634       {
2635          log_error(LOG_LEVEL_HEADER, "Couldn't parse: %s in %s (crunching!)", header_time, *header);
2636          freez(*header);
2637       }
2638       else
2639       {
2640          time_t now;
2641          struct tm *timeptr = NULL;
2642          long int rtime;
2643 #ifdef HAVE_GMTIME_R
2644          struct tm gmt;
2645 #endif
2646          now = time(NULL);
2647          rtime = (long int)difftime(now, last_modified);
2648          if (rtime)
2649          {
2650             long int days, hours, minutes, seconds;
2651             const int negative_delta = (rtime < 0);
2652
2653             if (negative_delta)
2654             {
2655                rtime *= -1;
2656                log_error(LOG_LEVEL_HEADER, "Server time in the future.");
2657             }
2658             rtime = pick_from_range(rtime);
2659             if (negative_delta)
2660             {
2661                rtime *= -1;
2662             }
2663             last_modified += rtime;
2664 #ifdef HAVE_GMTIME_R
2665             timeptr = gmtime_r(&last_modified, &gmt);
2666 #elif defined(MUTEX_LOCKS_AVAILABLE)
2667             privoxy_mutex_lock(&gmtime_mutex);
2668             timeptr = gmtime(&last_modified);
2669             privoxy_mutex_unlock(&gmtime_mutex);
2670 #else
2671             timeptr = gmtime(&last_modified);
2672 #endif
2673             if ((NULL == timeptr) || !strftime(newheader,
2674                   sizeof(newheader), "%a, %d %b %Y %H:%M:%S GMT", timeptr))
2675             {
2676                log_error(LOG_LEVEL_ERROR,
2677                   "Randomizing '%s' failed. Crunching the header without replacement.",
2678                   *header);
2679                freez(*header);
2680                return JB_ERR_OK;
2681             }
2682
2683             freez(*header);
2684             *header = strdup("Last-Modified: ");
2685             string_append(header, newheader);
2686
2687             if (*header == NULL)
2688             {
2689                log_error(LOG_LEVEL_ERROR, "Insufficient memory, header crunched without replacement.");
2690                return JB_ERR_MEMORY;
2691             }
2692
2693             days    = rtime / (3600 * 24);
2694             hours   = rtime / 3600 % 24;
2695             minutes = rtime / 60 % 60;
2696             seconds = rtime % 60;
2697
2698             log_error(LOG_LEVEL_HEADER,
2699                "Randomized:  %s (added %d da%s %d hou%s %d minut%s %d second%s",
2700                *header, days, (days == 1) ? "y" : "ys", hours, (hours == 1) ? "r" : "rs",
2701                minutes, (minutes == 1) ? "e" : "es", seconds, (seconds == 1) ? ")" : "s)");
2702          }
2703          else
2704          {
2705             log_error(LOG_LEVEL_HEADER, "Randomized ... or not. No time difference to work with.");
2706          }
2707       }
2708    }
2709
2710    return JB_ERR_OK;
2711 }
2712
2713
2714 /*********************************************************************
2715  *
2716  * Function    :  client_accept_encoding
2717  *
2718  * Description :  Rewrite the client's Accept-Encoding header so that
2719  *                if doesn't allow compression, if the action applies.
2720  *                Note: For HTTP/1.0 the absence of the header is enough.
2721  *
2722  * Parameters  :
2723  *          1  :  csp = Current client state (buffers, headers, etc...)
2724  *          2  :  header = On input, pointer to header to modify.
2725  *                On output, pointer to the modified header, or NULL
2726  *                to remove the header.  This function frees the
2727  *                original string if necessary.
2728  *
2729  * Returns     :  JB_ERR_OK on success, or
2730  *                JB_ERR_MEMORY on out-of-memory error.
2731  *
2732  *********************************************************************/
2733 static jb_err client_accept_encoding(struct client_state *csp, char **header)
2734 {
2735 #ifdef FEATURE_COMPRESSION
2736    if ((csp->config->feature_flags & RUNTIME_FEATURE_COMPRESSION)
2737       && strstr(*header, "deflate"))
2738    {
2739       csp->flags |= CSP_FLAG_CLIENT_SUPPORTS_DEFLATE;
2740    }
2741 #endif
2742    if ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
2743    {
2744       log_error(LOG_LEVEL_HEADER, "Suppressed offer to compress content");
2745       freez(*header);
2746    }
2747
2748    return JB_ERR_OK;
2749 }
2750
2751
2752 /*********************************************************************
2753  *
2754  * Function    :  client_te
2755  *
2756  * Description :  Rewrite the client's TE header so that
2757  *                if doesn't allow compression, if the action applies.
2758  *
2759  * Parameters  :
2760  *          1  :  csp = Current client state (buffers, headers, etc...)
2761  *          2  :  header = On input, pointer to header to modify.
2762  *                On output, pointer to the modified header, or NULL
2763  *                to remove the header.  This function frees the
2764  *                original string if necessary.
2765  *
2766  * Returns     :  JB_ERR_OK on success, or
2767  *                JB_ERR_MEMORY on out-of-memory error.
2768  *
2769  *********************************************************************/
2770 static jb_err client_te(struct client_state *csp, char **header)
2771 {
2772    if ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
2773    {
2774       freez(*header);
2775       log_error(LOG_LEVEL_HEADER, "Suppressed offer to compress transfer");
2776    }
2777
2778    return JB_ERR_OK;
2779 }
2780
2781
2782 /*********************************************************************
2783  *
2784  * Function    :  client_referrer
2785  *
2786  * Description :  Handle the "referer" config setting properly.
2787  *                Called from `sed'.
2788  *
2789  * Parameters  :
2790  *          1  :  csp = Current client state (buffers, headers, etc...)
2791  *          2  :  header = On input, pointer to header to modify.
2792  *                On output, pointer to the modified header, or NULL
2793  *                to remove the header.  This function frees the
2794  *                original string if necessary.
2795  *
2796  * Returns     :  JB_ERR_OK on success, or
2797  *                JB_ERR_MEMORY on out-of-memory error.
2798  *
2799  *********************************************************************/
2800 static jb_err client_referrer(struct client_state *csp, char **header)
2801 {
2802    const char *parameter;
2803    /* booleans for parameters we have to check multiple times */
2804    int parameter_conditional_block;
2805    int parameter_conditional_forge;
2806
2807 #ifdef FEATURE_FORCE_LOAD
2808    /*
2809     * Since the referrer can include the prefix even
2810     * if the request itself is non-forced, we must
2811     * clean it unconditionally.
2812     *
2813     * XXX: strclean is too broad
2814     */
2815    strclean(*header, FORCE_PREFIX);
2816 #endif /* def FEATURE_FORCE_LOAD */
2817
2818    if ((csp->action->flags & ACTION_HIDE_REFERER) == 0)
2819    {
2820       /* Nothing left to do */
2821       return JB_ERR_OK;
2822    }
2823
2824    parameter = csp->action->string[ACTION_STRING_REFERER];
2825    assert(parameter != NULL);
2826    parameter_conditional_block = (0 == strcmpic(parameter, "conditional-block"));
2827    parameter_conditional_forge = (0 == strcmpic(parameter, "conditional-forge"));
2828
2829    if (!parameter_conditional_block && !parameter_conditional_forge)
2830    {
2831       /*
2832        * As conditional-block and conditional-forge are the only
2833        * parameters that rely on the original referrer, we can
2834        * remove it now for all the others.
2835        */
2836       freez(*header);
2837    }
2838
2839    if (0 == strcmpic(parameter, "block"))
2840    {
2841       log_error(LOG_LEVEL_HEADER, "Referer crunched!");
2842       return JB_ERR_OK;
2843    }
2844    else if (parameter_conditional_block || parameter_conditional_forge)
2845    {
2846       return handle_conditional_hide_referrer_parameter(header,
2847          csp->http->hostport, parameter_conditional_block);
2848    }
2849    else if (0 == strcmpic(parameter, "forge"))
2850    {
2851       return create_forged_referrer(header, csp->http->hostport);
2852    }
2853    else
2854    {
2855       /* interpret parameter as user-supplied referer to fake */
2856       return create_fake_referrer(header, parameter);
2857    }
2858 }
2859
2860
2861 /*********************************************************************
2862  *
2863  * Function    :  client_accept_language
2864  *
2865  * Description :  Handle the "Accept-Language" config setting properly.
2866  *                Called from `sed'.
2867  *
2868  * Parameters  :
2869  *          1  :  csp = Current client state (buffers, headers, etc...)
2870  *          2  :  header = On input, pointer to header to modify.
2871  *                On output, pointer to the modified header, or NULL
2872  *                to remove the header.  This function frees the
2873  *                original string if necessary.
2874  *
2875  * Returns     :  JB_ERR_OK on success, or
2876  *                JB_ERR_MEMORY on out-of-memory error.
2877  *
2878  *********************************************************************/
2879 static jb_err client_accept_language(struct client_state *csp, char **header)
2880 {
2881    const char *newval;
2882
2883    /*
2884     * Are we messing with the Accept-Language?
2885     */
2886    if ((csp->action->flags & ACTION_HIDE_ACCEPT_LANGUAGE) == 0)
2887    {
2888       /*I don't think so*/
2889       return JB_ERR_OK;
2890    }
2891
2892    newval = csp->action->string[ACTION_STRING_LANGUAGE];
2893
2894    if ((newval == NULL) || (0 == strcmpic(newval, "block")))
2895    {
2896       /*
2897        * Blocking Accept-Language header
2898        */
2899       log_error(LOG_LEVEL_HEADER, "Crunching Accept-Language!");
2900       freez(*header);
2901       return JB_ERR_OK;
2902    }
2903    else
2904    {
2905       /*
2906        * Replacing Accept-Language header
2907        */
2908       freez(*header);
2909       *header = strdup("Accept-Language: ");
2910       string_append(header, newval);
2911
2912       if (*header == NULL)
2913       {
2914          log_error(LOG_LEVEL_ERROR,
2915             "Insufficient memory. Accept-Language header crunched without replacement.");
2916       }
2917       else
2918       {
2919          log_error(LOG_LEVEL_HEADER,
2920             "Accept-Language header crunched and replaced with: %s", *header);
2921       }
2922    }
2923    return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
2924 }
2925
2926
2927 /*********************************************************************
2928  *
2929  * Function    :  crunch_client_header
2930  *
2931  * Description :  Crunch client header if it matches a string supplied by the
2932  *                user. Called from `sed'.
2933  *
2934  * Parameters  :
2935  *          1  :  csp = Current client state (buffers, headers, etc...)
2936  *          2  :  header = On input, pointer to header to modify.
2937  *                On output, pointer to the modified header, or NULL
2938  *                to remove the header.  This function frees the
2939  *                original string if necessary.
2940  *
2941  * Returns     :  JB_ERR_OK on success and always succeeds
2942  *
2943  *********************************************************************/
2944 static jb_err crunch_client_header(struct client_state *csp, char **header)
2945 {
2946    const char *crunch_pattern;
2947
2948    /* Do we feel like crunching? */
2949    if ((csp->action->flags & ACTION_CRUNCH_CLIENT_HEADER))
2950    {
2951       crunch_pattern = csp->action->string[ACTION_STRING_CLIENT_HEADER];
2952
2953       /* Is the current header the lucky one? */
2954       if (strstr(*header, crunch_pattern))
2955       {
2956          log_error(LOG_LEVEL_HEADER, "Crunching client header: %s (contains: %s)", *header, crunch_pattern);
2957          freez(*header);
2958       }
2959    }
2960    return JB_ERR_OK;
2961 }
2962
2963
2964 /*********************************************************************
2965  *
2966  * Function    :  client_uagent
2967  *
2968  * Description :  Handle the "user-agent" config setting properly
2969  *                and remember its original value to enable browser
2970  *                bug workarounds. Called from `sed'.
2971  *
2972  * Parameters  :
2973  *          1  :  csp = Current client state (buffers, headers, etc...)
2974  *          2  :  header = On input, pointer to header to modify.
2975  *                On output, pointer to the modified header, or NULL
2976  *                to remove the header.  This function frees the
2977  *                original string if necessary.
2978  *
2979  * Returns     :  JB_ERR_OK on success, or
2980  *                JB_ERR_MEMORY on out-of-memory error.
2981  *
2982  *********************************************************************/
2983 static jb_err client_uagent(struct client_state *csp, char **header)
2984 {
2985    const char *newval;
2986
2987    if ((csp->action->flags & ACTION_HIDE_USER_AGENT) == 0)
2988    {
2989       return JB_ERR_OK;
2990    }
2991
2992    newval = csp->action->string[ACTION_STRING_USER_AGENT];
2993    if (newval == NULL)
2994    {
2995       return JB_ERR_OK;
2996    }
2997
2998    freez(*header);
2999    *header = strdup("User-Agent: ");
3000    string_append(header, newval);
3001
3002    log_error(LOG_LEVEL_HEADER, "Modified: %s", *header);
3003
3004    return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
3005 }
3006
3007
3008 /*********************************************************************
3009  *
3010  * Function    :  client_ua
3011  *
3012  * Description :  Handle "ua-" headers properly.  Called from `sed'.
3013  *
3014  * Parameters  :
3015  *          1  :  csp = Current client state (buffers, headers, etc...)
3016  *          2  :  header = On input, pointer to header to modify.
3017  *                On output, pointer to the modified header, or NULL
3018  *                to remove the header.  This function frees the
3019  *                original string if necessary.
3020  *
3021  * Returns     :  JB_ERR_OK on success, or
3022  *                JB_ERR_MEMORY on out-of-memory error.
3023  *
3024  *********************************************************************/
3025 static jb_err client_ua(struct client_state *csp, char **header)
3026 {
3027    if ((csp->action->flags & ACTION_HIDE_USER_AGENT) != 0)
3028    {
3029       log_error(LOG_LEVEL_HEADER, "crunched User-Agent!");
3030       freez(*header);
3031    }
3032
3033    return JB_ERR_OK;
3034 }
3035
3036
3037 /*********************************************************************
3038  *
3039  * Function    :  client_from
3040  *
3041  * Description :  Handle the "from" config setting properly.
3042  *                Called from `sed'.
3043  *
3044  * Parameters  :
3045  *          1  :  csp = Current client state (buffers, headers, etc...)
3046  *          2  :  header = On input, pointer to header to modify.
3047  *                On output, pointer to the modified header, or NULL
3048  *                to remove the header.  This function frees the
3049  *                original string if necessary.
3050  *
3051  * Returns     :  JB_ERR_OK on success, or
3052  *                JB_ERR_MEMORY on out-of-memory error.
3053  *
3054  *********************************************************************/
3055 static jb_err client_from(struct client_state *csp, char **header)
3056 {
3057    const char *newval;
3058
3059    if ((csp->action->flags & ACTION_HIDE_FROM) == 0)
3060    {
3061       return JB_ERR_OK;
3062    }
3063
3064    freez(*header);
3065
3066    newval = csp->action->string[ACTION_STRING_FROM];
3067
3068    /*
3069     * Are we blocking the e-mail address?
3070     */
3071    if ((newval == NULL) || (0 == strcmpic(newval, "block")))
3072    {
3073       log_error(LOG_LEVEL_HEADER, "crunched From!");
3074       return JB_ERR_OK;
3075    }
3076
3077    log_error(LOG_LEVEL_HEADER, " modified");
3078
3079    *header = strdup("From: ");
3080    string_append(header, newval);
3081
3082    return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
3083 }
3084
3085
3086 /*********************************************************************
3087  *
3088  * Function    :  client_send_cookie
3089  *
3090  * Description :  Crunches the "cookie" header if necessary.
3091  *                Called from `sed'.
3092  *
3093  *                XXX: Stupid name, doesn't send squat.
3094  *
3095  * Parameters  :
3096  *          1  :  csp = Current client state (buffers, headers, etc...)
3097  *          2  :  header = On input, pointer to header to modify.
3098  *                On output, pointer to the modified header, or NULL
3099  *                to remove the header.  This function frees the
3100  *                original string if necessary.
3101  *
3102  * Returns     :  JB_ERR_OK on success, or
3103  *                JB_ERR_MEMORY on out-of-memory error.
3104  *
3105  *********************************************************************/
3106 static jb_err client_send_cookie(struct client_state *csp, char **header)
3107 {
3108    if (csp->action->flags & ACTION_CRUNCH_OUTGOING_COOKIES)
3109    {
3110       log_error(LOG_LEVEL_HEADER, "Crunched outgoing cookie: %s", *header);
3111       freez(*header);
3112    }
3113
3114    return JB_ERR_OK;
3115 }
3116
3117
3118 /*********************************************************************
3119  *
3120  * Function    :  client_x_forwarded
3121  *
3122  * Description :  Handle the "x-forwarded-for" config setting properly,
3123  *                also used in the add_client_headers list.  Called from `sed'.
3124  *
3125  * Parameters  :
3126  *          1  :  csp = Current client state (buffers, headers, etc...)
3127  *          2  :  header = On input, pointer to header to modify.
3128  *                On output, pointer to the modified header, or NULL
3129  *                to remove the header.  This function frees the
3130  *                original string if necessary.
3131  *
3132  * Returns     :  JB_ERR_OK on success, or
3133  *                JB_ERR_MEMORY on out-of-memory error.
3134  *
3135  *********************************************************************/
3136 jb_err client_x_forwarded(struct client_state *csp, char **header)
3137 {
3138    if (0 != (csp->action->flags & ACTION_CHANGE_X_FORWARDED_FOR))
3139    {
3140       const char *parameter = csp->action->string[ACTION_STRING_CHANGE_X_FORWARDED_FOR];
3141
3142       if (0 == strcmpic(parameter, "block"))
3143       {
3144          freez(*header);
3145          log_error(LOG_LEVEL_HEADER, "crunched x-forwarded-for!");
3146       }
3147       else if (0 == strcmpic(parameter, "add"))
3148       {
3149          string_append(header, ", ");
3150          string_append(header, csp->ip_addr_str);
3151
3152          if (*header == NULL)
3153          {
3154             return JB_ERR_MEMORY;
3155          }
3156          log_error(LOG_LEVEL_HEADER,
3157             "Appended client IP address to %s", *header);
3158          csp->flags |= CSP_FLAG_X_FORWARDED_FOR_APPENDED;
3159       }
3160       else
3161       {
3162          log_error(LOG_LEVEL_FATAL,
3163             "Invalid change-x-forwarded-for parameter: '%s'", parameter);
3164       }
3165    }
3166
3167    return JB_ERR_OK;
3168 }
3169
3170
3171 /*********************************************************************
3172  *
3173  * Function    :  client_max_forwards
3174  *
3175  * Description :  If the HTTP method is OPTIONS or TRACE, subtract one
3176  *                from the value of the Max-Forwards header field.
3177  *
3178  * Parameters  :
3179  *          1  :  csp = Current client state (buffers, headers, etc...)
3180  *          2  :  header = On input, pointer to header to modify.
3181  *                On output, pointer to the modified header, or NULL
3182  *                to remove the header.  This function frees the
3183  *                original string if necessary.
3184  *
3185  * Returns     :  JB_ERR_OK on success, or
3186  *                JB_ERR_MEMORY on out-of-memory error.
3187  *
3188  *********************************************************************/
3189 static jb_err client_max_forwards(struct client_state *csp, char **header)
3190 {
3191    int max_forwards;
3192
3193    if ((0 == strcmpic(csp->http->gpc, "trace")) ||
3194        (0 == strcmpic(csp->http->gpc, "options")))
3195    {
3196       assert(*(*header+12) == ':');
3197       if (1 == sscanf(*header+12, ": %d", &max_forwards))
3198       {
3199          if (max_forwards > 0)
3200          {
3201             snprintf(*header, strlen(*header)+1, "Max-Forwards: %d", --max_forwards);
3202             log_error(LOG_LEVEL_HEADER,
3203                "Max-Forwards value for %s request reduced to %d.",
3204                csp->http->gpc, max_forwards);
3205          }
3206          else if (max_forwards < 0)
3207          {
3208             log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header);
3209             freez(*header);
3210          }
3211       }
3212       else
3213       {
3214          log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header);
3215          freez(*header);
3216       }
3217    }
3218
3219    return JB_ERR_OK;
3220 }
3221
3222
3223 /*********************************************************************
3224  *
3225  * Function    :  client_host
3226  *
3227  * Description :  If the request URI did not contain host and
3228  *                port information, parse and evaluate the Host
3229  *                header field.
3230  *
3231  * Parameters  :
3232  *          1  :  csp = Current client state (buffers, headers, etc...)
3233  *          2  :  header = On input, pointer to header to modify.
3234  *                On output, pointer to the modified header, or NULL
3235  *                to remove the header.  This function frees the
3236  *                original string if necessary.
3237  *
3238  * Returns     :  JB_ERR_OK on success, or
3239  *                JB_ERR_MEMORY on out-of-memory error.
3240  *
3241  *********************************************************************/
3242 static jb_err client_host(struct client_state *csp, char **header)
3243 {
3244    char *p, *q;
3245
3246    if (!csp->http->hostport || (*csp->http->hostport == '*') ||
3247        *csp->http->hostport == ' ' || *csp->http->hostport == '\0')
3248    {
3249
3250       p = strdup_or_die((*header)+6);
3251       chomp(p);
3252       q = strdup_or_die(p);
3253
3254       freez(csp->http->hostport);
3255       csp->http->hostport = p;
3256       freez(csp->http->host);
3257       csp->http->host = q;
3258       q = strchr(csp->http->host, ':');
3259       if (q != NULL)
3260       {
3261          /* Terminate hostname and evaluate port string */
3262          *q++ = '\0';
3263          csp->http->port = atoi(q);
3264       }
3265       else
3266       {
3267          csp->http->port = csp->http->ssl ? 443 : 80;
3268       }
3269
3270       log_error(LOG_LEVEL_HEADER, "New host and port from Host field: %s = %s:%d",
3271                 csp->http->hostport, csp->http->host, csp->http->port);
3272    }
3273
3274    /* Signal client_host_adder() to return right away */
3275    csp->flags |= CSP_FLAG_HOST_HEADER_IS_SET;
3276
3277    return JB_ERR_OK;
3278 }
3279
3280
3281 /*********************************************************************
3282  *
3283  * Function    :  client_if_modified_since
3284  *
3285  * Description :  Remove or modify the If-Modified-Since header.
3286  *
3287  * Parameters  :
3288  *          1  :  csp = Current client state (buffers, headers, etc...)
3289  *          2  :  header = On input, pointer to header to modify.
3290  *                On output, pointer to the modified header, or NULL
3291  *                to remove the header.  This function frees the
3292  *                original string if necessary.
3293  *
3294  * Returns     :  JB_ERR_OK on success, or
3295  *                JB_ERR_MEMORY on out-of-memory error.
3296  *
3297  *********************************************************************/
3298 static jb_err client_if_modified_since(struct client_state *csp, char **header)
3299 {
3300    char newheader[50];
3301 #ifdef HAVE_GMTIME_R
3302    struct tm gmt;
3303 #endif
3304    struct tm *timeptr = NULL;
3305    time_t tm = 0;
3306    const char *newval;
3307    char * endptr;
3308
3309    if (0 == strcmpic(*header, "If-Modified-Since: Wed, 08 Jun 1955 12:00:00 GMT"))
3310    {
3311       /*
3312        * The client got an error message because of a temporary problem,
3313        * the problem is gone and the client now tries to revalidate our
3314        * error message on the real server. The revalidation would always
3315        * end with the transmission of the whole document and there is
3316        * no need to expose the bogus If-Modified-Since header.
3317        */
3318       log_error(LOG_LEVEL_HEADER, "Crunching useless If-Modified-Since header.");
3319       freez(*header);
3320    }
3321    else if (csp->action->flags & ACTION_HIDE_IF_MODIFIED_SINCE)
3322    {
3323       newval = csp->action->string[ACTION_STRING_IF_MODIFIED_SINCE];
3324
3325       if ((0 == strcmpic(newval, "block")))
3326       {
3327          log_error(LOG_LEVEL_HEADER, "Crunching %s", *header);
3328          freez(*header);
3329       }
3330       else /* add random value */
3331       {
3332          const char *header_time = *header + sizeof("If-Modified-Since:");
3333
3334          if (JB_ERR_OK != parse_header_time(header_time, &tm))
3335          {
3336             log_error(LOG_LEVEL_HEADER, "Couldn't parse: %s in %s (crunching!)", header_time, *header);
3337             freez(*header);
3338          }
3339          else
3340          {
3341             long int hours, minutes, seconds;
3342             long int rtime = strtol(newval, &endptr, 0);
3343             const int negative_range = (rtime < 0);
3344
3345             if (rtime)
3346             {
3347                log_error(LOG_LEVEL_HEADER, "Randomizing: %s (random range: %d minut%s)",
3348                   *header, rtime, (rtime == 1 || rtime == -1) ? "e": "es");
3349                if (negative_range)
3350                {
3351                   rtime *= -1;
3352                }
3353                rtime *= 60;
3354                rtime = pick_from_range(rtime);
3355             }
3356             else
3357             {
3358                log_error(LOG_LEVEL_ERROR, "Random range is 0. Assuming time transformation test.",
3359                   *header);
3360             }
3361             tm += rtime * (negative_range ? -1 : 1);
3362 #ifdef HAVE_GMTIME_R
3363             timeptr = gmtime_r(&tm, &gmt);
3364 #elif defined(MUTEX_LOCKS_AVAILABLE)
3365             privoxy_mutex_lock(&gmtime_mutex);
3366             timeptr = gmtime(&tm);
3367             privoxy_mutex_unlock(&gmtime_mutex);
3368 #else
3369             timeptr = gmtime(&tm);
3370 #endif
3371             if ((NULL == timeptr) || !strftime(newheader,
3372                   sizeof(newheader), "%a, %d %b %Y %H:%M:%S GMT", timeptr))
3373             {
3374                log_error(LOG_LEVEL_ERROR,
3375                   "Randomizing '%s' failed. Crunching the header without replacement.",
3376                   *header);
3377                freez(*header);
3378                return JB_ERR_OK;
3379             }
3380
3381             freez(*header);
3382             *header = strdup("If-Modified-Since: ");
3383             string_append(header, newheader);
3384
3385             if (*header == NULL)
3386             {
3387                log_error(LOG_LEVEL_HEADER, "Insufficient memory, header crunched without replacement.");
3388                return JB_ERR_MEMORY;
3389             }
3390
3391             hours   = rtime / 3600;
3392             minutes = rtime / 60 % 60;
3393             seconds = rtime % 60;
3394
3395             log_error(LOG_LEVEL_HEADER,
3396                "Randomized:  %s (%s %d hou%s %d minut%s %d second%s",
3397                *header, (negative_range) ? "subtracted" : "added", hours,
3398                (hours == 1) ? "r" : "rs", minutes, (minutes == 1) ? "e" : "es",
3399                seconds, (seconds == 1) ? ")" : "s)");
3400          }
3401       }
3402    }
3403
3404    return JB_ERR_OK;
3405 }
3406
3407
3408 /*********************************************************************
3409  *
3410  * Function    :  client_if_none_match
3411  *
3412  * Description :  Remove the If-None-Match header.
3413  *
3414  * Parameters  :
3415  *          1  :  csp = Current client state (buffers, headers, etc...)
3416  *          2  :  header = On input, pointer to header to modify.
3417  *                On output, pointer to the modified header, or NULL
3418  *                to remove the header.  This function frees the
3419  *                original string if necessary.
3420  *
3421  * Returns     :  JB_ERR_OK on success, or
3422  *                JB_ERR_MEMORY on out-of-memory error.
3423  *
3424  *********************************************************************/
3425 static jb_err client_if_none_match(struct client_state *csp, char **header)
3426 {
3427    if (csp->action->flags & ACTION_CRUNCH_IF_NONE_MATCH)
3428    {
3429       log_error(LOG_LEVEL_HEADER, "Crunching %s", *header);
3430       freez(*header);
3431    }
3432
3433    return JB_ERR_OK;
3434 }
3435
3436
3437 /*********************************************************************
3438  *
3439  * Function    :  client_x_filter
3440  *
3441  * Description :  Disables filtering if the client set "X-Filter: No".
3442  *                Called from `sed'.
3443  *
3444  * Parameters  :
3445  *          1  :  csp = Current client state (buffers, headers, etc...)
3446  *          2  :  header = On input, pointer to header to modify.
3447  *                On output, pointer to the modified header, or NULL
3448  *                to remove the header.  This function frees the
3449  *                original string if necessary.
3450  *
3451  * Returns     :  JB_ERR_OK on success
3452  *
3453  *********************************************************************/
3454 jb_err client_x_filter(struct client_state *csp, char **header)
3455 {
3456    if (0 == strcmpic(*header, "X-Filter: No"))
3457    {
3458       if (!(csp->config->feature_flags & RUNTIME_FEATURE_HTTP_TOGGLE))
3459       {
3460          log_error(LOG_LEVEL_INFO, "Ignored the client's request to fetch without filtering.");
3461       }
3462       else
3463       {
3464          if (csp->action->flags & ACTION_FORCE_TEXT_MODE)
3465          {
3466             log_error(LOG_LEVEL_HEADER,
3467                "force-text-mode overruled the client's request to fetch without filtering!");
3468          }
3469          else
3470          {
3471             csp->content_type = CT_TABOO; /* XXX: This hack shouldn't be necessary */
3472             csp->flags |= CSP_FLAG_NO_FILTERING;
3473             log_error(LOG_LEVEL_HEADER, "Accepted the client's request to fetch without filtering.");
3474          }
3475          log_error(LOG_LEVEL_HEADER, "Crunching %s", *header);
3476          freez(*header);
3477       }
3478    }
3479    return JB_ERR_OK;
3480 }
3481
3482
3483 /*********************************************************************
3484  *
3485  * Function    :  client_range
3486  *
3487  * Description :  Removes Range, Request-Range and If-Range headers if
3488  *                content filtering is enabled and the range doesn't
3489  *                start at byte 0.
3490  *
3491  *                If the client's version of the document has been
3492  *                altered by Privoxy, the server could interpret the
3493  *                range differently than the client intended in which
3494  *                case the user could end up with corrupted content.
3495  *
3496  *                If the range starts at byte 0 this isn't an issue
3497  *                so the header can pass. Partial requests like this
3498  *                are used to render preview images for videos without
3499  *                downloading the whole video.
3500  *
3501  *                While HTTP doesn't require that range requests are
3502  *                honoured and the client could simply abort the download
3503  *                after receiving a sufficient amount of data, various
3504  *                clients don't handle complete responses to range
3505  *                requests gracefully and emit misleading error messages
3506  *                instead.
3507  *
3508  * Parameters  :
3509  *          1  :  csp = Current client state (buffers, headers, etc...)
3510  *          2  :  header = On input, pointer to header to modify.
3511  *                On output, pointer to the modified header, or NULL
3512  *                to remove the header.  This function frees the
3513  *                original string if necessary.
3514  *
3515  * Returns     :  JB_ERR_OK
3516  *
3517  *********************************************************************/
3518 static jb_err client_range(struct client_state *csp, char **header)
3519 {
3520    if (content_filters_enabled(csp->action)
3521       && (0 != strncmpic(strstr(*header, ":"), ": bytes=0-", 10)))
3522    {
3523       log_error(LOG_LEVEL_HEADER, "Content filtering is enabled."
3524          " Crunching: \'%s\' to prevent range-mismatch problems.", *header);
3525       freez(*header);
3526    }
3527
3528    return JB_ERR_OK;
3529 }
3530
3531 /* the following functions add headers directly to the header list */
3532
3533 /*********************************************************************
3534  *
3535  * Function    :  client_host_adder
3536  *
3537  * Description :  Adds the Host: header field if it is missing.
3538  *                Called from `sed'.
3539  *
3540  * Parameters  :
3541  *          1  :  csp = Current client state (buffers, headers, etc...)
3542  *
3543  * Returns     :  JB_ERR_OK on success, or
3544  *                JB_ERR_MEMORY on out-of-memory error.
3545  *
3546  *********************************************************************/
3547 static jb_err client_host_adder(struct client_state *csp)
3548 {
3549    char *p;
3550    jb_err err;
3551
3552    if (csp->flags & CSP_FLAG_HOST_HEADER_IS_SET)
3553    {
3554       /* Header already set by the client, nothing to do. */
3555       return JB_ERR_OK;
3556    }
3557
3558    if (!csp->http->hostport || !*(csp->http->hostport))
3559    {
3560       /* XXX: When does this happen and why is it OK? */
3561       log_error(LOG_LEVEL_INFO, "Weirdness in client_host_adder detected and ignored.");
3562       return JB_ERR_OK;
3563    }
3564
3565    /*
3566     * remove 'user:pass@' from 'proto://user:pass@host'
3567     */
3568    if ((p = strchr( csp->http->hostport, '@')) != NULL)
3569    {
3570       p++;
3571    }
3572    else
3573    {
3574       p = csp->http->hostport;
3575    }
3576
3577    /* XXX: Just add it, we already made sure that it will be unique */
3578    log_error(LOG_LEVEL_HEADER, "addh-unique: Host: %s", p);
3579    err = enlist_unique_header(csp->headers, "Host", p);
3580    return err;
3581
3582 }
3583
3584
3585 /*********************************************************************
3586  *
3587  * Function    :  client_xtra_adder
3588  *
3589  * Description :  Used in the add_client_headers list.  Called from `sed'.
3590  *
3591  * Parameters  :
3592  *          1  :  csp = Current client state (buffers, headers, etc...)
3593  *
3594  * Returns     :  JB_ERR_OK on success, or
3595  *                JB_ERR_MEMORY on out-of-memory error.
3596  *
3597  *********************************************************************/
3598 static jb_err client_xtra_adder(struct client_state *csp)
3599 {
3600    struct list_entry *lst;
3601    jb_err err;
3602
3603    for (lst = csp->action->multi[ACTION_MULTI_ADD_HEADER]->first;
3604         lst ; lst = lst->next)
3605    {
3606       log_error(LOG_LEVEL_HEADER, "addh: %s", lst->str);
3607       err = enlist(csp->headers, lst->str);
3608       if (err)
3609       {
3610          return err;
3611       }
3612
3613    }
3614
3615    return JB_ERR_OK;
3616 }
3617
3618
3619 /*********************************************************************
3620  *
3621  * Function    :  client_x_forwarded_for_adder
3622  *
3623  * Description :  Used in the add_client_headers list.  Called from `sed'.
3624  *
3625  * Parameters  :
3626  *          1  :  csp = Current client state (buffers, headers, etc...)
3627  *
3628  * Returns     :  JB_ERR_OK on success, or
3629  *                JB_ERR_MEMORY on out-of-memory error.
3630  *
3631  *********************************************************************/
3632 static jb_err client_x_forwarded_for_adder(struct client_state *csp)
3633 {
3634    char *header = NULL;
3635    jb_err err;
3636
3637    if (!((csp->action->flags & ACTION_CHANGE_X_FORWARDED_FOR)
3638          && (0 == strcmpic(csp->action->string[ACTION_STRING_CHANGE_X_FORWARDED_FOR], "add")))
3639       || (csp->flags & CSP_FLAG_X_FORWARDED_FOR_APPENDED))
3640    {
3641       /*
3642        * If we aren't adding X-Forwarded-For headers,
3643        * or we already appended an existing X-Forwarded-For
3644        * header, there's nothing left to do here.
3645        */
3646       return JB_ERR_OK;
3647    }
3648
3649    header = strdup("X-Forwarded-For: ");
3650    string_append(&header, csp->ip_addr_str);
3651
3652    if (header == NULL)
3653    {
3654       return JB_ERR_MEMORY;
3655    }
3656
3657    log_error(LOG_LEVEL_HEADER, "addh: %s", header);
3658    err = enlist(csp->headers, header);
3659    freez(header);
3660
3661    return err;
3662 }
3663
3664
3665 /*********************************************************************
3666  *
3667  * Function    :  server_connection_adder
3668  *
3669  * Description :  Adds an appropriate "Connection:" header to csp->headers
3670  *                unless the header was already present. Called from `sed'.
3671  *
3672  * Parameters  :
3673  *          1  :  csp = Current client state (buffers, headers, etc...)
3674  *
3675  * Returns     :  JB_ERR_OK on success, or
3676  *                JB_ERR_MEMORY on out-of-memory error.
3677  *
3678  *********************************************************************/
3679 static jb_err server_connection_adder(struct client_state *csp)
3680 {
3681    const unsigned int flags = csp->flags;
3682    const char *response_status_line = csp->headers->first->str;
3683    static const char connection_close[] = "Connection: close";
3684
3685    if ((flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
3686     && (flags & CSP_FLAG_SERVER_CONNECTION_HEADER_SET))
3687    {
3688       return JB_ERR_OK;
3689    }
3690
3691    /*
3692     * XXX: if we downgraded the response, this check will fail.
3693     */
3694    if ((csp->config->feature_flags &
3695         RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
3696     && (NULL != response_status_line)
3697     && !strncmpic(response_status_line, "HTTP/1.1", 8)
3698 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
3699     && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
3700 #endif
3701       )
3702    {
3703       log_error(LOG_LEVEL_HEADER, "A HTTP/1.1 response "
3704          "without Connection header implies keep-alive.");
3705       csp->flags |= CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE;
3706       return JB_ERR_OK;
3707    }
3708
3709    log_error(LOG_LEVEL_HEADER, "Adding: %s", connection_close);
3710
3711    return enlist(csp->headers, connection_close);
3712 }
3713
3714
3715 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
3716 /*********************************************************************
3717  *
3718  * Function    :  server_proxy_connection_adder
3719  *
3720  * Description :  Adds a "Proxy-Connection: keep-alive" header to
3721  *                csp->headers when appropriate.
3722  *
3723  * Parameters  :
3724  *          1  :  csp = Current client state (buffers, headers, etc...)
3725  *
3726  * Returns     :  JB_ERR_OK on success, or
3727  *                JB_ERR_MEMORY on out-of-memory error.
3728  *
3729  *********************************************************************/
3730 static jb_err server_proxy_connection_adder(struct client_state *csp)
3731 {
3732    static const char proxy_connection_header[] = "Proxy-Connection: keep-alive";
3733    jb_err err = JB_ERR_OK;
3734
3735    if ((csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE)
3736     && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
3737     && !(csp->flags & CSP_FLAG_SERVER_PROXY_CONNECTION_HEADER_SET)
3738     && ((csp->flags & CSP_FLAG_SERVER_CONTENT_LENGTH_SET)
3739        || (csp->flags & CSP_FLAG_CHUNKED)))
3740    {
3741       log_error(LOG_LEVEL_HEADER, "Adding: %s", proxy_connection_header);
3742       err = enlist(csp->headers, proxy_connection_header);
3743    }
3744
3745    return err;
3746 }
3747 #endif /* FEATURE_CONNECTION_KEEP_ALIVE */
3748
3749
3750 /*********************************************************************
3751  *
3752  * Function    :  client_connection_header_adder
3753  *
3754  * Description :  Adds a proper "Connection:" header to csp->headers
3755  *                unless the header was already present. Called from `sed'.
3756  *
3757  * Parameters  :
3758  *          1  :  csp = Current client state (buffers, headers, etc...)
3759  *
3760  * Returns     :  JB_ERR_OK on success, or
3761  *                JB_ERR_MEMORY on out-of-memory error.
3762  *
3763  *********************************************************************/
3764 static jb_err client_connection_header_adder(struct client_state *csp)
3765 {
3766    static const char connection_close[] = "Connection: close";
3767
3768    if (!(csp->flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
3769      && (csp->flags & CSP_FLAG_CLIENT_CONNECTION_HEADER_SET))
3770    {
3771       return JB_ERR_OK;
3772    }
3773
3774 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
3775    if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
3776       && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
3777       && (csp->http->ssl == 0)
3778       && !strcmpic(csp->http->ver, "HTTP/1.1"))
3779    {
3780       csp->flags |= CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
3781       return JB_ERR_OK;
3782    }
3783 #endif /* FEATURE_CONNECTION_KEEP_ALIVE */
3784
3785    log_error(LOG_LEVEL_HEADER, "Adding: %s", connection_close);
3786
3787    return enlist(csp->headers, connection_close);
3788 }
3789
3790
3791 /*********************************************************************
3792  *
3793  * Function    :  server_http
3794  *
3795  * Description :  - Save the HTTP Status into csp->http->status
3796  *                - Set CT_TABOO to prevent filtering if the answer
3797  *                  is a partial range (HTTP status 206)
3798  *                - Rewrite HTTP/1.1 answers to HTTP/1.0 if +downgrade
3799  *                  action applies.
3800  *
3801  * Parameters  :
3802  *          1  :  csp = Current client state (buffers, headers, etc...)
3803  *          2  :  header = On input, pointer to header to modify.
3804  *                On output, pointer to the modified header, or NULL
3805  *                to remove the header.  This function frees the
3806  *                original string if necessary.
3807  *
3808  * Returns     :  JB_ERR_OK on success, or
3809  *                JB_ERR_MEMORY on out-of-memory error.
3810  *
3811  *********************************************************************/
3812 static jb_err server_http(struct client_state *csp, char **header)
3813 {
3814    sscanf(*header, "HTTP/%*d.%*d %d", &(csp->http->status));
3815    if (csp->http->status == 206)
3816    {
3817       csp->content_type = CT_TABOO;
3818    }
3819
3820    if ((csp->action->flags & ACTION_DOWNGRADE) != 0)
3821    {
3822       /* XXX: Should we do a real validity check here? */
3823       if (strlen(*header) > 8)
3824       {
3825          (*header)[7] = '0';
3826          log_error(LOG_LEVEL_HEADER, "Downgraded answer to HTTP/1.0");
3827       }
3828       else
3829       {
3830          /*
3831           * XXX: Should we block the request or
3832           * enlist a valid status code line here?
3833           */
3834          log_error(LOG_LEVEL_INFO, "Malformed server response detected. "
3835             "Downgrading to HTTP/1.0 impossible.");
3836       }
3837    }
3838
3839    return JB_ERR_OK;
3840 }
3841
3842 /*********************************************************************
3843  *
3844  * Function    :  add_cooky_expiry_date
3845  *
3846  * Description :  Adds a cookie expiry date to a string.
3847  *
3848  * Parameters  :
3849  *          1  :  cookie = On input, pointer to cookie to modify.
3850  *                         On output, pointer to the modified header.
3851  *                         The original string is freed.
3852  *          2  :  lifetime = Seconds the cookie should be valid
3853  *
3854  * Returns     :  N/A
3855  *
3856  *********************************************************************/
3857 static void add_cookie_expiry_date(char **cookie, time_t lifetime)
3858 {
3859    char tmp[50];
3860    struct tm *timeptr = NULL;
3861    time_t expiry_date = time(NULL) + lifetime;
3862 #ifdef HAVE_GMTIME_R
3863    struct tm gmt;
3864
3865    timeptr = gmtime_r(&expiry_date, &gmt);
3866 #elif defined(MUTEX_LOCKS_AVAILABLE)
3867    privoxy_mutex_lock(&gmtime_mutex);
3868    timeptr = gmtime(&expiry_date);
3869    privoxy_mutex_unlock(&gmtime_mutex);
3870 #else
3871    timeptr = gmtime(&expiry_date);
3872 #endif
3873
3874    if (NULL == timeptr)
3875    {
3876       log_error(LOG_LEVEL_FATAL,
3877          "Failed to get the time in add_cooky_expiry_date()");
3878    }
3879    strftime(tmp, sizeof(tmp), "; expires=%a, %d-%b-%Y %H:%M:%S GMT", timeptr);
3880    if (JB_ERR_OK != string_append(cookie, tmp))
3881    {
3882       log_error(LOG_LEVEL_FATAL, "Out of memory in add_cooky_expiry()");
3883    }
3884 }
3885
3886
3887 /*********************************************************************
3888  *
3889  * Function    :  server_set_cookie
3890  *
3891  * Description :  Handle the server "cookie" header properly.
3892  *                Crunch, accept or rewrite it to a session cookie.
3893  *                Called from `sed'.
3894  *
3895  * Parameters  :
3896  *          1  :  csp = Current client state (buffers, headers, etc...)
3897  *          2  :  header = On input, pointer to header to modify.
3898  *                On output, pointer to the modified header, or NULL
3899  *                to remove the header.  This function frees the
3900  *                original string if necessary.
3901  *
3902  * Returns     :  JB_ERR_OK on success, or
3903  *                JB_ERR_MEMORY on out-of-memory error.
3904  *
3905  *********************************************************************/
3906 static jb_err server_set_cookie(struct client_state *csp, char **header)
3907 {
3908    if ((csp->action->flags & ACTION_CRUNCH_INCOMING_COOKIES) != 0)
3909    {
3910       log_error(LOG_LEVEL_HEADER, "Crunching incoming cookie: %s", *header);
3911       freez(*header);
3912    }
3913    else if ((0 != (csp->action->flags & ACTION_SESSION_COOKIES_ONLY))
3914          || (0 != (csp->action->flags & ACTION_LIMIT_COOKIE_LIFETIME)))
3915    {
3916       time_t now;
3917       time_t cookie_time;
3918       long cookie_lifetime = 0;
3919       enum
3920       {
3921          NO_EXPIRY_DATE_SPECIFIED,
3922          EXPIRY_DATE_ACCEPTABLE,
3923          EXPIRY_DATE_UNACCEPTABLE
3924       } expiry_date_status = NO_EXPIRY_DATE_SPECIFIED;
3925
3926       /* A variable to store the tag we're working on */
3927       char *cur_tag;
3928
3929       /* Skip "Set-Cookie:" (11 characters) in header */
3930       cur_tag = *header + 11;
3931
3932       /* skip whitespace between "Set-Cookie:" and value */
3933       while (*cur_tag && privoxy_isspace(*cur_tag))
3934       {
3935          cur_tag++;
3936       }
3937
3938       time(&now);
3939
3940       if ((csp->action->flags & ACTION_LIMIT_COOKIE_LIFETIME) != 0)
3941       {
3942          const char *param = csp->action->string[ACTION_STRING_LIMIT_COOKIE_LIFETIME];
3943
3944          cookie_lifetime = strtol(param, NULL, 0);
3945          if (cookie_lifetime < 0)
3946          {
3947             log_error(LOG_LEVEL_FATAL, "Invalid cookie lifetime limit: %s", param);
3948          }
3949          cookie_lifetime *= 60;
3950       }
3951
3952       /* Loop through each tag in the cookie */
3953       while (*cur_tag)
3954       {
3955          /* Find next tag */
3956          char *next_tag = strchr(cur_tag, ';');
3957          if (next_tag != NULL)
3958          {
3959             /* Skip the ';' character itself */
3960             next_tag++;
3961
3962             /* skip whitespace ";" and start of tag */
3963             while (*next_tag && privoxy_isspace(*next_tag))
3964             {
3965                next_tag++;
3966             }
3967          }
3968          else
3969          {
3970             /* "Next tag" is the end of the string */
3971             next_tag = cur_tag + strlen(cur_tag);
3972          }
3973
3974          /*
3975           * Check the expiration date to see
3976           * if the cookie is still valid, if yes,
3977           * rewrite it to a session cookie.
3978           */
3979          if ((strncmpic(cur_tag, "expires=", 8) == 0) && *(cur_tag + 8))
3980          {
3981             char *expiration_date = cur_tag + 8; /* Skip "[Ee]xpires=" */
3982
3983             if ((expiration_date[0] == '"')
3984              && (expiration_date[1] != '\0'))
3985             {
3986                /*
3987                 * Skip quotation mark. RFC 2109 10.1.2 seems to hint
3988                 * that the expiration date isn't supposed to be quoted,
3989                 * but some servers do it anyway.
3990                 */
3991                expiration_date++;
3992             }
3993
3994             /* Did we detect the date properly? */
3995             if (JB_ERR_OK != parse_header_time(expiration_date, &cookie_time))
3996             {
3997                /*
3998                 * Nope, treat it as if it was still valid.
3999                 *
4000                 * XXX: Should we remove the whole cookie instead?
4001                 */
4002                log_error(LOG_LEVEL_ERROR,
4003                   "Can't parse \'%s\', send by %s. Unsupported time format?", cur_tag, csp->http->url);
4004                string_move(cur_tag, next_tag);
4005                expiry_date_status = EXPIRY_DATE_UNACCEPTABLE;
4006             }
4007             else
4008             {
4009                /*
4010                 * Yes. Check if the cookie is still valid.
4011                 *
4012                 * If the cookie is already expired it's probably
4013                 * a delete cookie and even if it isn't, the browser
4014                 * will discard it anyway.
4015                 */
4016
4017                /*
4018                 * XXX: timegm() isn't available on some AmigaOS
4019                 * versions and our replacement doesn't work.
4020                 *
4021                 * Our options are to either:
4022                 *
4023                 * - disable session-cookies-only completely if timegm
4024                 *   is missing,
4025                 *
4026                 * - to simply remove all expired tags, like it has
4027                 *   been done until Privoxy 3.0.6 and to live with
4028                 *    the consequence that it can cause login/logout
4029                 *   problems on servers that don't validate their
4030                 *   input properly, or
4031                 *
4032                 * - to replace it with mktime in which
4033                 *   case there is a slight chance of valid cookies
4034                 *   passing as already expired.
4035                 *
4036                 *   This is the way it's currently done and it's not
4037                 *   as bad as it sounds. If the missing GMT offset is
4038                 *   enough to change the result of the expiration check
4039                 *   the cookie will be only valid for a few hours
4040                 *   anyway, which in many cases will be shorter
4041                 *   than a browser session.
4042                 */
4043                if (cookie_time < now)
4044                {
4045                   log_error(LOG_LEVEL_HEADER,
4046                      "Cookie \'%s\' is already expired and can pass unmodified.", *header);
4047                   /* Just in case some clown sets more then one expiration date */
4048                   cur_tag = next_tag;
4049                   expiry_date_status = EXPIRY_DATE_ACCEPTABLE;
4050                }
4051                else if ((cookie_lifetime != 0) && (cookie_time < (now + cookie_lifetime)))
4052                {
4053                   log_error(LOG_LEVEL_HEADER, "Cookie \'%s\' can pass unmodified. "
4054                      "Its lifetime is below the limit.", *header);
4055                   /* Just in case some clown sets more then one expiration date */
4056                   cur_tag = next_tag;
4057                   expiry_date_status = EXPIRY_DATE_ACCEPTABLE;
4058                }
4059                else
4060                {
4061                   /*
4062                    * Still valid, delete expiration date by copying
4063                    * the rest of the string over it.
4064                    */
4065                   string_move(cur_tag, next_tag);
4066
4067                   /* That changed the header, need to issue a log message */
4068                   expiry_date_status = EXPIRY_DATE_UNACCEPTABLE;
4069
4070                   /*
4071                    * Note that the next tag has now been moved to *cur_tag,
4072                    * so we do not need to update the cur_tag pointer.
4073                    */
4074                }
4075             }
4076
4077          }
4078          else
4079          {
4080             /* Move on to next cookie tag */
4081             cur_tag = next_tag;
4082          }
4083       }
4084
4085       if (expiry_date_status != EXPIRY_DATE_ACCEPTABLE)
4086       {
4087          assert(NULL != *header);
4088          if (cookie_lifetime != 0)
4089          {
4090             add_cookie_expiry_date(header, cookie_lifetime);
4091             log_error(LOG_LEVEL_HEADER, "Cookie rewritten to: %s", *header);
4092          }
4093          else if (expiry_date_status != NO_EXPIRY_DATE_SPECIFIED)
4094          {
4095             log_error(LOG_LEVEL_HEADER,
4096                "Cookie rewritten to a temporary one: %s", *header);
4097          }
4098       }
4099    }
4100
4101    return JB_ERR_OK;
4102 }
4103
4104
4105 #ifdef FEATURE_FORCE_LOAD
4106 /*********************************************************************
4107  *
4108  * Function    :  strclean
4109  *
4110  * Description :  In-Situ-Eliminate all occurrences of substring in
4111  *                string
4112  *
4113  * Parameters  :
4114  *          1  :  string = string to clean
4115  *          2  :  substring = substring to eliminate
4116  *
4117  * Returns     :  Number of eliminations
4118  *
4119  *********************************************************************/
4120 int strclean(char *string, const char *substring)
4121 {
4122    int hits = 0;
4123    size_t len;
4124    char *pos, *p;
4125
4126    len = strlen(substring);
4127
4128    while((pos = strstr(string, substring)) != NULL)
4129    {
4130       p = pos + len;
4131       do
4132       {
4133          *(p - len) = *p;
4134       }
4135       while (*p++ != '\0');
4136
4137       hits++;
4138    }
4139
4140    return(hits);
4141 }
4142 #endif /* def FEATURE_FORCE_LOAD */
4143
4144
4145 /*********************************************************************
4146  *
4147  * Function    :  parse_header_time
4148  *
4149  * Description :  Parses time formats used in HTTP header strings
4150  *                to get the numerical respresentation.
4151  *
4152  * Parameters  :
4153  *          1  :  header_time = HTTP header time as string.
4154  *          2  :  result = storage for header_time in seconds
4155  *
4156  * Returns     :  JB_ERR_OK if the time format was recognized, or
4157  *                JB_ERR_PARSE otherwise.
4158  *
4159  *********************************************************************/
4160 static jb_err parse_header_time(const char *header_time, time_t *result)
4161 {
4162    struct tm gmt;
4163    /*
4164     * Checking for two-digit years first in an
4165     * attempt to work around GNU libc's strptime()
4166     * reporting negative year values when using %Y.
4167     */
4168    static const char time_formats[][22] = {
4169       /* Tue, 02-Jun-37 20:00:00 */
4170       "%a, %d-%b-%y %H:%M:%S",
4171       /* Tue, 02 Jun 2037 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       /* Tuesday, 02-Jun-2037 20:00:00 */
4176       "%A, %d-%b-%Y %H:%M:%S",
4177       /* Tuesday Jun 02 20:00:00 2037 */
4178       "%A %b %d %H:%M:%S %Y"
4179    };
4180    unsigned int i;
4181
4182    for (i = 0; i < SZ(time_formats); i++)
4183    {
4184       /*
4185        * Zero out gmt to prevent time zone offsets.
4186        * Documented to be required for GNU libc.
4187        */
4188       memset(&gmt, 0, sizeof(gmt));
4189
4190       if (NULL != strptime(header_time, time_formats[i], &gmt))
4191       {
4192          /* Sanity check for GNU libc. */
4193          if (gmt.tm_year < 0)
4194          {
4195             log_error(LOG_LEVEL_HEADER,
4196                "Failed to parse '%s' using '%s'. Moving on.",
4197                header_time, time_formats[i]);
4198             continue;
4199          }
4200          *result = timegm(&gmt);
4201
4202 #ifdef FEATURE_STRPTIME_SANITY_CHECKS
4203          /*
4204           * Verify that parsing the date recreated from the first
4205           * parse operation gets the previous result. If it doesn't,
4206           * either strptime() or strftime() are malfunctioning.
4207           *
4208           * We could string-compare the recreated date with the original
4209           * header date, but this leads to false positives as strptime()
4210           * may let %a accept all day formats while strftime() will only
4211           * create one.
4212           */
4213          {
4214             char recreated_date[100];
4215             struct tm *tm;
4216             time_t result2;
4217
4218             tm = gmtime(result);
4219             strftime(recreated_date, sizeof(recreated_date), time_formats[i], tm);
4220             memset(&gmt, 0, sizeof(gmt));
4221             if (NULL == strptime(recreated_date, time_formats[i], &gmt))
4222             {
4223                log_error(LOG_LEVEL_ERROR,
4224                   "Failed to parse '%s' generated with '%s' to recreate '%s'.",
4225                   recreated_date, time_formats[i], header_time);
4226                continue;
4227             }
4228             result2 = timegm(&gmt);
4229             if (*result != result2)
4230             {
4231                log_error(LOG_LEVEL_ERROR, "strftime() and strptime() disagree. "
4232                   "Format: '%s'. In: '%s', out: '%s'. %d != %d. Rejecting.",
4233                   time_formats[i], header_time, recreated_date, *result, result2);
4234                continue;
4235             }
4236          }
4237 #endif
4238
4239          return JB_ERR_OK;
4240       }
4241    }
4242
4243    return JB_ERR_PARSE;
4244
4245 }
4246
4247
4248 /*********************************************************************
4249  *
4250  * Function    :  get_destination_from_headers
4251  *
4252  * Description :  Parse the "Host:" header to get the request's destination.
4253  *                Only needed if the client's request was forcefully
4254  *                redirected into Privoxy.
4255  *
4256  *                Code mainly copied from client_host() which is currently
4257  *                run too late for this purpose.
4258  *
4259  * Parameters  :
4260  *          1  :  headers = List of headers (one of them hopefully being
4261  *                the "Host:" header)
4262  *          2  :  http = storage for the result (host, port and hostport).
4263  *
4264  * Returns     :  JB_ERR_MEMORY (or terminates) in case of memory problems,
4265  *                JB_ERR_PARSE if the host header couldn't be found,
4266  *                JB_ERR_OK otherwise.
4267  *
4268  *********************************************************************/
4269 jb_err get_destination_from_headers(const struct list *headers, struct http_request *http)
4270 {
4271    char *q;
4272    char *p;
4273    char *host;
4274
4275    host = get_header_value(headers, "Host:");
4276
4277    if (NULL == host)
4278    {
4279       log_error(LOG_LEVEL_ERROR, "No \"Host:\" header found.");
4280       return JB_ERR_PARSE;
4281    }
4282
4283    p = strdup_or_die(host);
4284    chomp(p);
4285    q = strdup_or_die(p);
4286
4287    freez(http->hostport);
4288    http->hostport = p;
4289    freez(http->host);
4290    http->host = q;
4291    q = strchr(http->host, ':');
4292    if (q != NULL)
4293    {
4294       /* Terminate hostname and evaluate port string */
4295       *q++ = '\0';
4296       http->port = atoi(q);
4297    }
4298    else
4299    {
4300       http->port = http->ssl ? 443 : 80;
4301    }
4302
4303    /* Rebuild request URL */
4304    freez(http->url);
4305    http->url = strdup(http->ssl ? "https://" : "http://");
4306    string_append(&http->url, http->hostport);
4307    string_append(&http->url, http->path);
4308    if (http->url == NULL)
4309    {
4310       return JB_ERR_MEMORY;
4311    }
4312
4313    log_error(LOG_LEVEL_HEADER, "Destination extracted from \"Host:\" header. New request URL: %s",
4314       http->url);
4315
4316    return JB_ERR_OK;
4317
4318 }
4319
4320
4321 /*********************************************************************
4322  *
4323  * Function    :  create_forged_referrer
4324  *
4325  * Description :  Helper for client_referrer to forge a referer as
4326  *                'http://hostname[:port]/' to fool stupid
4327  *                checks for in-site links
4328  *
4329  * Parameters  :
4330  *          1  :  header   = Pointer to header pointer
4331  *          2  :  hostport = Host and optionally port as string
4332  *
4333  * Returns     :  JB_ERR_OK in case of success, or
4334  *                JB_ERR_MEMORY in case of memory problems.
4335  *
4336  *********************************************************************/
4337 static jb_err create_forged_referrer(char **header, const char *hostport)
4338 {
4339     assert(NULL == *header);
4340
4341     *header = strdup("Referer: http://");
4342     string_append(header, hostport);
4343     string_append(header, "/");
4344
4345     if (NULL == *header)
4346     {
4347        return JB_ERR_MEMORY;
4348     }
4349
4350     log_error(LOG_LEVEL_HEADER, "Referer forged to: %s", *header);
4351
4352     return JB_ERR_OK;
4353
4354 }
4355
4356
4357 /*********************************************************************
4358  *
4359  * Function    :  create_fake_referrer
4360  *
4361  * Description :  Helper for client_referrer to create a fake referrer
4362  *                based on a string supplied by the user.
4363  *
4364  * Parameters  :
4365  *          1  :  header   = Pointer to header pointer
4366  *          2  :  hosthost = Referrer to fake
4367  *
4368  * Returns     :  JB_ERR_OK in case of success, or
4369  *                JB_ERR_MEMORY in case of memory problems.
4370  *
4371  *********************************************************************/
4372 static jb_err create_fake_referrer(char **header, const char *fake_referrer)
4373 {
4374    assert(NULL == *header);
4375
4376    if ((0 != strncmpic(fake_referrer, "http://", 7)) && (0 != strncmpic(fake_referrer, "https://", 8)))
4377    {
4378       log_error(LOG_LEVEL_HEADER,
4379          "Parameter: +hide-referrer{%s} is a bad idea, but I don't care.", fake_referrer);
4380    }
4381    *header = strdup("Referer: ");
4382    string_append(header, fake_referrer);
4383
4384    if (NULL == *header)
4385    {
4386       return JB_ERR_MEMORY;
4387    }
4388
4389    log_error(LOG_LEVEL_HEADER, "Referer replaced with: %s", *header);
4390
4391    return JB_ERR_OK;
4392
4393 }
4394
4395
4396 /*********************************************************************
4397  *
4398  * Function    :  handle_conditional_hide_referrer_parameter
4399  *
4400  * Description :  Helper for client_referrer to crunch or forge
4401  *                the referrer header if the host has changed.
4402  *
4403  * Parameters  :
4404  *          1  :  header = Pointer to header pointer
4405  *          2  :  host   = The target host (may include the port)
4406  *          3  :  parameter_conditional_block = Boolean to signal
4407  *                if we're in conditional-block mode. If not set,
4408  *                we're in conditional-forge mode.
4409  *
4410  * Returns     :  JB_ERR_OK in case of success, or
4411  *                JB_ERR_MEMORY in case of memory problems.
4412  *
4413  *********************************************************************/
4414 static jb_err handle_conditional_hide_referrer_parameter(char **header,
4415    const char *host, const int parameter_conditional_block)
4416 {
4417    char *referer = strdup_or_die(*header);
4418    const size_t hostlength = strlen(host);
4419    const char *referer_url = NULL;
4420
4421    /* referer begins with 'Referer: http[s]://' */
4422    if ((hostlength+17) < strlen(referer))
4423    {
4424       /*
4425        * Shorten referer to make sure the referer is blocked
4426        * if www.example.org/www.example.com-shall-see-the-referer/
4427        * links to www.example.com/
4428        */
4429       referer[hostlength+17] = '\0';
4430    }
4431    referer_url = strstr(referer, "http://");
4432    if ((NULL == referer_url) || (NULL == strstr(referer_url, host)))
4433    {
4434       /* Host has changed, Referer is invalid or a https URL. */
4435       if (parameter_conditional_block)
4436       {
4437          log_error(LOG_LEVEL_HEADER, "New host is: %s. Crunching %s!", host, *header);
4438          freez(*header);
4439       }
4440       else
4441       {
4442          freez(*header);
4443          freez(referer);
4444