filters.c

   1 const char filters_rcs[] = "$Id: filters.c,v 1.58.2.3 2002/09/25 14:51:51 oes Exp $";
   2 /*********************************************************************
   3  *
   4  * File        :  $Source: /cvsroot/ijbswa/current/Attic/filters.c,v $
   5  *
   6  * Purpose     :  Declares functions to parse/crunch headers and pages.
   7  *                Functions declared include:
   8  *                   `acl_addr', `add_stats', `block_acl', `block_imageurl',
   9  *                   `block_url', `url_actions', `domain_split',
  10  *                   `filter_popups', `forward_url', 'redirect_url',
  11  *                   `ij_untrusted_url', `intercept_url', `pcrs_filter_respose',
  12  *                   'ijb_send_banner', and `trust_url'
  13  *
  14  * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
  15  *                Privoxy team. http://www.privoxy.org/
  16  *
  17  *                Based on the Internet Junkbuster originally written
  18  *                by and Copyright (C) 1997 Anonymous Coders and
  19  *                Junkbusters Corporation.  http://www.junkbusters.com
  20  *
  21  *                This program is free software; you can redistribute it
  22  *                and/or modify it under the terms of the GNU General
  23  *                Public License as published by the Free Software
  24  *                Foundation; either version 2 of the License, or (at
  25  *                your option) any later version.
  26  *
  27  *                This program is distributed in the hope that it will
  28  *                be useful, but WITHOUT ANY WARRANTY; without even the
  29  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  30  *                PARTICULAR PURPOSE.  See the GNU General Public
  31  *                License for more details.
  32  *
  33  *                The GNU General Public License should be included with
  34  *                this file.  If not, you can view it at
  35  *                http://www.gnu.org/copyleft/gpl.html
  36  *                or write to the Free Software Foundation, Inc., 59
  37  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  38  *
  39  * Revisions   :
  40  *    $Log: filters.c,v $
  41  *    Revision 1.58.2.3  2002/09/25 14:51:51  oes
  42  *    Added basic support for OPTIONS and TRACE HTTP methods:
  43  *    New function direct_response which handles OPTIONS and
  44  *    TRACE requests whose Max-Forwards header field is zero.
  45  *
  46  *    Revision 1.58.2.2  2002/08/01 17:18:28  oes
  47  *    Fixed BR 537651 / SR 579724 (MSIE image detect improper for IE/Mac)
  48  *
  49  *    Revision 1.58.2.1  2002/07/26 15:18:53  oes
  50  *    - Bugfix: Executing a filters without jobs no longer results in
  51  *      turing off *all* filters.
  52  *    - Security fix: Malicious web servers can't cause a seg fault
  53  *      through bogus chunk sizes anymore
  54  *
  55  *    Revision 1.58  2002/04/24 02:11:17  oes
  56  *    Jon's multiple AF patch: url_actions now evaluates rules
  57  *    from all AFs.
  58  *
  59  *    Revision 1.57  2002/04/08 20:38:34  swa
  60  *    fixed JB spelling
  61  *
  62  *    Revision 1.56  2002/04/05 15:51:24  oes
  63  *     - bugfix: error-pages now get correct request protocol
  64  *     - fix for invalid HTML in trust info
  65  *
  66  *    Revision 1.55  2002/04/02 16:13:51  oes
  67  *    Fix: No "Go there anyway" for SSL
  68  *
  69  *    Revision 1.54  2002/04/02 14:55:56  oes
  70  *    Bugfix: is_untrusted_url() now depends on FEATURE_TRUST, not FEATURE_COOKIE_JAR
  71  *
  72  *    Revision 1.53  2002/03/26 22:29:54  swa
  73  *    we have a new homepage!
  74  *
  75  *    Revision 1.52  2002/03/24 16:35:57  jongfoster
  76  *    Removing logo
  77  *
  78  *    Revision 1.51  2002/03/24 15:23:33  jongfoster
  79  *    Name changes
  80  *
  81  *    Revision 1.50  2002/03/24 13:25:43  swa
  82  *    name change related issues
  83  *
  84  *    Revision 1.49  2002/03/16 20:29:14  oes
  85  *    Cosmetics
  86  *
  87  *    Revision 1.48  2002/03/13 20:25:34  oes
  88  *    Better logging for content filters
  89  *
  90  *    Revision 1.47  2002/03/13 00:30:52  jongfoster
  91  *    Killing warnings
  92  *    Added option of always sending redirect for imageblock,
  93  *    currently disabled with #if 0.
  94  *
  95  *    Revision 1.46  2002/03/12 01:42:49  oes
  96  *    Introduced modular filters
  97  *
  98  *    Revision 1.45  2002/03/08 16:47:50  oes
  99  *    Added choice beween GIF and PNG built-in images
 100  *
 101  *    Revision 1.44  2002/03/07 03:49:31  oes
 102  *     - Fixed compiler warnings etc
 103  *     - Changed built-in images from GIF to PNG
 104  *       (with regard to Unisys patent issue)
 105  *     - Added a 4x4 pattern PNG which is less intrusive
 106  *       than the logo but also clearly marks the deleted banners
 107  *
 108  *    Revision 1.43  2002/01/22 23:51:59  jongfoster
 109  *    Replacing strsav() with the safer string_append().
 110  *
 111  *    Adding missing html_encode() to error message generators.  Where encoded
 112  *    and unencoded versions of a string were provided, removing the unencoded
 113  *    one.
 114  *
 115  *    Revision 1.42  2002/01/17 21:00:32  jongfoster
 116  *    Moving all our URL and URL pattern parsing code to urlmatch.c.
 117  *
 118  *    Using a single, simple url_match(pattern,url) function - rather than
 119  *    the 3-line match routine which was repeated all over the place.
 120  *
 121  *    Renaming free_url to free_url_spec, since it frees a struct url_spec.
 122  *
 123  *    Using parse_http_url() to parse URLs without faking a HTTP
 124  *    request line for parse_http_request().
 125  *
 126  *    Revision 1.41  2001/11/13 00:14:07  jongfoster
 127  *    Fixing stupid bug now I've figured out what || means.
 128  *    (It always returns 0 or 1, not one of it's paramaters.)
 129  *
 130  *    Revision 1.40  2001/10/26 17:37:55  oes
 131  *    - Re-enabled Netscape 200/404 bug workaround in block_url():
 132  *      - Removed OS/2 special case
 133  *      - Made block_url() independant from sed() having been run
 134  *    - Made trust_url independant from sed() having been run
 135  *    - Made is_imageurl independant from sed() having been run.
 136  *      It now checks User-Agent: and Accept: by itself.
 137  *
 138  *
 139  *    Revision 1.39  2001/10/25 03:40:48  david__schmidt
 140  *    Change in porting tactics: OS/2's EMX porting layer doesn't allow multiple
 141  *    threads to call select() simultaneously.  So, it's time to do a real, live,
 142  *    native OS/2 port.  See defines for __EMX__ (the porting layer) vs. __OS2__
 143  *    (native). Both versions will work, but using __OS2__ offers multi-threading.
 144  *
 145  *    Revision 1.38  2001/10/23 21:32:33  jongfoster
 146  *    Adding error-checking to selected functions
 147  *
 148  *    Revision 1.37  2001/10/22 15:33:56  david__schmidt
 149  *    Special-cased OS/2 out of the Netscape-abort-on-404-in-js problem in
 150  *    filters.c.  Added a FIXME in front of the offending code.  I'll gladly
 151  *    put in a better/more robust fix for all parties if one is presented...
 152  *    It seems that just returning 200 instead of 404 would pretty much fix
 153  *    it for everyone, but I don't know all the history of the problem.
 154  *
 155  *    Revision 1.36  2001/10/10 16:44:16  oes
 156  *    Added match_portlist function
 157  *
 158  *    Revision 1.35  2001/10/07 15:41:23  oes
 159  *    Replaced 6 boolean members of csp with one bitmap (csp->flags)
 160  *
 161  *    New function remove_chunked_transfer_coding that strips chunked
 162  *      transfer coding to plain and is called by pcrs_filter_response
 163  *      and gif_deanimate_response if neccessary
 164  *
 165  *    Improved handling of zero-change re_filter runs
 166  *
 167  *    pcrs_filter_response and gif_deanimate_response now remove
 168  *      chunked transfer codeing before processing the body.
 169  *
 170  *    Revision 1.34  2001/09/20 15:49:36  steudten
 171  *
 172  *    Fix BUG: Change int size to size_t size in pcrs_filter_response().
 173  *    See cgi.c fill_template().
 174  *
 175  *    Revision 1.33  2001/09/16 17:05:14  jongfoster
 176  *    Removing unused #include showarg.h
 177  *
 178  *    Revision 1.32  2001/09/16 13:21:27  jongfoster
 179  *    Changes to use new list functions.
 180  *
 181  *    Revision 1.31  2001/09/16 11:38:02  jongfoster
 182  *    Splitting fill_template() into 2 functions:
 183  *    template_load() loads the file
 184  *    template_fill() performs the PCRS regexps.
 185  *    This is because the CGI edit interface has a "table row"
 186  *    template which is used many times in the page - this
 187  *    change means it's only loaded from disk once.
 188  *
 189  *    Revision 1.30  2001/09/16 11:00:10  jongfoster
 190  *    New function alloc_http_response, for symmetry with free_http_response
 191  *
 192  *    Revision 1.29  2001/09/13 23:32:40  jongfoster
 193  *    Moving image data to cgi.c rather than cgi.h
 194  *    Fixing a GPF under Win32 (and any other OS that protects global
 195  *    constants from being written to).
 196  *
 197  *    Revision 1.28  2001/09/10 10:18:51  oes
 198  *    Silenced compiler warnings
 199  *
 200  *    Revision 1.27  2001/08/05 16:06:20  jongfoster
 201  *    Modifiying "struct map" so that there are now separate header and
 202  *    "map_entry" structures.  This means that functions which modify a
 203  *    map no longer need to return a pointer to the modified map.
 204  *    Also, it no longer reverses the order of the entries (which may be
 205  *    important with some advanced template substitutions).
 206  *
 207  *    Revision 1.26  2001/07/30 22:08:36  jongfoster
 208  *    Tidying up #defines:
 209  *    - All feature #defines are now of the form FEATURE_xxx
 210  *    - Permanently turned off WIN_GUI_EDIT
 211  *    - Permanently turned on WEBDAV and SPLIT_PROXY_ARGS
 212  *
 213  *    Revision 1.25  2001/07/26 10:09:46  oes
 214  *    Made browser detection a little less naive
 215  *
 216  *    Revision 1.24  2001/07/25 17:22:51  oes
 217  *    Added workaround for Netscape bug that prevents display of page when loading a component fails.
 218  *
 219  *    Revision 1.23  2001/07/23 13:40:12  oes
 220  *    Fixed bug that caused document body to be dropped when pcrs joblist was empty.
 221  *
 222  *    Revision 1.22  2001/07/18 12:29:34  oes
 223  *    - Made gif_deanimate_response respect
 224  *      csp->action->string[ACTION_STRING_DEANIMATE]
 225  *    - Logging cosmetics
 226  *
 227  *    Revision 1.21  2001/07/13 13:59:53  oes
 228  *     - Introduced gif_deanimate_response which shares the
 229  *       generic content modification interface of pcrs_filter_response
 230  *       and acts as a wrapper to deanimate.c:gif_deanimate()
 231  *     - Renamed re_process_buffer to pcrs_filter_response
 232  *     - pcrs_filter_response now returns NULL on failiure
 233  *     - Removed all #ifdef PCRS
 234  *
 235  *    Revision 1.20  2001/07/01 17:01:04  oes
 236  *    Added comments and missing return statement in is_untrusted_url()
 237  *
 238  *    Revision 1.19  2001/06/29 21:45:41  oes
 239  *    Indentation, CRLF->LF, Tab-> Space
 240  *
 241  *    Revision 1.18  2001/06/29 13:27:38  oes
 242  *    - Cleaned up, renamed and reorderd functions
 243  *      and improved comments
 244  *
 245  *    - block_url:
 246  *      - Ported to CGI platform. Now delivers
 247  *        http_response or NULL
 248  *      - Unified HTML and GIF generation (moved image detection
 249  *        and GIF generation here from jcc.c:chat())
 250  *      - Fixed HTTP status to:
 251  *       -  403 (Forbidden) for the "blocked" HTML message
 252  *       -  200 (OK) for GIF answers
 253  *       -  302 (Redirect) for redirect to GIF
 254  *
 255  *    - trust_url:
 256  *      - Ported to CGI platform. Now delivers
 257  *        http_response or NULL
 258  *      - Separated detection of untrusted URL into
 259  *        (bool)is_untrusted_url
 260  *      - Added enforcement of untrusted requests
 261  *
 262  *    - Moved redirect_url() from cgi.c to here
 263  *      and ported it to the CGI platform
 264  *
 265  *    - Removed logentry from cancelled commit
 266  *
 267  *    Revision 1.17  2001/06/09 10:55:28  jongfoster
 268  *    Changing BUFSIZ ==> BUFFER_SIZE
 269  *
 270  *    Revision 1.16  2001/06/07 23:10:26  jongfoster
 271  *    Allowing unanchored domain patterns to back off and retry
 272  *    if they partially match.  Optimized right-anchored patterns.
 273  *    Moving ACL and forward files into config file.
 274  *    Replacing struct gateway with struct forward_spec
 275  *
 276  *    Revision 1.15  2001/06/03 19:12:00  oes
 277  *    extracted-CGI relevant stuff
 278  *
 279  *    Revision 1.14  2001/06/01 10:30:55  oes
 280  *    Added optional left-anchoring to domaincmp
 281  *
 282  *    Revision 1.13  2001/05/31 21:21:30  jongfoster
 283  *    Permissionsfile / actions file changes:
 284  *    - Changed "permission" to "action" throughout
 285  *    - changes to file format to allow string parameters
 286  *    - Moved helper functions to actions.c
 287  *
 288  *    Revision 1.12  2001/05/31 17:35:20  oes
 289  *
 290  *     - Enhanced domain part globbing with infix and prefix asterisk
 291  *       matching and optional unanchored operation
 292  *
 293  *    Revision 1.11  2001/05/29 11:53:23  oes
 294  *    "See why" link added to "blocked" page
 295  *
 296  *    Revision 1.10  2001/05/29 09:50:24  jongfoster
 297  *    Unified blocklist/imagelist/permissionslist.
 298  *    File format is still under discussion, but the internal changes
 299  *    are (mostly) done.
 300  *
 301  *    Also modified interceptor behaviour:
 302  *    - We now intercept all URLs beginning with one of the following
 303  *      prefixes (and *only* these prefixes):
 304  *        * http://i.j.b/
 305  *        * http://ijbswa.sf.net/config/
 306  *        * http://ijbswa.sourceforge.net/config/
 307  *    - New interceptors "home page" - go to http://i.j.b/ to see it.
 308  *    - Internal changes so that intercepted and fast redirect pages
 309  *      are not replaced with an image.
 310  *    - Interceptors now have the option to send a binary page direct
 311  *      to the client. (i.e. ijb-send-banner uses this)
 312  *    - Implemented show-url-info interceptor.  (Which is why I needed
 313  *      the above interceptors changes - a typical URL is
 314  *      "http://i.j.b/show-url-info?url=www.somesite.com/banner.gif".
 315  *      The previous mechanism would not have intercepted that, and
 316  *      if it had been intercepted then it then it would have replaced
 317  *      it with an image.)
 318  *
 319  *    Revision 1.9  2001/05/27 22:17:04  oes
 320  *
 321  *    - re_process_buffer no longer writes the modified buffer
 322  *      to the client, which was very ugly. It now returns the
 323  *      buffer, which it is then written by chat.
 324  *
 325  *    - content_length now adjusts the Content-Length: header
 326  *      for modified documents rather than crunch()ing it.
 327  *      (Length info in csp->content_length, which is 0 for
 328  *      unmodified documents)
 329  *
 330  *    - For this to work, sed() is called twice when filtering.
 331  *
 332  *    Revision 1.8  2001/05/26 17:13:28  jongfoster
 333  *    Filled in a function comment.
 334  *
 335  *    Revision 1.7  2001/05/26 15:26:15  jongfoster
 336  *    ACL feature now provides more security by immediately dropping
 337  *    connections from untrusted hosts.
 338  *
 339  *    Revision 1.6  2001/05/26 00:28:36  jongfoster
 340  *    Automatic reloading of config file.
 341  *    Removed obsolete SIGHUP support (Unix) and Reload menu option (Win32).
 342  *    Most of the global variables have been moved to a new
 343  *    struct configuration_spec, accessed through csp->config->globalname
 344  *    Most of the globals remaining are used by the Win32 GUI.
 345  *
 346  *    Revision 1.5  2001/05/25 22:34:30  jongfoster
 347  *    Hard tabs->Spaces
 348  *
 349  *    Revision 1.4  2001/05/22 18:46:04  oes
 350  *
 351  *    - Enabled filtering banners by size rather than URL
 352  *      by adding patterns that replace all standard banner
 353  *      sizes with the "Junkbuster" gif to the re_filterfile
 354  *
 355  *    - Enabled filtering WebBugs by providing a pattern
 356  *      which kills all 1x1 images
 357  *
 358  *    - Added support for PCRE_UNGREEDY behaviour to pcrs,
 359  *      which is selected by the (nonstandard and therefore
 360  *      capital) letter 'U' in the option string.
 361  *      It causes the quantifiers to be ungreedy by default.
 362  *      Appending a ? turns back to greedy (!).
 363  *
 364  *    - Added a new interceptor ijb-send-banner, which
 365  *      sends back the "Junkbuster" gif. Without imagelist or
 366  *      MSIE detection support, or if tinygif = 1, or the
 367  *      URL isn't recognized as an imageurl, a lame HTML
 368  *      explanation is sent instead.
 369  *
 370  *    - Added new feature, which permits blocking remote
 371  *      script redirects and firing back a local redirect
 372  *      to the browser.
 373  *      The feature is conditionally compiled, i.e. it
 374  *      can be disabled with --disable-fast-redirects,
 375  *      plus it must be activated by a "fast-redirects"
 376  *      line in the config file, has its own log level
 377  *      and of course wants to be displayed by show-proxy-args
 378  *      Note: Boy, all the #ifdefs in 1001 locations and
 379  *      all the fumbling with configure.in and acconfig.h
 380  *      were *way* more work than the feature itself :-(
 381  *
 382  *    - Because a generic redirect template was needed for
 383  *      this, tinygif = 3 now uses the same.
 384  *
 385  *    - Moved GIFs, and other static HTTP response templates
 386  *      to project.h
 387  *
 388  *    - Some minor fixes
 389  *
 390  *    - Removed some >400 CRs again (Jon, you really worked
 391  *      a lot! ;-)
 392  *
 393  *    Revision 1.3  2001/05/20 16:44:47  jongfoster
 394  *    Removing last hardcoded Junkbusters.com URLs.
 395  *
 396  *    Revision 1.2  2001/05/20 01:21:20  jongfoster
 397  *    Version 2.9.4 checkin.
 398  *    - Merged popupfile and cookiefile, and added control over PCRS
 399  *      filtering, in new "permissionsfile".
 400  *    - Implemented LOG_LEVEL_FATAL, so that if there is a configuration
 401  *      file error you now get a message box (in the Win32 GUI) rather
 402  *      than the program exiting with no explanation.
 403  *    - Made killpopup use the PCRS MIME-type checking and HTTP-header
 404  *      skipping.
 405  *    - Removed tabs from "config"
 406  *    - Moved duplicated url parsing code in "loaders.c" to a new funcition.
 407  *    - Bumped up version number.
 408  *
 409  *    Revision 1.1.1.1  2001/05/15 13:58:52  oes
 410  *    Initial import of version 2.9.3 source tree
 411  *
 412  *
 413  *********************************************************************/
 414 \f
 415
 416 #include "config.h"
 417
 418 #include <stdio.h>
 419 #include <sys/types.h>
 420 #include <stdlib.h>
 421 #include <ctype.h>
 422 #include <string.h>
 423 #include <assert.h>
 424
 425 #ifndef _WIN32
 426 #ifndef __OS2__
 427 #include <unistd.h>
 428 #endif /* ndef __OS2__ */
 429 #include <netinet/in.h>
 430 #else
 431 #include <winsock2.h>
 432 #endif /* ndef _WIN32 */
 433
 434 #ifdef __OS2__
 435 #include <utils.h>
 436 #endif /* def __OS2__ */
 437
 438 #include "project.h"
 439 #include "filters.h"
 440 #include "encode.h"
 441 #include "parsers.h"
 442 #include "ssplit.h"
 443 #include "errlog.h"
 444 #include "jbsockets.h"
 445 #include "miscutil.h"
 446 #include "actions.h"
 447 #include "cgi.h"
 448 #include "list.h"
 449 #include "deanimate.h"
 450 #include "urlmatch.h"
 451
 452 #ifdef _WIN32
 453 #include "win32.h"
 454 #endif
 455
 456 const char filters_h_rcs[] = FILTERS_H_VERSION;
 457
 458 /* Fix a problem with Solaris.  There should be no effect on other
 459  * platforms.
 460  * Solaris's isspace() is a macro which uses it's argument directly
 461  * as an array index.  Therefore we need to make sure that high-bit
 462  * characters generate +ve values, and ideally we also want to make
 463  * the argument match the declared parameter type of "int".
 464  */
 465 #define ijb_isdigit(__X) isdigit((int)(unsigned char)(__X))
 466
 467
 468 #ifdef FEATURE_ACL
 469 /*********************************************************************
 470  *
 471  * Function    :  block_acl
 472  *
 473  * Description :  Block this request?
 474  *                Decide yes or no based on ACL file.
 475  *
 476  * Parameters  :
 477  *          1  :  dst = The proxy or gateway address this is going to.
 478  *                      Or NULL to check all possible targets.
 479  *          2  :  csp = Current client state (buffers, headers, etc...)
 480  *                      Also includes the client IP address.
 481  *
 482  * Returns     : 0 = FALSE (don't block) and 1 = TRUE (do block)
 483  *
 484  *********************************************************************/
 485 int block_acl(struct access_control_addr *dst, struct client_state *csp)
 486 {
 487    struct access_control_list *acl = csp->config->acl;
 488
 489    /* if not using an access control list, then permit the connection */
 490    if (acl == NULL)
 491    {
 492       return(0);
 493    }
 494
 495    /* search the list */
 496    while (acl != NULL)
 497    {
 498       if ((csp->ip_addr_long & acl->src->mask) == acl->src->addr)
 499       {
 500          if (dst == NULL)
 501          {
 502             /* Just want to check if they have any access */
 503             if (acl->action == ACL_PERMIT)
 504             {
 505                return(0);
 506             }
 507          }
 508          else if ( ((dst->addr & acl->dst->mask) == acl->dst->addr)
 509            && ((dst->port == acl->dst->port) || (acl->dst->port == 0)))
 510          {
 511             if (acl->action == ACL_PERMIT)
 512             {
 513                return(0);
 514             }
 515             else
 516             {
 517                return(1);
 518             }
 519          }
 520       }
 521       acl = acl->next;
 522    }
 523
 524    return(1);
 525
 526 }
 527
 528
 529 /*********************************************************************
 530  *
 531  * Function    :  acl_addr
 532  *
 533  * Description :  Called from `load_config' to parse an ACL address.
 534  *
 535  * Parameters  :
 536  *          1  :  aspec = String specifying ACL address.
 537  *          2  :  aca = struct access_control_addr to fill in.
 538  *
 539  * Returns     :  0 => Ok, everything else is an error.
 540  *
 541  *********************************************************************/
 542 int acl_addr(char *aspec, struct access_control_addr *aca)
 543 {
 544    int i, masklength, port;
 545    char *p;
 546
 547    masklength = 32;
 548    port       =  0;
 549
 550    if ((p = strchr(aspec, '/')) != NULL)
 551    {
 552       *p++ = '\0';
 553
 554       if (ijb_isdigit(*p) == 0)
 555       {
 556          return(-1);
 557       }
 558       masklength = atoi(p);
 559    }
 560
 561    if ((masklength < 0) || (masklength > 32))
 562    {
 563       return(-1);
 564    }
 565
 566    if ((p = strchr(aspec, ':')) != NULL)
 567    {
 568       *p++ = '\0';
 569
 570       if (ijb_isdigit(*p) == 0)
 571       {
 572          return(-1);
 573       }
 574       port = atoi(p);
 575    }
 576
 577    aca->port = port;
 578
 579    aca->addr = ntohl(resolve_hostname_to_ip(aspec));
 580
 581    if (aca->addr == INADDR_NONE)
 582    {
 583       return(-1);
 584    }
 585
 586    /* build the netmask */
 587    aca->mask = 0;
 588    for (i=1; i <= masklength ; i++)
 589    {
 590       aca->mask |= (1 << (32 - i));
 591    }
 592
 593    /* now mask off the host portion of the ip address
 594     * (i.e. save on the network portion of the address).
 595     */
 596    aca->addr = aca->addr & aca->mask;
 597
 598    return(0);
 599
 600 }
 601 #endif /* def FEATURE_ACL */
 602
 603
 604 /*********************************************************************
 605  *
 606  * Function    :  match_portlist
 607  *
 608  * Description :  Check if a given number is covered by a comma
 609  *                separated list of numbers and ranges (a,b-c,d,..)
 610  *
 611  * Parameters  :
 612  *          1  :  portlist = String with list
 613  *          2  :  port = port to check
 614  *
 615  * Returns     :  0 => no match
 616  *                1 => match
 617  *
 618  *********************************************************************/
 619 int match_portlist(const char *portlist, int port)
 620 {
 621    char *min, *max, *next, *portlist_copy;
 622
 623    min = next = portlist_copy = strdup(portlist);
 624
 625    /*
 626     * Zero-terminate first item and remember offset for next
 627     */
 628    if (NULL != (next = strchr(portlist_copy, (int) ',')))
 629    {
 630       *next++ = '\0';
 631    }
 632
 633    /*
 634     * Loop through all items, checking for match
 635     */
 636    while(min)
 637    {
 638       if (NULL == (max = strchr(min, (int) '-')))
 639       {
 640          /*
 641           * No dash, check for equality
 642           */
 643          if (port == atoi(min))
 644          {
 645             free(portlist_copy);
 646             return(1);
 647          }
 648       }
 649       else
 650       {
 651          /*
 652           * This is a range, so check if between min and max,
 653           * or, if max was omitted, between min and 65K
 654           */
 655          *max++ = '\0';
 656          if(port >= atoi(min) && port <= (atoi(max) ? atoi(max) : 65535))
 657          {
 658             free(portlist_copy);
 659             return(1);
 660          }
 661
 662       }
 663
 664       /*
 665        * Jump to next item
 666        */
 667       min = next;
 668
 669       /*
 670        * Zero-terminate next item and remember offset for n+1
 671        */
 672       if ((NULL != next) && (NULL != (next = strchr(next, (int) ','))))
 673       {
 674          *next++ = '\0';
 675       }
 676    }
 677
 678    free(portlist_copy);
 679    return 0;
 680
 681 }
 682
 683
 684 /*********************************************************************
 685  *
 686  * Function    :  block_url
 687  *
 688  * Description :  Called from `chat'.  Check to see if we need to block this.
 689  *
 690  * Parameters  :
 691  *          1  :  csp = Current client state (buffers, headers, etc...)
 692  *
 693  * Returns     :  NULL => unblocked, else HTTP block response
 694  *
 695  *********************************************************************/
 696 struct http_response *block_url(struct client_state *csp)
 697 {
 698 #ifdef FEATURE_IMAGE_BLOCKING
 699    char *p;
 700 #endif /* def FEATURE_IMAGE_BLOCKING */
 701    struct http_response *rsp;
 702
 703    /*
 704     * If it's not blocked, don't block it ;-)
 705     */
 706    if ((csp->action->flags & ACTION_BLOCK) == 0)
 707    {
 708       return NULL;
 709    }
 710
 711    /*
 712     * Else, prepare a response
 713     */
 714    if (NULL == (rsp = alloc_http_response()))
 715    {
 716       return cgi_error_memory();
 717    }
 718
 719    /*
 720     * If it's an image-url, send back an image or redirect
 721     * as specified by the relevant +image action
 722     */
 723 #ifdef FEATURE_IMAGE_BLOCKING
 724    if (((csp->action->flags & ACTION_IMAGE_BLOCKER) != 0)
 725         && is_imageurl(csp))
 726    {
 727       /* determine HOW images should be blocked */
 728       p = csp->action->string[ACTION_STRING_IMAGE_BLOCKER];
 729
 730 #if 1 /* Two alternative strategies, use this one for now: */
 731
 732       /* and handle accordingly: */
 733       if ((p == NULL) || (0 == strcmpic(p, "pattern")))
 734       {
 735          rsp->body = bindup(image_pattern_data, image_pattern_length);
 736          if (rsp->body == NULL)
 737          {
 738             free_http_response(rsp);
 739             return cgi_error_memory();
 740          }
 741          rsp->content_length = image_pattern_length;
 742
 743          if (enlist_unique_header(rsp->headers, "Content-Type", BUILTIN_IMAGE_MIMETYPE))
 744          {
 745             free_http_response(rsp);
 746             return cgi_error_memory();
 747          }
 748       }
 749
 750       else if (0 == strcmpic(p, "blank"))
 751       {
 752          rsp->body = bindup(image_blank_data, image_blank_length);
 753          if (rsp->body == NULL)
 754          {
 755             free_http_response(rsp);
 756             return cgi_error_memory();
 757          }
 758          rsp->content_length = image_blank_length;
 759
 760          if (enlist_unique_header(rsp->headers, "Content-Type", BUILTIN_IMAGE_MIMETYPE))
 761          {
 762             free_http_response(rsp);
 763             return cgi_error_memory();
 764          }
 765       }
 766
 767       else
 768       {
 769          rsp->status = strdup("302 Local Redirect from Privoxy");
 770          if (rsp->status == NULL)
 771          {
 772             free_http_response(rsp);
 773             return cgi_error_memory();
 774          }
 775
 776          if (enlist_unique_header(rsp->headers, "Location", p))
 777          {
 778             free_http_response(rsp);
 779             return cgi_error_memory();
 780          }
 781       }
 782
 783 #else /* Following code is disabled for now */
 784
 785       /* and handle accordingly: */
 786       if ((p == NULL) || (0 == strcmpic(p, "pattern")))
 787       {
 788          p = CGI_PREFIX "send-banner?type=pattern";
 789       }
 790       else if (0 == strcmpic(p, "blank"))
 791       {
 792          p = CGI_PREFIX "send-banner?type=blank";
 793       }
 794       rsp->status = strdup("302 Local Redirect from Privoxy");
 795       if (rsp->status == NULL)
 796       {
 797          free_http_response(rsp);
 798          return cgi_error_memory();
 799       }
 800
 801       if (enlist_unique_header(rsp->headers, "Location", p))
 802       {
 803          free_http_response(rsp);
 804          return cgi_error_memory();
 805       }
 806 #endif /* Preceeding code is disabled for now */
 807    }
 808    else
 809 #endif /* def FEATURE_IMAGE_BLOCKING */
 810
 811    /*
 812     * Else, generate an HTML "blocked" message:
 813     */
 814    {
 815       jb_err err;
 816       struct map * exports;
 817
 818       /*
 819        * Workaround for stupid Netscape bug which prevents
 820        * pages from being displayed if loading a referenced
 821        * JavaScript or style sheet fails. So make it appear
 822        * as if it succeeded.
 823        */
 824       if ( NULL != (p = get_header_value(csp->headers, "User-Agent:"))
 825            && !strncmpic(p, "mozilla", 7) /* Catch Netscape but */
 826            && !strstr(p, "Gecko")         /* save Mozilla, */
 827            && !strstr(p, "compatible")    /* MSIE */
 828            && !strstr(p, "Opera"))        /* and Opera. */
 829       {
 830          rsp->status = strdup("200 Request for blocked URL");
 831       }
 832       else
 833       {
 834          rsp->status = strdup("404 Request for blocked URL");
 835       }
 836
 837       if (rsp->status == NULL)
 838       {
 839          free_http_response(rsp);
 840          return cgi_error_memory();
 841       }
 842
 843       exports = default_exports(csp, NULL);
 844       if (exports == NULL)
 845       {
 846          free_http_response(rsp);
 847          return cgi_error_memory();
 848       }
 849
 850 #ifdef FEATURE_FORCE_LOAD
 851       err = map(exports, "force-prefix", 1, FORCE_PREFIX, 1);
 852       if (csp->http->ssl != 0)
 853 #endif /* ndef FEATURE_FORCE_LOAD */
 854       {
 855          err = map_block_killer(exports, "force-support");
 856       }
 857
 858       if (!err) err = map(exports, "protocol", 1, csp->http->ssl ? "https://" : "http://", 1);
 859       if (!err) err = map(exports, "hostport", 1, html_encode(csp->http->hostport), 0);
 860       if (!err) err = map(exports, "path", 1, html_encode(csp->http->path), 0);
 861
 862       if (err)
 863       {
 864          free_map(exports);
 865          free_http_response(rsp);
 866          return cgi_error_memory();
 867       }
 868
 869       err = template_fill_for_cgi(csp, "blocked", exports, rsp);
 870       if (err)
 871       {
 872          free_http_response(rsp);
 873          return cgi_error_memory();
 874       }
 875    }
 876
 877    return finish_http_response(rsp);
 878
 879 }
 880
 881
 882 #ifdef FEATURE_TRUST
 883 /*********************************************************************
 884  *
 885  * Function    :  trust_url FIXME: I should be called distrust_url
 886  *
 887  * Description :  Calls is_untrusted_url to determine if the URL is trusted
 888  *                and if not, returns a HTTP 304 response with a reject message.
 889  *
 890  * Parameters  :
 891  *          1  :  csp = Current client state (buffers, headers, etc...)
 892  *
 893  * Returns     :  NULL => trusted, else http_response.
 894  *
 895  *********************************************************************/
 896 struct http_response *trust_url(struct client_state *csp)
 897 {
 898    struct http_response *rsp;
 899    struct map * exports;
 900    char buf[BUFFER_SIZE];
 901    char *p;
 902    struct url_spec **tl;
 903    struct url_spec *t;
 904    jb_err err;
 905
 906    /*
 907     * Don't bother to work on trusted URLs
 908     */
 909    if (!is_untrusted_url(csp))
 910    {
 911       return NULL;
 912    }
 913
 914    /*
 915     * Else, prepare a response:
 916     */
 917    if (NULL == (rsp = alloc_http_response()))
 918    {
 919       return cgi_error_memory();
 920    }
 921
 922    exports = default_exports(csp, NULL);
 923    if (exports == NULL)
 924    {
 925       free_http_response(rsp);
 926       return cgi_error_memory();
 927    }
 928
 929    /*
 930     * Export the protocol, host, port, and referrer information
 931     */
 932    err = map(exports, "hostport", 1, csp->http->hostport, 1);
 933    if (!err) err = map(exports, "protocol", 1, csp->http->ssl ? "https://" : "http://", 1);
 934    if (!err) err = map(exports, "path", 1, csp->http->path, 1);
 935
 936    if (NULL != (p = get_header_value(csp->headers, "Referer:")))
 937    {
 938       if (!err) err = map(exports, "referrer", 1, html_encode(p), 0);
 939    }
 940    else
 941    {
 942       if (!err) err = map(exports, "referrer", 1, "unknown", 1);
 943    }
 944
 945    if (err)
 946    {
 947       free_map(exports);
 948       free_http_response(rsp);
 949       return cgi_error_memory();
 950    }
 951
 952    /*
 953     * Export the trust list
 954     */
 955    p = strdup("");
 956    for (tl = csp->config->trust_list; (t = *tl) != NULL ; tl++)
 957    {
 958       sprintf(buf, "<li>%s</li>\n", t->spec);
 959       string_append(&p, buf);
 960    }
 961    err = map(exports, "trusted-referrers", 1, p, 0);
 962
 963    if (err)
 964    {
 965       free_map(exports);
 966       free_http_response(rsp);
 967       return cgi_error_memory();
 968    }
 969
 970    /*
 971     * Export the trust info, if available
 972     */
 973    if (csp->config->trust_info->first)
 974    {
 975       struct list_entry *l;
 976
 977       p = strdup("");
 978       for (l = csp->config->trust_info->first; l ; l = l->next)
 979       {
 980          sprintf(buf, "<li> <a href=\"%s\">%s</a><br>\n",l->str, l->str);
 981          string_append(&p, buf);
 982       }
 983       err = map(exports, "trust-info", 1, p, 0);
 984    }
 985    else
 986    {
 987       err = map_block_killer(exports, "have-trust-info");
 988    }
 989
 990    if (err)
 991    {
 992       free_map(exports);
 993       free_http_response(rsp);
 994       return cgi_error_memory();
 995    }
 996
 997    /*
 998     * Export the force prefix or the force conditional block killer
 999     */
1000 #ifdef FEATURE_FORCE_LOAD
1001    err = map(exports, "force-prefix", 1, FORCE_PREFIX, 1);
1002 #else /* ifndef FEATURE_FORCE_LOAD */
1003    err = map_block_killer(exports, "force-support");
1004 #endif /* ndef FEATURE_FORCE_LOAD */
1005
1006    if (err)
1007    {
1008       free_map(exports);
1009       free_http_response(rsp);
1010       return cgi_error_memory();
1011    }
1012
1013    /*
1014     * Build the response
1015     */
1016    err = template_fill_for_cgi(csp, "untrusted", exports, rsp);
1017    if (err)
1018    {
1019       free_http_response(rsp);
1020       return cgi_error_memory();
1021    }
1022
1023    return finish_http_response(rsp);
1024 }
1025 #endif /* def FEATURE_TRUST */
1026
1027
1028 #ifdef FEATURE_FAST_REDIRECTS
1029 /*********************************************************************
1030  *
1031  * Function    :  redirect_url
1032  *
1033  * Description :  Checks for redirection URLs and returns a HTTP redirect
1034  *                to the destination URL, if necessary
1035  *
1036  * Parameters  :
1037  *          1  :  csp = Current client state (buffers, headers, etc...)
1038  *
1039  * Returns     :  NULL if URL was clean, HTTP redirect otherwise.
1040  *
1041  *********************************************************************/
1042 struct http_response *redirect_url(struct client_state *csp)
1043 {
1044    char *p, *q;
1045    struct http_response *rsp;
1046
1047    p = q = csp->http->path;
1048    log_error(LOG_LEVEL_REDIRECTS, "checking path for redirects: %s", p);
1049
1050    /*
1051     * find the last URL encoded in the request
1052     */
1053    while ((p = strstr(p, "http://")) != NULL)
1054    {
1055       q = p++;
1056    }
1057
1058    /*
1059     * if there was any, generate and return a HTTP redirect
1060     */
1061    if (q != csp->http->path)
1062    {
1063       log_error(LOG_LEVEL_REDIRECTS, "redirecting to: %s", q);
1064
1065       if (NULL == (rsp = alloc_http_response()))
1066       {
1067          return cgi_error_memory();
1068       }
1069
1070       if ( enlist_unique_header(rsp->headers, "Location", q)
1071         || (NULL == (rsp->status = strdup("302 Local Redirect from Privoxy"))) )
1072       {
1073          free_http_response(rsp);
1074          return cgi_error_memory();
1075       }
1076
1077       return finish_http_response(rsp);
1078    }
1079    else
1080    {
1081       return NULL;
1082    }
1083
1084 }
1085 #endif /* def FEATURE_FAST_REDIRECTS */
1086
1087
1088 #ifdef FEATURE_IMAGE_BLOCKING
1089 /*********************************************************************
1090  *
1091  * Function    :  is_imageurl
1092  *
1093  * Description :  Given a URL, decide whether it is an image or not,
1094  *                using either the info from a previous +image action
1095  *                or, #ifdef FEATURE_IMAGE_DETECT_MSIE, and the browser
1096  *                is MSIE and not on a Mac, tell from the browser's accept
1097  *                header.
1098  *
1099  * Parameters  :
1100  *          1  :  csp = Current client state (buffers, headers, etc...)
1101  *
1102  * Returns     :  True (nonzero) if URL is an image, false (0)
1103  *                otherwise
1104  *
1105  *********************************************************************/
1106 int is_imageurl(struct client_state *csp)
1107 {
1108 #ifdef FEATURE_IMAGE_DETECT_MSIE
1109    char *tmp;
1110
1111    tmp = get_header_value(csp->headers, "User-Agent:");
1112    if (tmp && strstr(tmp, "MSIE") && !strstr(tmp, "Mac_"))
1113    {
1114       tmp = get_header_value(csp->headers, "Accept:");
1115       if (tmp && strstr(tmp, "image/gif"))
1116       {
1117          /* Client will accept HTML.  If this seems counterintuitive,
1118           * blame Microsoft.
1119           */
1120          return(0);
1121       }
1122       else
1123       {
1124          return(1);
1125       }
1126    }
1127 #endif /* def FEATURE_IMAGE_DETECT_MSIE */
1128
1129    return ((csp->action->flags & ACTION_IMAGE) != 0);
1130
1131 }
1132 #endif /* def FEATURE_IMAGE_BLOCKING */
1133
1134
1135 #ifdef FEATURE_TRUST
1136 /*********************************************************************
1137  *
1138  * Function    :  is_untrusted_url
1139  *
1140  * Description :  Should we "distrust" this URL (and block it)?
1141  *
1142  *                Yes if it matches a line in the trustfile, or if the
1143  *                    referrer matches a line starting with "+" in the
1144  *                    trustfile.
1145  *                No  otherwise.
1146  *
1147  * Parameters  :
1148  *          1  :  csp = Current client state (buffers, headers, etc...)
1149  *
1150  * Returns     :  0 => trusted, 1 => untrusted
1151  *
1152  *********************************************************************/
1153 int is_untrusted_url(struct client_state *csp)
1154 {
1155    struct file_list *fl;
1156    struct block_spec *b;
1157    struct url_spec **trusted_url;
1158    struct http_request rhttp[1];
1159    const char * referer;
1160    jb_err err;
1161
1162    /*
1163     * If we don't have a trustlist, we trust everybody
1164     */
1165    if (((fl = csp->tlist) == NULL) || ((b  = fl->f) == NULL))
1166    {
1167       return 0;
1168    }
1169
1170    memset(rhttp, '\0', sizeof(*rhttp));
1171
1172    /*
1173     * Do we trust the request URL itself?
1174     */
1175    for (b = b->next; b ; b = b->next)
1176    {
1177       if (url_match(b->url, csp->http))
1178       {
1179          return b->reject;
1180       }
1181    }
1182
1183    if (NULL == (referer = get_header_value(csp->headers, "Referer:")))
1184    {
1185       /* no referrer was supplied */
1186       return 1;
1187    }
1188
1189
1190    /*
1191     * If not, do we maybe trust its referrer?
1192     */
1193    err = parse_http_url(referer, rhttp, csp);
1194    if (err)
1195    {
1196       return 1;
1197    }
1198
1199    for (trusted_url = csp->config->trust_list; *trusted_url != NULL; trusted_url++)
1200    {
1201       if (url_match(*trusted_url, rhttp))
1202       {
1203          /* if the URL's referrer is from a trusted referrer, then
1204           * add the target spec to the trustfile as an unblocked
1205           * domain and return NULL (which means it's OK).
1206           */
1207
1208          FILE *fp;
1209
1210          if (NULL != (fp = fopen(csp->config->trustfile, "a")))
1211          {
1212             char * path;
1213             char * path_end;
1214             char * new_entry = strdup("~");
1215
1216             string_append(&new_entry, csp->http->hostport);
1217
1218             path = csp->http->path;
1219             if ( (path[0] == '/')
1220               && (path[1] == '~')
1221               && ((path_end = strchr(path + 2, '/')) != NULL))
1222             {
1223                /* since this path points into a user's home space
1224                 * be sure to include this spec in the trustfile.
1225                 */
1226                int path_len = path_end - path; /* save offset */
1227                path = strdup(path); /* Copy string */
1228                if (path != NULL)
1229                {
1230                   path_end = path + path_len; /* regenerate ptr to new buffer */
1231                   *(path_end + 1) = '\0'; /* Truncate path after '/' */
1232                }
1233                string_join(&new_entry, path);
1234             }
1235
1236             if (new_entry != NULL)
1237             {
1238                fprintf(fp, "%s\n", new_entry);
1239                free(new_entry);
1240             }
1241             else
1242             {
1243                /* FIXME: No way to handle out-of memory, so mostly ignoring it */
1244                log_error(LOG_LEVEL_ERROR, "Out of memory adding pattern to trust file");
1245             }
1246
1247             fclose(fp);
1248          }
1249          return 0;
1250       }
1251    }
1252    return 1;
1253 }
1254 #endif /* def FEATURE_TRUST */
1255
1256
1257 /*********************************************************************
1258  *
1259  * Function    :  pcrs_filter_response
1260  *
1261  * Description :  Execute all text substitutions from all applying
1262  *                +filter actions on the text buffer that's been accumulated
1263  *                in csp->iob->buf. If this changes the contents, set
1264  *                csp->content_length to the modified size and raise the
1265  *                CSP_FLAG_MODIFIED flag.
1266  *
1267  * Parameters  :
1268  *          1  :  csp = Current client state (buffers, headers, etc...)
1269  *
1270  * Returns     :  a pointer to the (newly allocated) modified buffer.
1271  *                or NULL if there were no hits or something went wrong
1272  *
1273  *********************************************************************/
1274 char *pcrs_filter_response(struct client_state *csp)
1275 {
1276    int hits=0;
1277    size_t size;
1278
1279    char *old = csp->iob->cur, *new = NULL;
1280    pcrs_job *job;
1281
1282    struct file_list *fl;
1283    struct re_filterfile_spec *b;
1284    struct list_entry *filtername;
1285
1286    /*
1287     * Sanity first
1288     */
1289    if (csp->iob->cur >= csp->iob->eod)
1290    {
1291       return(NULL);
1292    }
1293    size = csp->iob->eod - csp->iob->cur;
1294
1295    if ( ( NULL == (fl = csp->rlist) ) || ( NULL == fl->f) )
1296    {
1297       log_error(LOG_LEVEL_ERROR, "Unable to get current state of regexp filtering.");
1298       return(NULL);
1299    }
1300
1301    /*
1302     * If the body has a "chunked" transfer-encoding,
1303     * get rid of it first, adjusting size and iob->eod
1304     */
1305    if (csp->flags & CSP_FLAG_CHUNKED)
1306    {
1307       log_error(LOG_LEVEL_RE_FILTER, "Need to de-chunk first");
1308       if (0 == (size = remove_chunked_transfer_coding(csp->iob->cur, size)))
1309       {
1310          return(NULL);
1311       }
1312       csp->iob->eod = csp->iob->cur + size;
1313       csp->flags |= CSP_FLAG_MODIFIED;
1314    }
1315
1316    /*
1317     * For all applying +filter actions, look if a filter by that
1318     * name exists and if yes, execute it's pcrs_joblist on the
1319     * buffer.
1320     */
1321    for (b = fl->f; b; b = b->next)
1322    {
1323       for (filtername = csp->action->multi[ACTION_MULTI_FILTER]->first;
1324            filtername ; filtername = filtername->next)
1325       {
1326          if (strcmp(b->name, filtername->str) == 0)
1327          {
1328             int current_hits = 0;
1329
1330             if ( NULL == b->joblist )
1331             {
1332                log_error(LOG_LEVEL_RE_FILTER, "Filter %s has empty joblist. Nothing to do.", b->name);
1333                continue;
1334             }
1335
1336             log_error(LOG_LEVEL_RE_FILTER, "re_filtering %s%s (size %d) with filter %s...",
1337                       csp->http->hostport, csp->http->path, size, b->name);
1338
1339             /* Apply all jobs from the joblist */
1340             for (job = b->joblist; NULL != job; job = job->next)
1341             {
1342                current_hits += pcrs_execute(job, old, size, &new, &size);
1343                if (old != csp->iob->cur) free(old);
1344                old=new;
1345             }
1346
1347             log_error(LOG_LEVEL_RE_FILTER, " ...produced %d hits (new size %d).", current_hits, size);
1348             hits += current_hits;
1349          }
1350       }
1351    }
1352
1353    /*
1354     * If there were no hits, destroy our copy and let
1355     * chat() use the original in csp->iob
1356     */
1357    if (!hits)
1358    {
1359       free(new);
1360       return(NULL);
1361    }
1362
1363    csp->flags |= CSP_FLAG_MODIFIED;
1364    csp->content_length = size;
1365    IOB_RESET(csp);
1366
1367    return(new);
1368
1369 }
1370
1371
1372 /*********************************************************************
1373  *
1374  * Function    :  gif_deanimate_response
1375  *
1376  * Description :  Deanimate the GIF image that has been accumulated in
1377  *                csp->iob->buf, set csp->content_length to the modified
1378  *                size and raise the CSP_FLAG_MODIFIED flag.
1379  *
1380  * Parameters  :
1381  *          1  :  csp = Current client state (buffers, headers, etc...)
1382  *
1383  * Returns     :  a pointer to the (newly allocated) modified buffer.
1384  *                or NULL in case something went wrong.
1385  *
1386  *********************************************************************/
1387 char *gif_deanimate_response(struct client_state *csp)
1388 {
1389    struct binbuffer *in, *out;
1390    char *p;
1391    size_t size = csp->iob->eod - csp->iob->cur;
1392
1393    /*
1394     * If the body has a "chunked" transfer-encoding,
1395     * get rid of it first, adjusting size and iob->eod
1396     */
1397    if (csp->flags & CSP_FLAG_CHUNKED)
1398    {
1399       log_error(LOG_LEVEL_DEANIMATE, "Need to de-chunk first");
1400       if (0 == (size = remove_chunked_transfer_coding(csp->iob->cur, size)))
1401       {
1402          return(NULL);
1403       }
1404       csp->iob->eod = csp->iob->cur + size;
1405       csp->flags |= CSP_FLAG_MODIFIED;
1406    }
1407
1408    if (  (NULL == (in =  (struct binbuffer *)zalloc(sizeof *in )))
1409       || (NULL == (out = (struct binbuffer *)zalloc(sizeof *out))) )
1410    {
1411       log_error(LOG_LEVEL_DEANIMATE, "failed! (no mem)");
1412       return NULL;
1413    }
1414
1415    in->buffer = csp->iob->cur;
1416    in->size = size;
1417
1418    if (gif_deanimate(in, out, strncmp("last", csp->action->string[ACTION_STRING_DEANIMATE], 4)))
1419    {
1420       log_error(LOG_LEVEL_DEANIMATE, "failed! (gif parsing)");
1421       free(in);
1422       buf_free(out);
1423       return(NULL);
1424    }
1425    else
1426    {
1427       if ((int)size == out->offset)
1428       {
1429          log_error(LOG_LEVEL_DEANIMATE, "GIF not changed.");
1430       }
1431       else
1432       {
1433          log_error(LOG_LEVEL_DEANIMATE, "Success! GIF shrunk from %d bytes to %d.", size, out->offset);
1434       }
1435       csp->content_length = out->offset;
1436       csp->flags |= CSP_FLAG_MODIFIED;
1437       p = out->buffer;
1438       free(in);
1439       free(out);
1440       return(p);
1441    }
1442
1443 }
1444
1445
1446 /*********************************************************************
1447  *
1448  * Function    :  remove_chunked_transfer_coding
1449  *
1450  * Description :  In-situ remove the "chunked" transfer coding as defined
1451  *                in rfc2616 from a buffer.
1452  *
1453  * Parameters  :
1454  *          1  :  buffer = Pointer to the text buffer
1455  *          2  :  size = Number of bytes to be processed
1456  *
1457  * Returns     :  The new size, i.e. the number of bytes from buffer which
1458  *                are occupied by the stripped body, or 0 in case something
1459  *                went wrong
1460  *
1461  *********************************************************************/
1462 int remove_chunked_transfer_coding(char *buffer, const size_t size)
1463 {
1464    size_t newsize = 0;
1465    unsigned int chunksize = 0;
1466    char *from_p, *to_p;
1467
1468    assert(buffer);
1469    from_p = to_p = buffer;
1470
1471    if (sscanf(buffer, "%x", &chunksize) != 1)
1472    {
1473       log_error(LOG_LEVEL_ERROR, "Invalid first chunksize while stripping \"chunked\" transfer coding");
1474       return(0);
1475    }
1476
1477    while (chunksize > 0)
1478    {
1479       if (NULL == (from_p = strstr(from_p, "\r\n")))
1480       {
1481          log_error(LOG_LEVEL_ERROR, "Parse error while stripping \"chunked\" transfer coding");
1482          return(0);
1483       }
1484
1485       if ((newsize += chunksize) >= size)
1486       {
1487          log_error(LOG_LEVEL_ERROR, "Chunksize exceeds buffer in  \"chunked\" transfer coding");
1488          return(0);
1489       }
1490       from_p += 2;
1491
1492       memmove(to_p, from_p, (size_t) chunksize);
1493       to_p = buffer + newsize;
1494       from_p += chunksize + 2;
1495
1496       if (sscanf(from_p, "%x", &chunksize) != 1)
1497       {
1498          log_error(LOG_LEVEL_ERROR, "Parse error while stripping \"chunked\" transfer coding");
1499          return(0);
1500       }
1501    }
1502
1503    /* FIXME: Should this get its own loglevel? */
1504    log_error(LOG_LEVEL_RE_FILTER, "De-chunking successful. Shrunk from %d to %d\n", size, newsize);
1505    return(newsize);
1506
1507 }
1508
1509
1510 /*********************************************************************
1511  *
1512  * Function    :  url_actions
1513  *
1514  * Description :  Gets the actions for this URL.
1515  *
1516  * Parameters  :
1517  *          1  :  http = http_request request for blocked URLs
1518  *          2  :  csp = Current client state (buffers, headers, etc...)
1519  *
1520  * Returns     :  N/A
1521  *
1522  *********************************************************************/
1523 void url_actions(struct http_request *http,
1524                  struct client_state *csp)
1525 {
1526    struct file_list *fl;
1527    struct url_actions *b;
1528    int i;
1529
1530    init_current_action(csp->action);
1531
1532    for (i = 0; i < MAX_ACTION_FILES; i++)
1533    {
1534       if (((fl = csp->actions_list[i]) == NULL) || ((b = fl->f) == NULL))
1535       {
1536          return;
1537       }
1538
1539       apply_url_actions(csp->action, http, b);
1540    }
1541
1542    return;
1543 }
1544
1545
1546 /*********************************************************************
1547  *
1548  * Function    :  apply_url_actions
1549  *
1550  * Description :  Applies a list of URL actions.
1551  *
1552  * Parameters  :
1553  *          1  :  action = Destination.
1554  *          2  :  http = Current URL
1555  *          3  :  b = list of URL actions to apply
1556  *
1557  * Returns     :  N/A
1558  *
1559  *********************************************************************/
1560 void apply_url_actions(struct current_action_spec *action,
1561                        struct http_request *http,
1562                        struct url_actions *b)
1563 {
1564    if (b == NULL)
1565    {
1566       /* Should never happen */
1567       return;
1568    }
1569
1570    for (b = b->next; NULL != b; b = b->next)
1571    {
1572       if (url_match(b->url, http))
1573       {
1574          merge_current_action(action, b->action);
1575       }
1576    }
1577 }
1578
1579
1580 /*********************************************************************
1581  *
1582  * Function    :  forward_url
1583  *
1584  * Description :  Should we forward this to another proxy?
1585  *
1586  * Parameters  :
1587  *          1  :  http = http_request request for current URL
1588  *          2  :  csp = Current client state (buffers, headers, etc...)
1589  *
1590  * Returns     :  Pointer to forwarding information.
1591  *
1592  *********************************************************************/
1593 const struct forward_spec * forward_url(struct http_request *http,
1594                                         struct client_state *csp)
1595 {
1596    static const struct forward_spec fwd_default[1] = { FORWARD_SPEC_INITIALIZER };
1597    struct forward_spec *fwd = csp->config->forward;
1598
1599    if (fwd == NULL)
1600    {
1601       return fwd_default;
1602    }
1603
1604    while (fwd != NULL)
1605    {
1606       if (url_match(fwd->url, http))
1607       {
1608          return fwd;
1609       }
1610       fwd = fwd->next;
1611    }
1612
1613    return fwd_default;
1614 }
1615
1616
1617 /*********************************************************************
1618  *
1619  * Function    :  direct_response
1620  *
1621  * Description :  Check if Max-Forwards == 0 for an OPTIONS or TRACE
1622  *                request and if so, return a HTTP 501 to the client.
1623  *
1624  *                FIXME: I have a stupid name and I should handle the
1625  *                requests properly. Still, what we do here is rfc-
1626  *                compliant, whereas ignoring or forwarding are not.
1627  *
1628  * Parameters  :
1629  *          1  :  csp = Current client state (buffers, headers, etc...)
1630  *
1631  * Returns     :  http_response if , NULL if nonmatch or handler fail
1632  *
1633  *********************************************************************/
1634 struct http_response *direct_response(struct client_state *csp)
1635 {
1636    struct http_response *rsp;
1637    struct list_entry *p;
1638
1639    if ((0 == strcmpic(csp->http->gpc, "trace"))
1640       || (0 == strcmpic(csp->http->gpc, "options")))
1641    {
1642       for (p = csp->headers->first; (p != NULL) ; p = p->next)
1643       {
1644          if (!strncmp("Max-Forwards:", p->str, 13)
1645              && (*(p->str+13) != '\0') && (atoi(p->str+13) == 0))
1646          {
1647             /* FIXME: We could handle at least TRACE here,
1648                but that would require a verbatim copy of
1649                the request which we don't have anymore */
1650
1651             log_error(LOG_LEVEL_HEADER, "Found Max-Forwards:0 in OPTIONS or TRACE request -- Returning 501");
1652
1653             /* Get mem for response or fail*/
1654             if (NULL == (rsp = alloc_http_response()))
1655             {
1656                return cgi_error_memory();
1657             }
1658
1659             if (NULL == (rsp->status = strdup("501 Not Implemented")))
1660             {
1661                free_http_response(rsp);
1662                return cgi_error_memory();
1663             }
1664
1665             rsp->is_static = 1;
1666             return(finish_http_response(rsp));
1667          }
1668       }
1669    }
1670    return NULL;
1671 }
1672
1673
1674 /*
1675   Local Variables:
1676   tab-width: 3
1677   end:
1678 */