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