Removed client_host, (was only required for the old 2.0.2-11 http://noijb.
[privoxy.git] / parsers.c
1 const char parsers_rcs[] = "$Id: parsers.c,v 1.35 2001/10/09 22:39:21 jongfoster 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', `free_http_request', `get_header',
14  *                   `list_to_text', `parse_http_request', `sed',
15  *                   and `server_set_cookie'.
16  *
17  * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
18  *                IJBSWA team.  http://ijbswa.sourceforge.net
19  *
20  *                Based on the Internet Junkbuster originally written
21  *                by and Copyright (C) 1997 Anonymous Coders and 
22  *                Junkbusters Corporation.  http://www.junkbusters.com
23  *
24  *                This program is free software; you can redistribute it 
25  *                and/or modify it under the terms of the GNU General
26  *                Public License as published by the Free Software
27  *                Foundation; either version 2 of the License, or (at
28  *                your option) any later version.
29  *
30  *                This program is distributed in the hope that it will
31  *                be useful, but WITHOUT ANY WARRANTY; without even the
32  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
33  *                PARTICULAR PURPOSE.  See the GNU General Public
34  *                License for more details.
35  *
36  *                The GNU General Public License should be included with
37  *                this file.  If not, you can view it at
38  *                http://www.gnu.org/copyleft/gpl.html
39  *                or write to the Free Software Foundation, Inc., 59
40  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
41  *
42  * Revisions   :
43  *    $Log: parsers.c,v $
44  *    Revision 1.35  2001/10/09 22:39:21  jongfoster
45  *    assert.h is also required under Win32, so moving out of #ifndef _WIN32
46  *    block.
47  *
48  *    Revision 1.34  2001/10/07 18:50:55  oes
49  *    Added server_content_encoding, renamed server_transfer_encoding
50  *
51  *    Revision 1.33  2001/10/07 18:04:49  oes
52  *    Changed server_http11 to server_http and its pattern to "HTTP".
53  *      Additional functionality: it now saves the HTTP status into
54  *      csp->http->status and sets CT_TABOO for Status 206 (partial range)
55  *
56  *    Revision 1.32  2001/10/07 15:43:28  oes
57  *    Removed FEATURE_DENY_GZIP and replaced it with client_accept_encoding,
58  *       client_te and client_accept_encoding_adder, triggered by the new
59  *       +no-compression action. For HTTP/1.1 the Accept-Encoding header is
60  *       changed to allow only identity and chunked, and the TE header is
61  *       crunched. For HTTP/1.0, Accept-Encoding is crunched.
62  *
63  *    parse_http_request no longer does anything than parsing. The rewriting
64  *      of http->cmd and version mangling are gone. It now also recognizes
65  *      the put and delete methods and saves the url in http->url. Removed
66  *      unused variable.
67  *
68  *    renamed content_type and content_length to have the server_ prefix
69  *
70  *    server_content_type now only works if csp->content_type != CT_TABOO
71  *
72  *    added server_transfer_encoding, which
73  *      - Sets CT_TABOO to prohibit filtering if encoding compresses
74  *      - Raises the CSP_FLAG_CHUNKED flag if Encoding is "chunked"
75  *      - Change from "chunked" to "identity" if body was chunked
76  *        but has been de-chunked for filtering.
77  *
78  *    added server_content_md5 which crunches any Content-MD5 headers
79  *      if the body was modified.
80  *
81  *    made server_http11 conditional on +downgrade action
82  *
83  *    Replaced 6 boolean members of csp with one bitmap (csp->flags)
84  *
85  *    Revision 1.31  2001/10/05 14:25:02  oes
86  *    Crumble Keep-Alive from Server
87  *
88  *    Revision 1.30  2001/09/29 12:56:03  joergs
89  *    IJB now changes HTTP/1.1 to HTTP/1.0 in requests and answers.
90  *
91  *    Revision 1.29  2001/09/24 21:09:24  jongfoster
92  *    Fixing 2 memory leaks that Guy spotted, where the paramater to
93  *    enlist() was not being free()d.
94  *
95  *    Revision 1.28  2001/09/22 16:32:28  jongfoster
96  *    Removing unused #includes.
97  *
98  *    Revision 1.27  2001/09/20 15:45:25  steudten
99  *
100  *    add casting from size_t to int for printf()
101  *    remove local variable shadow s2
102  *
103  *    Revision 1.26  2001/09/16 17:05:14  jongfoster
104  *    Removing unused #include showarg.h
105  *
106  *    Revision 1.25  2001/09/16 13:21:27  jongfoster
107  *    Changes to use new list functions.
108  *
109  *    Revision 1.24  2001/09/13 23:05:50  jongfoster
110  *    Changing the string paramater to the header parsers a "const".
111  *
112  *    Revision 1.23  2001/09/12 18:08:19  steudten
113  *
114  *    In parse_http_request() header rewriting miss the host value, so
115  *    from http://www.mydomain.com the result was just " / " not
116  *    http://www.mydomain.com/ in case we forward.
117  *
118  *    Revision 1.22  2001/09/10 10:58:53  oes
119  *    Silenced compiler warnings
120  *
121  *    Revision 1.21  2001/07/31 14:46:00  oes
122  *     - Persistant connections now suppressed
123  *     - sed() no longer appends empty header to csp->headers
124  *
125  *    Revision 1.20  2001/07/30 22:08:36  jongfoster
126  *    Tidying up #defines:
127  *    - All feature #defines are now of the form FEATURE_xxx
128  *    - Permanently turned off WIN_GUI_EDIT
129  *    - Permanently turned on WEBDAV and SPLIT_PROXY_ARGS
130  *
131  *    Revision 1.19  2001/07/25 17:21:54  oes
132  *    client_uagent now saves copy of User-Agent: header value
133  *
134  *    Revision 1.18  2001/07/13 14:02:46  oes
135  *     - Included fix to repair broken HTTP requests that
136  *       don't contain a path, not even '/'.
137  *     - Removed all #ifdef PCRS
138  *     - content_type now always inspected and classified as
139  *       text, gif or other.
140  *     - formatting / comments
141  *
142  *    Revision 1.17  2001/06/29 21:45:41  oes
143  *    Indentation, CRLF->LF, Tab-> Space
144  *
145  *    Revision 1.16  2001/06/29 13:32:42  oes
146  *    - Fixed a comment
147  *    - Adapted free_http_request
148  *    - Removed logentry from cancelled commit
149  *
150  *    Revision 1.15  2001/06/03 19:12:38  oes
151  *    deleted const struct interceptors
152  *
153  *    Revision 1.14  2001/06/01 18:49:17  jongfoster
154  *    Replaced "list_share" with "list" - the tiny memory gain was not
155  *    worth the extra complexity.
156  *
157  *    Revision 1.13  2001/05/31 21:30:33  jongfoster
158  *    Removed list code - it's now in list.[ch]
159  *    Renamed "permission" to "action", and changed many features
160  *    to use the actions file rather than the global config.
161  *
162  *    Revision 1.12  2001/05/31 17:33:13  oes
163  *
164  *    CRLF -> LF
165  *
166  *    Revision 1.11  2001/05/29 20:11:19  joergs
167  *    '/ * inside comment' warning removed.
168  *
169  *    Revision 1.10  2001/05/29 09:50:24  jongfoster
170  *    Unified blocklist/imagelist/permissionslist.
171  *    File format is still under discussion, but the internal changes
172  *    are (mostly) done.
173  *
174  *    Also modified interceptor behaviour:
175  *    - We now intercept all URLs beginning with one of the following
176  *      prefixes (and *only* these prefixes):
177  *        * http://i.j.b/
178  *        * http://ijbswa.sf.net/config/
179  *        * http://ijbswa.sourceforge.net/config/
180  *    - New interceptors "home page" - go to http://i.j.b/ to see it.
181  *    - Internal changes so that intercepted and fast redirect pages
182  *      are not replaced with an image.
183  *    - Interceptors now have the option to send a binary page direct
184  *      to the client. (i.e. ijb-send-banner uses this)
185  *    - Implemented show-url-info interceptor.  (Which is why I needed
186  *      the above interceptors changes - a typical URL is
187  *      "http://i.j.b/show-url-info?url=www.somesite.com/banner.gif".
188  *      The previous mechanism would not have intercepted that, and
189  *      if it had been intercepted then it then it would have replaced
190  *      it with an image.)
191  *
192  *    Revision 1.9  2001/05/28 17:26:33  jongfoster
193  *    Fixing segfault if last header was crunched.
194  *    Fixing Windows build (snprintf() is _snprintf() under Win32, but we
195  *    can use the cross-platform sprintf() instead.)
196  *
197  *    Revision 1.8  2001/05/27 22:17:04  oes
198  *
199  *    - re_process_buffer no longer writes the modified buffer
200  *      to the client, which was very ugly. It now returns the
201  *      buffer, which it is then written by chat.
202  *
203  *    - content_length now adjusts the Content-Length: header
204  *      for modified documents rather than crunch()ing it.
205  *      (Length info in csp->content_length, which is 0 for
206  *      unmodified documents)
207  *
208  *    - For this to work, sed() is called twice when filtering.
209  *
210  *    Revision 1.7  2001/05/27 13:19:06  oes
211  *    Patched Joergs solution for the content-length in.
212  *
213  *    Revision 1.6  2001/05/26 13:39:32  jongfoster
214  *    Only crunches Content-Length header if applying RE filtering.
215  *    Without this fix, Microsoft Windows Update wouldn't work.
216  *
217  *    Revision 1.5  2001/05/26 00:28:36  jongfoster
218  *    Automatic reloading of config file.
219  *    Removed obsolete SIGHUP support (Unix) and Reload menu option (Win32).
220  *    Most of the global variables have been moved to a new
221  *    struct configuration_spec, accessed through csp->config->globalname
222  *    Most of the globals remaining are used by the Win32 GUI.
223  *
224  *    Revision 1.4  2001/05/22 18:46:04  oes
225  *
226  *    - Enabled filtering banners by size rather than URL
227  *      by adding patterns that replace all standard banner
228  *      sizes with the "Junkbuster" gif to the re_filterfile
229  *
230  *    - Enabled filtering WebBugs by providing a pattern
231  *      which kills all 1x1 images
232  *
233  *    - Added support for PCRE_UNGREEDY behaviour to pcrs,
234  *      which is selected by the (nonstandard and therefore
235  *      capital) letter 'U' in the option string.
236  *      It causes the quantifiers to be ungreedy by default.
237  *      Appending a ? turns back to greedy (!).
238  *
239  *    - Added a new interceptor ijb-send-banner, which
240  *      sends back the "Junkbuster" gif. Without imagelist or
241  *      MSIE detection support, or if tinygif = 1, or the
242  *      URL isn't recognized as an imageurl, a lame HTML
243  *      explanation is sent instead.
244  *
245  *    - Added new feature, which permits blocking remote
246  *      script redirects and firing back a local redirect
247  *      to the browser.
248  *      The feature is conditionally compiled, i.e. it
249  *      can be disabled with --disable-fast-redirects,
250  *      plus it must be activated by a "fast-redirects"
251  *      line in the config file, has its own log level
252  *      and of course wants to be displayed by show-proxy-args
253  *      Note: Boy, all the #ifdefs in 1001 locations and
254  *      all the fumbling with configure.in and acconfig.h
255  *      were *way* more work than the feature itself :-(
256  *
257  *    - Because a generic redirect template was needed for
258  *      this, tinygif = 3 now uses the same.
259  *
260  *    - Moved GIFs, and other static HTTP response templates
261  *      to project.h
262  *
263  *    - Some minor fixes
264  *
265  *    - Removed some >400 CRs again (Jon, you really worked
266  *      a lot! ;-)
267  *
268  *    Revision 1.3  2001/05/20 01:21:20  jongfoster
269  *    Version 2.9.4 checkin.
270  *    - Merged popupfile and cookiefile, and added control over PCRS
271  *      filtering, in new "permissionsfile".
272  *    - Implemented LOG_LEVEL_FATAL, so that if there is a configuration
273  *      file error you now get a message box (in the Win32 GUI) rather
274  *      than the program exiting with no explanation.
275  *    - Made killpopup use the PCRS MIME-type checking and HTTP-header
276  *      skipping.
277  *    - Removed tabs from "config"
278  *    - Moved duplicated url parsing code in "loaders.c" to a new funcition.
279  *    - Bumped up version number.
280  *
281  *    Revision 1.2  2001/05/17 23:02:36  oes
282  *     - Made referrer option accept 'L' as a substitute for 'ยง'
283  *
284  *    Revision 1.1.1.1  2001/05/15 13:59:01  oes
285  *    Initial import of version 2.9.3 source tree
286  *
287  *
288  *********************************************************************/
289 \f
290
291 #include "config.h"
292
293 #ifndef _WIN32
294 #include <stdio.h>
295 #include <sys/types.h>
296 #include <stdlib.h>
297 #include <ctype.h>
298 #endif
299
300 #include <assert.h>
301 #include <string.h>
302
303 #ifndef _WIN32
304 #include <unistd.h>
305 #endif
306
307 #include "project.h"
308 #include "list.h"
309 #include "parsers.h"
310 #include "encode.h"
311 #include "ssplit.h"
312 #include "errlog.h"
313 #include "jbsockets.h"
314 #include "miscutil.h"
315
316 const char parsers_h_rcs[] = PARSERS_H_VERSION;
317
318 /* Fix a problem with Solaris.  There should be no effect on other
319  * platforms.
320  * Solaris's isspace() is a macro which uses it's argument directly
321  * as an array index.  Therefore we need to make sure that high-bit
322  * characters generate +ve values, and ideally we also want to make
323  * the argument match the declared parameter type of "int".
324  * 
325  * Why did they write a character function that can't take a simple 
326  * "char" argument?  Doh!
327  */
328 #define ijb_isupper(__X) isupper((int)(unsigned char)(__X))
329 #define ijb_tolower(__X) tolower((int)(unsigned char)(__X))
330
331
332 const struct parsers client_patterns[] = {
333    { "referer:",                 8,    client_referrer },
334    { "user-agent:",              11,   client_uagent },
335    { "ua-",                      3,    client_ua },
336    { "from:",                    5,    client_from },
337    { "cookie:",                  7,    client_send_cookie },
338    { "x-forwarded-for:",         16,   client_x_forwarded },
339    { "Accept-Encoding:",         16,   client_accept_encoding },
340    { "TE:",                      3,    client_te },
341 #if defined(FEATURE_IMAGE_DETECT_MSIE)
342    { "Accept:",                   7,   client_accept },
343 #endif /* defined(FEATURE_IMAGE_DETECT_MSIE) */
344    { "Host:",                     5,   crumble },
345 /* { "if-modified-since:",       18,   crumble }, */
346    { "Keep-Alive:",              11,   crumble },
347    { "connection:",              11,   crumble },
348    { "proxy-connection:",        17,   crumble },        
349    { NULL,                       0,    NULL }
350 };
351
352
353 const struct parsers server_patterns[] = {
354    { "HTTP",                4, server_http },
355    { "set-cookie:",        11, server_set_cookie },
356    { "connection:",        11, crumble },
357    { "Content-Type:",      13, server_content_type },
358    { "Content-Length:",    15, server_content_length },
359    { "Content-MD5:",       12, server_content_md5 },
360    { "Content-Encoding:",  17, server_content_encoding },   
361    { "Transfer-Encoding:", 18, server_transfer_coding },
362    { "Keep-Alive:",        11, crumble },
363    { NULL, 0, NULL }
364 };
365
366
367 void (* const add_client_headers[])(struct client_state *) = {
368    client_host_adder,
369    client_cookie_adder,
370    client_x_forwarded_adder,
371    client_xtra_adder,
372    client_accept_encoding_adder,
373    connection_close_adder, 
374    NULL
375 };
376
377
378 void (* const add_server_headers[])(struct client_state *) = {
379    connection_close_adder, 
380    NULL
381 };
382
383
384 /*********************************************************************
385  *
386  * Function    :  flush_socket
387  *
388  * Description :  Write any pending "buffered" content.
389  *
390  * Parameters  :
391  *          1  :  fd = file descriptor of the socket to read
392  *          2  :  csp = Current client state (buffers, headers, etc...)
393  *
394  * Returns     :  On success, the number of bytes written are returned (zero
395  *                indicates nothing was written).  On error, -1 is returned,
396  *                and errno is set appropriately.  If count is zero and the
397  *                file descriptor refers to a regular file, 0 will be
398  *                returned without causing any other effect.  For a special
399  *                file, the results are not portable.
400  *
401  *********************************************************************/
402 int flush_socket(int fd, struct client_state *csp)
403 {
404    struct iob *iob = csp->iob;
405    int n = iob->eod - iob->cur;
406
407    if (n <= 0)
408    {
409       return(0);
410    }
411
412    n = write_socket(fd, iob->cur, n);
413    iob->eod = iob->cur = iob->buf;
414    return(n);
415
416 }
417
418
419 /*********************************************************************
420  *
421  * Function    :  add_to_iob
422  *
423  * Description :  Add content to the buffered page.
424  *
425  * Parameters  :
426  *          1  :  csp = Current client state (buffers, headers, etc...)
427  *          2  :  buf = holds the content to be added to the page
428  *          3  :  n = number of bytes to be added
429  *
430  * Returns     :  Number of bytes in the content buffer.
431  *
432  *********************************************************************/
433 int add_to_iob(struct client_state *csp, char *buf, int n)
434 {
435    struct iob *iob = csp->iob;
436    int have, need;
437    char *p;
438
439    have = iob->eod - iob->cur;
440
441    if (n <= 0)
442    {
443       return(have);
444    }
445
446    need = have + n;
447
448    if ((p = (char *)malloc(need + 1)) == NULL)
449    {
450       log_error(LOG_LEVEL_ERROR, "malloc() iob failed: %E");
451       return(-1);
452    }
453
454    if (have)
455    {
456       /* there is something in the buffer - save it */
457       memcpy(p, iob->cur, have);
458
459       /* replace the buffer with the new space */
460       freez(iob->buf);
461       iob->buf = p;
462
463       /* point to the end of the data */
464       p += have;
465    }
466    else
467    {
468       /* the buffer is empty, free it and reinitialize */
469       freez(iob->buf);
470       iob->buf = p;
471    }
472
473    /* copy the new data into the iob buffer */
474    memcpy(p, buf, n);
475
476    /* point to the end of the data */
477    p += n;
478
479    /* null terminate == cheap insurance */
480    *p = '\0';
481
482    /* set the pointers to the new values */
483    iob->cur = iob->buf;
484    iob->eod = p;
485
486    return(need);
487
488 }
489
490
491 /*********************************************************************
492  *
493  * Function    :  get_header
494  *
495  * Description :  This (odd) routine will parse the csp->iob
496  *
497  * Parameters  :
498  *          1  :  csp = Current client state (buffers, headers, etc...)
499  *
500  * Returns     :  Any one of the following:
501  *
502  * 1) a pointer to a dynamically allocated string that contains a header line
503  * 2) NULL  indicating that the end of the header was reached
504  * 3) ""    indicating that the end of the iob was reached before finding
505  *          a complete header line.
506  *
507  *********************************************************************/
508 char *get_header(struct client_state *csp)
509 {
510    struct iob *iob;
511    char *p, *q, *ret;
512    iob = csp->iob;
513
514    if ((iob->cur == NULL)
515       || ((p = strchr(iob->cur, '\n')) == NULL))
516    {
517       return(""); /* couldn't find a complete header */
518    }
519
520    *p = '\0';
521
522    ret = strdup(iob->cur);
523
524    iob->cur = p+1;
525
526    if ((q = strchr(ret, '\r'))) *q = '\0';
527
528    /* is this a blank linke (i.e. the end of the header) ? */
529    if (*ret == '\0')
530    {
531       freez(ret);
532       return(NULL);
533    }
534
535    return(ret);
536
537 }
538
539
540 /*********************************************************************
541  *
542  * Function    :  sed
543  *
544  * Description :  add, delete or modify lines in the HTTP header streams.
545  *                On entry, it receives a linked list of headers space
546  *                that was allocated dynamically (both the list nodes
547  *                and the header contents).
548  *
549  *                As a side effect it frees the space used by the original
550  *                header lines.
551  *
552  * Parameters  :
553  *          1  :  pats = list of patterns to match against headers
554  *          2  :  more_headers = list of functions to add more
555  *                headers (client or server)
556  *          3  :  csp = Current client state (buffers, headers, etc...)
557  *
558  * Returns     :  Single pointer to a fully formed header.
559  *
560  *********************************************************************/
561 char *sed(const struct parsers pats[], void (* const more_headers[])(struct client_state *), struct client_state *csp)
562 {
563    struct list_entry *p;
564    const struct parsers *v;
565    char *hdr;
566    void (* const *f)();
567
568    for (v = pats; v->str ; v++)
569    {
570       for (p = csp->headers->first; p ; p = p->next)
571       {
572          /* Header crunch()ed in previous run? -> ignore */
573          if (p->str == NULL) continue;
574
575          if (v == pats) log_error(LOG_LEVEL_HEADER, "scan: %s", p->str);
576
577          if (strncmpic(p->str, v->str, v->len) == 0)
578          {
579             hdr = v->parser(v, p->str, csp);
580             freez((char *)p->str); /* FIXME: Yuck! patching a list...*/
581             p->str = hdr;
582          }
583       }
584    }
585
586    /* place any additional headers on the csp->headers list */
587    for (f = more_headers; *f ; f++)
588    {
589       (*f)(csp);
590    }
591
592    hdr = list_to_text(csp->headers);
593
594    return(hdr);
595
596 }
597
598
599 /*********************************************************************
600  *
601  * Function    :  free_http_request
602  *
603  * Description :  Freez a http_request structure
604  *
605  * Parameters  :
606  *          1  :  http = points to a http_request structure to free
607  *
608  * Returns     :  N/A
609  *
610  *********************************************************************/
611 void free_http_request(struct http_request *http)
612 {
613    assert(http);
614
615    freez(http->cmd);
616    freez(http->gpc);
617    freez(http->host);
618    freez(http->url);
619    freez(http->hostport);
620    freez(http->path);
621    freez(http->ver);
622    freez(http->host_ip_addr_str);
623    freez(http->user_agent);
624
625 }
626
627
628 /*********************************************************************
629  *
630  * Function    :  parse_http_request
631  *
632  * Description :  Parse out the host and port from the URL.  Find the
633  *                hostname & path, port (if ':'), and/or password (if '@')
634  *
635  * Parameters  :
636  *          1  :  req = URL (or is it URI?) to break down
637  *          2  :  http = pointer to the http structure to hold elements
638  *          3  :  csp = Current client state (buffers, headers, etc...)
639  *
640  * Returns     :  N/A
641  *
642  *********************************************************************/
643 void parse_http_request(char *req, struct http_request *http, struct client_state *csp)
644 {
645    char *buf, *v[10], *url, *p;
646    int n;
647
648    memset(http, '\0', sizeof(*http));
649    http->cmd = strdup(req);  
650
651    buf = strdup(req);
652    n = ssplit(buf, " \r\n", v, SZ(v), 1, 1);
653
654    if (n == 3)
655    {
656       /* this could be a CONNECT request */
657       if (strcmpic(v[0], "connect") == 0)
658       {
659          http->ssl      = 1;
660          http->gpc      = strdup(v[0]);
661          http->hostport = strdup(v[1]);
662          http->ver      = strdup(v[2]);
663       }
664
665       /* or it could be any other basic HTTP request type */
666       if ((0 == strcmpic(v[0], "get"))
667        || (0 == strcmpic(v[0], "head"))
668        || (0 == strcmpic(v[0], "post"))
669        || (0 == strcmpic(v[0], "put"))
670        || (0 == strcmpic(v[0], "delete"))
671
672        /* or a webDAV extension (RFC2518) */
673        || (0 == strcmpic(v[0], "propfind"))
674        || (0 == strcmpic(v[0], "proppatch"))
675        || (0 == strcmpic(v[0], "move"))
676        || (0 == strcmpic(v[0], "copy"))
677        || (0 == strcmpic(v[0], "mkcol"))
678        || (0 == strcmpic(v[0], "lock"))
679        || (0 == strcmpic(v[0], "unlock"))
680        )
681       {
682          http->ssl    = 0;
683          http->gpc    = strdup(v[0]);
684          http->url    = strdup(v[1]);
685          http->ver    = strdup(v[2]);
686
687          url = v[1];
688          if (strncmpic(url, "http://",  7) == 0)
689          {
690             url += 7;
691          }
692          else if (strncmpic(url, "https://", 8) == 0)
693          {
694             url += 8;
695          }
696          else
697          {
698             url = NULL;
699          }
700
701          if (url)
702          {
703             if ((p = strchr(url, '/')))
704             {
705                http->path = strdup(p);
706                *p = '\0';
707                http->hostport = strdup(url);
708             }
709             /* 
710              * Repair broken HTTP requests that don't contain a path
711              */
712             else
713             {
714                http->path = strdup("/");
715                http->hostport = strdup(url);
716             }
717          }
718       }
719    }
720
721    freez(buf);
722
723
724    if (http->hostport == NULL)
725    {
726       free_http_request(http);
727       return;
728    }
729
730    buf = strdup(http->hostport);
731
732
733    /* check if url contains password */
734    n = ssplit(buf, "@", v, SZ(v), 1, 1);
735    if (n == 2)
736    {
737       char * newbuf = NULL;
738       newbuf = strdup(v[1]);
739       freez(buf);
740       buf = newbuf;
741    }
742
743    n = ssplit(buf, ":", v, SZ(v), 1, 1);
744
745    if (n == 1)
746    {
747       http->host = strdup(v[0]);
748       http->port = 80;
749    }
750
751    if (n == 2)
752    {
753       http->host = strdup(v[0]);
754       http->port = atoi(v[1]);
755    }
756
757    freez(buf);
758
759    if (http->host == NULL)
760    {
761       free_http_request(http);
762    }
763
764    if (http->path == NULL)
765    {
766       http->path = strdup("/");
767    }
768
769 }
770
771
772 /* here begins the family of parser functions that reformat header lines */
773
774
775 /*********************************************************************
776  *
777  * Function    :  crumble
778  *
779  * Description :  This is called if a header matches a pattern to "crunch"
780  *
781  * Parameters  :
782  *          1  :  v = Pointer to parsers structure, which basically holds
783  *                headers (client or server) that we want to "crunch"
784  *          2  :  s = header (from sed) to "crunch"
785  *          3  :  csp = Current client state (buffers, headers, etc...)
786  *
787  * Returns     :  Always NULL.
788  *
789  *********************************************************************/
790 char *crumble(const struct parsers *v, const char *s, struct client_state *csp)
791 {
792    log_error(LOG_LEVEL_HEADER, "crunch!");
793    return(NULL);
794
795 }
796
797
798 /*********************************************************************
799  *
800  * Function    :  server_content_type
801  *
802  * Description :  Set the content-type for filterable types (text/.*,
803  *                javascript and image/gif) unless filtering has been
804  *                forbidden (CT_TABOO) while parsing earlier headers.
805  *
806  * Parameters  :
807  *          1  :  v = ignored
808  *          2  :  s = header string we are "considering"
809  *          3  :  csp = Current client state (buffers, headers, etc...)
810  *
811  * Returns     :  A duplicate string pointer to this header (ie. pass thru)
812  *
813  *********************************************************************/
814 char *server_content_type(const struct parsers *v, const char *s, struct client_state *csp)
815 {
816    if (csp->content_type != CT_TABOO)
817    {
818       if (strstr(s, " text/") || strstr(s, "application/x-javascript"))
819          csp->content_type = CT_TEXT;
820       else if (strstr(s, " image/gif"))
821          csp->content_type = CT_GIF;
822       else
823          csp->content_type = 0;
824    }
825
826    return(strdup(s));
827
828 }
829
830
831 /*********************************************************************
832  *
833  * Function    :  server_transfer_coding
834  *
835  * Description :  - Prohibit filtering (CT_TABOO) if transfer coding compresses
836  *                - Raise the CSP_FLAG_CHUNKED flag if coding is "chunked"
837  *                - Change from "chunked" to "identity" if body was chunked
838  *                  but has been de-chunked for filtering.
839  *
840  * Parameters  :
841  *          1  :  v = ignored
842  *          2  :  s = header string we are "considering"
843  *          3  :  csp = Current client state (buffers, headers, etc...)
844  *
845  * Returns     :  A duplicate string pointer to this header (ie. pass thru)
846  *
847  *********************************************************************/
848 char *server_transfer_coding(const struct parsers *v, const char *s, struct client_state *csp)
849 {
850    /*
851     * Turn off pcrs and gif filtering if body compressed
852     */
853    if (strstr(s, "gzip") || strstr(s, "compress") || strstr(s, "deflate"))
854    {
855       csp->content_type = CT_TABOO;
856    }
857
858    /* 
859     * Raise flag if body chunked
860     */
861    if (strstr(s, "chunked"))
862    {
863       csp->flags |= CSP_FLAG_CHUNKED;
864
865       /*
866        * If the body was modified, it has been 
867        * de-chunked first, so adjust the header:
868        */
869       if (csp->flags & CSP_FLAG_MODIFIED)
870       {
871          return(strdup("Transfer-Encoding: identity"));
872       }
873    }
874
875    return(strdup(s));
876
877 }
878
879
880 /*********************************************************************
881  *
882  * Function    :  server_content_encoding
883  *
884  * Description :  Prohibit filtering (CT_TABOO) if content encoding compresses
885  *
886  * Parameters  :
887  *          1  :  v = ignored
888  *          2  :  s = header string we are "considering"
889  *          3  :  csp = Current client state (buffers, headers, etc...)
890  *
891  * Returns     :  A duplicate string pointer to this header (ie. pass thru)
892  *
893  *********************************************************************/
894 char *server_content_encoding(const struct parsers *v, const char *s, struct client_state *csp)
895 {
896    /*
897     * Turn off pcrs and gif filtering if body compressed
898     */
899    if (strstr(s, "gzip") || strstr(s, "compress") || strstr(s, "deflate"))
900    {
901       csp->content_type = CT_TABOO;
902    }
903
904    return(strdup(s));
905
906 }
907
908
909 /*********************************************************************
910  *
911  * Function    :  server_content_length
912  *
913  * Description :  Adjust Content-Length header if we modified
914  *                the body.
915  *
916  * Parameters  :
917  *          1  :  v = ignored
918  *          2  :  s = header string we are "considering"
919  *          3  :  csp = Current client state (buffers, headers, etc...)
920  *
921  * Returns     :  A duplicate string pointer to this header (ie. pass thru)
922  *
923  *********************************************************************/
924 char *server_content_length(const struct parsers *v, const char *s, struct client_state *csp)
925 {
926    if (csp->content_length != 0) /* Content length has been modified */
927    {
928       char * s2 = (char *) zalloc(100);
929       sprintf(s2, "Content-Length: %d", (int) csp->content_length);
930
931       log_error(LOG_LEVEL_HEADER, "Adjust Content-Length to %d", (int) csp->content_length);
932       return(s2);
933    }
934    else
935    {
936       return(strdup(s));
937    }
938
939 }
940
941
942 /*********************************************************************
943  *
944  * Function    :  server_content_md5
945  *
946  * Description :  Crumble any Content-MD5 headers if the document was
947  *                modified. FIXME: Should we re-compute instead?
948  *
949  * Parameters  :
950  *          1  :  v = ignored
951  *          2  :  s = header string we are "considering"
952  *          3  :  csp = Current client state (buffers, headers, etc...)
953  *
954  * Returns     :  A duplicate string pointer to this header (ie. pass thru)
955  *
956  *********************************************************************/
957 char *server_content_md5(const struct parsers *v, const char *s, struct client_state *csp)
958 {
959    if (csp->flags & CSP_FLAG_MODIFIED)
960    {
961       log_error(LOG_LEVEL_HEADER, "Crunching Content-MD5");
962       return(NULL);
963    }
964    else
965    {
966       return(strdup(s));
967    }
968
969 }
970
971
972 /*********************************************************************
973  *
974  * Function    :  client_accept_encoding
975  *
976  * Description :  Rewrite the client's Accept-Encoding header so that
977  *                if doesn't allow compression, if the action applies.
978  *                Note: For HTTP/1.0 the absence of the header is enough.
979  *
980  * Parameters  :
981  *          1  :  v = ignored
982  *          2  :  s = header string we are "considering"
983  *          3  :  csp = Current client state (buffers, headers, etc...)
984  *
985  * Returns     :  A copy of the client's original or the modified header.
986  *
987  *********************************************************************/
988 char *client_accept_encoding(const struct parsers *v, const char *s, struct client_state *csp)
989 {
990    if ((csp->action->flags & ACTION_NO_COMPRESSION) == 0)
991    {
992       return(strdup(s));
993    }
994    else
995    {
996       log_error(LOG_LEVEL_HEADER, "Supressed offer to compress content");
997
998       if (!strcmpic(csp->http->ver, "HTTP/1.1"))
999       {
1000          return(strdup("Accept-Encoding: identity;q=1.0, *;q=0"));
1001       }
1002       else
1003       {
1004          return(NULL);
1005       }
1006    }
1007
1008 }
1009
1010
1011 /*********************************************************************
1012  *
1013  * Function    :  client_te
1014  *
1015  * Description :  Rewrite the client's TE header so that
1016  *                if doesn't allow compression, if the action applies.
1017  *
1018  * Parameters  :
1019  *          1  :  v = ignored
1020  *          2  :  s = header string we are "considering"
1021  *          3  :  csp = Current client state (buffers, headers, etc...)
1022  *
1023  * Returns     :  A copy of the client's original or the modified header.
1024  *
1025  *********************************************************************/
1026 char *client_te(const struct parsers *v, const char *s, struct client_state *csp)
1027 {
1028    if ((csp->action->flags & ACTION_NO_COMPRESSION) == 0)
1029    {
1030       return(strdup(s));
1031    }
1032    else
1033    {
1034       log_error(LOG_LEVEL_HEADER, "Supressed offer to compress transfer");
1035       return(NULL);
1036    }
1037
1038 }
1039
1040 /*********************************************************************
1041  *
1042  * Function    :  client_referrer
1043  *
1044  * Description :  Handle the "referer" config setting properly.
1045  *                Called from `sed'.
1046  *
1047  * Parameters  :
1048  *          1  :  v = ignored
1049  *          2  :  s = header (from sed) to "crunch"
1050  *          3  :  csp = Current client state (buffers, headers, etc...)
1051  *
1052  * Returns     :  NULL if crunched, or a malloc'ed string with the original
1053  *                or modified header
1054  *
1055  *********************************************************************/
1056 char *client_referrer(const struct parsers *v, const char *s, struct client_state *csp)
1057 {
1058    const char * newval;
1059    char * s2;
1060 #ifdef FEATURE_FORCE_LOAD
1061    /* Since the referrer can include the prefix even
1062     * even if the request itself is non-forced, we must
1063     * clean it unconditionally 
1064     */
1065    strclean(s, FORCE_PREFIX);
1066 #endif /* def FEATURE_FORCE_LOAD */
1067
1068 #ifdef FEATURE_TRUST
1069    csp->referrer = strdup(s);
1070 #endif /* def FEATURE_TRUST */
1071
1072    /*
1073     * Are we sending referer?
1074     */
1075    if ((csp->action->flags & ACTION_HIDE_REFERER) == 0)
1076    {
1077       return(strdup(s));
1078    }
1079
1080    newval = csp->action->string[ACTION_STRING_REFERER];
1081
1082    /*
1083     * Are we blocking referer?
1084     */
1085    if ((newval == NULL) || (0 == strcmpic(newval, "block")) )
1086    {
1087       log_error(LOG_LEVEL_HEADER, "crunch!");
1088       return(NULL);
1089    }
1090
1091    /*
1092     * Are we forging referer?
1093     */
1094    if (0 == strcmpic(newval, "forge"))
1095    {
1096       /*
1097        * Forge a referer as http://[hostname:port of REQUEST]/
1098        * to fool stupid checks for in-site links
1099        */
1100       log_error(LOG_LEVEL_HEADER, "crunch+forge!");
1101       s2 = strsav(NULL, "Referer: ");
1102       s2 = strsav(s2, "http://");
1103       s2 = strsav(s2, csp->http->hostport);
1104       s2 = strsav(s2, "/");
1105       return(s2);
1106    }
1107
1108    /*
1109     * Have we got a fixed referer?
1110     */
1111    if (0 == strncmpic(newval, "http://", 7))
1112    {
1113       /*
1114        * We have a specific (fixed) referer we want to send.
1115        */
1116       char * s3;
1117
1118       log_error(LOG_LEVEL_HEADER, "modified");
1119
1120       s3 = strsav( NULL, "Referer: " );
1121       s3 = strsav( s3, newval );
1122       return(s3);
1123    }
1124
1125    /* Should never get here! */
1126    log_error(LOG_LEVEL_ERROR, "Bad parameter: +referer{%s}", newval);
1127
1128    /*
1129     * Forge is probably the best default.
1130     *
1131     * Forge a referer as http://[hostname:port of REQUEST]/
1132     * to fool stupid checks for in-site links
1133     */
1134    log_error(LOG_LEVEL_HEADER, "crunch+forge!");
1135    s2 = strsav(NULL, "Referer: ");
1136    s2 = strsav(s2, "http://");
1137    s2 = strsav(s2, csp->http->hostport);
1138    s2 = strsav(s2, "/");
1139    return(s2);
1140 }
1141
1142
1143 /*********************************************************************
1144  *
1145  * Function    :  client_uagent
1146  *
1147  * Description :  Handle the "user-agent" config setting properly
1148  *                and remember its original value to enable browser
1149  *                bug workarounds. Called from `sed'.
1150  *
1151  * Parameters  :
1152  *          1  :  v = ignored
1153  *          2  :  s = header (from sed) to "crunch"
1154  *          3  :  csp = Current client state (buffers, headers, etc...)
1155  *
1156  * Returns     :  A malloc'ed pointer to the default agent, or
1157  *                a malloc'ed string pointer to this header (ie. pass thru).
1158  *
1159  *********************************************************************/
1160 char *client_uagent(const struct parsers *v, const char *s, struct client_state *csp)
1161 {
1162    const char * newval;
1163    char * s2;
1164
1165    /* Save the client's User-Agent: value */
1166    if (strlen(s) >= 12)
1167    {
1168       csp->http->user_agent = strdup(s + 12);
1169    }
1170
1171 #ifdef FEATURE_IMAGE_DETECT_MSIE
1172    if (strstr (s, "MSIE "))
1173    {
1174       /* This is Microsoft Internet Explorer.
1175        * Enable auto-detect.
1176        */
1177       csp->accept_types |= ACCEPT_TYPE_IS_MSIE;
1178    }
1179 #endif /* def FEATURE_IMAGE_DETECT_MSIE */
1180
1181    if ((csp->action->flags & ACTION_HIDE_USER_AGENT) == 0)
1182    {
1183       return(strdup(s));
1184    }
1185
1186    newval = csp->action->string[ACTION_STRING_USER_AGENT];
1187    if (newval == NULL)
1188    {
1189       return(strdup(s));
1190    }
1191
1192    log_error(LOG_LEVEL_HEADER, "modified");
1193
1194    s2 = strsav( NULL, "User-Agent: " );
1195    s2 = strsav( s2, newval );
1196    return(s2);
1197
1198 }
1199
1200
1201 /*********************************************************************
1202  *
1203  * Function    :  client_ua
1204  *
1205  * Description :  Handle "ua-" headers properly.  Called from `sed'.
1206  *
1207  * Parameters  :
1208  *          1  :  v = ignored
1209  *          2  :  s = header (from sed) to "crunch"
1210  *          3  :  csp = Current client state (buffers, headers, etc...)
1211  *
1212  * Returns     :  NULL if crunched, or a malloc'ed string to original header
1213  *
1214  *********************************************************************/
1215 char *client_ua(const struct parsers *v, const char *s, struct client_state *csp)
1216 {
1217    if ((csp->action->flags & ACTION_HIDE_USER_AGENT) == 0)
1218    {
1219       return(strdup(s));
1220    }
1221    else
1222    {
1223       log_error(LOG_LEVEL_HEADER, "crunch!");
1224       return(NULL);
1225    }
1226 }
1227
1228
1229 /*********************************************************************
1230  *
1231  * Function    :  client_from
1232  *
1233  * Description :  Handle the "from" config setting properly.
1234  *                Called from `sed'.
1235  *
1236  * Parameters  :
1237  *          1  :  v = ignored
1238  *          2  :  s = header (from sed) to "crunch"
1239  *          3  :  csp = Current client state (buffers, headers, etc...)
1240  *
1241  * Returns     :  NULL if crunched, or a malloc'ed string to
1242  *                modified/original header.
1243  *
1244  *********************************************************************/
1245 char *client_from(const struct parsers *v, const char *s, struct client_state *csp)
1246 {
1247    const char * newval;
1248    char * s2;
1249
1250    if ((csp->action->flags & ACTION_HIDE_FROM) == 0)
1251    {
1252       return(strdup(s));
1253    }
1254
1255    newval = csp->action->string[ACTION_STRING_FROM];
1256
1257    /*
1258     * Are we blocking referer?
1259     */
1260    if ((newval == NULL) || (0 == strcmpic(newval, "block")) )
1261    {
1262       log_error(LOG_LEVEL_HEADER, "crunch!");
1263       return(NULL);
1264    }
1265
1266    log_error(LOG_LEVEL_HEADER, " modified");
1267
1268    s2 = strsav( NULL, "From: " );
1269    s2 = strsav( s2, newval );
1270    return(s2);
1271
1272 }
1273
1274
1275 /*********************************************************************
1276  *
1277  * Function    :  client_send_cookie
1278  *
1279  * Description :  Handle the "cookie" header properly.  Called from `sed'.
1280  *                If cookie is accepted, add it to the cookie_list,
1281  *                else we crunch it.  Mmmmmmmmmmm ... cookie ......
1282  *
1283  * Parameters  :
1284  *          1  :  v = pattern of cookie `sed' found matching
1285  *          2  :  s = header (from sed) to "crunch"
1286  *          3  :  csp = Current client state (buffers, headers, etc...)
1287  *
1288  * Returns     :  Always NULL.
1289  *
1290  *********************************************************************/
1291 char *client_send_cookie(const struct parsers *v, const char *s, struct client_state *csp)
1292 {
1293    if ((csp->action->flags & ACTION_NO_COOKIE_READ) == 0)
1294    {
1295       enlist(csp->cookie_list, s + v->len + 1);
1296    }
1297    else
1298    {
1299       log_error(LOG_LEVEL_HEADER, " crunch!");
1300    }
1301
1302    /*
1303     * Always return NULL here.  The cookie header
1304     * will be sent at the end of the header.
1305     */
1306    return(NULL);
1307
1308 }
1309
1310
1311 /*********************************************************************
1312  *
1313  * Function    :  client_x_forwarded
1314  *
1315  * Description :  Handle the "x-forwarded-for" config setting properly,
1316  *                also used in the add_client_headers list.  Called from `sed'.
1317  *
1318  * Parameters  :
1319  *          1  :  v = ignored
1320  *          2  :  s = header (from sed) to "crunch"
1321  *          3  :  csp = Current client state (buffers, headers, etc...)
1322  *
1323  * Returns     :  Always NULL.
1324  *
1325  *********************************************************************/
1326 char *client_x_forwarded(const struct parsers *v, const char *s, struct client_state *csp)
1327 {
1328    if ((csp->action->flags & ACTION_HIDE_FORWARDED) == 0)
1329    {
1330       /* Save it so we can re-add it later */
1331       csp->x_forwarded = strdup(s);
1332    }
1333
1334    /*
1335     * Always return NULL, since this information
1336     * will be sent at the end of the header.
1337     */
1338
1339    return(NULL);
1340
1341 }
1342
1343 #if defined(FEATURE_IMAGE_DETECT_MSIE)
1344 /*********************************************************************
1345  *
1346  * Function    :  client_accept
1347  *
1348  * Description :  Detect whether the client wants HTML or an image.
1349  *                Clients do not always make this information available
1350  *                in a sane way.  Always passes the header through
1351  *                the proxy unchanged.
1352  *
1353  * Parameters  :
1354  *          1  :  v = Ignored.
1355  *          2  :  s = Header string.  Null terminated.
1356  *          3  :  csp = Current client state (buffers, headers, etc...)
1357  *
1358  * Returns     :  Duplicate of argument s.
1359  *
1360  *********************************************************************/
1361 char *client_accept(const struct parsers *v, const char *s, struct client_state *csp)
1362 {
1363 #ifdef FEATURE_IMAGE_DETECT_MSIE
1364    if (strstr (s, "image/gif"))
1365    {
1366       /* Client will accept HTML.  If this seems counterintuitive,
1367        * blame Microsoft. 
1368        */
1369       csp->accept_types |= ACCEPT_TYPE_MSIE_HTML;
1370    }
1371    else
1372    {
1373       csp->accept_types |= ACCEPT_TYPE_MSIE_IMAGE;
1374    }
1375 #endif /* def FEATURE_IMAGE_DETECT_MSIE */
1376
1377    return(strdup(s));
1378
1379 }
1380 #endif /* defined(FEATURE_IMAGE_DETECT_MSIE) */
1381
1382
1383
1384 /* the following functions add headers directly to the header list */
1385
1386
1387 /*********************************************************************
1388  *
1389  * Function    :  client_host_adder
1390  *
1391  * Description :  (re)adds the host header. Called from `sed'.
1392  *
1393  * Parameters  :
1394  *          1  :  csp = Current client state (buffers, headers, etc...)
1395  *
1396  * Returns     :  N/A
1397  *
1398  *********************************************************************/
1399 void client_host_adder(struct client_state *csp)
1400 {
1401    char *p = NULL;
1402
1403    p = strsav(p, "Host: ");
1404    p = strsav(p, csp->http->hostport);
1405
1406    log_error(LOG_LEVEL_HEADER, "addh: %s", p);
1407    enlist(csp->headers, p);
1408
1409    freez(p);
1410 }
1411
1412
1413 /*********************************************************************
1414  *
1415  * Function    :  client_cookie_adder
1416  *
1417  * Description :  Used in the add_client_headers list.  Called from `sed'.
1418  *
1419  * Parameters  :
1420  *          1  :  csp = Current client state (buffers, headers, etc...)
1421  *
1422  * Returns     :  N/A
1423  *
1424  *********************************************************************/
1425 void client_cookie_adder(struct client_state *csp)
1426 {
1427    struct list_entry *lst;
1428    char *tmp = NULL;
1429    char *e;
1430
1431    for (lst = csp->cookie_list->first; lst ; lst = lst->next)
1432    {
1433       if (tmp)
1434       {
1435          tmp = strsav(tmp, "; ");
1436       }
1437       tmp = strsav(tmp, lst->str);
1438    }
1439
1440    for (lst = csp->action->multi[ACTION_MULTI_WAFER]->first;  lst ; lst = lst->next)
1441    {
1442       if (tmp)
1443       {
1444          tmp = strsav(tmp, "; ");
1445       }
1446
1447       if ((e = cookie_encode(lst->str)))
1448       {
1449          tmp = strsav(tmp, e);
1450          freez(e);
1451       }
1452    }
1453
1454    if (tmp)
1455    {
1456       char *ret;
1457
1458       ret = strdup("Cookie: ");
1459       ret = strsav(ret, tmp);
1460       log_error(LOG_LEVEL_HEADER, "addh: %s", ret);
1461       enlist(csp->headers, ret);
1462       freez(tmp);
1463       freez(ret);
1464    }
1465
1466 }
1467
1468
1469 /*********************************************************************
1470  *
1471  * Function    :  client_accept_encoding_adder
1472  *
1473  * Description :  Add an Accept-Encoding header to the client's request
1474  *                that disables compression if the action applies, and
1475  *                the header is not already there. Called from `sed'.
1476  *                Note: For HTTP/1.0, the absence of the header is enough.
1477  *
1478  * Parameters  :
1479  *          1  :  csp = Current client state (buffers, headers, etc...)
1480  *
1481  * Returns     :  N/A
1482  *
1483  *********************************************************************/
1484 void client_accept_encoding_adder(struct client_state *csp)
1485 {
1486    if (   ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
1487        && (!strcmpic(csp->http->ver, "HTTP/1.1")) )
1488    {
1489       enlist_unique(csp->headers, "Accept-Encoding: identity;q=1.0, *;q=0", 16);
1490    }
1491
1492 }
1493
1494
1495 /*********************************************************************
1496  *
1497  * Function    :  client_xtra_adder
1498  *
1499  * Description :  Used in the add_client_headers list.  Called from `sed'.
1500  *
1501  * Parameters  :
1502  *          1  :  csp = Current client state (buffers, headers, etc...)
1503  *
1504  * Returns     :  N/A
1505  *
1506  *********************************************************************/
1507 void client_xtra_adder(struct client_state *csp)
1508 {
1509    struct list_entry *lst;
1510
1511    for (lst = csp->action->multi[ACTION_MULTI_ADD_HEADER]->first;
1512         lst ; lst = lst->next)
1513    {
1514       log_error(LOG_LEVEL_HEADER, "addh: %s", lst->str);
1515       enlist(csp->headers, lst->str);
1516    }
1517
1518 }
1519
1520
1521 /*********************************************************************
1522  *
1523  * Function    :  client_x_forwarded_adder
1524  *
1525  * Description :  Used in the add_client_headers list.  Called from `sed'.
1526  *
1527  * Parameters  :
1528  *          1  :  csp = Current client state (buffers, headers, etc...)
1529  *
1530  * Returns     :  N/A
1531  *
1532  *********************************************************************/
1533 void client_x_forwarded_adder(struct client_state *csp)
1534 {
1535    char *p = NULL;
1536
1537    if ((csp->action->flags & ACTION_HIDE_FORWARDED) != 0)
1538    {
1539       return;
1540    }
1541
1542    if (csp->x_forwarded)
1543    {
1544       p = strsav(p, csp->x_forwarded);
1545       p = strsav(p, ", ");
1546       p = strsav(p, csp->ip_addr_str);
1547    }
1548    else
1549    {
1550       p = strsav(p, "X-Forwarded-For: ");
1551       p = strsav(p, csp->ip_addr_str);
1552    }
1553
1554    log_error(LOG_LEVEL_HEADER, "addh: %s", p);
1555    enlist(csp->headers, p);
1556
1557    freez(p);
1558 }
1559
1560
1561 /*********************************************************************
1562  *
1563  * Function    :  connection_close_adder
1564  *
1565  * Description :  Adds a "Connection: close" header to csp->headers
1566  *                as a temporary fix for the needed but missing HTTP/1.1
1567  *                support. Called from `sed'.
1568  *                FIXME: This whole function shouldn't be neccessary!
1569  *
1570  * Parameters  :
1571  *          1  :  csp = Current client state (buffers, headers, etc...)
1572  *
1573  * Returns     :  N/A
1574  *
1575  *********************************************************************/
1576 void connection_close_adder(struct client_state *csp)
1577 {
1578    enlist(csp->headers, "Connection: close");
1579 }
1580
1581
1582 /*********************************************************************
1583  *
1584  * Function    :  server_http
1585  *
1586  * Description :  - Save the HTTP Status into csp->http->status
1587  *                - Set CT_TABOO to prevent filtering if the answer
1588  *                  is a partial range (HTTP status 206)
1589  *                - Rewrite HTTP/1.1 answers to HTTP/1.0 if +downgrade
1590  *                  action applies.
1591  *
1592  * Parameters  :
1593  *          1  :  v = parser pattern that matched this header
1594  *          2  :  s = header that matched this pattern
1595  *          3  :  csp = Current client state (buffers, headers, etc...)
1596  *
1597  * Returns     :  Copy of changed  or original answer.
1598  *
1599  *********************************************************************/
1600 char *server_http(const struct parsers *v, const char *s, struct client_state *csp)
1601 {
1602    char *ret = strdup(s);
1603    
1604    sscanf(ret, "HTTP/%*d.%*d %d", &(csp->http->status));
1605    if (csp->http->status == 206)
1606    {
1607       csp->content_type = CT_TABOO;
1608    }
1609
1610    if ((csp->action->flags & ACTION_DOWNGRADE) != 0)
1611    {
1612       ret[7] = '0';
1613       log_error(LOG_LEVEL_HEADER, "Downgraded answer to HTTP/1.0");
1614    }
1615    return(ret);
1616
1617 }
1618
1619
1620 /*********************************************************************
1621  *
1622  * Function    :  server_set_cookie
1623  *
1624  * Description :  Handle the server "cookie" header properly.
1625  *                Log cookie to the jar file.  Then "crunch" it,
1626  *                or accept it.  Called from `sed'.
1627  *
1628  * Parameters  :
1629  *          1  :  v = parser pattern that matched this header
1630  *          2  :  s = header that matched this pattern
1631  *          3  :  csp = Current client state (buffers, headers, etc...)
1632  *
1633  * Returns     :  `crumble' or a newly malloc'ed string.
1634  *
1635  *********************************************************************/
1636 char *server_set_cookie(const struct parsers *v, const char *s, struct client_state *csp)
1637 {
1638 #ifdef FEATURE_COOKIE_JAR
1639    if (csp->config->jar)
1640    {
1641       fprintf(csp->config->jar, "%s\t%s\n", csp->http->host, (s + v->len + 1));
1642    }
1643 #endif /* def FEATURE_COOKIE_JAR */
1644
1645    if ((csp->action->flags & ACTION_NO_COOKIE_SET) != 0)
1646    {
1647       return(crumble(v, s, csp));
1648    }
1649
1650    return(strdup(s));
1651
1652 }
1653
1654
1655 #ifdef FEATURE_FORCE_LOAD 
1656 /*********************************************************************
1657  *
1658  * Function    :  strclean
1659  *
1660  * Description :  In-Situ-Eliminate all occurances of substring in 
1661  *                string
1662  *
1663  * Parameters  :
1664  *          1  :  string = string to clean
1665  *          2  :  substring = substring to eliminate
1666  *
1667  * Returns     :  Number of eliminations
1668  *
1669  *********************************************************************/
1670 int strclean(const char *string, const char *substring)
1671 {
1672    int hits = 0, len = strlen(substring);
1673    char *pos, *p;
1674
1675    while((pos = strstr(string, substring)))
1676    {
1677       p = pos + len;
1678       do
1679       {
1680          *(p - len) = *p; 
1681       }
1682       while (*p++ != '\0');
1683
1684       hits++;
1685    }
1686
1687    return(hits);
1688 }
1689 #endif /* def FEATURE_FORCE_LOAD */
1690
1691
1692 /*
1693   Local Variables:
1694   tab-width: 3
1695   end:
1696 */