src/filters.c

   1 const char filters_rcs[] = "$Id: filters.c,v 2.2 2002/09/04 15:38:24 oes Exp $";
   2 /*********************************************************************
   3  *
   4  * File        :  $Source: /cvsroot/ijbswa/current/src/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 2.2  2002/09/04 15:38:24  oes
  42  *    Synced with the stable branch:
  43  *        Revision 1.58.2.2  2002/08/01 17:18:28  oes
  44  *        Fixed BR 537651 / SR 579724 (MSIE image detect improper for IE/Mac)
  45  *
  46  *        Revision 1.58.2.1  2002/07/26 15:18:53  oes
  47  *        - Bugfix: Executing a filters without jobs no longer results in
  48  *          turing off *all* filters.
  49  *        - Security fix: Malicious web servers can't cause a seg fault
  50  *          through bogus chunk sizes anymore
  51  *
  52  *    Revision 2.1  2002/08/26 11:08:18  sarantis
  53  *    Fix typo.
  54  *
  55  *    Revision 2.0  2002/06/04 14:34:21  jongfoster
  56  *    Moving source files to src/
  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 failure
 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 #ifdef FEATURE_ACTIVITY_CONSOLE
 455 #include "stats.h"
 456 #endif /* def FEATURE_ACTIVITY_CONSOLE */
 457 #ifdef _WIN32
 458 #include "win32.h"
 459 #endif
 460
 461 const char filters_h_rcs[] = FILTERS_H_VERSION;
 462
 463 /* Fix a problem with Solaris.  There should be no effect on other
 464  * platforms.
 465  * Solaris's isspace() is a macro which uses it's argument directly
 466  * as an array index.  Therefore we need to make sure that high-bit
 467  * characters generate +ve values, and ideally we also want to make
 468  * the argument match the declared parameter type of "int".
 469  */
 470 #define ijb_isdigit(__X) isdigit((int)(unsigned char)(__X))
 471
 472
 473 #ifdef FEATURE_ACL
 474 /*********************************************************************
 475  *
 476  * Function    :  block_acl
 477  *
 478  * Description :  Block this request?
 479  *                Decide yes or no based on ACL file.
 480  *
 481  * Parameters  :
 482  *          1  :  dst = The proxy or gateway address this is going to.
 483  *                      Or NULL to check all possible targets.
 484  *          2  :  csp = Current client state (buffers, headers, etc...)
 485  *                      Also includes the client IP address.
 486  *
 487  * Returns     : 0 = FALSE (don't block) and 1 = TRUE (do block)
 488  *
 489  *********************************************************************/
 490 int block_acl(struct access_control_addr *dst, struct client_state *csp)
 491 {
 492    struct access_control_list *acl = csp->config->acl;
 493
 494    /* if not using an access control list, then permit the connection */
 495    if (acl == NULL)
 496    {
 497       return(0);
 498    }
 499
 500    /* search the list */
 501    while (acl != NULL)
 502    {
 503       if ((csp->ip_addr_long & acl->src->mask) == acl->src->addr)
 504       {
 505          if (dst == NULL)
 506          {
 507             /* Just want to check if they have any access */
 508             if (acl->action == ACL_PERMIT)
 509             {
 510                return(0);
 511             }
 512          }
 513          else if ( ((dst->addr & acl->dst->mask) == acl->dst->addr)
 514            && ((dst->port == acl->dst->port) || (acl->dst->port == 0)))
 515          {
 516             if (acl->action == ACL_PERMIT)
 517             {
 518                return(0);
 519             }
 520             else
 521             {
 522 #ifdef FEATURE_ACTIVITY_CONSOLE
 523                accumulate_stats(STATS_ACL_RESTRICT, 1);
 524 #endif /* def FEATURE_ACTIVITY_CONSOLE */
 525                return(1);
 526             }
 527          }
 528       }
 529       acl = acl->next;
 530    }
 531
 532    return(1);
 533
 534 }
 535
 536
 537 /*********************************************************************
 538  *
 539  * Function    :  acl_addr
 540  *
 541  * Description :  Called from `load_config' to parse an ACL address.
 542  *
 543  * Parameters  :
 544  *          1  :  aspec = String specifying ACL address.
 545  *          2  :  aca = struct access_control_addr to fill in.
 546  *
 547  * Returns     :  0 => Ok, everything else is an error.
 548  *
 549  *********************************************************************/
 550 int acl_addr(char *aspec, struct access_control_addr *aca)
 551 {
 552    int i, masklength, port;
 553    char *p;
 554
 555    masklength = 32;
 556    port       =  0;
 557
 558    if ((p = strchr(aspec, '/')) != NULL)
 559    {
 560       *p++ = '\0';
 561
 562       if (ijb_isdigit(*p) == 0)
 563       {
 564          return(-1);
 565       }
 566       masklength = atoi(p);
 567    }
 568
 569    if ((masklength < 0) || (masklength > 32))
 570    {
 571       return(-1);
 572    }
 573
 574    if ((p = strchr(aspec, ':')) != NULL)
 575    {
 576       *p++ = '\0';
 577
 578       if (ijb_isdigit(*p) == 0)
 579       {
 580          return(-1);
 581       }
 582       port = atoi(p);
 583    }
 584
 585    aca->port = port;
 586
 587    aca->addr = ntohl(resolve_hostname_to_ip(aspec));
 588
 589    if (aca->addr == INADDR_NONE)
 590    {
 591       return(-1);
 592    }
 593
 594    /* build the netmask */
 595    aca->mask = 0;
 596    for (i=1; i <= masklength ; i++)
 597    {
 598       aca->mask |= (1 << (32 - i));
 599    }
 600
 601    /* now mask off the host portion of the ip address
 602     * (i.e. save on the network portion of the address).
 603     */
 604    aca->addr = aca->addr & aca->mask;
 605
 606    return(0);
 607
 608 }
 609 #endif /* def FEATURE_ACL */
 610
 611
 612 /*********************************************************************
 613  *
 614  * Function    :  match_portlist
 615  *
 616  * Description :  Check if a given number is covered by a comma
 617  *                separated list of numbers and ranges (a,b-c,d,..)
 618  *
 619  * Parameters  :
 620  *          1  :  portlist = String with list
 621  *          2  :  port = port to check
 622  *
 623  * Returns     :  0 => no match
 624  *                1 => match
 625  *
 626  *********************************************************************/
 627 int match_portlist(const char *portlist, int port)
 628 {
 629    char *min, *max, *next, *portlist_copy;
 630
 631    min = next = portlist_copy = strdup(portlist);
 632
 633    /*
 634     * Zero-terminate first item and remember offset for next
 635     */
 636    if (NULL != (next = strchr(portlist_copy, (int) ',')))
 637    {
 638       *next++ = '\0';
 639    }
 640
 641    /*
 642     * Loop through all items, checking for match
 643     */
 644    while(min)
 645    {
 646       if (NULL == (max = strchr(min, (int) '-')))
 647       {
 648          /*
 649           * No dash, check for equality
 650           */
 651          if (port == atoi(min))
 652          {
 653             free(portlist_copy);
 654             return(1);
 655          }
 656       }
 657       else
 658       {
 659          /*
 660           * This is a range, so check if between min and max,
 661           * or, if max was omitted, between min and 65K
 662           */
 663          *max++ = '\0';
 664          if(port >= atoi(min) && port <= (atoi(max) ? atoi(max) : 65535))
 665          {
 666             free(portlist_copy);
 667             return(1);
 668          }
 669
 670       }
 671
 672       /*
 673        * Jump to next item
 674        */
 675       min = next;
 676
 677       /*
 678        * Zero-terminate next item and remember offset for n+1
 679        */
 680       if ((NULL != next) && (NULL != (next = strchr(next, (int) ','))))
 681       {
 682          *next++ = '\0';
 683       }
 684    }
 685
 686    free(portlist_copy);
 687    return 0;
 688
 689 }
 690
 691
 692 /*********************************************************************
 693  *
 694  * Function    :  block_url
 695  *
 696  * Description :  Called from `chat'.  Check to see if we need to block this.
 697  *
 698  * Parameters  :
 699  *          1  :  csp = Current client state (buffers, headers, etc...)
 700  *
 701  * Returns     :  NULL => unblocked, else HTTP block response
 702  *
 703  *********************************************************************/
 704 struct http_response *block_url(struct client_state *csp)
 705 {
 706 #ifdef FEATURE_IMAGE_BLOCKING
 707    char *p;
 708 #endif /* def FEATURE_IMAGE_BLOCKING */
 709    struct http_response *rsp;
 710
 711    /*
 712     * If it's not blocked, don't block it ;-)
 713     */
 714    if ((csp->action->flags & ACTION_BLOCK) == 0)
 715    {
 716       return NULL;
 717    }
 718
 719    /*
 720     * Else, prepare a response
 721     */
 722    if (NULL == (rsp = alloc_http_response()))
 723    {
 724       return cgi_error_memory();
 725    }
 726
 727    /*
 728     * If it's an image-url, send back an image or redirect
 729     * as specified by the relevant +image action
 730     */
 731 #ifdef FEATURE_IMAGE_BLOCKING
 732    if (((csp->action->flags & ACTION_IMAGE_BLOCKER) != 0)
 733         && is_imageurl(csp))
 734    {
 735       /* determine HOW images should be blocked */
 736       p = csp->action->string[ACTION_STRING_IMAGE_BLOCKER];
 737
 738 #if 1 /* Two alternative strategies, use this one for now: */
 739
 740       /* and handle accordingly: */
 741       if ((p == NULL) || (0 == strcmpic(p, "pattern")))
 742       {
 743 #ifdef FEATURE_ACTIVITY_CONSOLE
 744          accumulate_stats(STATS_IMAGE_BLOCK, 1);
 745 #endif /* def FEATURE_ACTIVITY_CONSOLE */
 746          rsp->body = bindup(image_pattern_data, image_pattern_length);
 747          if (rsp->body == NULL)
 748          {
 749             free_http_response(rsp);
 750             return cgi_error_memory();
 751          }
 752          rsp->content_length = image_pattern_length;
 753
 754          if (enlist_unique_header(rsp->headers, "Content-Type", BUILTIN_IMAGE_MIMETYPE))
 755          {
 756             free_http_response(rsp);
 757             return cgi_error_memory();
 758          }
 759       }
 760
 761       else if (0 == strcmpic(p, "blank"))
 762       {
 763 #ifdef FEATURE_ACTIVITY_CONSOLE
 764          accumulate_stats(STATS_IMAGE_BLOCK, 1);
 765 #endif /* def FEATURE_ACTIVITY_CONSOLE */
 766          rsp->body = bindup(image_blank_data, image_blank_length);
 767          if (rsp->body == NULL)
 768          {
 769             free_http_response(rsp);
 770             return cgi_error_memory();
 771          }
 772          rsp->content_length = image_blank_length;
 773
 774          if (enlist_unique_header(rsp->headers, "Content-Type", BUILTIN_IMAGE_MIMETYPE))
 775          {
 776             free_http_response(rsp);
 777             return cgi_error_memory();
 778          }
 779       }
 780
 781       else
 782       {
 783          rsp->status = strdup("302 Local Redirect from Privoxy");
 784          if (rsp->status == NULL)
 785          {
 786             free_http_response(rsp);
 787             return cgi_error_memory();
 788          }
 789
 790          if (enlist_unique_header(rsp->headers, "Location", p))
 791          {
 792             free_http_response(rsp);
 793             return cgi_error_memory();
 794          }
 795       }
 796
 797 #else /* Following code is disabled for now */
 798
 799       /* and handle accordingly: */
 800       if ((p == NULL) || (0 == strcmpic(p, "pattern")))
 801       {
 802          p = CGI_PREFIX "send-banner?type=pattern";
 803       }
 804       else if (0 == strcmpic(p, "blank"))
 805       {
 806          p = CGI_PREFIX "send-banner?type=blank";
 807       }
 808       rsp->status = strdup("302 Local Redirect from Privoxy");
 809       if (rsp->status == NULL)
 810       {
 811          free_http_response(rsp);
 812          return cgi_error_memory();
 813       }
 814
 815       if (enlist_unique_header(rsp->headers, "Location", p))
 816       {
 817          free_http_response(rsp);
 818          return cgi_error_memory();
 819       }
 820 #endif /* Preceeding code is disabled for now */
 821    }
 822    else
 823 #endif /* def FEATURE_IMAGE_BLOCKING */
 824
 825    /*
 826     * Else, generate an HTML "blocked" message:
 827     */
 828    {
 829       jb_err err;
 830       struct map * exports;
 831
 832       /*
 833        * Workaround for stupid Netscape bug which prevents
 834        * pages from being displayed if loading a referenced
 835        * JavaScript or style sheet fails. So make it appear
 836        * as if it succeeded.
 837        */
 838       if ( NULL != (p = get_header_value(csp->headers, "User-Agent:"))
 839            && !strncmpic(p, "mozilla", 7) /* Catch Netscape but */
 840            && !strstr(p, "Gecko")         /* save Mozilla, */
 841            && !strstr(p, "compatible")    /* MSIE */
 842            && !strstr(p, "Opera"))        /* and Opera. */
 843       {
 844          rsp->status = strdup("200 Request for blocked URL");
 845       }
 846       else
 847       {
 848          rsp->status = strdup("404 Request for blocked URL");
 849       }
 850
 851       if (rsp->status == NULL)
 852       {
 853          free_http_response(rsp);
 854          return cgi_error_memory();
 855       }
 856
 857       exports = default_exports(csp, NULL);
 858       if (exports == NULL)
 859       {
 860          free_http_response(rsp);
 861          return cgi_error_memory();
 862       }
 863
 864 #ifdef FEATURE_FORCE_LOAD
 865       err = map(exports, "force-prefix", 1, FORCE_PREFIX, 1);
 866       if (csp->http->ssl != 0)
 867 #endif /* ndef FEATURE_FORCE_LOAD */
 868       {
 869          err = map_block_killer(exports, "force-support");
 870       }
 871
 872       if (!err) err = map(exports, "protocol", 1, csp->http->ssl ? "https://" : "http://", 1);
 873       if (!err) err = map(exports, "hostport", 1, html_encode(csp->http->hostport), 0);
 874       if (!err) err = map(exports, "path", 1, html_encode(csp->http->path), 0);
 875
 876       if (err)
 877       {
 878          free_map(exports);
 879          free_http_response(rsp);
 880          return cgi_error_memory();
 881       }
 882
 883       err = template_fill_for_cgi(csp, "blocked", exports, rsp);
 884       if (err)
 885       {
 886          free_http_response(rsp);
 887          return cgi_error_memory();
 888       }
 889    }
 890
 891    return finish_http_response(rsp);
 892
 893 }
 894
 895
 896 #ifdef FEATURE_TRUST
 897 /*********************************************************************
 898  *
 899  * Function    :  trust_url FIXME: I should be called distrust_url
 900  *
 901  * Description :  Calls is_untrusted_url to determine if the URL is trusted
 902  *                and if not, returns a HTTP 304 response with a reject message.
 903  *
 904  * Parameters  :
 905  *          1  :  csp = Current client state (buffers, headers, etc...)
 906  *
 907  * Returns     :  NULL => trusted, else http_response.
 908  *
 909  *********************************************************************/
 910 struct http_response *trust_url(struct client_state *csp)
 911 {
 912    struct http_response *rsp;
 913    struct map * exports;
 914    char buf[BUFFER_SIZE];
 915    char *p;
 916    struct url_spec **tl;
 917    struct url_spec *t;
 918    jb_err err;
 919
 920    /*
 921     * Don't bother to work on trusted URLs
 922     */
 923    if (!is_untrusted_url(csp))
 924    {
 925       return NULL;
 926    }
 927
 928    /*
 929     * Else, prepare a response:
 930     */
 931    if (NULL == (rsp = alloc_http_response()))
 932    {
 933       return cgi_error_memory();
 934    }
 935
 936    exports = default_exports(csp, NULL);
 937    if (exports == NULL)
 938    {
 939       free_http_response(rsp);
 940       return cgi_error_memory();
 941    }
 942
 943    /*
 944     * Export the protocol, host, port, and referrer information
 945     */
 946    err = map(exports, "hostport", 1, csp->http->hostport, 1);
 947    if (!err) err = map(exports, "protocol", 1, csp->http->ssl ? "https://" : "http://", 1);
 948    if (!err) err = map(exports, "path", 1, csp->http->path, 1);
 949
 950    if (NULL != (p = get_header_value(csp->headers, "Referer:")))
 951    {
 952       if (!err) err = map(exports, "referrer", 1, html_encode(p), 0);
 953    }
 954    else
 955    {
 956       if (!err) err = map(exports, "referrer", 1, "unknown", 1);
 957    }
 958
 959    if (err)
 960    {
 961       free_map(exports);
 962       free_http_response(rsp);
 963       return cgi_error_memory();
 964    }
 965
 966    /*
 967     * Export the trust list
 968     */
 969    p = strdup("");
 970    for (tl = csp->config->trust_list; (t = *tl) != NULL ; tl++)
 971    {
 972       sprintf(buf, "<li>%s</li>\n", t->spec);
 973       string_append(&p, buf);
 974    }
 975    err = map(exports, "trusted-referrers", 1, p, 0);
 976
 977    if (err)
 978    {
 979       free_map(exports);
 980       free_http_response(rsp);
 981       return cgi_error_memory();
 982    }
 983
 984    /*
 985     * Export the trust info, if available
 986     */
 987    if (csp->config->trust_info->first)
 988    {
 989       struct list_entry *l;
 990
 991       p = strdup("");
 992       for (l = csp->config->trust_info->first; l ; l = l->next)
 993       {
 994          sprintf(buf, "<li> <a href=\"%s\">%s</a><br>\n",l->str, l->str);
 995          string_append(&p, buf);
 996       }
 997       err = map(exports, "trust-info", 1, p, 0);
 998    }
 999    else
1000    {
1001       err = map_block_killer(exports, "have-trust-info");
1002    }
1003
1004    if (err)
1005    {
1006       free_map(exports);
1007       free_http_response(rsp);
1008       return cgi_error_memory();
1009    }
1010
1011    /*
1012     * Export the force prefix or the force conditional block killer
1013     */
1014 #ifdef FEATURE_FORCE_LOAD
1015    err = map(exports, "force-prefix", 1, FORCE_PREFIX, 1);
1016 #else /* ifndef FEATURE_FORCE_LOAD */
1017    err = map_block_killer(exports, "force-support");
1018 #endif /* ndef FEATURE_FORCE_LOAD */
1019
1020    if (err)
1021    {
1022       free_map(exports);
1023       free_http_response(rsp);
1024       return cgi_error_memory();
1025    }
1026
1027    /*
1028     * Build the response
1029     */
1030    err = template_fill_for_cgi(csp, "untrusted", exports, rsp);
1031    if (err)
1032    {
1033       free_http_response(rsp);
1034       return cgi_error_memory();
1035    }
1036
1037    return finish_http_response(rsp);
1038 }
1039 #endif /* def FEATURE_TRUST */
1040
1041
1042 #ifdef FEATURE_FAST_REDIRECTS
1043 /*********************************************************************
1044  *
1045  * Function    :  redirect_url
1046  *
1047  * Description :  Checks for redirection URLs and returns a HTTP redirect
1048  *                to the destination URL, if necessary
1049  *
1050  * Parameters  :
1051  *          1  :  csp = Current client state (buffers, headers, etc...)
1052  *
1053  * Returns     :  NULL if URL was clean, HTTP redirect otherwise.
1054  *
1055  *********************************************************************/
1056 struct http_response *redirect_url(struct client_state *csp)
1057 {
1058    char *p, *q;
1059    struct http_response *rsp;
1060
1061    p = q = csp->http->path;
1062    log_error(LOG_LEVEL_REDIRECTS, "checking path for redirects: %s", p);
1063
1064    /*
1065     * find the last URL encoded in the request
1066     */
1067    while ((p = strstr(p, "http://")) != NULL)
1068    {
1069       q = p++;
1070    }
1071
1072    /*
1073     * if there was any, generate and return a HTTP redirect
1074     */
1075    if (q != csp->http->path)
1076    {
1077       log_error(LOG_LEVEL_REDIRECTS, "redirecting to: %s", q);
1078
1079       if (NULL == (rsp = alloc_http_response()))
1080       {
1081          return cgi_error_memory();
1082       }
1083
1084       if ( enlist_unique_header(rsp->headers, "Location", q)
1085         || (NULL == (rsp->status = strdup("302 Local Redirect from Privoxy"))) )
1086       {
1087          free_http_response(rsp);
1088          return cgi_error_memory();
1089       }
1090
1091       return finish_http_response(rsp);
1092    }
1093    else
1094    {
1095       return NULL;
1096    }
1097
1098 }
1099 #endif /* def FEATURE_FAST_REDIRECTS */
1100
1101
1102 #ifdef FEATURE_IMAGE_BLOCKING
1103 /*********************************************************************
1104  *
1105  * Function    :  is_imageurl
1106  *
1107  * Description :  Given a URL, decide whether it is an image or not,
1108  *                using either the info from a previous +image action
1109  *                or, #ifdef FEATURE_IMAGE_DETECT_MSIE, and the browser
1110  *                is MSIE and not on a Mac, tell from the browser's accept
1111  *                header.
1112  *
1113  * Parameters  :
1114  *          1  :  csp = Current client state (buffers, headers, etc...)
1115  *
1116  * Returns     :  True (nonzero) if URL is an image, false (0)
1117  *                otherwise
1118  *
1119  *********************************************************************/
1120 int is_imageurl(struct client_state *csp)
1121 {
1122 #ifdef FEATURE_IMAGE_DETECT_MSIE
1123    char *tmp;
1124
1125    tmp = get_header_value(csp->headers, "User-Agent:");
1126    if (tmp && strstr(tmp, "MSIE") && !strstr(tmp, "Mac_"))
1127    {
1128       tmp = get_header_value(csp->headers, "Accept:");
1129       if (tmp && strstr(tmp, "image/gif"))
1130       {
1131          /* Client will accept HTML.  If this seems counterintuitive,
1132           * blame Microsoft.
1133           */
1134          return(0);
1135       }
1136       else
1137       {
1138          return(1);
1139       }
1140    }
1141 #endif /* def FEATURE_IMAGE_DETECT_MSIE */
1142
1143    return ((csp->action->flags & ACTION_IMAGE) != 0);
1144
1145 }
1146 #endif /* def FEATURE_IMAGE_BLOCKING */
1147
1148
1149 #ifdef FEATURE_TRUST
1150 /*********************************************************************
1151  *
1152  * Function    :  is_untrusted_url
1153  *
1154  * Description :  Should we "distrust" this URL (and block it)?
1155  *
1156  *                Yes if it matches a line in the trustfile, or if the
1157  *                    referrer matches a line starting with "+" in the
1158  *                    trustfile.
1159  *                No  otherwise.
1160  *
1161  * Parameters  :
1162  *          1  :  csp = Current client state (buffers, headers, etc...)
1163  *
1164  * Returns     :  0 => trusted, 1 => untrusted
1165  *
1166  *********************************************************************/
1167 int is_untrusted_url(struct client_state *csp)
1168 {
1169    struct file_list *fl;
1170    struct block_spec *b;
1171    struct url_spec **trusted_url;
1172    struct http_request rhttp[1];
1173    const char * referer;
1174    jb_err err;
1175
1176    /*
1177     * If we don't have a trustlist, we trust everybody
1178     */
1179    if (((fl = csp->tlist) == NULL) || ((b  = fl->f) == NULL))
1180    {
1181       return 0;
1182    }
1183
1184    memset(rhttp, '\0', sizeof(*rhttp));
1185
1186    /*
1187     * Do we trust the request URL itself?
1188     */
1189    for (b = b->next; b ; b = b->next)
1190    {
1191       if (url_match(b->url, csp->http))
1192       {
1193          return b->reject;
1194       }
1195    }
1196
1197    if (NULL == (referer = get_header_value(csp->headers, "Referer:")))
1198    {
1199       /* no referrer was supplied */
1200       return 1;
1201    }
1202
1203
1204    /*
1205     * If not, do we maybe trust its referrer?
1206     */
1207    err = parse_http_url(referer, rhttp, csp);
1208    if (err)
1209    {
1210       return 1;
1211    }
1212
1213    for (trusted_url = csp->config->trust_list; *trusted_url != NULL; trusted_url++)
1214    {
1215       if (url_match(*trusted_url, rhttp))
1216       {
1217          /* if the URL's referrer is from a trusted referrer, then
1218           * add the target spec to the trustfile as an unblocked
1219           * domain and return NULL (which means it's OK).
1220           */
1221
1222          FILE *fp;
1223
1224          if (NULL != (fp = fopen(csp->config->trustfile, "a")))
1225          {
1226             char * path;
1227             char * path_end;
1228             char * new_entry = strdup("~");
1229
1230             string_append(&new_entry, csp->http->hostport);
1231
1232             path = csp->http->path;
1233             if ( (path[0] == '/')
1234               && (path[1] == '~')
1235               && ((path_end = strchr(path + 2, '/')) != NULL))
1236             {
1237                /* since this path points into a user's home space
1238                 * be sure to include this spec in the trustfile.
1239                 */
1240                int path_len = path_end - path; /* save offset */
1241                path = strdup(path); /* Copy string */
1242                if (path != NULL)
1243                {
1244                   path_end = path + path_len; /* regenerate ptr to new buffer */
1245                   *(path_end + 1) = '\0'; /* Truncate path after '/' */
1246                }
1247                string_join(&new_entry, path);
1248             }
1249
1250             if (new_entry != NULL)
1251             {
1252                fprintf(fp, "%s\n", new_entry);
1253                free(new_entry);
1254             }
1255             else
1256             {
1257                /* FIXME: No way to handle out-of memory, so mostly ignoring it */
1258                log_error(LOG_LEVEL_ERROR, "Out of memory adding pattern to trust file");
1259             }
1260
1261             fclose(fp);
1262          }
1263          return 0;
1264       }
1265    }
1266    return 1;
1267 }
1268 #endif /* def FEATURE_TRUST */
1269
1270
1271 /*********************************************************************
1272  *
1273  * Function    :  pcrs_filter_response
1274  *
1275  * Description :  Ecexute all text substitutions from all applying
1276  *                +filter actions on the text buffer that's been accumulated
1277  *                in csp->iob->buf. If this changes the contents, set
1278  *                csp->content_length to the modified size and raise the
1279  *                CSP_FLAG_MODIFIED flag.
1280  *
1281  * Parameters  :
1282  *          1  :  csp = Current client state (buffers, headers, etc...)
1283  *
1284  * Returns     :  a pointer to the (newly allocated) modified buffer.
1285  *                or NULL if there were no hits or something went wrong
1286  *
1287  *********************************************************************/
1288 char *pcrs_filter_response(struct client_state *csp)
1289 {
1290    int hits=0;
1291    size_t size;
1292
1293    char *old = csp->iob->cur, *new = NULL;
1294    pcrs_job *job;
1295
1296    struct file_list *fl;
1297    struct re_filterfile_spec *b;
1298    struct list_entry *filtername;
1299
1300    /*
1301     * Sanity first
1302     */
1303    if (csp->iob->cur >= csp->iob->eod)
1304    {
1305       return(NULL);
1306    }
1307    size = csp->iob->eod - csp->iob->cur;
1308
1309    if ( ( NULL == (fl = csp->rlist) ) || ( NULL == fl->f) )
1310    {
1311       log_error(LOG_LEVEL_ERROR, "Unable to get current state of regexp filtering.");
1312       return(NULL);
1313    }
1314
1315    /*
1316     * If the body has a "chunked" transfer-encoding,
1317     * get rid of it first, adjusting size and iob->eod
1318     */
1319    if (csp->flags & CSP_FLAG_CHUNKED)
1320    {
1321       log_error(LOG_LEVEL_RE_FILTER, "Need to de-chunk first");
1322       if (0 == (size = remove_chunked_transfer_coding(csp->iob->cur, size)))
1323       {
1324          return(NULL);
1325       }
1326       csp->iob->eod = csp->iob->cur + size;
1327       csp->flags |= CSP_FLAG_MODIFIED;
1328    }
1329
1330    /*
1331     * For all applying +filter actions, look if a filter by that
1332     * name exists and if yes, execute it's pcrs_joblist on the
1333     * buffer.
1334     */
1335    for (b = fl->f; b; b = b->next)
1336    {
1337       for (filtername = csp->action->multi[ACTION_MULTI_FILTER]->first;
1338            filtername ; filtername = filtername->next)
1339       {
1340          if (strcmp(b->name, filtername->str) == 0)
1341          {
1342             int current_hits = 0;
1343
1344             if ( NULL == b->joblist )
1345             {
1346                log_error(LOG_LEVEL_RE_FILTER, "Filter %s has empty joblist. Nothing to do.", b->name);
1347                continue;
1348             }
1349
1350             log_error(LOG_LEVEL_RE_FILTER, "re_filtering %s%s (size %d) with filter %s...",
1351                       csp->http->hostport, csp->http->path, size, b->name);
1352
1353             /* Apply all jobs from the joblist */
1354             for (job = b->joblist; NULL != job; job = job->next)
1355             {
1356                current_hits += pcrs_execute(job, old, size, &new, &size);
1357                if (old != csp->iob->cur) free(old);
1358                old=new;
1359             }
1360
1361             log_error(LOG_LEVEL_RE_FILTER, " ...produced %d hits (new size %d).", current_hits, size);
1362             hits += current_hits;
1363          }
1364       }
1365    }
1366
1367    /*
1368     * If there were no hits, destroy our copy and let
1369     * chat() use the original in csp->iob
1370     */
1371    if (!hits)
1372    {
1373       free(new);
1374       return(NULL);
1375    }
1376 #ifdef FEATURE_ACTIVITY_CONSOLE
1377    else
1378      accumulate_stats(STATS_FILTER, hits);
1379 #endif /* def FEATURE_ACTIVITY_CONSOLE */
1380
1381    csp->flags |= CSP_FLAG_MODIFIED;
1382    csp->content_length = size;
1383    IOB_RESET(csp);
1384
1385    return(new);
1386
1387 }
1388
1389
1390 /*********************************************************************
1391  *
1392  * Function    :  gif_deanimate_response
1393  *
1394  * Description :  Deanimate the GIF image that has been accumulated in
1395  *                csp->iob->buf, set csp->content_length to the modified
1396  *                size and raise the CSP_FLAG_MODIFIED flag.
1397  *
1398  * Parameters  :
1399  *          1  :  csp = Current client state (buffers, headers, etc...)
1400  *
1401  * Returns     :  a pointer to the (newly allocated) modified buffer.
1402  *                or NULL in case something went wrong.
1403  *
1404  *********************************************************************/
1405 char *gif_deanimate_response(struct client_state *csp)
1406 {
1407    struct binbuffer *in, *out;
1408    char *p;
1409    size_t size = csp->iob->eod - csp->iob->cur;
1410
1411    /*
1412     * If the body has a "chunked" transfer-encoding,
1413     * get rid of it first, adjusting size and iob->eod
1414     */
1415    if (csp->flags & CSP_FLAG_CHUNKED)
1416    {
1417       log_error(LOG_LEVEL_DEANIMATE, "Need to de-chunk first");
1418       if (0 == (size = remove_chunked_transfer_coding(csp->iob->cur, size)))
1419       {
1420          return(NULL);
1421       }
1422       csp->iob->eod = csp->iob->cur + size;
1423       csp->flags |= CSP_FLAG_MODIFIED;
1424    }
1425
1426    if (  (NULL == (in =  (struct binbuffer *)zalloc(sizeof *in )))
1427       || (NULL == (out = (struct binbuffer *)zalloc(sizeof *out))) )
1428    {
1429       log_error(LOG_LEVEL_DEANIMATE, "failed! (no mem)");
1430       return NULL;
1431    }
1432
1433    in->buffer = csp->iob->cur;
1434    in->size = size;
1435
1436    if (gif_deanimate(in, out, strncmp("last", csp->action->string[ACTION_STRING_DEANIMATE], 4)))
1437    {
1438       log_error(LOG_LEVEL_DEANIMATE, "failed! (gif parsing)");
1439       free(in);
1440       buf_free(out);
1441       return(NULL);
1442    }
1443    else
1444    {
1445       if ((int)size == out->offset)
1446       {
1447          log_error(LOG_LEVEL_DEANIMATE, "GIF not changed.");
1448       }
1449       else
1450       {
1451 #ifdef FEATURE_ACTIVITY_CONSOLE
1452          accumulate_stats(STATS_GIF_DEANIMATE, 1);
1453 #endif /* def FEATURE_ACTIVITY_CONSOLE */
1454          log_error(LOG_LEVEL_DEANIMATE, "Success! GIF shrunk from %d bytes to %d.", size, out->offset);
1455       }
1456       csp->content_length = out->offset;
1457       csp->flags |= CSP_FLAG_MODIFIED;
1458       p = out->buffer;
1459       free(in);
1460       free(out);
1461       return(p);
1462    }
1463
1464 }
1465
1466
1467 /*********************************************************************
1468  *
1469  * Function    :  remove_chunked_transfer_coding
1470  *
1471  * Description :  In-situ remove the "chunked" transfer coding as defined
1472  *                in rfc2616 from a buffer.
1473  *
1474  * Parameters  :
1475  *          1  :  buffer = Pointer to the text buffer
1476  *          2  :  size = Number of bytes to be processed
1477  *
1478  * Returns     :  The new size, i.e. the number of bytes from buffer which
1479  *                are occupied by the stripped body, or 0 in case something
1480  *                went wrong
1481  *
1482  *********************************************************************/
1483 int remove_chunked_transfer_coding(char *buffer, const size_t size)
1484 {
1485    size_t newsize = 0;
1486    unsigned int chunksize = 0;
1487    char *from_p, *to_p;
1488
1489    assert(buffer);
1490    from_p = to_p = buffer;
1491
1492    if (sscanf(buffer, "%x", &chunksize) != 1)
1493    {
1494       log_error(LOG_LEVEL_ERROR, "Invalid first chunksize while stripping \"chunked\" transfer coding");
1495       return(0);
1496    }
1497
1498    while (chunksize > 0)
1499    {
1500       if (NULL == (from_p = strstr(from_p, "\r\n")))
1501       {
1502          log_error(LOG_LEVEL_ERROR, "Parse error while stripping \"chunked\" transfer coding");
1503          return(0);
1504       }
1505
1506       if ((newsize += chunksize) >= size)
1507       {
1508          log_error(LOG_LEVEL_ERROR, "Chunksize exceeds buffer in  \"chunked\" transfer coding");
1509          return(0);
1510       }
1511       from_p += 2;
1512
1513       memmove(to_p, from_p, (size_t) chunksize);
1514       to_p = buffer + newsize;
1515       from_p += chunksize + 2;
1516
1517       if (sscanf(from_p, "%x", &chunksize) != 1)
1518       {
1519          log_error(LOG_LEVEL_ERROR, "Parse error while stripping \"chunked\" transfer coding");
1520          return(0);
1521       }
1522    }
1523
1524    /* FIXME: Should this get its own loglevel? */
1525    log_error(LOG_LEVEL_RE_FILTER, "De-chunking successful. Shrunk from %d to %d\n", size, newsize);
1526    return(newsize);
1527
1528 }
1529
1530
1531 /*********************************************************************
1532  *
1533  * Function    :  url_actions
1534  *
1535  * Description :  Gets the actions for this URL.
1536  *
1537  * Parameters  :
1538  *          1  :  http = http_request request for blocked URLs
1539  *          2  :  csp = Current client state (buffers, headers, etc...)
1540  *
1541  * Returns     :  N/A
1542  *
1543  *********************************************************************/
1544 void url_actions(struct http_request *http,
1545                  struct client_state *csp)
1546 {
1547    struct file_list *fl;
1548    struct url_actions *b;
1549    int i;
1550
1551    init_current_action(csp->action);
1552
1553    for (i = 0; i < MAX_ACTION_FILES; i++)
1554    {
1555       if (((fl = csp->actions_list[i]) == NULL) || ((b = fl->f) == NULL))
1556       {
1557          return;
1558       }
1559
1560       apply_url_actions(csp->action, http, b);
1561    }
1562
1563    return;
1564 }
1565
1566
1567 /*********************************************************************
1568  *
1569  * Function    :  apply_url_actions
1570  *
1571  * Description :  Applies a list of URL actions.
1572  *
1573  * Parameters  :
1574  *          1  :  action = Destination.
1575  *          2  :  http = Current URL
1576  *          3  :  b = list of URL actions to apply
1577  *
1578  * Returns     :  N/A
1579  *
1580  *********************************************************************/
1581 void apply_url_actions(struct current_action_spec *action,
1582                        struct http_request *http,
1583                        struct url_actions *b)
1584 {
1585    if (b == NULL)
1586    {
1587       /* Should never happen */
1588       return;
1589    }
1590
1591    for (b = b->next; NULL != b; b = b->next)
1592    {
1593       if (url_match(b->url, http))
1594       {
1595          merge_current_action(action, b->action);
1596       }
1597    }
1598 }
1599
1600
1601 /*********************************************************************
1602  *
1603  * Function    :  forward_url
1604  *
1605  * Description :  Should we forward this to another proxy?
1606  *
1607  * Parameters  :
1608  *          1  :  http = http_request request for current URL
1609  *          2  :  csp = Current client state (buffers, headers, etc...)
1610  *
1611  * Returns     :  Pointer to forwarding information.
1612  *
1613  *********************************************************************/
1614 const struct forward_spec * forward_url(struct http_request *http,
1615                                         struct client_state *csp)
1616 {
1617    static const struct forward_spec fwd_default[1] = { FORWARD_SPEC_INITIALIZER };
1618    struct forward_spec *fwd = csp->config->forward;
1619
1620    if (fwd == NULL)
1621    {
1622       return fwd_default;
1623    }
1624
1625    while (fwd != NULL)
1626    {
1627       if (url_match(fwd->url, http))
1628       {
1629          return fwd;
1630       }
1631       fwd = fwd->next;
1632    }
1633
1634    return fwd_default;
1635 }
1636
1637
1638 /*
1639   Local Variables:
1640   tab-width: 3
1641   end:
1642 */