filters.c

   1 const char filters_rcs[] = "$Id: filters.c,v 1.83 2007/03/17 15:20:05 fabiankeil Exp $";
   2 /*********************************************************************
   3  *
   4  * File        :  $Source: /cvsroot/ijbswa/current/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', `trust_url', `gif_deanimate_response',
  13  *                   `jpeg_inspect_response', `execute_single_pcrs_command',
  14  *                   `rewrite_url', `get_last_url'
  15  *
  16  * Copyright   :  Written by and Copyright (C) 2001, 2004-2007 the SourceForge
  17  *                Privoxy team. http://www.privoxy.org/
  18  *
  19  *                Based on the Internet Junkbuster originally written
  20  *                by and Copyright (C) 1997 Anonymous Coders and
  21  *                Junkbusters Corporation.  http://www.junkbusters.com
  22  *
  23  *                This program is free software; you can redistribute it
  24  *                and/or modify it under the terms of the GNU General
  25  *                Public License as published by the Free Software
  26  *                Foundation; either version 2 of the License, or (at
  27  *                your option) any later version.
  28  *
  29  *                This program is distributed in the hope that it will
  30  *                be useful, but WITHOUT ANY WARRANTY; without even the
  31  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  32  *                PARTICULAR PURPOSE.  See the GNU General Public
  33  *                License for more details.
  34  *
  35  *                The GNU General Public License should be included with
  36  *                this file.  If not, you can view it at
  37  *                http://www.gnu.org/copyleft/gpl.html
  38  *                or write to the Free Software Foundation, Inc., 59
  39  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  40  *
  41  * Revisions   :
  42  *    $Log: filters.c,v $
  43  *    Revision 1.83  2007/03/17 15:20:05  fabiankeil
  44  *    New config option: enforce-blocks.
  45  *
  46  *    Revision 1.82  2007/03/13 11:28:43  fabiankeil
  47  *    - Fix port handling in acl_addr() and use a temporary acl spec
  48  *      copy so error messages don't contain a truncated version.
  49  *    - Log size of iob before and after decompression.
  50  *
  51  *    Revision 1.81  2007/03/05 14:40:53  fabiankeil
  52  *    - Cosmetical changes for LOG_LEVEL_RE_FILTER messages.
  53  *    - Hide the "Go there anyway" link for blocked CONNECT
  54  *      requests where going there anyway doesn't work anyway.
  55  *
  56  *    Revision 1.80  2007/02/07 10:55:20  fabiankeil
  57  *    - Save the reason for generating http_responses.
  58  *    - Block (+block) with status code 403 instead of 404.
  59  *    - Use a different kludge to remember a failed decompression.
  60  *
  61  *    Revision 1.79  2007/01/31 16:21:38  fabiankeil
  62  *    Search for Max-Forwards headers case-insensitive,
  63  *    don't generate the "501 unsupported" message for invalid
  64  *    Max-Forwards values and don't increase negative ones.
  65  *
  66  *    Revision 1.78  2007/01/28 13:41:18  fabiankeil
  67  *    - Add HEAD support to finish_http_response.
  68  *    - Add error favicon to internal HTML error messages.
  69  *
  70  *    Revision 1.77  2007/01/12 15:36:44  fabiankeil
  71  *    Mark *csp as immutable for is_untrusted_url()
  72  *    and is_imageurl(). Closes FR 1237736.
  73  *
  74  *    Revision 1.76  2007/01/01 19:36:37  fabiankeil
  75  *    Integrate a modified version of Wil Mahan's
  76  *    zlib patch (PR #895531).
  77  *
  78  *    Revision 1.75  2006/12/29 18:30:46  fabiankeil
  79  *    Fixed gcc43 conversion warnings,
  80  *    changed sprintf calls to snprintf.
  81  *
  82  *    Revision 1.74  2006/12/24 17:37:38  fabiankeil
  83  *    Adjust comment in pcrs_filter_response()
  84  *    to recent pcrs changes. Hohoho.
  85  *
  86  *    Revision 1.73  2006/12/23 16:01:02  fabiankeil
  87  *    Don't crash if pcre returns an error code
  88  *    that pcrs didn't expect. Fixes BR 1621173.
  89  *
  90  *    Revision 1.72  2006/12/22 18:52:53  fabiankeil
  91  *    Modified is_untrusted_url to complain in case of
  92  *    write errors and to give a reason when adding new
  93  *    entries to the trustfile. Closes FR 1097611.
  94  *
  95  *    Revision 1.71  2006/12/22 14:24:52  fabiankeil
  96  *    Skip empty filter files in pcrs_filter_response,
  97  *    but don't ignore the ones that come afterwards.
  98  *    Fixes parts of BR 1619208.
  99  *
 100  *    Revision 1.70  2006/12/09 13:33:15  fabiankeil
 101  *    Added some sanity checks for get_last_url().
 102  *    Fixed possible segfault caused by my last commit.
 103  *
 104  *    Revision 1.69  2006/12/08 12:39:13  fabiankeil
 105  *    Let get_last_url() catch https URLs as well.
 106  *
 107  *    Revision 1.68  2006/12/05 14:45:48  fabiankeil
 108  *    Make sure get_last_url() behaves like advertised
 109  *    and fast-redirects{} can be combined with redirect{}.
 110  *
 111  *    Revision 1.67  2006/11/28 15:19:43  fabiankeil
 112  *    Implemented +redirect{s@foo@bar@} to generate
 113  *    a redirect based on a rewritten version of the
 114  *    original URL.
 115  *
 116  *    Revision 1.66  2006/09/23 13:26:38  roro
 117  *    Replace TABs by spaces in source code.
 118  *
 119  *    Revision 1.65  2006/09/21 12:54:43  fabiankeil
 120  *    Fix +redirect{}. Didn't work with -fast-redirects.
 121  *
 122  *    Revision 1.64  2006/08/31 10:55:49  fabiankeil
 123  *    Block requests for untrusted URLs with status
 124  *    code 403 instead of 200.
 125  *
 126  *    Revision 1.63  2006/08/31 10:11:28  fabiankeil
 127  *    Don't free p which is still in use and will be later
 128  *    freed by free_map(). Don't claim the referrer is unknown
 129  *    when the client didn't set one.
 130  *
 131  *    Revision 1.62  2006/08/14 00:27:47  david__schmidt
 132  *    Feature request 595948: Re-Filter logging in single line
 133  *
 134  *    Revision 1.61  2006/08/03 02:46:41  david__schmidt
 135  *    Incorporate Fabian Keil's patch work:\rhttp://www.fabiankeil.de/sourcecode/privoxy/
 136  *
 137  *    Revision 1.60  2006/07/18 14:48:46  david__schmidt
 138  *    Reorganizing the repository: swapping out what was HEAD (the old 3.1 branch)
 139  *    with what was really the latest development (the v_3_0_branch branch)
 140  *
 141  *    Revision 1.58.2.9  2006/01/29 23:10:56  david__schmidt
 142  *    Multiple filter file support
 143  *
 144  *    Revision 1.58.2.8  2005/05/07 21:50:55  david__schmidt
 145  *    A few memory leaks plugged (mostly on error paths)
 146  *
 147  *    Revision 1.58.2.7  2004/10/03 12:53:32  david__schmidt
 148  *    Add the ability to check jpeg images for invalid
 149  *    lengths of comment blocks.  Defensive strategy
 150  *    against the exploit:
 151  *       Microsoft Security Bulletin MS04-028
 152  *       Buffer Overrun in JPEG Processing (GDI+) Could
 153  *       Allow Code Execution (833987)
 154  *    Enabled with +inspect-jpegs in actions files.
 155  *
 156  *    Revision 1.58.2.6  2003/12/06 22:18:27  gliptak
 157  *    Correcting compile problem with FEATURE_IMAGE_BLOCKING
 158  *
 159  *    Revision 1.58.2.5  2003/11/11 13:10:31  oes
 160  *    Fixed bug #839859: "See why" link URL now gets url-encoded.
 161  *
 162  *    Revision 1.58.2.4  2003/02/28 12:52:45  oes
 163  *    Fixed a typo
 164  *
 165  *    Revision 1.58.2.3  2002/09/25 14:51:51  oes
 166  *    Added basic support for OPTIONS and TRACE HTTP methods:
 167  *    New function direct_response which handles OPTIONS and
 168  *    TRACE requests whose Max-Forwards header field is zero.
 169  *
 170  *    Revision 1.58.2.2  2002/08/01 17:18:28  oes
 171  *    Fixed BR 537651 / SR 579724 (MSIE image detect improper for IE/Mac)
 172  *
 173  *    Revision 1.58.2.1  2002/07/26 15:18:53  oes
 174  *    - Bugfix: Executing a filters without jobs no longer results in
 175  *      turing off *all* filters.
 176  *    - Security fix: Malicious web servers can't cause a seg fault
 177  *      through bogus chunk sizes anymore
 178  *
 179  *    Revision 1.58  2002/04/24 02:11:17  oes
 180  *    Jon's multiple AF patch: url_actions now evaluates rules
 181  *    from all AFs.
 182  *
 183  *    Revision 1.57  2002/04/08 20:38:34  swa
 184  *    fixed JB spelling
 185  *
 186  *    Revision 1.56  2002/04/05 15:51:24  oes
 187  *     - bugfix: error-pages now get correct request protocol
 188  *     - fix for invalid HTML in trust info
 189  *
 190  *    Revision 1.55  2002/04/02 16:13:51  oes
 191  *    Fix: No "Go there anyway" for SSL
 192  *
 193  *    Revision 1.54  2002/04/02 14:55:56  oes
 194  *    Bugfix: is_untrusted_url() now depends on FEATURE_TRUST, not FEATURE_COOKIE_JAR
 195  *
 196  *    Revision 1.53  2002/03/26 22:29:54  swa
 197  *    we have a new homepage!
 198  *
 199  *    Revision 1.52  2002/03/24 16:35:57  jongfoster
 200  *    Removing logo
 201  *
 202  *    Revision 1.51  2002/03/24 15:23:33  jongfoster
 203  *    Name changes
 204  *
 205  *    Revision 1.50  2002/03/24 13:25:43  swa
 206  *    name change related issues
 207  *
 208  *    Revision 1.49  2002/03/16 20:29:14  oes
 209  *    Cosmetics
 210  *
 211  *    Revision 1.48  2002/03/13 20:25:34  oes
 212  *    Better logging for content filters
 213  *
 214  *    Revision 1.47  2002/03/13 00:30:52  jongfoster
 215  *    Killing warnings
 216  *    Added option of always sending redirect for imageblock,
 217  *    currently disabled with #if 0.
 218  *
 219  *    Revision 1.46  2002/03/12 01:42:49  oes
 220  *    Introduced modular filters
 221  *
 222  *    Revision 1.45  2002/03/08 16:47:50  oes
 223  *    Added choice beween GIF and PNG built-in images
 224  *
 225  *    Revision 1.44  2002/03/07 03:49:31  oes
 226  *     - Fixed compiler warnings etc
 227  *     - Changed built-in images from GIF to PNG
 228  *       (with regard to Unisys patent issue)
 229  *     - Added a 4x4 pattern PNG which is less intrusive
 230  *       than the logo but also clearly marks the deleted banners
 231  *
 232  *    Revision 1.43  2002/01/22 23:51:59  jongfoster
 233  *    Replacing strsav() with the safer string_append().
 234  *
 235  *    Adding missing html_encode() to error message generators.  Where encoded
 236  *    and unencoded versions of a string were provided, removing the unencoded
 237  *    one.
 238  *
 239  *    Revision 1.42  2002/01/17 21:00:32  jongfoster
 240  *    Moving all our URL and URL pattern parsing code to urlmatch.c.
 241  *
 242  *    Using a single, simple url_match(pattern,url) function - rather than
 243  *    the 3-line match routine which was repeated all over the place.
 244  *
 245  *    Renaming free_url to free_url_spec, since it frees a struct url_spec.
 246  *
 247  *    Using parse_http_url() to parse URLs without faking a HTTP
 248  *    request line for parse_http_request().
 249  *
 250  *    Revision 1.41  2001/11/13 00:14:07  jongfoster
 251  *    Fixing stupid bug now I've figured out what || means.
 252  *    (It always returns 0 or 1, not one of it's paramaters.)
 253  *
 254  *    Revision 1.40  2001/10/26 17:37:55  oes
 255  *    - Re-enabled Netscape 200/404 bug workaround in block_url():
 256  *      - Removed OS/2 special case
 257  *      - Made block_url() independant from sed() having been run
 258  *    - Made trust_url independant from sed() having been run
 259  *    - Made is_imageurl independant from sed() having been run.
 260  *      It now checks User-Agent: and Accept: by itself.
 261  *
 262  *
 263  *    Revision 1.39  2001/10/25 03:40:48  david__schmidt
 264  *    Change in porting tactics: OS/2's EMX porting layer doesn't allow multiple
 265  *    threads to call select() simultaneously.  So, it's time to do a real, live,
 266  *    native OS/2 port.  See defines for __EMX__ (the porting layer) vs. __OS2__
 267  *    (native). Both versions will work, but using __OS2__ offers multi-threading.
 268  *
 269  *    Revision 1.38  2001/10/23 21:32:33  jongfoster
 270  *    Adding error-checking to selected functions
 271  *
 272  *    Revision 1.37  2001/10/22 15:33:56  david__schmidt
 273  *    Special-cased OS/2 out of the Netscape-abort-on-404-in-js problem in
 274  *    filters.c.  Added a FIXME in front of the offending code.  I'll gladly
 275  *    put in a better/more robust fix for all parties if one is presented...
 276  *    It seems that just returning 200 instead of 404 would pretty much fix
 277  *    it for everyone, but I don't know all the history of the problem.
 278  *
 279  *    Revision 1.36  2001/10/10 16:44:16  oes
 280  *    Added match_portlist function
 281  *
 282  *    Revision 1.35  2001/10/07 15:41:23  oes
 283  *    Replaced 6 boolean members of csp with one bitmap (csp->flags)
 284  *
 285  *    New function remove_chunked_transfer_coding that strips chunked
 286  *      transfer coding to plain and is called by pcrs_filter_response
 287  *      and gif_deanimate_response if neccessary
 288  *
 289  *    Improved handling of zero-change re_filter runs
 290  *
 291  *    pcrs_filter_response and gif_deanimate_response now remove
 292  *      chunked transfer codeing before processing the body.
 293  *
 294  *    Revision 1.34  2001/09/20 15:49:36  steudten
 295  *
 296  *    Fix BUG: Change int size to size_t size in pcrs_filter_response().
 297  *    See cgi.c fill_template().
 298  *
 299  *    Revision 1.33  2001/09/16 17:05:14  jongfoster
 300  *    Removing unused #include showarg.h
 301  *
 302  *    Revision 1.32  2001/09/16 13:21:27  jongfoster
 303  *    Changes to use new list functions.
 304  *
 305  *    Revision 1.31  2001/09/16 11:38:02  jongfoster
 306  *    Splitting fill_template() into 2 functions:
 307  *    template_load() loads the file
 308  *    template_fill() performs the PCRS regexps.
 309  *    This is because the CGI edit interface has a "table row"
 310  *    template which is used many times in the page - this
 311  *    change means it's only loaded from disk once.
 312  *
 313  *    Revision 1.30  2001/09/16 11:00:10  jongfoster
 314  *    New function alloc_http_response, for symmetry with free_http_response
 315  *
 316  *    Revision 1.29  2001/09/13 23:32:40  jongfoster
 317  *    Moving image data to cgi.c rather than cgi.h
 318  *    Fixing a GPF under Win32 (and any other OS that protects global
 319  *    constants from being written to).
 320  *
 321  *    Revision 1.28  2001/09/10 10:18:51  oes
 322  *    Silenced compiler warnings
 323  *
 324  *    Revision 1.27  2001/08/05 16:06:20  jongfoster
 325  *    Modifiying "struct map" so that there are now separate header and
 326  *    "map_entry" structures.  This means that functions which modify a
 327  *    map no longer need to return a pointer to the modified map.
 328  *    Also, it no longer reverses the order of the entries (which may be
 329  *    important with some advanced template substitutions).
 330  *
 331  *    Revision 1.26  2001/07/30 22:08:36  jongfoster
 332  *    Tidying up #defines:
 333  *    - All feature #defines are now of the form FEATURE_xxx
 334  *    - Permanently turned off WIN_GUI_EDIT
 335  *    - Permanently turned on WEBDAV and SPLIT_PROXY_ARGS
 336  *
 337  *    Revision 1.25  2001/07/26 10:09:46  oes
 338  *    Made browser detection a little less naive
 339  *
 340  *    Revision 1.24  2001/07/25 17:22:51  oes
 341  *    Added workaround for Netscape bug that prevents display of page when loading a component fails.
 342  *
 343  *    Revision 1.23  2001/07/23 13:40:12  oes
 344  *    Fixed bug that caused document body to be dropped when pcrs joblist was empty.
 345  *
 346  *    Revision 1.22  2001/07/18 12:29:34  oes
 347  *    - Made gif_deanimate_response respect
 348  *      csp->action->string[ACTION_STRING_DEANIMATE]
 349  *    - Logging cosmetics
 350  *
 351  *    Revision 1.21  2001/07/13 13:59:53  oes
 352  *     - Introduced gif_deanimate_response which shares the
 353  *       generic content modification interface of pcrs_filter_response
 354  *       and acts as a wrapper to deanimate.c:gif_deanimate()
 355  *     - Renamed re_process_buffer to pcrs_filter_response
 356  *     - pcrs_filter_response now returns NULL on failiure
 357  *     - Removed all #ifdef PCRS
 358  *
 359  *    Revision 1.20  2001/07/01 17:01:04  oes
 360  *    Added comments and missing return statement in is_untrusted_url()
 361  *
 362  *    Revision 1.19  2001/06/29 21:45:41  oes
 363  *    Indentation, CRLF->LF, Tab-> Space
 364  *
 365  *    Revision 1.18  2001/06/29 13:27:38  oes
 366  *    - Cleaned up, renamed and reorderd functions
 367  *      and improved comments
 368  *
 369  *    - block_url:
 370  *      - Ported to CGI platform. Now delivers
 371  *        http_response or NULL
 372  *      - Unified HTML and GIF generation (moved image detection
 373  *        and GIF generation here from jcc.c:chat())
 374  *      - Fixed HTTP status to:
 375  *       -  403 (Forbidden) for the "blocked" HTML message
 376  *       -  200 (OK) for GIF answers
 377  *       -  302 (Redirect) for redirect to GIF
 378  *
 379  *    - trust_url:
 380  *      - Ported to CGI platform. Now delivers
 381  *        http_response or NULL
 382  *      - Separated detection of untrusted URL into
 383  *        (bool)is_untrusted_url
 384  *      - Added enforcement of untrusted requests
 385  *
 386  *    - Moved redirect_url() from cgi.c to here
 387  *      and ported it to the CGI platform
 388  *
 389  *    - Removed logentry from cancelled commit
 390  *
 391  *    Revision 1.17  2001/06/09 10:55:28  jongfoster
 392  *    Changing BUFSIZ ==> BUFFER_SIZE
 393  *
 394  *    Revision 1.16  2001/06/07 23:10:26  jongfoster
 395  *    Allowing unanchored domain patterns to back off and retry
 396  *    if they partially match.  Optimized right-anchored patterns.
 397  *    Moving ACL and forward files into config file.
 398  *    Replacing struct gateway with struct forward_spec
 399  *
 400  *    Revision 1.15  2001/06/03 19:12:00  oes
 401  *    extracted-CGI relevant stuff
 402  *
 403  *    Revision 1.14  2001/06/01 10:30:55  oes
 404  *    Added optional left-anchoring to domaincmp
 405  *
 406  *    Revision 1.13  2001/05/31 21:21:30  jongfoster
 407  *    Permissionsfile / actions file changes:
 408  *    - Changed "permission" to "action" throughout
 409  *    - changes to file format to allow string parameters
 410  *    - Moved helper functions to actions.c
 411  *
 412  *    Revision 1.12  2001/05/31 17:35:20  oes
 413  *
 414  *     - Enhanced domain part globbing with infix and prefix asterisk
 415  *       matching and optional unanchored operation
 416  *
 417  *    Revision 1.11  2001/05/29 11:53:23  oes
 418  *    "See why" link added to "blocked" page
 419  *
 420  *    Revision 1.10  2001/05/29 09:50:24  jongfoster
 421  *    Unified blocklist/imagelist/permissionslist.
 422  *    File format is still under discussion, but the internal changes
 423  *    are (mostly) done.
 424  *
 425  *    Also modified interceptor behaviour:
 426  *    - We now intercept all URLs beginning with one of the following
 427  *      prefixes (and *only* these prefixes):
 428  *        * http://i.j.b/
 429  *        * http://ijbswa.sf.net/config/
 430  *        * http://ijbswa.sourceforge.net/config/
 431  *    - New interceptors "home page" - go to http://i.j.b/ to see it.
 432  *    - Internal changes so that intercepted and fast redirect pages
 433  *      are not replaced with an image.
 434  *    - Interceptors now have the option to send a binary page direct
 435  *      to the client. (i.e. ijb-send-banner uses this)
 436  *    - Implemented show-url-info interceptor.  (Which is why I needed
 437  *      the above interceptors changes - a typical URL is
 438  *      "http://i.j.b/show-url-info?url=www.somesite.com/banner.gif".
 439  *      The previous mechanism would not have intercepted that, and
 440  *      if it had been intercepted then it then it would have replaced
 441  *      it with an image.)
 442  *
 443  *    Revision 1.9  2001/05/27 22:17:04  oes
 444  *
 445  *    - re_process_buffer no longer writes the modified buffer
 446  *      to the client, which was very ugly. It now returns the
 447  *      buffer, which it is then written by chat.
 448  *
 449  *    - content_length now adjusts the Content-Length: header
 450  *      for modified documents rather than crunch()ing it.
 451  *      (Length info in csp->content_length, which is 0 for
 452  *      unmodified documents)
 453  *
 454  *    - For this to work, sed() is called twice when filtering.
 455  *
 456  *    Revision 1.8  2001/05/26 17:13:28  jongfoster
 457  *    Filled in a function comment.
 458  *
 459  *    Revision 1.7  2001/05/26 15:26:15  jongfoster
 460  *    ACL feature now provides more security by immediately dropping
 461  *    connections from untrusted hosts.
 462  *
 463  *    Revision 1.6  2001/05/26 00:28:36  jongfoster
 464  *    Automatic reloading of config file.
 465  *    Removed obsolete SIGHUP support (Unix) and Reload menu option (Win32).
 466  *    Most of the global variables have been moved to a new
 467  *    struct configuration_spec, accessed through csp->config->globalname
 468  *    Most of the globals remaining are used by the Win32 GUI.
 469  *
 470  *    Revision 1.5  2001/05/25 22:34:30  jongfoster
 471  *    Hard tabs->Spaces
 472  *
 473  *    Revision 1.4  2001/05/22 18:46:04  oes
 474  *
 475  *    - Enabled filtering banners by size rather than URL
 476  *      by adding patterns that replace all standard banner
 477  *      sizes with the "Junkbuster" gif to the re_filterfile
 478  *
 479  *    - Enabled filtering WebBugs by providing a pattern
 480  *      which kills all 1x1 images
 481  *
 482  *    - Added support for PCRE_UNGREEDY behaviour to pcrs,
 483  *      which is selected by the (nonstandard and therefore
 484  *      capital) letter 'U' in the option string.
 485  *      It causes the quantifiers to be ungreedy by default.
 486  *      Appending a ? turns back to greedy (!).
 487  *
 488  *    - Added a new interceptor ijb-send-banner, which
 489  *      sends back the "Junkbuster" gif. Without imagelist or
 490  *      MSIE detection support, or if tinygif = 1, or the
 491  *      URL isn't recognized as an imageurl, a lame HTML
 492  *      explanation is sent instead.
 493  *
 494  *    - Added new feature, which permits blocking remote
 495  *      script redirects and firing back a local redirect
 496  *      to the browser.
 497  *      The feature is conditionally compiled, i.e. it
 498  *      can be disabled with --disable-fast-redirects,
 499  *      plus it must be activated by a "fast-redirects"
 500  *      line in the config file, has its own log level
 501  *      and of course wants to be displayed by show-proxy-args
 502  *      Note: Boy, all the #ifdefs in 1001 locations and
 503  *      all the fumbling with configure.in and acconfig.h
 504  *      were *way* more work than the feature itself :-(
 505  *
 506  *    - Because a generic redirect template was needed for
 507  *      this, tinygif = 3 now uses the same.
 508  *
 509  *    - Moved GIFs, and other static HTTP response templates
 510  *      to project.h
 511  *
 512  *    - Some minor fixes
 513  *
 514  *    - Removed some >400 CRs again (Jon, you really worked
 515  *      a lot! ;-)
 516  *
 517  *    Revision 1.3  2001/05/20 16:44:47  jongfoster
 518  *    Removing last hardcoded Junkbusters.com URLs.
 519  *
 520  *    Revision 1.2  2001/05/20 01:21:20  jongfoster
 521  *    Version 2.9.4 checkin.
 522  *    - Merged popupfile and cookiefile, and added control over PCRS
 523  *      filtering, in new "permissionsfile".
 524  *    - Implemented LOG_LEVEL_FATAL, so that if there is a configuration
 525  *      file error you now get a message box (in the Win32 GUI) rather
 526  *      than the program exiting with no explanation.
 527  *    - Made killpopup use the PCRS MIME-type checking and HTTP-header
 528  *      skipping.
 529  *    - Removed tabs from "config"
 530  *    - Moved duplicated url parsing code in "loaders.c" to a new funcition.
 531  *    - Bumped up version number.
 532  *
 533  *    Revision 1.1.1.1  2001/05/15 13:58:52  oes
 534  *    Initial import of version 2.9.3 source tree
 535  *
 536  *
 537  *********************************************************************/
 538 \f
 539
 540 #include "config.h"
 541
 542 #include <stdio.h>
 543 #include <sys/types.h>
 544 #include <stdlib.h>
 545 #include <ctype.h>
 546 #include <string.h>
 547 #include <assert.h>
 548
 549 #ifndef _WIN32
 550 #ifndef __OS2__
 551 #include <unistd.h>
 552 #endif /* ndef __OS2__ */
 553 #include <netinet/in.h>
 554 #else
 555 #include <winsock2.h>
 556 #endif /* ndef _WIN32 */
 557
 558 #ifdef __OS2__
 559 #include <utils.h>
 560 #endif /* def __OS2__ */
 561
 562 #include "project.h"
 563 #include "filters.h"
 564 #include "encode.h"
 565 #include "parsers.h"
 566 #include "ssplit.h"
 567 #include "errlog.h"
 568 #include "jbsockets.h"
 569 #include "miscutil.h"
 570 #include "actions.h"
 571 #include "cgi.h"
 572 #include "list.h"
 573 #include "deanimate.h"
 574 #include "urlmatch.h"
 575
 576 #ifdef _WIN32
 577 #include "win32.h"
 578 #endif
 579
 580 const char filters_h_rcs[] = FILTERS_H_VERSION;
 581
 582 /* Fix a problem with Solaris.  There should be no effect on other
 583  * platforms.
 584  * Solaris's isspace() is a macro which uses it's argument directly
 585  * as an array index.  Therefore we need to make sure that high-bit
 586  * characters generate +ve values, and ideally we also want to make
 587  * the argument match the declared parameter type of "int".
 588  */
 589 #define ijb_isdigit(__X) isdigit((int)(unsigned char)(__X))
 590
 591
 592 #ifdef FEATURE_ACL
 593 /*********************************************************************
 594  *
 595  * Function    :  block_acl
 596  *
 597  * Description :  Block this request?
 598  *                Decide yes or no based on ACL file.
 599  *
 600  * Parameters  :
 601  *          1  :  dst = The proxy or gateway address this is going to.
 602  *                      Or NULL to check all possible targets.
 603  *          2  :  csp = Current client state (buffers, headers, etc...)
 604  *                      Also includes the client IP address.
 605  *
 606  * Returns     : 0 = FALSE (don't block) and 1 = TRUE (do block)
 607  *
 608  *********************************************************************/
 609 int block_acl(struct access_control_addr *dst, struct client_state *csp)
 610 {
 611    struct access_control_list *acl = csp->config->acl;
 612
 613    /* if not using an access control list, then permit the connection */
 614    if (acl == NULL)
 615    {
 616       return(0);
 617    }
 618
 619    /* search the list */
 620    while (acl != NULL)
 621    {
 622       if ((csp->ip_addr_long & acl->src->mask) == acl->src->addr)
 623       {
 624          if (dst == NULL)
 625          {
 626             /* Just want to check if they have any access */
 627             if (acl->action == ACL_PERMIT)
 628             {
 629                return(0);
 630             }
 631          }
 632          else if ( ((dst->addr & acl->dst->mask) == acl->dst->addr)
 633            && ((dst->port == acl->dst->port) || (acl->dst->port == 0)))
 634          {
 635             if (acl->action == ACL_PERMIT)
 636             {
 637                return(0);
 638             }
 639             else
 640             {
 641                return(1);
 642             }
 643          }
 644       }
 645       acl = acl->next;
 646    }
 647
 648    return(1);
 649
 650 }
 651
 652
 653 /*********************************************************************
 654  *
 655  * Function    :  acl_addr
 656  *
 657  * Description :  Called from `load_config' to parse an ACL address.
 658  *
 659  * Parameters  :
 660  *          1  :  aspec = String specifying ACL address.
 661  *          2  :  aca = struct access_control_addr to fill in.
 662  *
 663  * Returns     :  0 => Ok, everything else is an error.
 664  *
 665  *********************************************************************/
 666 int acl_addr(const char *aspec, struct access_control_addr *aca)
 667 {
 668    int i, masklength;
 669    long port;
 670    char *p;
 671    char *acl_spec = NULL;
 672
 673    masklength = 32;
 674    port       =  0;
 675
 676    /*
 677     * Use a temporary acl spec copy so we can log
 678     * the unmodified original in case of parse errors.
 679     */
 680    acl_spec = strdup(aspec);
 681    if (acl_spec == NULL)
 682    {
 683       /* XXX: This will be logged as parse error. */
 684       return(-1);
 685    }
 686
 687    if ((p = strchr(acl_spec, '/')) != NULL)
 688    {
 689       *p++ = '\0';
 690       if (ijb_isdigit(*p) == 0)
 691       {
 692          free(acl_spec);
 693          return(-1);
 694       }
 695       masklength = atoi(p);
 696    }
 697
 698    if ((masklength < 0) || (masklength > 32))
 699    {
 700       free(acl_spec);
 701       return(-1);
 702    }
 703
 704    if ((p = strchr(acl_spec, ':')) != NULL)
 705    {
 706       char *endptr;
 707
 708       *p++ = '\0';
 709       port = strtol(p, &endptr, 10);
 710
 711       if (port <= 0 || port > 65535 || *endptr != '\0')
 712       {
 713          free(acl_spec);
 714          return(-1);
 715       }
 716    }
 717
 718    aca->port = (unsigned long)port;
 719
 720    aca->addr = ntohl(resolve_hostname_to_ip(acl_spec));
 721    free(acl_spec);
 722
 723    if (aca->addr == INADDR_NONE)
 724    {
 725       /* XXX: This will be logged as parse error. */
 726       return(-1);
 727    }
 728
 729    /* build the netmask */
 730    aca->mask = 0;
 731    for (i=1; i <= masklength ; i++)
 732    {
 733       aca->mask |= (1 << (32 - i));
 734    }
 735
 736    /* now mask off the host portion of the ip address
 737     * (i.e. save on the network portion of the address).
 738     */
 739    aca->addr = aca->addr & aca->mask;
 740
 741    return(0);
 742
 743 }
 744 #endif /* def FEATURE_ACL */
 745
 746
 747 /*********************************************************************
 748  *
 749  * Function    :  match_portlist
 750  *
 751  * Description :  Check if a given number is covered by a comma
 752  *                separated list of numbers and ranges (a,b-c,d,..)
 753  *
 754  * Parameters  :
 755  *          1  :  portlist = String with list
 756  *          2  :  port = port to check
 757  *
 758  * Returns     :  0 => no match
 759  *                1 => match
 760  *
 761  *********************************************************************/
 762 int match_portlist(const char *portlist, int port)
 763 {
 764    char *min, *max, *next, *portlist_copy;
 765
 766    min = next = portlist_copy = strdup(portlist);
 767
 768    /*
 769     * Zero-terminate first item and remember offset for next
 770     */
 771    if (NULL != (next = strchr(portlist_copy, (int) ',')))
 772    {
 773       *next++ = '\0';
 774    }
 775
 776    /*
 777     * Loop through all items, checking for match
 778     */
 779    while(min)
 780    {
 781       if (NULL == (max = strchr(min, (int) '-')))
 782       {
 783          /*
 784           * No dash, check for equality
 785           */
 786          if (port == atoi(min))
 787          {
 788             free(portlist_copy);
 789             return(1);
 790          }
 791       }
 792       else
 793       {
 794          /*
 795           * This is a range, so check if between min and max,
 796           * or, if max was omitted, between min and 65K
 797           */
 798          *max++ = '\0';
 799          if(port >= atoi(min) && port <= (atoi(max) ? atoi(max) : 65535))
 800          {
 801             free(portlist_copy);
 802             return(1);
 803          }
 804
 805       }
 806
 807       /*
 808        * Jump to next item
 809        */
 810       min = next;
 811
 812       /*
 813        * Zero-terminate next item and remember offset for n+1
 814        */
 815       if ((NULL != next) && (NULL != (next = strchr(next, (int) ','))))
 816       {
 817          *next++ = '\0';
 818       }
 819    }
 820
 821    free(portlist_copy);
 822    return 0;
 823
 824 }
 825
 826
 827 /*********************************************************************
 828  *
 829  * Function    :  block_url
 830  *
 831  * Description :  Called from `chat'.  Check to see if we need to block this.
 832  *
 833  * Parameters  :
 834  *          1  :  csp = Current client state (buffers, headers, etc...)
 835  *
 836  * Returns     :  NULL => unblocked, else HTTP block response
 837  *
 838  *********************************************************************/
 839 struct http_response *block_url(struct client_state *csp)
 840 {
 841    struct http_response *rsp;
 842    const char *new_content_type = NULL;
 843
 844    /*
 845     * If it's not blocked, don't block it ;-)
 846     */
 847    if ((csp->action->flags & ACTION_BLOCK) == 0)
 848    {
 849       return NULL;
 850    }
 851    if (csp->action->flags & ACTION_REDIRECT)
 852    {
 853       log_error(LOG_LEVEL_ERROR, "redirect{} overruled by block.");
 854    }
 855    /*
 856     * Else, prepare a response
 857     */
 858    if (NULL == (rsp = alloc_http_response()))
 859    {
 860       return cgi_error_memory();
 861    }
 862
 863    /*
 864     * If it's an image-url, send back an image or redirect
 865     * as specified by the relevant +image action
 866     */
 867 #ifdef FEATURE_IMAGE_BLOCKING
 868    if (((csp->action->flags & ACTION_IMAGE_BLOCKER) != 0)
 869         && is_imageurl(csp))
 870    {
 871       char *p;
 872       /* determine HOW images should be blocked */
 873       p = csp->action->string[ACTION_STRING_IMAGE_BLOCKER];
 874
 875       if(csp->action->flags & ACTION_HANDLE_AS_EMPTY_DOCUMENT)
 876       {
 877          log_error(LOG_LEVEL_ERROR, "handle-as-empty-document overruled by handle-as-image.");
 878       }
 879 #if 1 /* Two alternative strategies, use this one for now: */
 880
 881       /* and handle accordingly: */
 882       if ((p == NULL) || (0 == strcmpic(p, "pattern")))
 883       {
 884          rsp->status = strdup("403 Request blocked by Privoxy");
 885          if (rsp->status == NULL)
 886          {
 887             free_http_response(rsp);
 888             return cgi_error_memory();
 889          }
 890          rsp->body = bindup(image_pattern_data, image_pattern_length);
 891          if (rsp->body == NULL)
 892          {
 893             free_http_response(rsp);
 894             return cgi_error_memory();
 895          }
 896          rsp->content_length = image_pattern_length;
 897
 898          if (enlist_unique_header(rsp->headers, "Content-Type", BUILTIN_IMAGE_MIMETYPE))
 899          {
 900             free_http_response(rsp);
 901             return cgi_error_memory();
 902          }
 903       }
 904
 905       else if (0 == strcmpic(p, "blank"))
 906       {
 907          rsp->status = strdup("403 Request blocked by Privoxy");
 908          if (rsp->status == NULL)
 909          {
 910             free_http_response(rsp);
 911             return cgi_error_memory();
 912          }
 913          rsp->body = bindup(image_blank_data, image_blank_length);
 914          if (rsp->body == NULL)
 915          {
 916             free_http_response(rsp);
 917             return cgi_error_memory();
 918          }
 919          rsp->content_length = image_blank_length;
 920
 921          if (enlist_unique_header(rsp->headers, "Content-Type", BUILTIN_IMAGE_MIMETYPE))
 922          {
 923             free_http_response(rsp);
 924             return cgi_error_memory();
 925          }
 926       }
 927
 928       else
 929       {
 930          rsp->status = strdup("302 Local Redirect from Privoxy");
 931          if (rsp->status == NULL)
 932          {
 933             free_http_response(rsp);
 934             return cgi_error_memory();
 935          }
 936
 937          if (enlist_unique_header(rsp->headers, "Location", p))
 938          {
 939             free_http_response(rsp);
 940             return cgi_error_memory();
 941          }
 942       }
 943
 944 #else /* Following code is disabled for now */
 945
 946       /* and handle accordingly: */
 947       if ((p == NULL) || (0 == strcmpic(p, "pattern")))
 948       {
 949          p = CGI_PREFIX "send-banner?type=pattern";
 950       }
 951       else if (0 == strcmpic(p, "blank"))
 952       {
 953          p = CGI_PREFIX "send-banner?type=blank";
 954       }
 955       rsp->status = strdup("302 Local Redirect from Privoxy");
 956       if (rsp->status == NULL)
 957       {
 958          free_http_response(rsp);
 959          return cgi_error_memory();
 960       }
 961
 962       if (enlist_unique_header(rsp->headers, "Location", p))
 963       {
 964          free_http_response(rsp);
 965          return cgi_error_memory();
 966       }
 967 #endif /* Preceeding code is disabled for now */
 968    }
 969    else if(csp->action->flags & ACTION_HANDLE_AS_EMPTY_DOCUMENT)
 970    {
 971      /*
 972       *  Send empty document.
 973       */
 974       new_content_type = csp->action->string[ACTION_STRING_CONTENT_TYPE];
 975
 976       freez(rsp->body);
 977       rsp->body = strdup(" ");
 978       rsp->content_length = 1;
 979
 980       rsp->status = strdup("403 Request blocked by Privoxy");
 981       if (rsp->status == NULL)
 982       {
 983          free_http_response(rsp);
 984          return cgi_error_memory();
 985       }
 986       if (new_content_type != 0)
 987       {
 988          log_error(LOG_LEVEL_HEADER, "Overwriting Content-Type with %s", new_content_type);
 989          if (enlist_unique_header(rsp->headers, "Content-Type", new_content_type))
 990          {
 991             free_http_response(rsp);
 992             return cgi_error_memory();
 993          }
 994       }
 995    }
 996    else
 997 #endif /* def FEATURE_IMAGE_BLOCKING */
 998
 999    /*
1000     * Else, generate an HTML "blocked" message:
1001     */
1002    {
1003       jb_err err;
1004       struct map * exports;
1005       char *p;
1006
1007       /*
1008        * Workaround for stupid Netscape bug which prevents
1009        * pages from being displayed if loading a referenced
1010        * JavaScript or style sheet fails. So make it appear
1011        * as if it succeeded.
1012        */
1013       if ( NULL != (p = get_header_value(csp->headers, "User-Agent:"))
1014            && !strncmpic(p, "mozilla", 7) /* Catch Netscape but */
1015            && !strstr(p, "Gecko")         /* save Mozilla, */
1016            && !strstr(p, "compatible")    /* MSIE */
1017            && !strstr(p, "Opera"))        /* and Opera. */
1018       {
1019          rsp->status = strdup("200 Request for blocked URL");
1020       }
1021       else
1022       {
1023          rsp->status = strdup("403 Request for blocked URL");
1024       }
1025
1026       if (rsp->status == NULL)
1027       {
1028          free_http_response(rsp);
1029          return cgi_error_memory();
1030       }
1031
1032       exports = default_exports(csp, NULL);
1033       if (exports == NULL)
1034       {
1035          free_http_response(rsp);
1036          return cgi_error_memory();
1037       }
1038
1039 #ifdef FEATURE_FORCE_LOAD
1040       err = map(exports, "force-prefix", 1, FORCE_PREFIX, 1);
1041       /*
1042        * Export the force conditional block killer if
1043        *
1044        * - Privoxy was compiled without FEATURE_FORCE_LOAD, or
1045        * - Privoxy is configured to enforce blocks, or
1046        * - it's a CONNECT request and enforcing wouldn't work anyway.
1047        */
1048       if ((csp->config->feature_flags & RUNTIME_FEATURE_ENFORCE_BLOCKS)
1049        || (0 == strcmpic(csp->http->gpc, "connect")))
1050 #endif /* ndef FEATURE_FORCE_LOAD */
1051       {
1052          err = map_block_killer(exports, "force-support");
1053       }
1054
1055       if (!err) err = map(exports, "protocol", 1, csp->http->ssl ? "https://" : "http://", 1);
1056       if (!err) err = map(exports, "hostport", 1, html_encode(csp->http->hostport), 0);
1057       if (!err) err = map(exports, "path", 1, html_encode(csp->http->path), 0);
1058       if (!err) err = map(exports, "path-ue", 1, url_encode(csp->http->path), 0);
1059
1060       if (err)
1061       {
1062          free_map(exports);
1063          free_http_response(rsp);
1064          return cgi_error_memory();
1065       }
1066
1067       err = template_fill_for_cgi(csp, "blocked", exports, rsp);
1068       if (err)
1069       {
1070          free_http_response(rsp);
1071          return cgi_error_memory();
1072       }
1073    }
1074    rsp->reason = RSP_REASON_BLOCKED;
1075
1076    return finish_http_response(csp, rsp);
1077
1078 }
1079
1080
1081 #ifdef FEATURE_TRUST
1082 /*********************************************************************
1083  *
1084  * Function    :  trust_url FIXME: I should be called distrust_url
1085  *
1086  * Description :  Calls is_untrusted_url to determine if the URL is trusted
1087  *                and if not, returns a HTTP 403 response with a reject message.
1088  *
1089  * Parameters  :
1090  *          1  :  csp = Current client state (buffers, headers, etc...)
1091  *
1092  * Returns     :  NULL => trusted, else http_response.
1093  *
1094  *********************************************************************/
1095 struct http_response *trust_url(struct client_state *csp)
1096 {
1097    struct http_response *rsp;
1098    struct map * exports;
1099    char buf[BUFFER_SIZE];
1100    char *p;
1101    struct url_spec **tl;
1102    struct url_spec *t;
1103    jb_err err;
1104
1105    /*
1106     * Don't bother to work on trusted URLs
1107     */
1108    if (!is_untrusted_url(csp))
1109    {
1110       return NULL;
1111    }
1112
1113    /*
1114     * Else, prepare a response:
1115     */
1116    if (NULL == (rsp = alloc_http_response()))
1117    {
1118       return cgi_error_memory();
1119    }
1120
1121    rsp->status = strdup("403 Request blocked by Privoxy");
1122    exports = default_exports(csp, NULL);
1123    if (exports == NULL || rsp->status == NULL)
1124    {
1125       free_http_response(rsp);
1126       return cgi_error_memory();
1127    }
1128
1129    /*
1130     * Export the protocol, host, port, and referrer information
1131     */
1132    err = map(exports, "hostport", 1, csp->http->hostport, 1);
1133    if (!err) err = map(exports, "protocol", 1, csp->http->ssl ? "https://" : "http://", 1);
1134    if (!err) err = map(exports, "path", 1, csp->http->path, 1);
1135
1136    if (NULL != (p = get_header_value(csp->headers, "Referer:")))
1137    {
1138       if (!err) err = map(exports, "referrer", 1, html_encode(p), 0);
1139    }
1140    else
1141    {
1142       if (!err) err = map(exports, "referrer", 1, "none set", 1);
1143    }
1144
1145    if (err)
1146    {
1147       free_map(exports);
1148       free_http_response(rsp);
1149       return cgi_error_memory();
1150    }
1151
1152    /*
1153     * Export the trust list
1154     */
1155    p = strdup("");
1156    for (tl = csp->config->trust_list; (t = *tl) != NULL ; tl++)
1157    {
1158       snprintf(buf, sizeof(buf), "<li>%s</li>\n", t->spec);
1159       string_append(&p, buf);
1160    }
1161    err = map(exports, "trusted-referrers", 1, p, 0);
1162
1163    if (err)
1164    {
1165       free_map(exports);
1166       free_http_response(rsp);
1167       return cgi_error_memory();
1168    }
1169
1170    /*
1171     * Export the trust info, if available
1172     */
1173    if (csp->config->trust_info->first)
1174    {
1175       struct list_entry *l;
1176
1177       p = strdup("");
1178       for (l = csp->config->trust_info->first; l ; l = l->next)
1179       {
1180          snprintf(buf, sizeof(buf), "<li> <a href=\"%s\">%s</a><br>\n", l->str, l->str);
1181          string_append(&p, buf);
1182       }
1183       err = map(exports, "trust-info", 1, p, 0);
1184    }
1185    else
1186    {
1187       err = map_block_killer(exports, "have-trust-info");
1188    }
1189
1190    if (err)
1191    {
1192       free_map(exports);
1193       free_http_response(rsp);
1194       return cgi_error_memory();
1195    }
1196
1197    /*
1198     * Export the force conditional block killer if
1199     *
1200     * - Privoxy was compiled without FEATURE_FORCE_LOAD, or
1201     * - Privoxy is configured to enforce blocks, or
1202     * - it's a CONNECT request and enforcing wouldn't work anyway.
1203     */
1204 #ifdef FEATURE_FORCE_LOAD
1205    if ((csp->config->feature_flags & RUNTIME_FEATURE_ENFORCE_BLOCKS)
1206     || (0 == strcmpic(csp->http->gpc, "connect")))
1207    {
1208       err = map_block_killer(exports, "force-support");
1209    }
1210    else
1211    {
1212       err = map(exports, "force-prefix", 1, FORCE_PREFIX, 1);
1213    }
1214 #else /* ifndef FEATURE_FORCE_LOAD */
1215    err = map_block_killer(exports, "force-support");
1216 #endif /* ndef FEATURE_FORCE_LOAD */
1217
1218    if (err)
1219    {
1220       free_map(exports);
1221       free_http_response(rsp);
1222       return cgi_error_memory();
1223    }
1224
1225    /*
1226     * Build the response
1227     */
1228    err = template_fill_for_cgi(csp, "untrusted", exports, rsp);
1229    if (err)
1230    {
1231       free_http_response(rsp);
1232       return cgi_error_memory();
1233    }
1234    rsp->reason = RSP_REASON_UNTRUSTED;
1235
1236    return finish_http_response(csp, rsp);
1237 }
1238 #endif /* def FEATURE_TRUST */
1239
1240 /*********************************************************************
1241  *
1242  * Function    :  execute_single_pcrs_command
1243  *
1244  * Description :  Apply single pcrs command to the subject.
1245  *                The subject itself is left untouched, memory for the result
1246  *                is malloc()ed and it is the caller's responsibility to free
1247  *                the result when it's no longer needed.
1248  *
1249  * Parameters  :
1250  *          1  :  subject = the subject (== original) string
1251  *          2  :  pcrs_command = the pcrs command as string (s@foo@bar@)
1252  *          3  :  hits = int* for returning  the number of modifications
1253  *
1254  * Returns     :  NULL in case of errors, otherwise the
1255  *                result of the pcrs command.
1256  *
1257  *********************************************************************/
1258 char *execute_single_pcrs_command(char *subject, const char *pcrs_command, int *hits)
1259 {
1260    int error;
1261    size_t size;
1262    char *result = NULL;
1263    pcrs_job *job;
1264
1265    assert(subject);
1266    assert(pcrs_command);
1267
1268    *hits = 0;
1269    size = strlen(subject);
1270
1271    if (NULL == (job = pcrs_compile_command(pcrs_command, &error)))
1272    {
1273       log_error(LOG_LEVEL_ERROR, "Failed to compile pcrs command \"%s\". Error: %d.",
1274          pcrs_command, error);
1275    }
1276    else if ((*hits = pcrs_execute(job, subject, size, &result, &size)) < 0)
1277    {
1278       log_error(LOG_LEVEL_ERROR, "Failed to execute pcrs command: %s", pcrs_strerror(*hits));
1279       *hits = 0;
1280       freez(result);
1281    }
1282
1283    if (job)
1284    {
1285       job = pcrs_free_job(job);
1286    }
1287
1288    return result;
1289
1290 }
1291
1292 /*********************************************************************
1293  *
1294  * Function    :  rewrite_url
1295  *
1296  * Description :  Rewrites a URL with a single pcrs command
1297  *                and returns the result if it differs from the
1298  *                original and isn't obviously invalid.
1299  *
1300  * Parameters  :
1301  *          1  :  old_url = URL to rewrite.
1302  *          2  :  pcrs_command = pcrs command formatted as string (s@foo@bar@)
1303  *
1304  *
1305  * Returns     :  NULL if the pcrs_command didn't change the url, or
1306  *                the result of the modification.
1307  *
1308  *********************************************************************/
1309 char *rewrite_url(char *old_url, const char *pcrs_command)
1310 {
1311    char *new_url = NULL;
1312    int hits;
1313
1314    assert(old_url);
1315    assert(pcrs_command);
1316
1317    new_url = execute_single_pcrs_command(old_url, pcrs_command, &hits);
1318
1319    if (hits == 0)
1320    {
1321       log_error(LOG_LEVEL_REDIRECTS,
1322          "pcrs command \"%s\" didn't change \"%s\".",
1323          pcrs_command, old_url, new_url);
1324       freez(new_url);
1325    }
1326    else if (strncmpic(new_url, "http://", 7) && strncmpic(new_url, "https://", 8))
1327    {
1328       log_error(LOG_LEVEL_ERROR,
1329          "pcrs command \"%s\" changed \"%s\" to \"%s\" (%u hi%s), "
1330          "but the result doesn't look like a valid URL and will be ignored.",
1331          pcrs_command, old_url, new_url, hits, (hits == 1) ? "t" : "ts");
1332       freez(new_url);
1333    }
1334    else
1335    {
1336       log_error(LOG_LEVEL_REDIRECTS,
1337          "pcrs command \"%s\" changed \"%s\" to \"%s\" (%u hi%s).",
1338          pcrs_command, old_url, new_url, hits, (hits == 1) ? "t" : "ts");
1339    }
1340
1341    return new_url;
1342
1343 }
1344
1345
1346 #ifdef FEATURE_FAST_REDIRECTS
1347 /*********************************************************************
1348  *
1349  * Function    :  get_last_url
1350  *
1351  * Description :  Search for the last URL inside a string.
1352  *                If the string already is a URL, it will
1353  *                be the first URL found.
1354  *
1355  * Parameters  :
1356  *          1  :  subject = the string to check
1357  *          2  :  redirect_mode = +fast-redirect{} mode
1358  *
1359  * Returns     :  NULL if no URL was found, or
1360  *                the last URL found.
1361  *
1362  *********************************************************************/
1363 char *get_last_url(char *subject, const char *redirect_mode)
1364 {
1365    char *new_url = NULL;
1366    char *tmp;
1367
1368    assert(subject);
1369    assert(redirect_mode);
1370
1371    subject = strdup(subject);
1372    if (subject == NULL)
1373    {
1374       log_error(LOG_LEVEL_ERROR, "Out of memory while searching for redirects.");
1375       return NULL;
1376    }
1377
1378    if (0 == strcmpic(redirect_mode, "check-decoded-url"))
1379    {
1380       log_error(LOG_LEVEL_REDIRECTS, "Decoding \"%s\" if necessary.", subject);
1381       new_url = url_decode(subject);
1382       if (new_url != NULL)
1383       {
1384          freez(subject);
1385          subject = new_url;
1386       }
1387       else
1388       {
1389          log_error(LOG_LEVEL_ERROR, "Unable to decode \"%s\".", subject);
1390       }
1391    }
1392
1393    log_error(LOG_LEVEL_REDIRECTS, "Checking \"%s\" for redirects.", subject);
1394
1395    /*
1396     * Find the last URL encoded in the request
1397     */
1398    tmp = subject;
1399    while ((tmp = strstr(tmp, "http://")) != NULL)
1400    {
1401       new_url = tmp++;
1402    }
1403    tmp = (new_url != NULL) ? new_url : subject;
1404    while ((tmp = strstr(tmp, "https://")) != NULL)
1405    {
1406       new_url = tmp++;
1407    }
1408
1409    if ((new_url != NULL)
1410       && (  (new_url != subject)
1411          || (0 == strncmpic(subject, "http://", 7))
1412          || (0 == strncmpic(subject, "https://", 8))
1413          ))
1414    {
1415       /*
1416        * Return new URL if we found a redirect
1417        * or if the subject already was a URL.
1418        *
1419        * The second case makes sure that we can
1420        * chain get_last_url after another redirection check
1421        * (like rewrite_url) without losing earlier redirects.
1422        */
1423       new_url = strdup(new_url);
1424       freez(subject);
1425       return new_url;
1426    }
1427
1428    freez(subject);
1429    return NULL;
1430
1431 }
1432 #endif /* def FEATURE_FAST_REDIRECTS */
1433
1434
1435 /*********************************************************************
1436  *
1437  * Function    :  redirect_url
1438  *
1439  * Description :  Checks if Privoxy should answer the request with
1440  *                a HTTP redirect and generates the redirect if
1441  *                necessary.
1442  *
1443  * Parameters  :
1444  *          1  :  csp = Current client state (buffers, headers, etc...)
1445  *
1446  * Returns     :  NULL if the request can pass, HTTP redirect otherwise.
1447  *
1448  *********************************************************************/
1449 struct http_response *redirect_url(struct client_state *csp)
1450 {
1451    struct http_response *rsp;
1452 #ifdef FEATURE_FAST_REDIRECTS
1453    /*
1454     * XXX: Do we still need FEATURE_FAST_REDIRECTS
1455     * as compile-time option? The user can easily disable
1456     * it in his action file.
1457     */
1458    char * redirect_mode;
1459 #endif /* def FEATURE_FAST_REDIRECTS */
1460    char *old_url = NULL;
1461    char *new_url = NULL;
1462    char *redirection_string;
1463
1464    if ((csp->action->flags & ACTION_REDIRECT))
1465    {
1466       redirection_string = csp->action->string[ACTION_STRING_REDIRECT];
1467
1468       /*
1469        * If the redirection string begins with 's',
1470        * assume it's a pcrs command, otherwise treat it as
1471        * properly formatted URL and use it for the redirection
1472        * directly.
1473        *
1474        * According to RFC 2616 section 14.30 the URL
1475        * has to be absolute and if the user tries:
1476        * +redirect{shit/this/will/be/parsed/as/pcrs_command.html}
1477        * she would get undefined results anyway.
1478        *
1479        */
1480
1481       if (*redirection_string == 's')
1482       {
1483          old_url = csp->http->url;
1484          new_url = rewrite_url(old_url, redirection_string);
1485       }
1486       else
1487       {
1488          log_error(LOG_LEVEL_REDIRECTS,
1489             "No pcrs command recognized, assuming that \"%s\" is already properly formatted.",
1490             redirection_string);
1491          new_url = strdup(redirection_string);
1492       }
1493    }
1494
1495 #ifdef FEATURE_FAST_REDIRECTS
1496    if ((csp->action->flags & ACTION_FAST_REDIRECTS))
1497    {
1498       redirect_mode = csp->action->string[ACTION_STRING_FAST_REDIRECTS];
1499
1500       /*
1501        * If it exists, use the previously rewritten URL as input
1502        * otherwise just use the old path.
1503        */
1504       old_url = (new_url != NULL) ? new_url : strdup(csp->http->path);
1505       new_url = get_last_url(old_url, redirect_mode);
1506       freez(old_url);
1507    }
1508 #endif /* def FEATURE_FAST_REDIRECTS */
1509
1510    /* Did any redirect action trigger? */
1511    if (new_url)
1512    {
1513       if (0 == strcmpic(new_url, csp->http->url))
1514       {
1515          log_error(LOG_LEVEL_ERROR,
1516             "New URL \"%s\" and old URL \"%s\" are the same. Redirection loop prevented.",
1517             csp->http->url, new_url);
1518             freez(new_url);
1519       }
1520       else
1521       {
1522          log_error(LOG_LEVEL_REDIRECTS, "New URL is: %s", new_url);
1523
1524          if (NULL == (rsp = alloc_http_response()))
1525          {
1526             freez(new_url);
1527             return cgi_error_memory();
1528          }
1529
1530          if ( enlist_unique_header(rsp->headers, "Location", new_url)
1531            || (NULL == (rsp->status = strdup("302 Local Redirect from Privoxy"))) )
1532          {
1533             freez(new_url);
1534             free_http_response(rsp);
1535             return cgi_error_memory();
1536          }
1537          rsp->reason = RSP_REASON_REDIRECTED;
1538          freez(new_url);
1539
1540          return finish_http_response(csp, rsp);
1541       }
1542    }
1543
1544    /* Only reached if no redirect is required */
1545    return NULL;
1546
1547 }
1548
1549
1550 #ifdef FEATURE_IMAGE_BLOCKING
1551 /*********************************************************************
1552  *
1553  * Function    :  is_imageurl
1554  *
1555  * Description :  Given a URL, decide whether it is an image or not,
1556  *                using either the info from a previous +image action
1557  *                or, #ifdef FEATURE_IMAGE_DETECT_MSIE, and the browser
1558  *                is MSIE and not on a Mac, tell from the browser's accept
1559  *                header.
1560  *
1561  * Parameters  :
1562  *          1  :  csp = Current client state (buffers, headers, etc...)
1563  *
1564  * Returns     :  True (nonzero) if URL is an image, false (0)
1565  *                otherwise
1566  *
1567  *********************************************************************/
1568 int is_imageurl(const struct client_state *csp)
1569 {
1570 #ifdef FEATURE_IMAGE_DETECT_MSIE
1571    char *tmp;
1572
1573    tmp = get_header_value(csp->headers, "User-Agent:");
1574    if (tmp && strstr(tmp, "MSIE") && !strstr(tmp, "Mac_"))
1575    {
1576       tmp = get_header_value(csp->headers, "Accept:");
1577       if (tmp && strstr(tmp, "image/gif"))
1578       {
1579          /* Client will accept HTML.  If this seems counterintuitive,
1580           * blame Microsoft.
1581           */
1582          return(0);
1583       }
1584       else
1585       {
1586          return(1);
1587       }
1588    }
1589 #endif /* def FEATURE_IMAGE_DETECT_MSIE */
1590
1591    return ((csp->action->flags & ACTION_IMAGE) != 0);
1592
1593 }
1594 #endif /* def FEATURE_IMAGE_BLOCKING */
1595
1596
1597 #ifdef FEATURE_TRUST
1598 /*********************************************************************
1599  *
1600  * Function    :  is_untrusted_url
1601  *
1602  * Description :  Should we "distrust" this URL (and block it)?
1603  *
1604  *                Yes if it matches a line in the trustfile, or if the
1605  *                    referrer matches a line starting with "+" in the
1606  *                    trustfile.
1607  *                No  otherwise.
1608  *
1609  * Parameters  :
1610  *          1  :  csp = Current client state (buffers, headers, etc...)
1611  *
1612  * Returns     :  0 => trusted, 1 => untrusted
1613  *
1614  *********************************************************************/
1615 int is_untrusted_url(const struct client_state *csp)
1616 {
1617    struct file_list *fl;
1618    struct block_spec *b;
1619    struct url_spec **trusted_url;
1620    struct http_request rhttp[1];
1621    const char * referer;
1622    jb_err err;
1623
1624    /*
1625     * If we don't have a trustlist, we trust everybody
1626     */
1627    if (((fl = csp->tlist) == NULL) || ((b  = fl->f) == NULL))
1628    {
1629       return 0;
1630    }
1631
1632    memset(rhttp, '\0', sizeof(*rhttp));
1633
1634    /*
1635     * Do we trust the request URL itself?
1636     */
1637    for (b = b->next; b ; b = b->next)
1638    {
1639       if (url_match(b->url, csp->http))
1640       {
1641          return b->reject;
1642       }
1643    }
1644
1645    if (NULL == (referer = get_header_value(csp->headers, "Referer:")))
1646    {
1647       /* no referrer was supplied */
1648       return 1;
1649    }
1650
1651
1652    /*
1653     * If not, do we maybe trust its referrer?
1654     */
1655    err = parse_http_url(referer, rhttp, csp);
1656    if (err)
1657    {
1658       return 1;
1659    }
1660
1661    for (trusted_url = csp->config->trust_list; *trusted_url != NULL; trusted_url++)
1662    {
1663       if (url_match(*trusted_url, rhttp))
1664       {
1665          /* if the URL's referrer is from a trusted referrer, then
1666           * add the target spec to the trustfile as an unblocked
1667           * domain and return 0 (which means it's OK).
1668           */
1669
1670          FILE *fp;
1671
1672          if (NULL != (fp = fopen(csp->config->trustfile, "a")))
1673          {
1674             char * path;
1675             char * path_end;
1676             char * new_entry = strdup("~");
1677
1678             string_append(&new_entry, csp->http->hostport);
1679
1680             path = csp->http->path;
1681             if ( (path[0] == '/')
1682               && (path[1] == '~')
1683               && ((path_end = strchr(path + 2, '/')) != NULL))
1684             {
1685                /* since this path points into a user's home space
1686                 * be sure to include this spec in the trustfile.
1687                 */
1688                int path_len = path_end - path; /* save offset */
1689                path = strdup(path); /* Copy string */
1690                if (path != NULL)
1691                {
1692                   path_end = path + path_len; /* regenerate ptr to new buffer */
1693                   *(path_end + 1) = '\0'; /* Truncate path after '/' */
1694                }
1695                string_join(&new_entry, path);
1696             }
1697
1698             /*
1699              * Give a reason for generating this entry.
1700              */
1701             string_append(&new_entry, " # Trusted referrer was: ");
1702             string_append(&new_entry, referer);
1703
1704             if (new_entry != NULL)
1705             {
1706                if (-1 == fprintf(fp, "%s\n", new_entry))
1707                {
1708                   log_error(LOG_LEVEL_ERROR, "Failed to append \'%s\' to trustfile \'%s\': %E",
1709                      new_entry, csp->config->trustfile);
1710                }
1711                free(new_entry);
1712             }
1713             else
1714             {
1715                /* FIXME: No way to handle out-of memory, so mostly ignoring it */
1716                log_error(LOG_LEVEL_ERROR, "Out of memory adding pattern to trust file");
1717             }
1718
1719             fclose(fp);
1720          }
1721          else
1722          {
1723             log_error(LOG_LEVEL_ERROR, "Failed to append new entry for \'%s\' to trustfile \'%s\': %E",
1724                csp->http->hostport, csp->config->trustfile);
1725          }
1726          return 0;
1727       }
1728    }
1729
1730    return 1;
1731 }
1732 #endif /* def FEATURE_TRUST */
1733
1734
1735 /*********************************************************************
1736  *
1737  * Function    :  pcrs_filter_response
1738  *
1739  * Description :  Execute all text substitutions from all applying
1740  *                +filter actions on the text buffer that's been accumulated
1741  *                in csp->iob->buf. If this changes the contents, set
1742  *                csp->content_length to the modified size and raise the
1743  *                CSP_FLAG_MODIFIED flag.
1744  *
1745  *                XXX: Currently pcrs_filter_response is also responsible
1746  *                for dechunking and decompressing. Both should be
1747  *                done in separate functions so other content modifiers
1748  *                profit as well, even if pcrs filtering is disabled.
1749  *
1750  * Parameters  :
1751  *          1  :  csp = Current client state (buffers, headers, etc...)
1752  *
1753  * Returns     :  a pointer to the (newly allocated) modified buffer.
1754  *                or NULL if there were no hits or something went wrong
1755  *
1756  *********************************************************************/
1757 char *pcrs_filter_response(struct client_state *csp)
1758 {
1759    int hits=0;
1760    size_t size, prev_size;
1761
1762    char *old = csp->iob->cur, *new = NULL;
1763    pcrs_job *job;
1764
1765    struct file_list *fl;
1766    struct re_filterfile_spec *b;
1767    struct list_entry *filtername;
1768
1769    int i, found_filters = 0;
1770
1771    /*
1772     * Sanity first
1773     */
1774    if (csp->iob->cur >= csp->iob->eod)
1775    {
1776       return(NULL);
1777    }
1778    size = (size_t)(csp->iob->eod - csp->iob->cur);
1779
1780    /*
1781     * Need to check the set of re_filterfiles...
1782     */
1783    for (i = 0; i < MAX_AF_FILES; i++)
1784    {
1785       fl = csp->rlist[i];
1786       if (NULL != fl)
1787       {
1788          if (NULL != fl->f)
1789          {
1790            found_filters = 1;
1791            break;
1792          }
1793       }
1794    }
1795
1796    if (0 == found_filters)
1797    {
1798       log_error(LOG_LEVEL_ERROR, "Unable to get current state of regexp filtering.");
1799       return(NULL);
1800    }
1801
1802    /*
1803     * If the body has a "chunked" transfer-encoding,
1804     * get rid of it first, adjusting size and iob->eod
1805     */
1806    if (csp->flags & CSP_FLAG_CHUNKED)
1807    {
1808       log_error(LOG_LEVEL_RE_FILTER, "Need to de-chunk first");
1809       if (0 == (size = remove_chunked_transfer_coding(csp->iob->cur, size)))
1810       {
1811          return(NULL);
1812       }
1813       csp->iob->eod = csp->iob->cur + size;
1814       csp->flags |= CSP_FLAG_MODIFIED;
1815    }
1816
1817 #ifdef FEATURE_ZLIB
1818    /*
1819     * If the body has a compressed transfer-encoding,
1820     * uncompress it first, adjusting size and iob->eod.
1821     * Note that decompression occurs after de-chunking.
1822     */
1823    if (csp->content_type & (CT_GZIP | CT_DEFLATE))
1824    {
1825       /* Notice that we at least tried to decompress. */
1826       if (JB_ERR_OK != decompress_iob(csp))
1827       {
1828          /*
1829           * We failed to decompress the data; there's no point
1830           * in continuing since we can't filter.
1831           *
1832           * XXX: Actually the Accept-Encoding header may
1833           * just be incorrect in which case we could continue
1834           * with filtering.
1835           *
1836           * Unset CT_GZIP and CT_DEFLATE to remember not
1837           * to modify the Content-Encoding header later.
1838           */
1839           csp->content_type &= ~CT_GZIP;
1840           csp->content_type &= ~CT_DEFLATE;
1841           return(NULL);
1842       }
1843       log_error(LOG_LEVEL_RE_FILTER,
1844          "Decompression successful. Old size: %d, new size: %d.",
1845          size, csp->iob->eod - csp->iob->cur);
1846
1847       /*
1848        * Decompression gives us a completely new iob,
1849        * so we need to update.
1850        */
1851       size = (size_t)(csp->iob->eod - csp->iob->cur);
1852       old  = csp->iob->cur;
1853
1854       csp->flags |= CSP_FLAG_MODIFIED;
1855       csp->content_type &= ~CT_TABOO;
1856    }
1857 #endif
1858
1859    for (i = 0; i < MAX_AF_FILES; i++)
1860    {
1861      fl = csp->rlist[i];
1862      if ((NULL == fl) || (NULL == fl->f))
1863      {
1864         /*
1865          * Either there are no filter files
1866          * left, or this filter file just
1867          * contains no valid filters.
1868          *
1869          * Continue to be sure we don't miss
1870          * valid filter files that are chained
1871          * after empty or invalid ones.
1872          */
1873         continue;
1874      }
1875    /*
1876     * For all applying +filter actions, look if a filter by that
1877     * name exists and if yes, execute it's pcrs_joblist on the
1878     * buffer.
1879     */
1880    for (b = fl->f; b; b = b->next)
1881    {
1882       if (b->type != FT_CONTENT_FILTER)
1883       {
1884          /* Skip header filters */
1885          continue;
1886       }
1887
1888       for (filtername = csp->action->multi[ACTION_MULTI_FILTER]->first;
1889            filtername ; filtername = filtername->next)
1890       {
1891          if (strcmp(b->name, filtername->str) == 0)
1892          {
1893             int current_hits = 0; /* Number of hits caused by this filter */
1894             int job_number   = 0; /* Which job we're currently executing  */
1895             int job_hits     = 0; /* How many hits the current job caused */
1896
1897             if ( NULL == b->joblist )
1898             {
1899                log_error(LOG_LEVEL_RE_FILTER, "Filter %s has empty joblist. Nothing to do.", b->name);
1900                continue;
1901             }
1902
1903             prev_size = size;
1904             /* Apply all jobs from the joblist */
1905             for (job = b->joblist; NULL != job; job = job->next)
1906             {
1907                job_number++;
1908                job_hits = pcrs_execute(job, old, size, &new, &size);
1909
1910                if (job_hits >= 0)
1911                {
1912                   /*
1913                    * That went well. Continue filtering
1914                    * and use the result of this job as
1915                    * input for the next one.
1916                    */
1917                   current_hits += job_hits;
1918                   if (old != csp->iob->cur)
1919                   {
1920                      free(old);
1921                   }
1922                   old = new;
1923                }
1924                else
1925                {
1926                   /*
1927                    * This job caused an unexpected error. Inform the user
1928                    * and skip the rest of the jobs in this filter. We could
1929                    * continue with the next job, but usually the jobs
1930                    * depend on each other or are similar enough to
1931                    * fail for the same reason.
1932                    *
1933                    * At the moment our pcrs expects the error codes of pcre 3.4,
1934                    * but newer pcre versions can return additional error codes.
1935                    * As a result pcrs_strerror()'s error message might be
1936                    * "Unknown error ...", therefore we print the numerical value
1937                    * as well.
1938                    *
1939                    * XXX: Is this important enough for LOG_LEVEL_ERROR or
1940                    * should we use LOG_LEVEL_RE_FILTER instead?
1941                    */
1942                   log_error(LOG_LEVEL_ERROR, "Skipped filter \'%s\' after job number %u: %s (%d)",
1943                      b->name, job_number, pcrs_strerror(job_hits), job_hits);
1944                   break;
1945                }
1946             }
1947
1948             log_error(LOG_LEVEL_RE_FILTER,
1949                "filtering %s%s (size %d) with \'%s\' produced %d hits (new size %d).",
1950                csp->http->hostport, csp->http->path, prev_size, b->name, current_hits, size);
1951
1952             hits += current_hits;
1953          }
1954       }
1955    }
1956    }
1957
1958    /*
1959     * If there were no hits, destroy our copy and let
1960     * chat() use the original in csp->iob
1961     */
1962    if (!hits)
1963    {
1964       free(new);
1965       return(NULL);
1966    }
1967
1968    csp->flags |= CSP_FLAG_MODIFIED;
1969    csp->content_length = size;
1970    IOB_RESET(csp);
1971
1972    return(new);
1973
1974 }
1975
1976
1977 /*********************************************************************
1978  *
1979  * Function    :  gif_deanimate_response
1980  *
1981  * Description :  Deanimate the GIF image that has been accumulated in
1982  *                csp->iob->buf, set csp->content_length to the modified
1983  *                size and raise the CSP_FLAG_MODIFIED flag.
1984  *
1985  * Parameters  :
1986  *          1  :  csp = Current client state (buffers, headers, etc...)
1987  *
1988  * Returns     :  a pointer to the (newly allocated) modified buffer.
1989  *                or NULL in case something went wrong.
1990  *
1991  *********************************************************************/
1992 char *gif_deanimate_response(struct client_state *csp)
1993 {
1994    struct binbuffer *in, *out;
1995    char *p;
1996    size_t size;
1997
1998    size = (size_t)(csp->iob->eod - csp->iob->cur);
1999
2000    /*
2001     * If the body has a "chunked" transfer-encoding,
2002     * get rid of it first, adjusting size and iob->eod
2003     */
2004    if (csp->flags & CSP_FLAG_CHUNKED)
2005    {
2006       log_error(LOG_LEVEL_DEANIMATE, "Need to de-chunk first");
2007       if (0 == (size = remove_chunked_transfer_coding(csp->iob->cur, size)))
2008       {
2009          return(NULL);
2010       }
2011       csp->iob->eod = csp->iob->cur + size;
2012       csp->flags |= CSP_FLAG_MODIFIED;
2013    }
2014
2015    if (  (NULL == (in =  (struct binbuffer *)zalloc(sizeof *in )))
2016       || (NULL == (out = (struct binbuffer *)zalloc(sizeof *out))) )
2017    {
2018       log_error(LOG_LEVEL_DEANIMATE, "failed! (no mem)");
2019       return NULL;
2020    }
2021
2022    in->buffer = csp->iob->cur;
2023    in->size = size;
2024
2025    if (gif_deanimate(in, out, strncmp("last", csp->action->string[ACTION_STRING_DEANIMATE], 4)))
2026    {
2027       log_error(LOG_LEVEL_DEANIMATE, "failed! (gif parsing)");
2028       free(in);
2029       buf_free(out);
2030       return(NULL);
2031    }
2032    else
2033    {
2034       if ((int)size == out->offset)
2035       {
2036          log_error(LOG_LEVEL_DEANIMATE, "GIF not changed.");
2037       }
2038       else
2039       {
2040          log_error(LOG_LEVEL_DEANIMATE, "Success! GIF shrunk from %d bytes to %d.", size, out->offset);
2041       }
2042       csp->content_length = out->offset;
2043       csp->flags |= CSP_FLAG_MODIFIED;
2044       p = out->buffer;
2045       free(in);
2046       free(out);
2047       return(p);
2048    }
2049
2050 }
2051
2052
2053 /*********************************************************************
2054  *
2055  * Function    :  jpeg_inspect_response
2056  *
2057  * Description :
2058  *
2059  * Parameters  :
2060  *          1  :  csp = Current client state (buffers, headers, etc...)
2061  *
2062  * Returns     :  a pointer to the (newly allocated) modified buffer
2063  *                or NULL in case something went wrong.
2064  *
2065  *********************************************************************/
2066 char *jpeg_inspect_response(struct client_state *csp)
2067 {
2068    struct binbuffer  *in = NULL;
2069    struct binbuffer *out = NULL;
2070    char *p = NULL;
2071    size_t size;
2072
2073    size = (size_t)(csp->iob->eod - csp->iob->cur);
2074
2075    /*
2076     * If the body has a "chunked" transfer-encoding,
2077     * get rid of it first, adjusting size and iob->eod
2078     */
2079    if (csp->flags & CSP_FLAG_CHUNKED)
2080    {
2081       log_error(LOG_LEVEL_DEANIMATE, "Need to de-chunk first");
2082       if (0 == (size = remove_chunked_transfer_coding(csp->iob->cur, size)))
2083       {
2084          return(NULL);
2085       }
2086       csp->iob->eod = csp->iob->cur + size;
2087       csp->flags |= CSP_FLAG_MODIFIED;
2088    }
2089
2090    if (NULL == (in =  (struct binbuffer *)zalloc(sizeof *in )))
2091    {
2092       log_error(LOG_LEVEL_DEANIMATE, "failed! (jpeg no mem 1)");
2093       return NULL;
2094    }
2095
2096    if (NULL == (out = (struct binbuffer *)zalloc(sizeof *out)))
2097    {
2098       log_error(LOG_LEVEL_DEANIMATE, "failed! (jpeg no mem 2)");
2099       return NULL;
2100    }
2101
2102    in->buffer = csp->iob->cur;
2103    in->size = size;
2104
2105    /*
2106     * Calling jpeg_inspect has the side-effect of creating and
2107     * modifying the image buffer of "out" directly.
2108     */
2109    if (jpeg_inspect(in, out))
2110    {
2111       log_error(LOG_LEVEL_DEANIMATE, "failed! (jpeg parsing)");
2112       free(in);
2113       buf_free(out);
2114       return(NULL);
2115
2116    }
2117    else
2118    {
2119       csp->content_length = out->offset;
2120       csp->flags |= CSP_FLAG_MODIFIED;
2121       p = out->buffer;
2122       free(in);
2123       free(out);
2124       return(p);
2125    }
2126
2127 }
2128
2129
2130 /*********************************************************************
2131  *
2132  * Function    :  remove_chunked_transfer_coding
2133  *
2134  * Description :  In-situ remove the "chunked" transfer coding as defined
2135  *                in rfc2616 from a buffer.
2136  *
2137  * Parameters  :
2138  *          1  :  buffer = Pointer to the text buffer
2139  *          2  :  size = Number of bytes to be processed
2140  *
2141  * Returns     :  The new size, i.e. the number of bytes from buffer which
2142  *                are occupied by the stripped body, or 0 in case something
2143  *                went wrong
2144  *
2145  *********************************************************************/
2146 size_t remove_chunked_transfer_coding(char *buffer, const size_t size)
2147 {
2148    size_t newsize = 0;
2149    unsigned int chunksize = 0;
2150    char *from_p, *to_p;
2151
2152    assert(buffer);
2153    from_p = to_p = buffer;
2154
2155    if (sscanf(buffer, "%x", &chunksize) != 1)
2156    {
2157       log_error(LOG_LEVEL_ERROR, "Invalid first chunksize while stripping \"chunked\" transfer coding");
2158       return(0);
2159    }
2160
2161    while (chunksize > 0)
2162    {
2163       if (NULL == (from_p = strstr(from_p, "\r\n")))
2164       {
2165          log_error(LOG_LEVEL_ERROR, "Parse error while stripping \"chunked\" transfer coding");
2166          return(0);
2167       }
2168
2169       if ((newsize += chunksize) >= size)
2170       {
2171          log_error(LOG_LEVEL_ERROR, "Chunksize exceeds buffer in  \"chunked\" transfer coding");
2172          return(0);
2173       }
2174       from_p += 2;
2175
2176       memmove(to_p, from_p, (size_t) chunksize);
2177       to_p = buffer + newsize;
2178       from_p += chunksize + 2;
2179
2180       if (sscanf(from_p, "%x", &chunksize) != 1)
2181       {
2182          log_error(LOG_LEVEL_ERROR, "Parse error while stripping \"chunked\" transfer coding");
2183          return(0);
2184       }
2185    }
2186
2187    /* FIXME: Should this get its own loglevel? */
2188    log_error(LOG_LEVEL_RE_FILTER, "De-chunking successful. Shrunk from %d to %d\n", size, newsize);
2189    return(newsize);
2190
2191 }
2192
2193
2194 /*********************************************************************
2195  *
2196  * Function    :  url_actions
2197  *
2198  * Description :  Gets the actions for this URL.
2199  *
2200  * Parameters  :
2201  *          1  :  http = http_request request for blocked URLs
2202  *          2  :  csp = Current client state (buffers, headers, etc...)
2203  *
2204  * Returns     :  N/A
2205  *
2206  *********************************************************************/
2207 void url_actions(struct http_request *http,
2208                  struct client_state *csp)
2209 {
2210    struct file_list *fl;
2211    struct url_actions *b;
2212    int i;
2213
2214    init_current_action(csp->action);
2215
2216    for (i = 0; i < MAX_AF_FILES; i++)
2217    {
2218       if (((fl = csp->actions_list[i]) == NULL) || ((b = fl->f) == NULL))
2219       {
2220          return;
2221       }
2222
2223       apply_url_actions(csp->action, http, b);
2224    }
2225
2226    return;
2227 }
2228
2229
2230 /*********************************************************************
2231  *
2232  * Function    :  apply_url_actions
2233  *
2234  * Description :  Applies a list of URL actions.
2235  *
2236  * Parameters  :
2237  *          1  :  action = Destination.
2238  *          2  :  http = Current URL
2239  *          3  :  b = list of URL actions to apply
2240  *
2241  * Returns     :  N/A
2242  *
2243  *********************************************************************/
2244 void apply_url_actions(struct current_action_spec *action,
2245                        struct http_request *http,
2246                        struct url_actions *b)
2247 {
2248    if (b == NULL)
2249    {
2250       /* Should never happen */
2251       return;
2252    }
2253
2254    for (b = b->next; NULL != b; b = b->next)
2255    {
2256       if (url_match(b->url, http))
2257       {
2258          merge_current_action(action, b->action);
2259       }
2260    }
2261 }
2262
2263
2264 /*********************************************************************
2265  *
2266  * Function    :  forward_url
2267  *
2268  * Description :  Should we forward this to another proxy?
2269  *
2270  * Parameters  :
2271  *          1  :  http = http_request request for current URL
2272  *          2  :  csp = Current client state (buffers, headers, etc...)
2273  *
2274  * Returns     :  Pointer to forwarding information.
2275  *
2276  *********************************************************************/
2277 const struct forward_spec * forward_url(struct http_request *http,
2278                                         struct client_state *csp)
2279 {
2280    static const struct forward_spec fwd_default[1] = { FORWARD_SPEC_INITIALIZER };
2281    struct forward_spec *fwd = csp->config->forward;
2282
2283    if (fwd == NULL)
2284    {
2285       return fwd_default;
2286    }
2287
2288    while (fwd != NULL)
2289    {
2290       if (url_match(fwd->url, http))
2291       {
2292          return fwd;
2293       }
2294       fwd = fwd->next;
2295    }
2296
2297    return fwd_default;
2298 }
2299
2300
2301 /*********************************************************************
2302  *
2303  * Function    :  direct_response
2304  *
2305  * Description :  Check if Max-Forwards == 0 for an OPTIONS or TRACE
2306  *                request and if so, return a HTTP 501 to the client.
2307  *
2308  *                FIXME: I have a stupid name and I should handle the
2309  *                requests properly. Still, what we do here is rfc-
2310  *                compliant, whereas ignoring or forwarding are not.
2311  *
2312  * Parameters  :
2313  *          1  :  csp = Current client state (buffers, headers, etc...)
2314  *
2315  * Returns     :  http_response if , NULL if nonmatch or handler fail
2316  *
2317  *********************************************************************/
2318 struct http_response *direct_response(struct client_state *csp)
2319 {
2320    struct http_response *rsp;
2321    struct list_entry *p;
2322
2323    if ((0 == strcmpic(csp->http->gpc, "trace"))
2324       || (0 == strcmpic(csp->http->gpc, "options")))
2325    {
2326       for (p = csp->headers->first; (p != NULL) ; p = p->next)
2327       {
2328          if (!strncmpic("Max-Forwards:", p->str, 13))
2329          {
2330             unsigned int max_forwards;
2331
2332             /*
2333              * If it's a Max-Forwards value of zero,
2334              * we have to intercept the request.
2335              */
2336             if (1 == sscanf(p->str+12, ": %u", &max_forwards) && max_forwards == 0)
2337             {
2338                /*
2339                 * FIXME: We could handle at least TRACE here,
2340                 * but that would require a verbatim copy of
2341                 * the request which we don't have anymore
2342                 */
2343                 log_error(LOG_LEVEL_HEADER,
2344                   "Detected header \'%s\' in OPTIONS or TRACE request. Returning 501.",
2345                   p->str);
2346
2347                /* Get mem for response or fail*/
2348                if (NULL == (rsp = alloc_http_response()))
2349                {
2350                   return cgi_error_memory();
2351                }
2352
2353                if (NULL == (rsp->status = strdup("501 Not Implemented")))
2354                {
2355                   free_http_response(rsp);
2356                   return cgi_error_memory();
2357                }
2358
2359                rsp->is_static = 1;
2360                rsp->reason = RSP_REASON_UNSUPPORTED;
2361
2362                return(finish_http_response(csp, rsp));
2363             }
2364          }
2365       }
2366    }
2367    return NULL;
2368 }
2369
2370
2371 /*
2372   Local Variables:
2373   tab-width: 3
2374   end:
2375 */