filters.c

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