The host parameter to connect_to() is now const.
[privoxy.git] / parsers.c
1 const char parsers_rcs[] = "$Id: parsers.c,v 1.15 2001/06/03 11:03:48 oes 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.15  2001/06/03 11:03:48  oes
45  *    Makefile/in
46  *
47  *    introduced cgi.c
48  *
49  *    actions.c:
50  *
51  *    adapted to new enlist_unique arg format
52  *
53  *    conf loadcfg.c
54  *
55  *    introduced confdir option
56  *
57  *    filters.c filtrers.h
58  *
59  *     extracted-CGI relevant stuff
60  *
61  *    jbsockets.c
62  *
63  *     filled comment
64  *
65  *    jcc.c
66  *
67  *     support for new cgi mechansim
68  *
69  *    list.c list.h
70  *
71  *    functions for new list type: "map"
72  *    extended enlist_unique
73  *
74  *    miscutil.c .h
75  *    introduced bindup()
76  *
77  *    parsers.c parsers.h
78  *
79  *    deleted const struct interceptors
80  *
81  *    pcrs.c
82  *    added FIXME
83  *
84  *    project.h
85  *
86  *    added struct map
87  *    added struct http_response
88  *    changes struct interceptors to struct cgi_dispatcher
89  *    moved HTML stuff to cgi.h
90  *
91  *    re_filterfile:
92  *
93  *    changed
94  *
95  *    showargs.c
96  *    NO TIME LEFT
97  *
98  *    Revision 1.14  2001/06/01 18:49:17  jongfoster
99  *    Replaced "list_share" with "list" - the tiny memory gain was not
100  *    worth the extra complexity.
101  *
102  *    Revision 1.13  2001/05/31 21:30:33  jongfoster
103  *    Removed list code - it's now in list.[ch]
104  *    Renamed "permission" to "action", and changed many features
105  *    to use the actions file rather than the global config.
106  *
107  *    Revision 1.12  2001/05/31 17:33:13  oes
108  *
109  *    CRLF -> LF
110  *
111  *    Revision 1.11  2001/05/29 20:11:19  joergs
112  *    '/* inside comment' warning removed.
113  *
114  *    Revision 1.10  2001/05/29 09:50:24  jongfoster
115  *    Unified blocklist/imagelist/permissionslist.
116  *    File format is still under discussion, but the internal changes
117  *    are (mostly) done.
118  *
119  *    Also modified interceptor behaviour:
120  *    - We now intercept all URLs beginning with one of the following
121  *      prefixes (and *only* these prefixes):
122  *        * http://i.j.b/
123  *        * http://ijbswa.sf.net/config/
124  *        * http://ijbswa.sourceforge.net/config/
125  *    - New interceptors "home page" - go to http://i.j.b/ to see it.
126  *    - Internal changes so that intercepted and fast redirect pages
127  *      are not replaced with an image.
128  *    - Interceptors now have the option to send a binary page direct
129  *      to the client. (i.e. ijb-send-banner uses this)
130  *    - Implemented show-url-info interceptor.  (Which is why I needed
131  *      the above interceptors changes - a typical URL is
132  *      "http://i.j.b/show-url-info?url=www.somesite.com/banner.gif".
133  *      The previous mechanism would not have intercepted that, and
134  *      if it had been intercepted then it then it would have replaced
135  *      it with an image.)
136  *
137  *    Revision 1.9  2001/05/28 17:26:33  jongfoster
138  *    Fixing segfault if last header was crunched.
139  *    Fixing Windows build (snprintf() is _snprintf() under Win32, but we
140  *    can use the cross-platform sprintf() instead.)
141  *
142  *    Revision 1.8  2001/05/27 22:17:04  oes
143  *
144  *    - re_process_buffer no longer writes the modified buffer
145  *      to the client, which was very ugly. It now returns the
146  *      buffer, which it is then written by chat.
147  *
148  *    - content_length now adjusts the Content-Length: header
149  *      for modified documents rather than crunch()ing it.
150  *      (Length info in csp->content_length, which is 0 for
151  *      unmodified documents)
152  *
153  *    - For this to work, sed() is called twice when filtering.
154  *
155  *    Revision 1.7  2001/05/27 13:19:06  oes
156  *    Patched Joergs solution for the content-length in.
157  *
158  *    Revision 1.6  2001/05/26 13:39:32  jongfoster
159  *    Only crunches Content-Length header if applying RE filtering.
160  *    Without this fix, Microsoft Windows Update wouldn't work.
161  *
162  *    Revision 1.5  2001/05/26 00:28:36  jongfoster
163  *    Automatic reloading of config file.
164  *    Removed obsolete SIGHUP support (Unix) and Reload menu option (Win32).
165  *    Most of the global variables have been moved to a new
166  *    struct configuration_spec, accessed through csp->config->globalname
167  *    Most of the globals remaining are used by the Win32 GUI.
168  *
169  *    Revision 1.4  2001/05/22 18:46:04  oes
170  *
171  *    - Enabled filtering banners by size rather than URL
172  *      by adding patterns that replace all standard banner
173  *      sizes with the "Junkbuster" gif to the re_filterfile
174  *
175  *    - Enabled filtering WebBugs by providing a pattern
176  *      which kills all 1x1 images
177  *
178  *    - Added support for PCRE_UNGREEDY behaviour to pcrs,
179  *      which is selected by the (nonstandard and therefore
180  *      capital) letter 'U' in the option string.
181  *      It causes the quantifiers to be ungreedy by default.
182  *      Appending a ? turns back to greedy (!).
183  *
184  *    - Added a new interceptor ijb-send-banner, which
185  *      sends back the "Junkbuster" gif. Without imagelist or
186  *      MSIE detection support, or if tinygif = 1, or the
187  *      URL isn't recognized as an imageurl, a lame HTML
188  *      explanation is sent instead.
189  *
190  *    - Added new feature, which permits blocking remote
191  *      script redirects and firing back a local redirect
192  *      to the browser.
193  *      The feature is conditionally compiled, i.e. it
194  *      can be disabled with --disable-fast-redirects,
195  *      plus it must be activated by a "fast-redirects"
196  *      line in the config file, has its own log level
197  *      and of course wants to be displayed by show-proxy-args
198  *      Note: Boy, all the #ifdefs in 1001 locations and
199  *      all the fumbling with configure.in and acconfig.h
200  *      were *way* more work than the feature itself :-(
201  *
202  *    - Because a generic redirect template was needed for
203  *      this, tinygif = 3 now uses the same.
204  *
205  *    - Moved GIFs, and other static HTTP response templates
206  *      to project.h
207  *
208  *    - Some minor fixes
209  *
210  *    - Removed some >400 CRs again (Jon, you really worked
211  *      a lot! ;-)
212  *
213  *    Revision 1.3  2001/05/20 01:21:20  jongfoster
214  *    Version 2.9.4 checkin.
215  *    - Merged popupfile and cookiefile, and added control over PCRS
216  *      filtering, in new "permissionsfile".
217  *    - Implemented LOG_LEVEL_FATAL, so that if there is a configuration
218  *      file error you now get a message box (in the Win32 GUI) rather
219  *      than the program exiting with no explanation.
220  *    - Made killpopup use the PCRS MIME-type checking and HTTP-header
221  *      skipping.
222  *    - Removed tabs from "config"
223  *    - Moved duplicated url parsing code in "loaders.c" to a new funcition.
224  *    - Bumped up version number.
225  *
226  *    Revision 1.2  2001/05/17 23:02:36  oes
227  *     - Made referrer option accept 'L' as a substitute for 'ยง'
228  *
229  *    Revision 1.1.1.1  2001/05/15 13:59:01  oes
230  *    Initial import of version 2.9.3 source tree
231  *
232  *
233  *********************************************************************/
234 \f
235
236 #include "config.h"
237
238 #include <stdio.h>
239 #include <sys/types.h>
240 #include <stdlib.h>
241 #include <ctype.h>
242 #include <string.h>
243
244 #ifndef _WIN32
245 #include <unistd.h>
246 #endif
247
248 #include "project.h"
249 #include "list.h"
250 #include "parsers.h"
251 #include "encode.h"
252 #include "filters.h"
253 #include "loaders.h"
254 #include "showargs.h"
255 #include "jcc.h"
256 #include "ssplit.h"
257 #include "errlog.h"
258 #include "jbsockets.h"
259 #include "miscutil.h"
260 #include "cgi.h"
261
262 const char parsers_h_rcs[] = PARSERS_H_VERSION;
263
264 /* Fix a problem with Solaris.  There should be no effect on other
265  * platforms.
266  * Solaris's isspace() is a macro which uses it's argument directly
267  * as an array index.  Therefore we need to make sure that high-bit
268  * characters generate +ve values, and ideally we also want to make
269  * the argument match the declared parameter type of "int".
270  * 
271  * Why did they write a character function that can't take a simple 
272  * "char" argument?  Doh!
273  */
274 #define ijb_isupper(__X) isupper((int)(unsigned char)(__X))
275 #define ijb_tolower(__X) tolower((int)(unsigned char)(__X))
276
277
278 const struct parsers client_patterns[] = {
279    { "referer:",                 8,    client_referrer },
280    { "user-agent:",              11,   client_uagent },
281    { "ua-",                      3,    client_ua },
282    { "from:",                    5,    client_from },
283    { "cookie:",                  7,    client_send_cookie },
284    { "x-forwarded-for:",         16,   client_x_forwarded },
285    { "proxy-connection:",        17,   crumble },
286 #ifdef DENY_GZIP
287    { "Accept-Encoding: gzip",    21,   crumble },
288 #endif /* def DENY_GZIP */
289 #if defined(DETECT_MSIE_IMAGES)
290    { "Accept:",                   7,   client_accept },
291 #endif /* defined(DETECT_MSIE_IMAGES) */
292 #ifdef FORCE_LOAD
293    { "Host:",                     5,   client_host },
294 #endif /* def FORCE_LOAD */
295 /* { "if-modified-since:",       18,   crumble }, */
296    { NULL,                       0,    NULL }
297 };
298
299
300 const struct parsers server_patterns[] = {
301    { "set-cookie:",        11, server_set_cookie },
302    { "connection:",        11, crumble },
303 #if defined(PCRS) || defined(KILLPOPUPS)
304    { "Content-Type:",      13, content_type },
305 #endif /* defined(PCRS) || defined(KILLPOPUPS) */
306 #ifdef PCRS
307    { "Content-Length:",    15, content_length },
308 #endif /* def PCRS */
309    { NULL, 0, NULL }
310 };
311
312
313 void (* const add_client_headers[])(struct client_state *) = {
314    client_cookie_adder,
315    client_x_forwarded_adder,
316    client_xtra_adder,
317    NULL
318 };
319
320
321 void (* const add_server_headers[])(struct client_state *) = {
322    NULL
323 };
324
325
326 /*********************************************************************
327  *
328  * Function    :  flush_socket
329  *
330  * Description :  Write any pending "buffered" content.
331  *
332  * Parameters  :
333  *          1  :  fd = file descriptor of the socket to read
334  *          2  :  csp = Current client state (buffers, headers, etc...)
335  *
336  * Returns     :  On success, the number of bytes written are returned (zero
337  *                indicates nothing was written).  On error, -1 is returned,
338  *                and errno is set appropriately.  If count is zero and the
339  *                file descriptor refers to a regular file, 0 will be
340  *                returned without causing any other effect.  For a special
341  *                file, the results are not portable.
342  *
343  *********************************************************************/
344 int flush_socket(int fd, struct client_state *csp)
345 {
346    struct iob *iob = csp->iob;
347    int n = iob->eod - iob->cur;
348
349    if (n <= 0)
350    {
351       return(0);
352    }
353
354    n = write_socket(fd, iob->cur, n);
355    iob->eod = iob->cur = iob->buf;
356    return(n);
357
358 }
359
360
361 /*********************************************************************
362  *
363  * Function    :  add_to_iob
364  *
365  * Description :  Add content to the buffered page.
366  *
367  * Parameters  :
368  *          1  :  csp = Current client state (buffers, headers, etc...)
369  *          2  :  buf = holds the content to be added to the page
370  *          3  :  n = number of bytes to be added
371  *
372  * Returns     :  Number of bytes in the content buffer.
373  *
374  *********************************************************************/
375 int add_to_iob(struct client_state *csp, char *buf, int n)
376 {
377    struct iob *iob = csp->iob;
378    int have, need;
379    char *p;
380
381    have = iob->eod - iob->cur;
382
383    if (n <= 0)
384    {
385       return(have);
386    }
387
388    need = have + n;
389
390    if ((p = (char *)malloc(need + 1)) == NULL)
391    {
392       log_error(LOG_LEVEL_ERROR, "malloc() iob failed: %E");
393       return(-1);
394    }
395
396    if (have)
397    {
398       /* there is something in the buffer - save it */
399       memcpy(p, iob->cur, have);
400
401       /* replace the buffer with the new space */
402       freez(iob->buf);
403       iob->buf = p;
404
405       /* point to the end of the data */
406       p += have;
407    }
408    else
409    {
410       /* the buffer is empty, free it and reinitialize */
411       freez(iob->buf);
412       iob->buf = p;
413    }
414
415    /* copy the new data into the iob buffer */
416    memcpy(p, buf, n);
417
418    /* point to the end of the data */
419    p += n;
420
421    /* null terminate == cheap insurance */
422    *p = '\0';
423
424    /* set the pointers to the new values */
425    iob->cur = iob->buf;
426    iob->eod = p;
427
428    return(need);
429
430 }
431
432
433 /*********************************************************************
434  *
435  * Function    :  get_header
436  *
437  * Description :  This (odd) routine will parse the csp->iob
438  *
439  * Parameters  :
440  *          1  :  csp = Current client state (buffers, headers, etc...)
441  *
442  * Returns     :  Any one of the following:
443  *
444  * 1) a pointer to a dynamically allocated string that contains a header line
445  * 2) NULL  indicating that the end of the header was reached
446  * 3) ""    indicating that the end of the iob was reached before finding
447  *          a complete header line.
448  *
449  *********************************************************************/
450 char *get_header(struct client_state *csp)
451 {
452    struct iob *iob;
453    char *p, *q, *ret;
454    iob = csp->iob;
455
456    if ((iob->cur == NULL)
457       || ((p = strchr(iob->cur, '\n')) == NULL))
458    {
459       return(""); /* couldn't find a complete header */
460    }
461
462    *p = '\0';
463
464    ret = strdup(iob->cur);
465
466    iob->cur = p+1;
467
468    if ((q = strchr(ret, '\r'))) *q = '\0';
469
470    /* is this a blank linke (i.e. the end of the header) ? */
471    if (*ret == '\0')
472    {
473       freez(ret);
474       return(NULL);
475    }
476
477    return(ret);
478
479 }
480
481
482 /*********************************************************************
483  *
484  * Function    :  sed
485  *
486  * Description :  add, delete or modify lines in the HTTP header streams.
487  *                On entry, it receives a linked list of headers space
488  *                that was allocated dynamically (both the list nodes
489  *                and the header contents).
490  *
491  *                As a side effect it frees the space used by the original
492  *                header lines.
493  *
494  * Parameters  :
495  *          1  :  pats = list of patterns to match against headers
496  *          2  :  more_headers = list of functions to add more
497  *                headers (client or server)
498  *          3  :  csp = Current client state (buffers, headers, etc...)
499  *
500  * Returns     :  Single pointer to a fully formed header.
501  *
502  *********************************************************************/
503 char *sed(const struct parsers pats[], void (* const more_headers[])(struct client_state *), struct client_state *csp)
504 {
505    struct list *p;
506    const struct parsers *v;
507    char *hdr;
508    void (* const *f)();
509
510    for (v = pats; v->str ; v++)
511    {
512       for (p = csp->headers->next; p ; p = p->next)
513       {
514          /* Header crunch()ed in previous run? -> ignore */
515          if (p->str == NULL) continue;
516
517          if (v == pats) log_error(LOG_LEVEL_HEADER, "scan: %s", p->str);
518
519          if (strncmpic(p->str, v->str, v->len) == 0)
520          {
521             hdr = v->parser(v, p->str, csp);
522             freez(p->str);
523             p->str = hdr;
524          }
525       }
526    }
527
528    /* place any additional headers on the csp->headers list */
529    for (f = more_headers; *f ; f++)
530    {
531       (*f)(csp);
532    }
533
534    /* add the blank line at the end of the header, if necessary */
535    if ( (csp->headers->last == NULL)
536      || (csp->headers->last->str == NULL)
537      || (*csp->headers->last->str != '\0') )
538    {
539       enlist(csp->headers, "");
540    }
541
542    hdr = list_to_text(csp->headers);
543
544    return(hdr);
545
546 }
547
548
549 /*********************************************************************
550  *
551  * Function    :  free_http_request
552  *
553  * Description :  Freez a http_request structure
554  *
555  * Parameters  :
556  *          1  :  http = points to a http_request structure to free
557  *
558  * Returns     :  N/A
559  *
560  *********************************************************************/
561 void free_http_request(struct http_request *http)
562 {
563    freez(http->cmd);
564    freez(http->gpc);
565    freez(http->host);
566    freez(http->hostport);
567    freez(http->path);
568    freez(http->ver);
569
570 }
571
572
573 /*********************************************************************
574  *
575  * Function    :  parse_http_request
576  *
577  * Description :  Parse out the host and port from the URL.  Find the
578  *                hostname & path, port (if ':'), and/or password (if '@')
579  *
580  * Parameters  :
581  *          1  :  req = URL (or is it URI?) to break down
582  *          2  :  http = pointer to the http structure to hold elements
583  *          3  :  csp = Current client state (buffers, headers, etc...)
584  *
585  * Returns     :  N/A
586  *
587  *********************************************************************/
588 void parse_http_request(char *req, struct http_request *http, struct client_state *csp)
589 {
590    char *buf, *v[10], *url, *p;
591    int n;
592
593    memset(http, '\0', sizeof(*http));
594
595    http->cmd = strdup(req);
596
597    buf = strdup(req);
598
599    n = ssplit(buf, " \r\n", v, SZ(v), 1, 1);
600
601    if (n == 3)
602    {
603       /* this could be a CONNECT request */
604       if (strcmpic(v[0], "connect") == 0)
605       {
606          http->ssl      = 1;
607          http->gpc      = strdup(v[0]);
608          http->hostport = strdup(v[1]);
609          http->ver      = strdup(v[2]);
610       }
611
612 #ifdef WEBDAV
613
614 /* This next line is a little ugly, but it simplifies the if statement below. */
615 /* Basically if using webDAV, we want the OR condition to use these too.      */
616
617 /*
618  * by haroon
619  * These are the headers as defined in RFC2518 to add webDAV support
620  */
621
622 #define OR_WEBDAV || \
623          (0 == strcmpic(v[0], "propfind")) || \
624          (0 == strcmpic(v[0], "proppatch")) || \
625          (0 == strcmpic(v[0], "move")) || \
626          (0 == strcmpic(v[0], "copy")) || \
627          (0 == strcmpic(v[0], "mkcol")) || \
628          (0 == strcmpic(v[0], "lock")) || \
629          (0 == strcmpic(v[0], "unlock"))
630
631 #else /* No webDAV support is enabled.  Provide an empty OR_WEBDAV macro. */
632
633 #define OR_WEBDAV
634
635 #endif
636
637       /* or it could be a GET or a POST (possibly webDAV too) */
638       if ((strcmpic(v[0], "get")  == 0) ||
639           (strcmpic(v[0], "head") == 0) OR_WEBDAV ||
640           (strcmpic(v[0], "post") == 0))
641       {
642          http->ssl      = 0;
643          http->gpc      = strdup(v[0]);
644          url            = v[1];
645          http->ver      = strdup(v[2]);
646
647          if (strncmpic(url, "http://",  7) == 0)
648          {
649             url += 7;
650          }
651          else if (strncmpic(url, "https://", 8) == 0)
652          {
653             url += 8;
654          }
655          else
656          {
657             url = NULL;
658          }
659
660          if (url && (p = strchr(url, '/')))
661          {
662             http->path = strdup(p);
663             *p = '\0';
664             http->hostport = strdup(url);
665          }
666       }
667    }
668
669    freez(buf);
670
671
672    if (http->hostport == NULL)
673    {
674       free_http_request(http);
675       return;
676    }
677
678    buf = strdup(http->hostport);
679
680
681    /* check if url contains password */
682    n = ssplit(buf, "@", v, SZ(v), 1, 1);
683    if (n == 2)
684    {
685       char * newbuf = NULL;
686       newbuf = strdup(v[1]);
687       freez(buf);
688       buf = newbuf;
689    }
690
691    n = ssplit(buf, ":", v, SZ(v), 1, 1);
692
693    if (n == 1)
694    {
695       http->host = strdup(v[0]);
696       http->port = 80;
697    }
698
699    if (n == 2)
700    {
701       http->host = strdup(v[0]);
702       http->port = atoi(v[1]);
703    }
704
705    freez(buf);
706
707    if (http->host == NULL)
708    {
709       free_http_request(http);
710    }
711
712    if (http->path == NULL)
713    {
714       http->path = strdup("");
715    }
716
717 }
718
719
720 /* here begins the family of parser functions that reformat header lines */
721
722
723 /*********************************************************************
724  *
725  * Function    :  crumble
726  *
727  * Description :  This is called if a header matches a pattern to "crunch"
728  *
729  * Parameters  :
730  *          1  :  v = Pointer to parsers structure, which basically holds
731  *                headers (client or server) that we want to "crunch"
732  *          2  :  s = header (from sed) to "crunch"
733  *          3  :  csp = Current client state (buffers, headers, etc...)
734  *
735  * Returns     :  Always NULL.
736  *
737  *********************************************************************/
738 char *crumble(const struct parsers *v, char *s, struct client_state *csp)
739 {
740    log_error(LOG_LEVEL_HEADER, "crunch!");
741    return(NULL);
742
743 }
744
745
746 #if defined(PCRS) || defined(KILLPOPUPS)
747
748 /*********************************************************************
749  *
750  * Function    :  content_type
751  *
752  * Description :  Is this a text/.* or javascript MIME Type?
753  *
754  * Parameters  :
755  *          1  :  v = ignored
756  *          2  :  s = header string we are "considering"
757  *          3  :  csp = Current client state (buffers, headers, etc...)
758  *
759  * Returns     :  A duplicate string pointer to this header (ie. pass thru)
760  *
761  *********************************************************************/
762 char *content_type(const struct parsers *v, char *s, struct client_state *csp)
763 {
764    if (strstr (s, " text/") || strstr (s, "application/x-javascript"))
765       csp->is_text = 1;
766    else
767       csp->is_text = 0;
768
769    return(strdup(s));
770
771 }
772 #endif /* defined(PCRS) || defined(KILLPOPUPS) */
773
774
775 #ifdef PCRS
776 /*********************************************************************
777  *
778  * Function    :  content_length
779  *
780  * Description :  Crunch Content-Length header if & only if we are
781  *                filtering this page through PCRS.
782  *
783  * Parameters  :
784  *          1  :  v = ignored
785  *          2  :  s = header string we are "considering"
786  *          3  :  csp = Current client state (buffers, headers, etc...)
787  *
788  * Returns     :  A duplicate string pointer to this header (ie. pass thru)
789  *
790  *********************************************************************/
791 char *content_length(const struct parsers *v, char *s, struct client_state *csp)
792 {
793    if (csp->content_length != 0) /* Content has been modified */
794         {
795            s = (char *) zalloc(100);
796            sprintf(s, "Content-Length: %d", csp->content_length);
797                 log_error(LOG_LEVEL_HEADER, "Adjust Content-Length to %d", csp->content_length);
798            return(s);
799         }
800    else
801    {
802       return(strdup(s));
803    }
804 }
805
806 #endif /* def PCRS */
807
808
809 /*********************************************************************
810  *
811  * Function    :  client_referrer
812  *
813  * Description :  Handle the "referer" config setting properly.
814  *                Called from `sed'.
815  *
816  * Parameters  :
817  *          1  :  v = ignored
818  *          2  :  s = header (from sed) to "crunch"
819  *          3  :  csp = Current client state (buffers, headers, etc...)
820  *
821  * Returns     :  NULL if crunched, or a malloc'ed string with the original
822  *                or modified header
823  *
824  *********************************************************************/
825 char *client_referrer(const struct parsers *v, char *s, struct client_state *csp)
826 {
827    const char * newval;
828 #ifdef FORCE_LOAD
829    /* Since the referrer can include the prefix even
830     * even if the request itself is non-forced, we must
831     * clean it unconditionally 
832     */
833    strclean(s, FORCE_PREFIX);
834 #endif /* def FORCE_LOAD */
835
836 #ifdef TRUST_FILES
837    csp->referrer = strdup(s);
838 #endif /* def TRUST_FILES */
839
840    /*
841     * Are we sending referer?
842     */
843    if ((csp->action->flags & ACTION_HIDE_REFERER) == 0)
844    {
845       return(strdup(s));
846    }
847
848    newval = csp->action->string[ACTION_STRING_REFERER];
849
850    /*
851     * Are we blocking referer?
852     */
853    if ((newval == NULL) || (0 == strcmpic(newval, "block")) )
854    {
855       log_error(LOG_LEVEL_HEADER, "crunch!");
856       return(NULL);
857    }
858
859    /*
860     * Are we forging referer?
861     */
862    if (0 == strcmpic(newval, "forge"))
863    {
864       /*
865        * Forge a referer as http://[hostname:port of REQUEST]/
866        * to fool stupid checks for in-site links
867        */
868       log_error(LOG_LEVEL_HEADER, "crunch+forge!");
869       s = strsav(NULL, "Referer: ");
870       s = strsav(s, "http://");
871       s = strsav(s, csp->http->hostport);
872       s = strsav(s, "/");
873       return(s);
874    }
875
876    /*
877     * Have we got a fixed referer?
878     */
879    if (0 == strncmpic(newval, "http://", 7))
880    {
881       /*
882        * We have a specific (fixed) referer we want to send.
883        */
884
885       log_error(LOG_LEVEL_HEADER, "modified");
886
887       s = strsav( NULL, "Referer: " );
888       s = strsav( s, newval );
889       return(s);
890    }
891
892    /* Should never get here! */
893    log_error(LOG_LEVEL_ERROR, "Bad parameter: +referer{%s}", newval);
894
895    /*
896     * Forge is probably the best default.
897     *
898     * Forge a referer as http://[hostname:port of REQUEST]/
899     * to fool stupid checks for in-site links
900     */
901    log_error(LOG_LEVEL_HEADER, "crunch+forge!");
902    s = strsav(NULL, "Referer: ");
903    s = strsav(s, "http://");
904    s = strsav(s, csp->http->hostport);
905    s = strsav(s, "/");
906    return(s);
907 }
908
909
910 /*********************************************************************
911  *
912  * Function    :  client_uagent
913  *
914  * Description :  Handle the "user-agent" config setting properly.
915  *                Called from `sed'.
916  *
917  * Parameters  :
918  *          1  :  v = ignored
919  *          2  :  s = header (from sed) to "crunch"
920  *          3  :  csp = Current client state (buffers, headers, etc...)
921  *
922  * Returns     :  A malloc'ed pointer to the default agent, or
923  *                a malloc'ed string pointer to this header (ie. pass thru).
924  *
925  *********************************************************************/
926 char *client_uagent(const struct parsers *v, char *s, struct client_state *csp)
927 {
928    const char * newval;
929
930 #ifdef DETECT_MSIE_IMAGES
931    if (strstr (s, "MSIE "))
932    {
933       /* This is Microsoft Internet Explorer.
934        * Enable auto-detect.
935        */
936       csp->accept_types |= ACCEPT_TYPE_IS_MSIE;
937    }
938 #endif /* def DETECT_MSIE_IMAGES */
939
940    if ((csp->action->flags & ACTION_HIDE_USER_AGENT) == 0)
941    {
942       return(strdup(s));
943    }
944
945    newval = csp->action->string[ACTION_STRING_USER_AGENT];
946    if (newval == NULL)
947    {
948       return(strdup(s));
949    }
950
951    log_error(LOG_LEVEL_HEADER, "modified");
952
953    s = strsav( NULL, "User-Agent: " );
954    s = strsav( s, newval );
955    return(s);
956
957 }
958
959
960 /*********************************************************************
961  *
962  * Function    :  client_ua
963  *
964  * Description :  Handle "ua-" headers properly.  Called from `sed'.
965  *
966  * Parameters  :
967  *          1  :  v = ignored
968  *          2  :  s = header (from sed) to "crunch"
969  *          3  :  csp = Current client state (buffers, headers, etc...)
970  *
971  * Returns     :  NULL if crunched, or a malloc'ed string to original header
972  *
973  *********************************************************************/
974 char *client_ua(const struct parsers *v, char *s, struct client_state *csp)
975 {
976    if ((csp->action->flags & ACTION_HIDE_USER_AGENT) == 0)
977    {
978       return(strdup(s));
979    }
980    else
981    {
982       log_error(LOG_LEVEL_HEADER, "crunch!");
983       return(NULL);
984    }
985 }
986
987
988 /*********************************************************************
989  *
990  * Function    :  client_from
991  *
992  * Description :  Handle the "from" config setting properly.
993  *                Called from `sed'.
994  *
995  * Parameters  :
996  *          1  :  v = ignored
997  *          2  :  s = header (from sed) to "crunch"
998  *          3  :  csp = Current client state (buffers, headers, etc...)
999  *
1000  * Returns     :  NULL if crunched, or a malloc'ed string to
1001  *                modified/original header.
1002  *
1003  *********************************************************************/
1004 char *client_from(const struct parsers *v, char *s, struct client_state *csp)
1005 {
1006    const char * newval;
1007
1008    if ((csp->action->flags & ACTION_HIDE_FROM) == 0)
1009    {
1010       return(strdup(s));
1011    }
1012
1013    newval = csp->action->string[ACTION_STRING_FROM];
1014
1015    /*
1016     * Are we blocking referer?
1017     */
1018    if ((newval == NULL) || (0 == strcmpic(newval, "block")) )
1019    {
1020       log_error(LOG_LEVEL_HEADER, "crunch!");
1021       return(NULL);
1022    }
1023
1024    log_error(LOG_LEVEL_HEADER, " modified");
1025
1026    s = strsav( NULL, "From: " );
1027    s = strsav( s, newval );
1028    return(s);
1029
1030 }
1031
1032
1033 /*********************************************************************
1034  *
1035  * Function    :  client_send_cookie
1036  *
1037  * Description :  Handle the "cookie" header properly.  Called from `sed'.
1038  *                If cookie is accepted, add it to the cookie_list,
1039  *                else we crunch it.  Mmmmmmmmmmm ... cookie ......
1040  *
1041  * Parameters  :
1042  *          1  :  v = pattern of cookie `sed' found matching
1043  *          2  :  s = header (from sed) to "crunch"
1044  *          3  :  csp = Current client state (buffers, headers, etc...)
1045  *
1046  * Returns     :  Always NULL.
1047  *
1048  *********************************************************************/
1049 char *client_send_cookie(const struct parsers *v, char *s, struct client_state *csp)
1050 {
1051    if ((csp->action->flags & ACTION_NO_COOKIE_READ) == 0)
1052    {
1053       enlist(csp->cookie_list, s + v->len + 1);
1054    }
1055    else
1056    {
1057       log_error(LOG_LEVEL_HEADER, " crunch!");
1058    }
1059
1060    /*
1061     * Always return NULL here.  The cookie header
1062     * will be sent at the end of the header.
1063     */
1064    return(NULL);
1065
1066 }
1067
1068
1069 /*********************************************************************
1070  *
1071  * Function    :  client_x_forwarded
1072  *
1073  * Description :  Handle the "x-forwarded-for" config setting properly,
1074  *                also used in the add_client_headers list.  Called from `sed'.
1075  *
1076  * Parameters  :
1077  *          1  :  v = ignored
1078  *          2  :  s = header (from sed) to "crunch"
1079  *          3  :  csp = Current client state (buffers, headers, etc...)
1080  *
1081  * Returns     :  Always NULL.
1082  *
1083  *********************************************************************/
1084 char *client_x_forwarded(const struct parsers *v, char *s, struct client_state *csp)
1085 {
1086    if ((csp->action->flags & ACTION_HIDE_FORWARDED) == 0)
1087    {
1088       /* Save it so we can re-add it later */
1089       csp->x_forwarded = strdup(s);
1090    }
1091
1092    /*
1093     * Always return NULL, since this information
1094     * will be sent at the end of the header.
1095     */
1096
1097    return(NULL);
1098
1099 }
1100
1101 #if defined(DETECT_MSIE_IMAGES)
1102 /*********************************************************************
1103  *
1104  * Function    :  client_accept
1105  *
1106  * Description :  Detect whether the client wants HTML or an image.
1107  *                Clients do not always make this information available
1108  *                in a sane way.  Always passes the header through
1109  *                the proxy unchanged.
1110  *
1111  * Parameters  :
1112  *          1  :  v = Ignored.
1113  *          2  :  s = Header string.  Null terminated.
1114  *          3  :  csp = Current client state (buffers, headers, etc...)
1115  *
1116  * Returns     :  Duplicate of argument s.
1117  *
1118  *********************************************************************/
1119 char *client_accept(const struct parsers *v, char *s, struct client_state *csp)
1120 {
1121 #ifdef DETECT_MSIE_IMAGES
1122    if (strstr (s, "image/gif"))
1123    {
1124       /* Client will accept HTML.  If this seems counterintuitive,
1125        * blame Microsoft. 
1126        */
1127       csp->accept_types |= ACCEPT_TYPE_MSIE_HTML;
1128    }
1129    else
1130    {
1131       csp->accept_types |= ACCEPT_TYPE_MSIE_IMAGE;
1132    }
1133 #endif /* def DETECT_MSIE_IMAGES */
1134
1135    return(strdup(s));
1136
1137 }
1138 #endif /* defined(DETECT_MSIE_IMAGES) */
1139
1140
1141
1142 /* the following functions add headers directly to the header list */
1143
1144
1145 /*********************************************************************
1146  *
1147  * Function    :  client_cookie_adder
1148  *
1149  * Description :  Used in the add_client_headers list.  Called from `sed'.
1150  *
1151  * Parameters  :
1152  *          1  :  csp = Current client state (buffers, headers, etc...)
1153  *
1154  * Returns     :  N/A
1155  *
1156  *********************************************************************/
1157 void client_cookie_adder(struct client_state *csp)
1158 {
1159    struct list *lst;
1160    char *tmp = NULL;
1161    char *e;
1162
1163    for (lst = csp->cookie_list->next; lst ; lst = lst->next)
1164    {
1165       if (tmp)
1166       {
1167          tmp = strsav(tmp, "; ");
1168       }
1169       tmp = strsav(tmp, lst->str);
1170    }
1171
1172    for (lst = csp->action->multi[ACTION_MULTI_WAFER]->next;  lst ; lst = lst->next)
1173    {
1174       if (tmp)
1175       {
1176          tmp = strsav(tmp, "; ");
1177       }
1178
1179       if ((e = cookie_encode(lst->str)))
1180       {
1181          tmp = strsav(tmp, e);
1182          freez(e);
1183       }
1184    }
1185
1186    if (tmp)
1187    {
1188       char *ret;
1189
1190       ret = strdup("Cookie: ");
1191       ret = strsav(ret, tmp);
1192       log_error(LOG_LEVEL_HEADER, "addh: %s", ret);
1193       enlist(csp->headers, ret);
1194       freez(tmp);
1195       freez(ret);
1196    }
1197
1198 }
1199
1200
1201 /*********************************************************************
1202  *
1203  * Function    :  client_xtra_adder
1204  *
1205  * Description :  Used in the add_client_headers list.  Called from `sed'.
1206  *
1207  * Parameters  :
1208  *          1  :  csp = Current client state (buffers, headers, etc...)
1209  *
1210  * Returns     :  N/A
1211  *
1212  *********************************************************************/
1213 void client_xtra_adder(struct client_state *csp)
1214 {
1215    struct list *lst = csp->action->multi[ACTION_MULTI_ADD_HEADER];
1216
1217    for (lst = lst->next; lst ; lst = lst->next)
1218    {
1219       log_error(LOG_LEVEL_HEADER, "addh: %s", lst->str);
1220       enlist(csp->headers, lst->str);
1221    }
1222
1223 }
1224
1225
1226 /*********************************************************************
1227  *
1228  * Function    :  client_x_forwarded_adder
1229  *
1230  * Description :  Used in the add_client_headers list.  Called from `sed'.
1231  *
1232  * Parameters  :
1233  *          1  :  csp = Current client state (buffers, headers, etc...)
1234  *
1235  * Returns     :  N/A
1236  *
1237  *********************************************************************/
1238 void client_x_forwarded_adder(struct client_state *csp)
1239 {
1240    char *p = NULL;
1241
1242    if ((csp->action->flags & ACTION_HIDE_FORWARDED) != 0)
1243    {
1244       return;
1245    }
1246
1247    if (csp->x_forwarded)
1248    {
1249       p = strsav(p, csp->x_forwarded);
1250       p = strsav(p, ", ");
1251       p = strsav(p, csp->ip_addr_str);
1252    }
1253    else
1254    {
1255       p = strsav(p, "X-Forwarded-For: ");
1256       p = strsav(p, csp->ip_addr_str);
1257    }
1258
1259    log_error(LOG_LEVEL_HEADER, "addh: %s", p);
1260    enlist(csp->headers, p);
1261
1262 }
1263
1264
1265 /*********************************************************************
1266  *
1267  * Function    :  server_set_cookie
1268  *
1269  * Description :  Handle the server "cookie" header properly.
1270  *                Log cookie to the jar file.  Then "crunch" it,
1271  *                or accept it.  Called from `sed'.
1272  *
1273  * Parameters  :
1274  *          1  :  v = parser pattern that matched this header
1275  *          2  :  s = header that matched this pattern
1276  *          3  :  csp = Current client state (buffers, headers, etc...)
1277  *
1278  * Returns     :  `crumble' or a newly malloc'ed string.
1279  *
1280  *********************************************************************/
1281 char *server_set_cookie(const struct parsers *v, char *s, struct client_state *csp)
1282 {
1283 #ifdef JAR_FILES
1284    if (csp->config->jar)
1285    {
1286       fprintf(csp->config->jar, "%s\t%s\n", csp->http->host, (s + v->len + 1));
1287    }
1288 #endif /* def JAR_FILES */
1289
1290    if ((csp->action->flags & ACTION_NO_COOKIE_SET) != 0)
1291    {
1292       return(crumble(v, s, csp));
1293    }
1294
1295    return(strdup(s));
1296
1297 }
1298
1299
1300 #ifdef FORCE_LOAD
1301 /*********************************************************************
1302  *
1303  * Function    :  client_host
1304  *
1305  * Description :  Clean the FORCE_PREFIX out of the 'host' http
1306  *                header, if we use force
1307  *
1308  * Parameters  :
1309  *          1  :  v = ignored
1310  *          2  :  s = header (from sed) to clean
1311  *          3  :  csp = Current client state (buffers, headers, etc...)
1312  *
1313  * Returns     :  A malloc'ed pointer to the cleaned host header 
1314  *
1315  *********************************************************************/
1316 char *client_host(const struct parsers *v, char *s, struct client_state *csp)
1317 {
1318    char *cleanhost = strdup(s);
1319  
1320    if(csp->force)
1321       strclean(cleanhost, FORCE_PREFIX);
1322  
1323    return(cleanhost);
1324 }
1325 #endif /* def FORCE_LOAD */
1326  
1327  
1328 #ifdef FORCE_LOAD 
1329 /*********************************************************************
1330  *
1331  * Function    :  strclean
1332  *
1333  * Description :  In-Situ-Eliminate all occurances of substring in 
1334  *                string
1335  *
1336  * Parameters  :
1337  *          1  :  string = string to clean
1338  *          2  :  substring = substring to eliminate
1339  *
1340  * Returns     :  Number of eliminations
1341  *
1342  *********************************************************************/
1343 int strclean(const char *string, const char *substring)
1344 {
1345    int hits = 0, len = strlen(substring);
1346    char *pos, *p;
1347
1348    while((pos = strstr(string, substring)))
1349    {
1350       p = pos + len;
1351       do
1352       {
1353          *(p - len) = *p; 
1354       }
1355       while (*p++ != '\0');
1356
1357       hits++;
1358    }
1359
1360    return(hits);
1361 }
1362 #endif /* def FORCE_LOAD */
1363
1364
1365 /*
1366   Local Variables:
1367   tab-width: 3
1368   end:
1369 */