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