parsers.c

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