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