filters.c

   1 const char filters_rcs[] = "$Id: filters.c,v 1.114 2009/04/17 11:27:49 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  *                   `execute_single_pcrs_command', `rewrite_url',
  14  *                   `get_last_url'
  15  *
  16  * Copyright   :  Written by and Copyright (C) 2001, 2004-2008 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.114  2009/04/17 11:27:49  fabiankeil
  44  *    Petr Pisar's privoxy-3.0.12-ipv6-3.diff.
  45  *
  46  *    Revision 1.113  2009/03/08 14:19:23  fabiankeil
  47  *    Fix justified (but harmless) compiler warnings
  48  *    on platforms where sizeof(int) < sizeof(long).
  49  *
  50  *    Revision 1.112  2009/03/01 18:28:23  fabiankeil
  51  *    Help clang understand that we aren't dereferencing
  52  *    NULL pointers here.
  53  *
  54  *    Revision 1.111  2008/12/04 18:13:46  fabiankeil
  55  *    Fix a cparser warning.
  56  *
  57  *    Revision 1.110  2008/11/10 16:40:25  fabiankeil
  58  *    Fix a gcc44 warning.
  59  *
  60  *    Revision 1.109  2008/11/08 15:48:41  fabiankeil
  61  *    Mention actual values when complaining about
  62  *    the chunk size exceeding the buffer size.
  63  *
  64  *    Revision 1.108  2008/05/21 15:35:08  fabiankeil
  65  *    - Mark csp as immutable for block_acl().
  66  *    - Remove an obsolete complaint about filter_popups().
  67  *
  68  *    Revision 1.107  2008/05/04 17:52:56  fabiankeil
  69  *    Adjust parse_http_url() call to new prototype.
  70  *
  71  *    Revision 1.106  2008/05/03 16:40:44  fabiankeil
  72  *    Change content_filters_enabled()'s parameter from
  73  *    csp->action to action so it can be also used in the
  74  *    CGI code. Don't bother checking if there are filters
  75  *    loaded, as that's somewhat besides the point.
  76  *
  77  *    Revision 1.105  2008/03/28 15:13:39  fabiankeil
  78  *    Remove inspect-jpegs action.
  79  *
  80  *    Revision 1.104  2008/03/27 18:27:24  fabiankeil
  81  *    Remove kill-popups action.
  82  *
  83  *    Revision 1.103  2008/03/06 16:33:45  fabiankeil
  84  *    If limit-connect isn't used, don't limit CONNECT requests to port 443.
  85  *
  86  *    Revision 1.102  2008/03/01 14:00:44  fabiankeil
  87  *    Let the block action take the reason for the block
  88  *    as argument and show it on the "blocked" page.
  89  *
  90  *    Revision 1.101  2008/02/23 16:57:12  fabiankeil
  91  *    Rename url_actions() to get_url_actions() and let it
  92  *    use the standard parameter ordering.
  93  *
  94  *    Revision 1.100  2008/02/23 16:33:43  fabiankeil
  95  *    Let forward_url() use the standard parameter ordering
  96  *    and mark its second parameter immutable.
  97  *
  98  *    Revision 1.99  2008/02/03 13:57:58  fabiankeil
  99  *    Add SOCKS5 support for forward-override{}.
 100  *
 101  *    Revision 1.98  2008/01/04 17:43:45  fabiankeil
 102  *    Improve the warning messages that get logged if the action files
 103  *    "enable" filters but no filters of that type have been loaded.
 104  *
 105  *    Revision 1.97  2007/11/30 15:37:03  fabiankeil
 106  *    Use freez instead of free.
 107  *
 108  *    Revision 1.96  2007/10/19 16:53:28  fabiankeil
 109  *    Add helper function to check if any content filters are enabled.
 110  *
 111  *    Revision 1.95  2007/10/17 19:31:20  fabiankeil
 112  *    Omitting the zero chunk that ends the chunk transfer encoding seems
 113  *    to be the new black. Log the problem and continue filtering anyway.
 114  *
 115  *    Revision 1.94  2007/09/29 13:20:20  fabiankeil
 116  *    Remove two redundant and one useless log messages.
 117  *
 118  *    Revision 1.93  2007/09/29 10:21:16  fabiankeil
 119  *    - Move get_filter_function() from jcc.c to filters.c
 120  *      so the filter functions can be static.
 121  *    - Don't bother filtering body-less responses.
 122  *
 123  *    Revision 1.92  2007/09/28 16:38:55  fabiankeil
 124  *    - Execute content filters through execute_content_filter().
 125  *    - Add prepare_for_filtering() so filter functions don't have to
 126  *      care about de-chunking and decompression. As a side effect this enables
 127  *      decompression for gif_deanimate_response() and jpeg_inspect_response().
 128  *    - Change remove_chunked_transfer_coding()'s return type to jb_err.
 129  *      Some clowns feel like chunking empty responses in which case
 130  *      (size == 0) is valid but previously would be interpreted as error.
 131  *
 132  *    Revision 1.91  2007/09/02 15:31:20  fabiankeil
 133  *    Move match_portlist() from filter.c to urlmatch.c.
 134  *    It's used for url matching, not for filtering.
 135  *
 136  *    Revision 1.90  2007/09/02 12:44:17  fabiankeil
 137  *    Remove newline at the end of a log_error() message.
 138  *
 139  *    Revision 1.89  2007/08/05 13:42:23  fabiankeil
 140  *    #1763173 from Stefan Huehner: declare some more functions static.
 141  *
 142  *    Revision 1.88  2007/06/01 16:41:11  fabiankeil
 143  *    Add forward-override{} to change the forwarding settings through
 144  *    action sections. This is mainly interesting to forward different
 145  *    clients differently (for example based on User-Agent or request
 146  *    origin).
 147  *
 148  *    Revision 1.87  2007/04/30 15:53:10  fabiankeil
 149  *    Make sure filters with dynamic jobs actually use them.
 150  *
 151  *    Revision 1.86  2007/04/30 15:03:28  fabiankeil
 152  *    - Introduce dynamic pcrs jobs that can resolve variables.
 153  *    - Don't run redirect functions more than once,
 154  *      unless they are activated more than once.
 155  *
 156  *    Revision 1.85  2007/03/21 12:24:47  fabiankeil
 157  *    - Log the content size after decompression in decompress_iob()
 158  *      instead of pcrs_filter_response().
 159  *
 160  *    Revision 1.84  2007/03/20 15:16:34  fabiankeil
 161  *    Use dedicated header filter actions instead of abusing "filter".
 162  *    Replace "filter-client-headers" and "filter-client-headers"
 163  *    with "server-header-filter" and "client-header-filter".
 164  *
 165  *    Revision 1.83  2007/03/17 15:20:05  fabiankeil
 166  *    New config option: enforce-blocks.
 167  *
 168  *    Revision 1.82  2007/03/13 11:28:43  fabiankeil
 169  *    - Fix port handling in acl_addr() and use a temporary acl spec
 170  *      copy so error messages don't contain a truncated version.
 171  *    - Log size of iob before and after decompression.
 172  *
 173  *    Revision 1.81  2007/03/05 14:40:53  fabiankeil
 174  *    - Cosmetical changes for LOG_LEVEL_RE_FILTER messages.
 175  *    - Hide the "Go there anyway" link for blocked CONNECT
 176  *      requests where going there anyway doesn't work anyway.
 177  *
 178  *    Revision 1.80  2007/02/07 10:55:20  fabiankeil
 179  *    - Save the reason for generating http_responses.
 180  *    - Block (+block) with status code 403 instead of 404.
 181  *    - Use a different kludge to remember a failed decompression.
 182  *
 183  *    Revision 1.79  2007/01/31 16:21:38  fabiankeil
 184  *    Search for Max-Forwards headers case-insensitive,
 185  *    don't generate the "501 unsupported" message for invalid
 186  *    Max-Forwards values and don't increase negative ones.
 187  *
 188  *    Revision 1.78  2007/01/28 13:41:18  fabiankeil
 189  *    - Add HEAD support to finish_http_response.
 190  *    - Add error favicon to internal HTML error messages.
 191  *
 192  *    Revision 1.77  2007/01/12 15:36:44  fabiankeil
 193  *    Mark *csp as immutable for is_untrusted_url()
 194  *    and is_imageurl(). Closes FR 1237736.
 195  *
 196  *    Revision 1.76  2007/01/01 19:36:37  fabiankeil
 197  *    Integrate a modified version of Wil Mahan's
 198  *    zlib patch (PR #895531).
 199  *
 200  *    Revision 1.75  2006/12/29 18:30:46  fabiankeil
 201  *    Fixed gcc43 conversion warnings,
 202  *    changed sprintf calls to snprintf.
 203  *
 204  *    Revision 1.74  2006/12/24 17:37:38  fabiankeil
 205  *    Adjust comment in pcrs_filter_response()
 206  *    to recent pcrs changes. Hohoho.
 207  *
 208  *    Revision 1.73  2006/12/23 16:01:02  fabiankeil
 209  *    Don't crash if pcre returns an error code
 210  *    that pcrs didn't expect. Fixes BR 1621173.
 211  *
 212  *    Revision 1.72  2006/12/22 18:52:53  fabiankeil
 213  *    Modified is_untrusted_url to complain in case of
 214  *    write errors and to give a reason when adding new
 215  *    entries to the trustfile. Closes FR 1097611.
 216  *
 217  *    Revision 1.71  2006/12/22 14:24:52  fabiankeil
 218  *    Skip empty filter files in pcrs_filter_response,
 219  *    but don't ignore the ones that come afterwards.
 220  *    Fixes parts of BR 1619208.
 221  *
 222  *    Revision 1.70  2006/12/09 13:33:15  fabiankeil
 223  *    Added some sanity checks for get_last_url().
 224  *    Fixed possible segfault caused by my last commit.
 225  *
 226  *    Revision 1.69  2006/12/08 12:39:13  fabiankeil
 227  *    Let get_last_url() catch https URLs as well.
 228  *
 229  *    Revision 1.68  2006/12/05 14:45:48  fabiankeil
 230  *    Make sure get_last_url() behaves like advertised
 231  *    and fast-redirects{} can be combined with redirect{}.
 232  *
 233  *    Revision 1.67  2006/11/28 15:19:43  fabiankeil
 234  *    Implemented +redirect{s@foo@bar@} to generate
 235  *    a redirect based on a rewritten version of the
 236  *    original URL.
 237  *
 238  *    Revision 1.66  2006/09/23 13:26:38  roro
 239  *    Replace TABs by spaces in source code.
 240  *
 241  *    Revision 1.65  2006/09/21 12:54:43  fabiankeil
 242  *    Fix +redirect{}. Didn't work with -fast-redirects.
 243  *
 244  *    Revision 1.64  2006/08/31 10:55:49  fabiankeil
 245  *    Block requests for untrusted URLs with status
 246  *    code 403 instead of 200.
 247  *
 248  *    Revision 1.63  2006/08/31 10:11:28  fabiankeil
 249  *    Don't free p which is still in use and will be later
 250  *    freed by free_map(). Don't claim the referrer is unknown
 251  *    when the client didn't set one.
 252  *
 253  *    Revision 1.62  2006/08/14 00:27:47  david__schmidt
 254  *    Feature request 595948: Re-Filter logging in single line
 255  *
 256  *    Revision 1.61  2006/08/03 02:46:41  david__schmidt
 257  *    Incorporate Fabian Keil's patch work:\rhttp://www.fabiankeil.de/sourcecode/privoxy/
 258  *
 259  *    Revision 1.60  2006/07/18 14:48:46  david__schmidt
 260  *    Reorganizing the repository: swapping out what was HEAD (the old 3.1 branch)
 261  *    with what was really the latest development (the v_3_0_branch branch)
 262  *
 263  *    Revision 1.58.2.9  2006/01/29 23:10:56  david__schmidt
 264  *    Multiple filter file support
 265  *
 266  *    Revision 1.58.2.8  2005/05/07 21:50:55  david__schmidt
 267  *    A few memory leaks plugged (mostly on error paths)
 268  *
 269  *    Revision 1.58.2.7  2004/10/03 12:53:32  david__schmidt
 270  *    Add the ability to check jpeg images for invalid
 271  *    lengths of comment blocks.  Defensive strategy
 272  *    against the exploit:
 273  *       Microsoft Security Bulletin MS04-028
 274  *       Buffer Overrun in JPEG Processing (GDI+) Could
 275  *       Allow Code Execution (833987)
 276  *    Enabled with +inspect-jpegs in actions files.
 277  *
 278  *    Revision 1.58.2.6  2003/12/06 22:18:27  gliptak
 279  *    Correcting compile problem with FEATURE_IMAGE_BLOCKING
 280  *
 281  *    Revision 1.58.2.5  2003/11/11 13:10:31  oes
 282  *    Fixed bug #839859: "See why" link URL now gets url-encoded.
 283  *
 284  *    Revision 1.58.2.4  2003/02/28 12:52:45  oes
 285  *    Fixed a typo
 286  *
 287  *    Revision 1.58.2.3  2002/09/25 14:51:51  oes
 288  *    Added basic support for OPTIONS and TRACE HTTP methods:
 289  *    New function direct_response which handles OPTIONS and
 290  *    TRACE requests whose Max-Forwards header field is zero.
 291  *
 292  *    Revision 1.58.2.2  2002/08/01 17:18:28  oes
 293  *    Fixed BR 537651 / SR 579724 (MSIE image detect improper for IE/Mac)
 294  *
 295  *    Revision 1.58.2.1  2002/07/26 15:18:53  oes
 296  *    - Bugfix: Executing a filters without jobs no longer results in
 297  *      turing off *all* filters.
 298  *    - Security fix: Malicious web servers can't cause a seg fault
 299  *      through bogus chunk sizes anymore
 300  *
 301  *    Revision 1.58  2002/04/24 02:11:17  oes
 302  *    Jon's multiple AF patch: url_actions now evaluates rules
 303  *    from all AFs.
 304  *
 305  *    Revision 1.57  2002/04/08 20:38:34  swa
 306  *    fixed JB spelling
 307  *
 308  *    Revision 1.56  2002/04/05 15:51:24  oes
 309  *     - bugfix: error-pages now get correct request protocol
 310  *     - fix for invalid HTML in trust info
 311  *
 312  *    Revision 1.55  2002/04/02 16:13:51  oes
 313  *    Fix: No "Go there anyway" for SSL
 314  *
 315  *    Revision 1.54  2002/04/02 14:55:56  oes
 316  *    Bugfix: is_untrusted_url() now depends on FEATURE_TRUST, not FEATURE_COOKIE_JAR
 317  *
 318  *    Revision 1.53  2002/03/26 22:29:54  swa
 319  *    we have a new homepage!
 320  *
 321  *    Revision 1.52  2002/03/24 16:35:57  jongfoster
 322  *    Removing logo
 323  *
 324  *    Revision 1.51  2002/03/24 15:23:33  jongfoster
 325  *    Name changes
 326  *
 327  *    Revision 1.50  2002/03/24 13:25:43  swa
 328  *    name change related issues
 329  *
 330  *    Revision 1.49  2002/03/16 20:29:14  oes
 331  *    Cosmetics
 332  *
 333  *    Revision 1.48  2002/03/13 20:25:34  oes
 334  *    Better logging for content filters
 335  *
 336  *    Revision 1.47  2002/03/13 00:30:52  jongfoster
 337  *    Killing warnings
 338  *    Added option of always sending redirect for imageblock,
 339  *    currently disabled with #if 0.
 340  *
 341  *    Revision 1.46  2002/03/12 01:42:49  oes
 342  *    Introduced modular filters
 343  *
 344  *    Revision 1.45  2002/03/08 16:47:50  oes
 345  *    Added choice beween GIF and PNG built-in images
 346  *
 347  *    Revision 1.44  2002/03/07 03:49:31  oes
 348  *     - Fixed compiler warnings etc
 349  *     - Changed built-in images from GIF to PNG
 350  *       (with regard to Unisys patent issue)
 351  *     - Added a 4x4 pattern PNG which is less intrusive
 352  *       than the logo but also clearly marks the deleted banners
 353  *
 354  *    Revision 1.43  2002/01/22 23:51:59  jongfoster
 355  *    Replacing strsav() with the safer string_append().
 356  *
 357  *    Adding missing html_encode() to error message generators.  Where encoded
 358  *    and unencoded versions of a string were provided, removing the unencoded
 359  *    one.
 360  *
 361  *    Revision 1.42  2002/01/17 21:00:32  jongfoster
 362  *    Moving all our URL and URL pattern parsing code to urlmatch.c.
 363  *
 364  *    Using a single, simple url_match(pattern,url) function - rather than
 365  *    the 3-line match routine which was repeated all over the place.
 366  *
 367  *    Renaming free_url to free_url_spec, since it frees a struct url_spec.
 368  *
 369  *    Using parse_http_url() to parse URLs without faking a HTTP
 370  *    request line for parse_http_request().
 371  *
 372  *    Revision 1.41  2001/11/13 00:14:07  jongfoster
 373  *    Fixing stupid bug now I've figured out what || means.
 374  *    (It always returns 0 or 1, not one of it's paramaters.)
 375  *
 376  *    Revision 1.40  2001/10/26 17:37:55  oes
 377  *    - Re-enabled Netscape 200/404 bug workaround in block_url():
 378  *      - Removed OS/2 special case
 379  *      - Made block_url() independant from sed() having been run
 380  *    - Made trust_url independant from sed() having been run
 381  *    - Made is_imageurl independant from sed() having been run.
 382  *      It now checks User-Agent: and Accept: by itself.
 383  *
 384  *
 385  *    Revision 1.39  2001/10/25 03:40:48  david__schmidt
 386  *    Change in porting tactics: OS/2's EMX porting layer doesn't allow multiple
 387  *    threads to call select() simultaneously.  So, it's time to do a real, live,
 388  *    native OS/2 port.  See defines for __EMX__ (the porting layer) vs. __OS2__
 389  *    (native). Both versions will work, but using __OS2__ offers multi-threading.
 390  *
 391  *    Revision 1.38  2001/10/23 21:32:33  jongfoster
 392  *    Adding error-checking to selected functions
 393  *
 394  *    Revision 1.37  2001/10/22 15:33:56  david__schmidt
 395  *    Special-cased OS/2 out of the Netscape-abort-on-404-in-js problem in
 396  *    filters.c.  Added a FIXME in front of the offending code.  I'll gladly
 397  *    put in a better/more robust fix for all parties if one is presented...
 398  *    It seems that just returning 200 instead of 404 would pretty much fix
 399  *    it for everyone, but I don't know all the history of the problem.
 400  *
 401  *    Revision 1.36  2001/10/10 16:44:16  oes
 402  *    Added match_portlist function
 403  *
 404  *    Revision 1.35  2001/10/07 15:41:23  oes
 405  *    Replaced 6 boolean members of csp with one bitmap (csp->flags)
 406  *
 407  *    New function remove_chunked_transfer_coding that strips chunked
 408  *      transfer coding to plain and is called by pcrs_filter_response
 409  *      and gif_deanimate_response if neccessary
 410  *
 411  *    Improved handling of zero-change re_filter runs
 412  *
 413  *    pcrs_filter_response and gif_deanimate_response now remove
 414  *      chunked transfer codeing before processing the body.
 415  *
 416  *    Revision 1.34  2001/09/20 15:49:36  steudten
 417  *
 418  *    Fix BUG: Change int size to size_t size in pcrs_filter_response().
 419  *    See cgi.c fill_template().
 420  *
 421  *    Revision 1.33  2001/09/16 17:05:14  jongfoster
 422  *    Removing unused #include showarg.h
 423  *
 424  *    Revision 1.32  2001/09/16 13:21:27  jongfoster
 425  *    Changes to use new list functions.
 426  *
 427  *    Revision 1.31  2001/09/16 11:38:02  jongfoster
 428  *    Splitting fill_template() into 2 functions:
 429  *    template_load() loads the file
 430  *    template_fill() performs the PCRS regexps.
 431  *    This is because the CGI edit interface has a "table row"
 432  *    template which is used many times in the page - this
 433  *    change means it's only loaded from disk once.
 434  *
 435  *    Revision 1.30  2001/09/16 11:00:10  jongfoster
 436  *    New function alloc_http_response, for symmetry with free_http_response
 437  *
 438  *    Revision 1.29  2001/09/13 23:32:40  jongfoster
 439  *    Moving image data to cgi.c rather than cgi.h
 440  *    Fixing a GPF under Win32 (and any other OS that protects global
 441  *    constants from being written to).
 442  *
 443  *    Revision 1.28  2001/09/10 10:18:51  oes
 444  *    Silenced compiler warnings
 445  *
 446  *    Revision 1.27  2001/08/05 16:06:20  jongfoster
 447  *    Modifiying "struct map" so that there are now separate header and
 448  *    "map_entry" structures.  This means that functions which modify a
 449  *    map no longer need to return a pointer to the modified map.
 450  *    Also, it no longer reverses the order of the entries (which may be
 451  *    important with some advanced template substitutions).
 452  *
 453  *    Revision 1.26  2001/07/30 22:08:36  jongfoster
 454  *    Tidying up #defines:
 455  *    - All feature #defines are now of the form FEATURE_xxx
 456  *    - Permanently turned off WIN_GUI_EDIT
 457  *    - Permanently turned on WEBDAV and SPLIT_PROXY_ARGS
 458  *
 459  *    Revision 1.25  2001/07/26 10:09:46  oes
 460  *    Made browser detection a little less naive
 461  *
 462  *    Revision 1.24  2001/07/25 17:22:51  oes
 463  *    Added workaround for Netscape bug that prevents display of page when loading a component fails.
 464  *
 465  *    Revision 1.23  2001/07/23 13:40:12  oes
 466  *    Fixed bug that caused document body to be dropped when pcrs joblist was empty.
 467  *
 468  *    Revision 1.22  2001/07/18 12:29:34  oes
 469  *    - Made gif_deanimate_response respect
 470  *      csp->action->string[ACTION_STRING_DEANIMATE]
 471  *    - Logging cosmetics
 472  *
 473  *    Revision 1.21  2001/07/13 13:59:53  oes
 474  *     - Introduced gif_deanimate_response which shares the
 475  *       generic content modification interface of pcrs_filter_response
 476  *       and acts as a wrapper to deanimate.c:gif_deanimate()
 477  *     - Renamed re_process_buffer to pcrs_filter_response
 478  *     - pcrs_filter_response now returns NULL on failiure
 479  *     - Removed all #ifdef PCRS
 480  *
 481  *    Revision 1.20  2001/07/01 17:01:04  oes
 482  *    Added comments and missing return statement in is_untrusted_url()
 483  *
 484  *    Revision 1.19  2001/06/29 21:45:41  oes
 485  *    Indentation, CRLF->LF, Tab-> Space
 486  *
 487  *    Revision 1.18  2001/06/29 13:27:38  oes
 488  *    - Cleaned up, renamed and reorderd functions
 489  *      and improved comments
 490  *
 491  *    - block_url:
 492  *      - Ported to CGI platform. Now delivers
 493  *        http_response or NULL
 494  *      - Unified HTML and GIF generation (moved image detection
 495  *        and GIF generation here from jcc.c:chat())
 496  *      - Fixed HTTP status to:
 497  *       -  403 (Forbidden) for the "blocked" HTML message
 498  *       -  200 (OK) for GIF answers
 499  *       -  302 (Redirect) for redirect to GIF
 500  *
 501  *    - trust_url:
 502  *      - Ported to CGI platform. Now delivers
 503  *        http_response or NULL
 504  *      - Separated detection of untrusted URL into
 505  *        (bool)is_untrusted_url
 506  *      - Added enforcement of untrusted requests
 507  *
 508  *    - Moved redirect_url() from cgi.c to here
 509  *      and ported it to the CGI platform
 510  *
 511  *    - Removed logentry from cancelled commit
 512  *
 513  *    Revision 1.17  2001/06/09 10:55:28  jongfoster
 514  *    Changing BUFSIZ ==> BUFFER_SIZE
 515  *
 516  *    Revision 1.16  2001/06/07 23:10:26  jongfoster
 517  *    Allowing unanchored domain patterns to back off and retry
 518  *    if they partially match.  Optimized right-anchored patterns.
 519  *    Moving ACL and forward files into config file.
 520  *    Replacing struct gateway with struct forward_spec
 521  *
 522  *    Revision 1.15  2001/06/03 19:12:00  oes
 523  *    extracted-CGI relevant stuff
 524  *
 525  *    Revision 1.14  2001/06/01 10:30:55  oes
 526  *    Added optional left-anchoring to domaincmp
 527  *
 528  *    Revision 1.13  2001/05/31 21:21:30  jongfoster
 529  *    Permissionsfile / actions file changes:
 530  *    - Changed "permission" to "action" throughout
 531  *    - changes to file format to allow string parameters
 532  *    - Moved helper functions to actions.c
 533  *
 534  *    Revision 1.12  2001/05/31 17:35:20  oes
 535  *
 536  *     - Enhanced domain part globbing with infix and prefix asterisk
 537  *       matching and optional unanchored operation
 538  *
 539  *    Revision 1.11  2001/05/29 11:53:23  oes
 540  *    "See why" link added to "blocked" page
 541  *
 542  *    Revision 1.10  2001/05/29 09:50:24  jongfoster
 543  *    Unified blocklist/imagelist/permissionslist.
 544  *    File format is still under discussion, but the internal changes
 545  *    are (mostly) done.
 546  *
 547  *    Also modified interceptor behaviour:
 548  *    - We now intercept all URLs beginning with one of the following
 549  *      prefixes (and *only* these prefixes):
 550  *        * http://i.j.b/
 551  *        * http://ijbswa.sf.net/config/
 552  *        * http://ijbswa.sourceforge.net/config/
 553  *    - New interceptors "home page" - go to http://i.j.b/ to see it.
 554  *    - Internal changes so that intercepted and fast redirect pages
 555  *      are not replaced with an image.
 556  *    - Interceptors now have the option to send a binary page direct
 557  *      to the client. (i.e. ijb-send-banner uses this)
 558  *    - Implemented show-url-info interceptor.  (Which is why I needed
 559  *      the above interceptors changes - a typical URL is
 560  *      "http://i.j.b/show-url-info?url=www.somesite.com/banner.gif".
 561  *      The previous mechanism would not have intercepted that, and
 562  *      if it had been intercepted then it then it would have replaced
 563  *      it with an image.)
 564  *
 565  *    Revision 1.9  2001/05/27 22:17:04  oes
 566  *
 567  *    - re_process_buffer no longer writes the modified buffer
 568  *      to the client, which was very ugly. It now returns the
 569  *      buffer, which it is then written by chat.
 570  *
 571  *    - content_length now adjusts the Content-Length: header
 572  *      for modified documents rather than crunch()ing it.
 573  *      (Length info in csp->content_length, which is 0 for
 574  *      unmodified documents)
 575  *
 576  *    - For this to work, sed() is called twice when filtering.
 577  *
 578  *    Revision 1.8  2001/05/26 17:13:28  jongfoster
 579  *    Filled in a function comment.
 580  *
 581  *    Revision 1.7  2001/05/26 15:26:15  jongfoster
 582  *    ACL feature now provides more security by immediately dropping
 583  *    connections from untrusted hosts.
 584  *
 585  *    Revision 1.6  2001/05/26 00:28:36  jongfoster
 586  *    Automatic reloading of config file.
 587  *    Removed obsolete SIGHUP support (Unix) and Reload menu option (Win32).
 588  *    Most of the global variables have been moved to a new
 589  *    struct configuration_spec, accessed through csp->config->globalname
 590  *    Most of the globals remaining are used by the Win32 GUI.
 591  *
 592  *    Revision 1.5  2001/05/25 22:34:30  jongfoster
 593  *    Hard tabs->Spaces
 594  *
 595  *    Revision 1.4  2001/05/22 18:46:04  oes
 596  *
 597  *    - Enabled filtering banners by size rather than URL
 598  *      by adding patterns that replace all standard banner
 599  *      sizes with the "Junkbuster" gif to the re_filterfile
 600  *
 601  *    - Enabled filtering WebBugs by providing a pattern
 602  *      which kills all 1x1 images
 603  *
 604  *    - Added support for PCRE_UNGREEDY behaviour to pcrs,
 605  *      which is selected by the (nonstandard and therefore
 606  *      capital) letter 'U' in the option string.
 607  *      It causes the quantifiers to be ungreedy by default.
 608  *      Appending a ? turns back to greedy (!).
 609  *
 610  *    - Added a new interceptor ijb-send-banner, which
 611  *      sends back the "Junkbuster" gif. Without imagelist or
 612  *      MSIE detection support, or if tinygif = 1, or the
 613  *      URL isn't recognized as an imageurl, a lame HTML
 614  *      explanation is sent instead.
 615  *
 616  *    - Added new feature, which permits blocking remote
 617  *      script redirects and firing back a local redirect
 618  *      to the browser.
 619  *      The feature is conditionally compiled, i.e. it
 620  *      can be disabled with --disable-fast-redirects,
 621  *      plus it must be activated by a "fast-redirects"
 622  *      line in the config file, has its own log level
 623  *      and of course wants to be displayed by show-proxy-args
 624  *      Note: Boy, all the #ifdefs in 1001 locations and
 625  *      all the fumbling with configure.in and acconfig.h
 626  *      were *way* more work than the feature itself :-(
 627  *
 628  *    - Because a generic redirect template was needed for
 629  *      this, tinygif = 3 now uses the same.
 630  *
 631  *    - Moved GIFs, and other static HTTP response templates
 632  *      to project.h
 633  *
 634  *    - Some minor fixes
 635  *
 636  *    - Removed some >400 CRs again (Jon, you really worked
 637  *      a lot! ;-)
 638  *
 639  *    Revision 1.3  2001/05/20 16:44:47  jongfoster
 640  *    Removing last hardcoded Junkbusters.com URLs.
 641  *
 642  *    Revision 1.2  2001/05/20 01:21:20  jongfoster
 643  *    Version 2.9.4 checkin.
 644  *    - Merged popupfile and cookiefile, and added control over PCRS
 645  *      filtering, in new "permissionsfile".
 646  *    - Implemented LOG_LEVEL_FATAL, so that if there is a configuration
 647  *      file error you now get a message box (in the Win32 GUI) rather
 648  *      than the program exiting with no explanation.
 649  *    - Made killpopup use the PCRS MIME-type checking and HTTP-header
 650  *      skipping.
 651  *    - Removed tabs from "config"
 652  *    - Moved duplicated url parsing code in "loaders.c" to a new funcition.
 653  *    - Bumped up version number.
 654  *
 655  *    Revision 1.1.1.1  2001/05/15 13:58:52  oes
 656  *    Initial import of version 2.9.3 source tree
 657  *
 658  *
 659  *********************************************************************/
 660 \f
 661
 662 #include "config.h"
 663
 664 #include <stdio.h>
 665 #include <sys/types.h>
 666 #include <stdlib.h>
 667 #include <ctype.h>
 668 #include <string.h>
 669 #include <assert.h>
 670
 671 #ifdef HAVE_GETADDRINFO
 672 #include <netdb.h>
 673 #include <sys/socket.h>
 674 #endif /* def HAVE_GETADDRINFO */
 675
 676 #ifndef _WIN32
 677 #ifndef __OS2__
 678 #include <unistd.h>
 679 #endif /* ndef __OS2__ */
 680 #include <netinet/in.h>
 681 #else
 682 #include <winsock2.h>
 683 #endif /* ndef _WIN32 */
 684
 685 #ifdef __OS2__
 686 #include <utils.h>
 687 #endif /* def __OS2__ */
 688
 689 #include "project.h"
 690 #include "filters.h"
 691 #include "encode.h"
 692 #include "parsers.h"
 693 #include "ssplit.h"
 694 #include "errlog.h"
 695 #include "jbsockets.h"
 696 #include "miscutil.h"
 697 #include "actions.h"
 698 #include "cgi.h"
 699 #include "list.h"
 700 #include "deanimate.h"
 701 #include "urlmatch.h"
 702 #include "loaders.h"
 703
 704 #ifdef _WIN32
 705 #include "win32.h"
 706 #endif
 707
 708 const char filters_h_rcs[] = FILTERS_H_VERSION;
 709
 710 /* Fix a problem with Solaris.  There should be no effect on other
 711  * platforms.
 712  * Solaris's isspace() is a macro which uses it's argument directly
 713  * as an array index.  Therefore we need to make sure that high-bit
 714  * characters generate +ve values, and ideally we also want to make
 715  * the argument match the declared parameter type of "int".
 716  */
 717 #define ijb_isdigit(__X) isdigit((int)(unsigned char)(__X))
 718
 719 static jb_err remove_chunked_transfer_coding(char *buffer, size_t *size);
 720 static jb_err prepare_for_filtering(struct client_state *csp);
 721
 722 #ifdef FEATURE_ACL
 723 #ifdef HAVE_GETADDRINFO
 724 /*********************************************************************
 725  *
 726  * Function    :  sockaddr_storage_to_ip
 727  *
 728  * Description :  Access internal structure of sockaddr_storage
 729  *
 730  * Parameters  :
 731  *          1  :  addr = socket address
 732  *          2  :  ip   = IP address as array of octets in network order
 733  *                       (it points into addr)
 734  *          3  :  len  = length of IP address in octets
 735  *          4  :  port = port number in network order;
 736  *
 737  * Returns     :  0 = no errror; otherwise
 738  *
 739  *********************************************************************/
 740 int sockaddr_storage_to_ip(const struct sockaddr_storage *addr, uint8_t **ip,
 741       unsigned int *len, in_port_t **port)
 742 {
 743    if (!addr)
 744    {
 745       return(-1);
 746    }
 747
 748    switch (addr->ss_family)
 749    {
 750       case AF_INET:
 751          if (len)
 752          {
 753             *len = 4;
 754          }
 755          if (ip)
 756          {
 757             *ip = (uint8_t *)
 758                &(( (struct sockaddr_in *) addr)->sin_addr.s_addr);
 759          }
 760          if (port)
 761          {
 762             *port = &((struct sockaddr_in *) addr)->sin_port;
 763          }
 764          break;
 765
 766       case AF_INET6:
 767          if (len)
 768          {
 769             *len = 16;
 770          }
 771          if (ip)
 772          {
 773             *ip = ( (struct sockaddr_in6 *) addr)->sin6_addr.s6_addr;
 774          }
 775          if (port)
 776          {
 777             *port = &((struct sockaddr_in6 *) addr)->sin6_port;
 778          }
 779          break;
 780
 781       default:
 782          /* Unsupported address family */
 783          return(-1);
 784    }
 785
 786    return(0);
 787 }
 788
 789
 790 /*********************************************************************
 791  *
 792  * Function    :  match_sockaddr
 793  *
 794  * Description :  Check whether address matches network (IP address and port)
 795  *
 796  * Parameters  :
 797  *          1  :  network = socket address of subnework
 798  *          3  :  netmask = network mask as socket address
 799  *          2  :  address = checked socket address against given network
 800  *
 801  * Returns     :  0 = doesn't match; 1 = does match
 802  *
 803  *********************************************************************/
 804 int match_sockaddr(const struct sockaddr_storage *network,
 805       const struct sockaddr_storage *netmask,
 806       const struct sockaddr_storage *address)
 807 {
 808    uint8_t *network_addr, *netmask_addr, *address_addr;
 809    unsigned int addr_len;
 810    in_port_t *network_port, *netmask_port, *address_port;
 811    int i;
 812
 813    if (network->ss_family != netmask->ss_family)
 814    {
 815       /* This should never happen */
 816       log_error(LOG_LEVEL_ERROR,
 817             "Internal error at %s:%llu: network and netmask differ in family",
 818             __FILE__, __LINE__);
 819       return 0;
 820    }
 821
 822    sockaddr_storage_to_ip(network, &network_addr, &addr_len, &network_port);
 823    sockaddr_storage_to_ip(netmask, &netmask_addr, NULL, &netmask_port);
 824    sockaddr_storage_to_ip(address, &address_addr, NULL, &address_port);
 825
 826    /* Check for family */
 827    if (network->ss_family == AF_INET && address->ss_family == AF_INET6 &&
 828          IN6_IS_ADDR_V4MAPPED((struct in6_addr *)address_addr))
 829    {
 830       /* Map AF_INET6 V4MAPPED address into AF_INET */
 831       address_addr += 12;
 832       addr_len = 4;
 833    }
 834    else if (network->ss_family == AF_INET6 && address->ss_family == AF_INET &&
 835          IN6_IS_ADDR_V4MAPPED((struct in6_addr *)network_addr))
 836    {
 837       /* Map AF_INET6 V4MAPPED network into AF_INET */
 838       network_addr += 12;
 839       netmask_addr += 12;
 840       addr_len = 4;
 841    }
 842    else if (network->ss_family != address->ss_family)
 843    {
 844       return 0;
 845    }
 846
 847    /* XXX: Port check is signaled in netmask */
 848    if (*netmask_port && *network_port != *address_port)
 849    {
 850       return 0;
 851    }
 852
 853    /* TODO: Optimize by checking by words insted of octets */
 854    for (i=0; i < addr_len && netmask_addr[i]; i++)
 855    {
 856       if ( (network_addr[i] & netmask_addr[i]) !=
 857            (address_addr[i] & netmask_addr[i]) )
 858       {
 859          return 0;
 860       }
 861    }
 862
 863    return 1;
 864 }
 865 #endif /* def HAVE_GETADDRINFO */
 866
 867
 868 /*********************************************************************
 869  *
 870  * Function    :  block_acl
 871  *
 872  * Description :  Block this request?
 873  *                Decide yes or no based on ACL file.
 874  *
 875  * Parameters  :
 876  *          1  :  dst = The proxy or gateway address this is going to.
 877  *                      Or NULL to check all possible targets.
 878  *          2  :  csp = Current client state (buffers, headers, etc...)
 879  *                      Also includes the client IP address.
 880  *
 881  * Returns     : 0 = FALSE (don't block) and 1 = TRUE (do block)
 882  *
 883  *********************************************************************/
 884 int block_acl(const struct access_control_addr *dst, const struct client_state *csp)
 885 {
 886    struct access_control_list *acl = csp->config->acl;
 887
 888    /* if not using an access control list, then permit the connection */
 889    if (acl == NULL)
 890    {
 891       return(0);
 892    }
 893
 894    /* search the list */
 895    while (acl != NULL)
 896    {
 897       if (
 898 #ifdef HAVE_GETADDRINFO
 899             match_sockaddr(&acl->src->addr, &acl->src->mask, &csp->tcp_addr)
 900 #else
 901             (csp->ip_addr_long & acl->src->mask) == acl->src->addr
 902 #endif
 903             )
 904       {
 905          if (dst == NULL)
 906          {
 907             /* Just want to check if they have any access */
 908             if (acl->action == ACL_PERMIT)
 909             {
 910                return(0);
 911             }
 912          }
 913          else if (
 914 #ifdef HAVE_GETADDRINFO
 915                /* XXX: Undefined acl->dst is full of zeros and should be
 916                 * considered as wildcard address.
 917                 * sockaddr_storage_to_ip() failes on such dst because of
 918                 * uknown sa_familly on glibc. However this test is not
 919                 * portable.
 920                 *
 921                 * So, we signal the acl->dst is wildcard in wildcard_dst.
 922                 */
 923                acl->wildcard_dst ||
 924                   match_sockaddr(&acl->dst->addr, &acl->dst->mask, &dst->addr)
 925 #else
 926                ((dst->addr & acl->dst->mask) == acl->dst->addr)
 927            && ((dst->port == acl->dst->port) || (acl->dst->port == 0))
 928 #endif
 929            )
 930          {
 931             if (acl->action == ACL_PERMIT)
 932             {
 933                return(0);
 934             }
 935             else
 936             {
 937                return(1);
 938             }
 939          }
 940       }
 941       acl = acl->next;
 942    }
 943
 944    return(1);
 945
 946 }
 947
 948
 949 /*********************************************************************
 950  *
 951  * Function    :  acl_addr
 952  *
 953  * Description :  Called from `load_config' to parse an ACL address.
 954  *
 955  * Parameters  :
 956  *          1  :  aspec = String specifying ACL address.
 957  *          2  :  aca = struct access_control_addr to fill in.
 958  *
 959  * Returns     :  0 => Ok, everything else is an error.
 960  *
 961  *********************************************************************/
 962 int acl_addr(const char *aspec, struct access_control_addr *aca)
 963 {
 964    int i, masklength;
 965 #ifdef HAVE_GETADDRINFO
 966    struct addrinfo hints, *result;
 967    uint8_t *mask_data;
 968    in_port_t *mask_port;
 969    unsigned int addr_len;
 970 #else
 971    long port;
 972 #endif /* def HAVE_GETADDRINFO */
 973    char *p;
 974    char *acl_spec = NULL;
 975
 976 #ifdef HAVE_GETADDRINFO
 977    /* FIXME: Depend on ai_family */
 978    masklength = 128;
 979 #else
 980    masklength = 32;
 981    port       =  0;
 982 #endif
 983
 984    /*
 985     * Use a temporary acl spec copy so we can log
 986     * the unmodified original in case of parse errors.
 987     */
 988    acl_spec = strdup(aspec);
 989    if (acl_spec == NULL)
 990    {
 991       /* XXX: This will be logged as parse error. */
 992       return(-1);
 993    }
 994
 995    if ((p = strchr(acl_spec, '/')) != NULL)
 996    {
 997       *p++ = '\0';
 998       if (ijb_isdigit(*p) == 0)
 999       {
1000          freez(acl_spec);
1001          return(-1);
1002       }
1003       masklength = atoi(p);
1004    }
1005
1006    if ((masklength < 0) ||
1007 #ifdef HAVE_GETADDRINFO
1008          (masklength > 128)
1009 #else
1010          (masklength > 32)
1011 #endif
1012          )
1013    {
1014       freez(acl_spec);
1015       return(-1);
1016    }
1017
1018    if (*acl_spec == '[' && NULL != (p = strchr(acl_spec, ']')))
1019    {
1020       *p = '\0';
1021       memmove(acl_spec, acl_spec + 1, (size_t) (p - acl_spec));
1022
1023       if (*++p != ':')
1024       {
1025          p = NULL;
1026       }
1027    }
1028    else
1029    {
1030       p = strchr(acl_spec, ':');
1031    }
1032
1033 #ifdef HAVE_GETADDRINFO
1034    memset(&hints, 0, sizeof(struct addrinfo));
1035    hints.ai_family = AF_UNSPEC;
1036    hints.ai_socktype = SOCK_STREAM;
1037
1038    i = getaddrinfo(acl_spec, (p) ? ++p : NULL, &hints, &result);
1039    freez(acl_spec);
1040
1041    if (i != 0)
1042    {
1043       log_error(LOG_LEVEL_ERROR, "Can not resolve [%s]:%s: %s", acl_spec, p,
1044             gai_strerror(i));
1045       return(-1);
1046    }
1047
1048    /* TODO: Allow multihomed hostnames */
1049    memcpy(&(aca->addr), result->ai_addr, result->ai_addrlen);
1050    freeaddrinfo(result);
1051 #else
1052    if (p != NULL)
1053    {
1054       char *endptr;
1055
1056       *p++ = '\0';
1057       port = strtol(p, &endptr, 10);
1058
1059       if (port <= 0 || port > 65535 || *endptr != '\0')
1060       {
1061          freez(acl_spec);
1062          return(-1);
1063       }
1064    }
1065
1066    aca->port = (unsigned long)port;
1067
1068    aca->addr = ntohl(resolve_hostname_to_ip(acl_spec));
1069    freez(acl_spec);
1070
1071    if (aca->addr == INADDR_NONE)
1072    {
1073       /* XXX: This will be logged as parse error. */
1074       return(-1);
1075    }
1076 #endif /* def HAVE_GETADDRINFO */
1077
1078    /* build the netmask */
1079 #ifdef HAVE_GETADDRINFO
1080    /* Clip masklength according current family */
1081    if (aca->addr.ss_family == AF_INET && masklength > 32)
1082    {
1083       masklength = 32;
1084    }
1085
1086    aca->mask.ss_family = aca->addr.ss_family;
1087    if (sockaddr_storage_to_ip(&aca->mask, &mask_data, &addr_len, &mask_port))
1088    {
1089       return(-1);
1090    }
1091
1092    if (p)
1093    {
1094       /* Port number in ACL has been specified, check ports in future */
1095       *mask_port = 1;
1096    }
1097
1098    /* XXX: This could be optimized to operate on whole words instead of octets
1099     * (128-bit CPU could do it in one iteration). */
1100    /* Octets after prefix can be ommitted because of previous initialization
1101     * to zeros. */
1102    for (i=0; i < addr_len && masklength; i++)
1103    {
1104       if (masklength >= 8)
1105       {
1106          mask_data[i] = 0xFF;
1107          masklength -= 8;
1108       }
1109       else
1110       {
1111          /* XXX: This assumes MSB of octet is on the left site. This should be
1112           * true for all architectures or solved on link layer of OSI model. */
1113          mask_data[i] = ~((1 << (8 - masklength)) - 1);
1114          masklength = 0;
1115       }
1116    }
1117
1118 #else
1119    aca->mask = 0;
1120    for (i=1; i <= masklength ; i++)
1121    {
1122       aca->mask |= (1U << (32 - i));
1123    }
1124
1125    /* now mask off the host portion of the ip address
1126     * (i.e. save on the network portion of the address).
1127     */
1128    aca->addr = aca->addr & aca->mask;
1129 #endif /* def HAVE_GETADDRINFO */
1130
1131    return(0);
1132
1133 }
1134 #endif /* def FEATURE_ACL */
1135
1136
1137 /*********************************************************************
1138  *
1139  * Function    :  connect_port_is_forbidden
1140  *
1141  * Description :  Check to see if CONNECT requests to the destination
1142  *                port of this request are forbidden. The check is
1143  *                independend of the actual request method.
1144  *
1145  * Parameters  :
1146  *          1  :  csp = Current client state (buffers, headers, etc...)
1147  *
1148  * Returns     :  True if yes, false otherwise.
1149  *
1150  *********************************************************************/
1151 int connect_port_is_forbidden(const struct client_state *csp)
1152 {
1153    return ((csp->action->flags & ACTION_LIMIT_CONNECT) &&
1154      !match_portlist(csp->action->string[ACTION_STRING_LIMIT_CONNECT],
1155         csp->http->port));
1156 }
1157
1158
1159 /*********************************************************************
1160  *
1161  * Function    :  block_url
1162  *
1163  * Description :  Called from `chat'.  Check to see if we need to block this.
1164  *
1165  * Parameters  :
1166  *          1  :  csp = Current client state (buffers, headers, etc...)
1167  *
1168  * Returns     :  NULL => unblocked, else HTTP block response
1169  *
1170  *********************************************************************/
1171 struct http_response *block_url(struct client_state *csp)
1172 {
1173    struct http_response *rsp;
1174    const char *new_content_type = NULL;
1175
1176    /*
1177     * If it's not blocked, don't block it ;-)
1178     */
1179    if ((csp->action->flags & ACTION_BLOCK) == 0)
1180    {
1181       return NULL;
1182    }
1183    if (csp->action->flags & ACTION_REDIRECT)
1184    {
1185       log_error(LOG_LEVEL_ERROR, "redirect{} overruled by block.");
1186    }
1187    /*
1188     * Else, prepare a response
1189     */
1190    if (NULL == (rsp = alloc_http_response()))
1191    {
1192       return cgi_error_memory();
1193    }
1194
1195    /*
1196     * If it's an image-url, send back an image or redirect
1197     * as specified by the relevant +image action
1198     */
1199 #ifdef FEATURE_IMAGE_BLOCKING
1200    if (((csp->action->flags & ACTION_IMAGE_BLOCKER) != 0)
1201         && is_imageurl(csp))
1202    {
1203       char *p;
1204       /* determine HOW images should be blocked */
1205       p = csp->action->string[ACTION_STRING_IMAGE_BLOCKER];
1206
1207       if(csp->action->flags & ACTION_HANDLE_AS_EMPTY_DOCUMENT)
1208       {
1209          log_error(LOG_LEVEL_ERROR, "handle-as-empty-document overruled by handle-as-image.");
1210       }
1211 #if 1 /* Two alternative strategies, use this one for now: */
1212
1213       /* and handle accordingly: */
1214       if ((p == NULL) || (0 == strcmpic(p, "pattern")))
1215       {
1216          rsp->status = strdup("403 Request blocked by Privoxy");
1217          if (rsp->status == NULL)
1218          {
1219             free_http_response(rsp);
1220             return cgi_error_memory();
1221          }
1222          rsp->body = bindup(image_pattern_data, image_pattern_length);
1223          if (rsp->body == NULL)
1224          {
1225             free_http_response(rsp);
1226             return cgi_error_memory();
1227          }
1228          rsp->content_length = image_pattern_length;
1229
1230          if (enlist_unique_header(rsp->headers, "Content-Type", BUILTIN_IMAGE_MIMETYPE))
1231          {
1232             free_http_response(rsp);
1233             return cgi_error_memory();
1234          }
1235       }
1236
1237       else if (0 == strcmpic(p, "blank"))
1238       {
1239          rsp->status = strdup("403 Request blocked by Privoxy");
1240          if (rsp->status == NULL)
1241          {
1242             free_http_response(rsp);
1243             return cgi_error_memory();
1244          }
1245          rsp->body = bindup(image_blank_data, image_blank_length);
1246          if (rsp->body == NULL)
1247          {
1248             free_http_response(rsp);
1249             return cgi_error_memory();
1250          }
1251          rsp->content_length = image_blank_length;
1252
1253          if (enlist_unique_header(rsp->headers, "Content-Type", BUILTIN_IMAGE_MIMETYPE))
1254          {
1255             free_http_response(rsp);
1256             return cgi_error_memory();
1257          }
1258       }
1259
1260       else
1261       {
1262          rsp->status = strdup("302 Local Redirect from Privoxy");
1263          if (rsp->status == NULL)
1264          {
1265             free_http_response(rsp);
1266             return cgi_error_memory();
1267          }
1268
1269          if (enlist_unique_header(rsp->headers, "Location", p))
1270          {
1271             free_http_response(rsp);
1272             return cgi_error_memory();
1273          }
1274       }
1275
1276 #else /* Following code is disabled for now */
1277
1278       /* and handle accordingly: */
1279       if ((p == NULL) || (0 == strcmpic(p, "pattern")))
1280       {
1281          p = CGI_PREFIX "send-banner?type=pattern";
1282       }
1283       else if (0 == strcmpic(p, "blank"))
1284       {
1285          p = CGI_PREFIX "send-banner?type=blank";
1286       }
1287       rsp->status = strdup("302 Local Redirect from Privoxy");
1288       if (rsp->status == NULL)
1289       {
1290          free_http_response(rsp);
1291          return cgi_error_memory();
1292       }
1293
1294       if (enlist_unique_header(rsp->headers, "Location", p))
1295       {
1296          free_http_response(rsp);
1297          return cgi_error_memory();
1298       }
1299 #endif /* Preceeding code is disabled for now */
1300    }
1301    else if(csp->action->flags & ACTION_HANDLE_AS_EMPTY_DOCUMENT)
1302    {
1303      /*
1304       *  Send empty document.
1305       */
1306       new_content_type = csp->action->string[ACTION_STRING_CONTENT_TYPE];
1307
1308       freez(rsp->body);
1309       rsp->body = strdup(" ");
1310       rsp->content_length = 1;
1311
1312       rsp->status = strdup("403 Request blocked by Privoxy");
1313       if (rsp->status == NULL)
1314       {
1315          free_http_response(rsp);
1316          return cgi_error_memory();
1317       }
1318       if (new_content_type != 0)
1319       {
1320          log_error(LOG_LEVEL_HEADER, "Overwriting Content-Type with %s", new_content_type);
1321          if (enlist_unique_header(rsp->headers, "Content-Type", new_content_type))
1322          {
1323             free_http_response(rsp);
1324             return cgi_error_memory();
1325          }
1326       }
1327    }
1328    else
1329 #endif /* def FEATURE_IMAGE_BLOCKING */
1330
1331    /*
1332     * Else, generate an HTML "blocked" message:
1333     */
1334    {
1335       jb_err err;
1336       struct map * exports;
1337       char *p;
1338
1339       /*
1340        * Workaround for stupid Netscape bug which prevents
1341        * pages from being displayed if loading a referenced
1342        * JavaScript or style sheet fails. So make it appear
1343        * as if it succeeded.
1344        */
1345       if ( NULL != (p = get_header_value(csp->headers, "User-Agent:"))
1346            && !strncmpic(p, "mozilla", 7) /* Catch Netscape but */
1347            && !strstr(p, "Gecko")         /* save Mozilla, */
1348            && !strstr(p, "compatible")    /* MSIE */
1349            && !strstr(p, "Opera"))        /* and Opera. */
1350       {
1351          rsp->status = strdup("200 Request for blocked URL");
1352       }
1353       else
1354       {
1355          rsp->status = strdup("403 Request for blocked URL");
1356       }
1357
1358       if (rsp->status == NULL)
1359       {
1360          free_http_response(rsp);
1361          return cgi_error_memory();
1362       }
1363
1364       exports = default_exports(csp, NULL);
1365       if (exports == NULL)
1366       {
1367          free_http_response(rsp);
1368          return cgi_error_memory();
1369       }
1370
1371 #ifdef FEATURE_FORCE_LOAD
1372       err = map(exports, "force-prefix", 1, FORCE_PREFIX, 1);
1373       /*
1374        * Export the force conditional block killer if
1375        *
1376        * - Privoxy was compiled without FEATURE_FORCE_LOAD, or
1377        * - Privoxy is configured to enforce blocks, or
1378        * - it's a CONNECT request and enforcing wouldn't work anyway.
1379        */
1380       if ((csp->config->feature_flags & RUNTIME_FEATURE_ENFORCE_BLOCKS)
1381        || (0 == strcmpic(csp->http->gpc, "connect")))
1382 #endif /* ndef FEATURE_FORCE_LOAD */
1383       {
1384          err = map_block_killer(exports, "force-support");
1385       }
1386
1387       if (!err) err = map(exports, "protocol", 1, csp->http->ssl ? "https://" : "http://", 1);
1388       if (!err) err = map(exports, "hostport", 1, html_encode(csp->http->hostport), 0);
1389       if (!err) err = map(exports, "path", 1, html_encode(csp->http->path), 0);
1390       if (!err) err = map(exports, "path-ue", 1, url_encode(csp->http->path), 0);
1391       if (!err)
1392       {
1393          const char *block_reason;
1394          if (csp->action->string[ACTION_STRING_BLOCK] != NULL)
1395          {
1396             block_reason = csp->action->string[ACTION_STRING_BLOCK];
1397          }
1398          else
1399          {
1400             assert(connect_port_is_forbidden(csp));
1401             block_reason = "Forbidden CONNECT port.";
1402          }
1403          err = map(exports, "block-reason", 1, html_encode(block_reason), 0);
1404       }
1405       if (err)
1406       {
1407          free_map(exports);
1408          free_http_response(rsp);
1409          return cgi_error_memory();
1410       }
1411
1412       err = template_fill_for_cgi(csp, "blocked", exports, rsp);
1413       if (err)
1414       {
1415          free_http_response(rsp);
1416          return cgi_error_memory();
1417       }
1418    }
1419    rsp->reason = RSP_REASON_BLOCKED;
1420
1421    return finish_http_response(csp, rsp);
1422
1423 }
1424
1425
1426 #ifdef FEATURE_TRUST
1427 /*********************************************************************
1428  *
1429  * Function    :  trust_url FIXME: I should be called distrust_url
1430  *
1431  * Description :  Calls is_untrusted_url to determine if the URL is trusted
1432  *                and if not, returns a HTTP 403 response with a reject message.
1433  *
1434  * Parameters  :
1435  *          1  :  csp = Current client state (buffers, headers, etc...)
1436  *
1437  * Returns     :  NULL => trusted, else http_response.
1438  *
1439  *********************************************************************/
1440 struct http_response *trust_url(struct client_state *csp)
1441 {
1442    struct http_response *rsp;
1443    struct map * exports;
1444    char buf[BUFFER_SIZE];
1445    char *p;
1446    struct url_spec **tl;
1447    struct url_spec *t;
1448    jb_err err;
1449
1450    /*
1451     * Don't bother to work on trusted URLs
1452     */
1453    if (!is_untrusted_url(csp))
1454    {
1455       return NULL;
1456    }
1457
1458    /*
1459     * Else, prepare a response:
1460     */
1461    if (NULL == (rsp = alloc_http_response()))
1462    {
1463       return cgi_error_memory();
1464    }
1465
1466    rsp->status = strdup("403 Request blocked by Privoxy");
1467    exports = default_exports(csp, NULL);
1468    if (exports == NULL || rsp->status == NULL)
1469    {
1470       free_http_response(rsp);
1471       return cgi_error_memory();
1472    }
1473
1474    /*
1475     * Export the protocol, host, port, and referrer information
1476     */
1477    err = map(exports, "hostport", 1, csp->http->hostport, 1);
1478    if (!err) err = map(exports, "protocol", 1, csp->http->ssl ? "https://" : "http://", 1);
1479    if (!err) err = map(exports, "path", 1, csp->http->path, 1);
1480
1481    if (NULL != (p = get_header_value(csp->headers, "Referer:")))
1482    {
1483       if (!err) err = map(exports, "referrer", 1, html_encode(p), 0);
1484    }
1485    else
1486    {
1487       if (!err) err = map(exports, "referrer", 1, "none set", 1);
1488    }
1489
1490    if (err)
1491    {
1492       free_map(exports);
1493       free_http_response(rsp);
1494       return cgi_error_memory();
1495    }
1496
1497    /*
1498     * Export the trust list
1499     */
1500    p = strdup("");
1501    for (tl = csp->config->trust_list; (t = *tl) != NULL ; tl++)
1502    {
1503       snprintf(buf, sizeof(buf), "<li>%s</li>\n", t->spec);
1504       string_append(&p, buf);
1505    }
1506    err = map(exports, "trusted-referrers", 1, p, 0);
1507
1508    if (err)
1509    {
1510       free_map(exports);
1511       free_http_response(rsp);
1512       return cgi_error_memory();
1513    }
1514
1515    /*
1516     * Export the trust info, if available
1517     */
1518    if (csp->config->trust_info->first)
1519    {
1520       struct list_entry *l;
1521
1522       p = strdup("");
1523       for (l = csp->config->trust_info->first; l ; l = l->next)
1524       {
1525          snprintf(buf, sizeof(buf), "<li> <a href=\"%s\">%s</a><br>\n", l->str, l->str);
1526          string_append(&p, buf);
1527       }
1528       err = map(exports, "trust-info", 1, p, 0);
1529    }
1530    else
1531    {
1532       err = map_block_killer(exports, "have-trust-info");
1533    }
1534
1535    if (err)
1536    {
1537       free_map(exports);
1538       free_http_response(rsp);
1539       return cgi_error_memory();
1540    }
1541
1542    /*
1543     * Export the force conditional block killer if
1544     *
1545     * - Privoxy was compiled without FEATURE_FORCE_LOAD, or
1546     * - Privoxy is configured to enforce blocks, or
1547     * - it's a CONNECT request and enforcing wouldn't work anyway.
1548     */
1549 #ifdef FEATURE_FORCE_LOAD
1550    if ((csp->config->feature_flags & RUNTIME_FEATURE_ENFORCE_BLOCKS)
1551     || (0 == strcmpic(csp->http->gpc, "connect")))
1552    {
1553       err = map_block_killer(exports, "force-support");
1554    }
1555    else
1556    {
1557       err = map(exports, "force-prefix", 1, FORCE_PREFIX, 1);
1558    }
1559 #else /* ifndef FEATURE_FORCE_LOAD */
1560    err = map_block_killer(exports, "force-support");
1561 #endif /* ndef FEATURE_FORCE_LOAD */
1562
1563    if (err)
1564    {
1565       free_map(exports);
1566       free_http_response(rsp);
1567       return cgi_error_memory();
1568    }
1569
1570    /*
1571     * Build the response
1572     */
1573    err = template_fill_for_cgi(csp, "untrusted", exports, rsp);
1574    if (err)
1575    {
1576       free_http_response(rsp);
1577       return cgi_error_memory();
1578    }
1579    rsp->reason = RSP_REASON_UNTRUSTED;
1580
1581    return finish_http_response(csp, rsp);
1582 }
1583 #endif /* def FEATURE_TRUST */
1584
1585
1586 /*********************************************************************
1587  *
1588  * Function    :  compile_dynamic_pcrs_job_list
1589  *
1590  * Description :  Compiles a dynamic pcrs job list (one with variables
1591  *                resolved at request time)
1592  *
1593  * Parameters  :
1594  *          1  :  csp = Current client state (buffers, headers, etc...)
1595  *          2  :  b = The filter list to compile
1596  *
1597  * Returns     :  NULL in case of errors, otherwise the
1598  *                pcrs job list.
1599  *
1600  *********************************************************************/
1601 pcrs_job *compile_dynamic_pcrs_job_list(const struct client_state *csp, const struct re_filterfile_spec *b)
1602 {
1603    struct list_entry *pattern;
1604    pcrs_job *job_list = NULL;
1605    pcrs_job *dummy = NULL;
1606    pcrs_job *lastjob = NULL;
1607    int error = 0;
1608
1609    const struct pcrs_variable variables[] =
1610    {
1611       {"url",    csp->http->url,   1},
1612       {"path",   csp->http->path,  1},
1613       {"host",   csp->http->host,  1},
1614       {"origin", csp->ip_addr_str, 1},
1615       {NULL,     NULL,             1}
1616    };
1617
1618    for (pattern = b->patterns->first; pattern != NULL; pattern = pattern->next)
1619    {
1620       assert(pattern->str != NULL);
1621
1622       dummy = pcrs_compile_dynamic_command(pattern->str, variables, &error);
1623       if (NULL == dummy)
1624       {
1625          assert(error < 0);
1626          log_error(LOG_LEVEL_ERROR,
1627             "Adding filter job \'%s\' to dynamic filter %s failed: %s",
1628             pattern->str, b->name, pcrs_strerror(error));
1629          continue;
1630       }
1631       else
1632       {
1633          if (error == PCRS_WARN_TRUNCATION)
1634          {
1635             log_error(LOG_LEVEL_ERROR,
1636                "At least one of the variables in \'%s\' had to "
1637                "be truncated before compilation", pattern->str);
1638          }
1639          if (job_list == NULL)
1640          {
1641             job_list = dummy;
1642          }
1643          else
1644          {
1645             lastjob->next = dummy;
1646          }
1647          lastjob = dummy;
1648       }
1649    }
1650
1651    return job_list;
1652 }
1653
1654
1655 /*********************************************************************
1656  *
1657  * Function    :  rewrite_url
1658  *
1659  * Description :  Rewrites a URL with a single pcrs command
1660  *                and returns the result if it differs from the
1661  *                original and isn't obviously invalid.
1662  *
1663  * Parameters  :
1664  *          1  :  old_url = URL to rewrite.
1665  *          2  :  pcrs_command = pcrs command formatted as string (s@foo@bar@)
1666  *
1667  *
1668  * Returns     :  NULL if the pcrs_command didn't change the url, or
1669  *                the result of the modification.
1670  *
1671  *********************************************************************/
1672 char *rewrite_url(char *old_url, const char *pcrs_command)
1673 {
1674    char *new_url = NULL;
1675    int hits;
1676
1677    assert(old_url);
1678    assert(pcrs_command);
1679
1680    new_url = pcrs_execute_single_command(old_url, pcrs_command, &hits);
1681
1682    if (hits == 0)
1683    {
1684       log_error(LOG_LEVEL_REDIRECTS,
1685          "pcrs command \"%s\" didn't change \"%s\".",
1686          pcrs_command, old_url);
1687       freez(new_url);
1688    }
1689    else if (hits < 0)
1690    {
1691       log_error(LOG_LEVEL_REDIRECTS,
1692          "executing pcrs command \"%s\" to rewrite %s failed: %s",
1693          pcrs_command, old_url, pcrs_strerror(hits));
1694       freez(new_url);
1695    }
1696    else if (strncmpic(new_url, "http://", 7) && strncmpic(new_url, "https://", 8))
1697    {
1698       log_error(LOG_LEVEL_ERROR,
1699          "pcrs command \"%s\" changed \"%s\" to \"%s\" (%u hi%s), "
1700          "but the result doesn't look like a valid URL and will be ignored.",
1701          pcrs_command, old_url, new_url, hits, (hits == 1) ? "t" : "ts");
1702       freez(new_url);
1703    }
1704    else
1705    {
1706       log_error(LOG_LEVEL_REDIRECTS,
1707          "pcrs command \"%s\" changed \"%s\" to \"%s\" (%u hi%s).",
1708          pcrs_command, old_url, new_url, hits, (hits == 1) ? "t" : "ts");
1709    }
1710
1711    return new_url;
1712
1713 }
1714
1715
1716 #ifdef FEATURE_FAST_REDIRECTS
1717 /*********************************************************************
1718  *
1719  * Function    :  get_last_url
1720  *
1721  * Description :  Search for the last URL inside a string.
1722  *                If the string already is a URL, it will
1723  *                be the first URL found.
1724  *
1725  * Parameters  :
1726  *          1  :  subject = the string to check
1727  *          2  :  redirect_mode = +fast-redirect{} mode
1728  *
1729  * Returns     :  NULL if no URL was found, or
1730  *                the last URL found.
1731  *
1732  *********************************************************************/
1733 char *get_last_url(char *subject, const char *redirect_mode)
1734 {
1735    char *new_url = NULL;
1736    char *tmp;
1737
1738    assert(subject);
1739    assert(redirect_mode);
1740
1741    subject = strdup(subject);
1742    if (subject == NULL)
1743    {
1744       log_error(LOG_LEVEL_ERROR, "Out of memory while searching for redirects.");
1745       return NULL;
1746    }
1747
1748    if (0 == strcmpic(redirect_mode, "check-decoded-url"))
1749    {
1750       log_error(LOG_LEVEL_REDIRECTS, "Decoding \"%s\" if necessary.", subject);
1751       new_url = url_decode(subject);
1752       if (new_url != NULL)
1753       {
1754          freez(subject);
1755          subject = new_url;
1756       }
1757       else
1758       {
1759          log_error(LOG_LEVEL_ERROR, "Unable to decode \"%s\".", subject);
1760       }
1761    }
1762
1763    log_error(LOG_LEVEL_REDIRECTS, "Checking \"%s\" for redirects.", subject);
1764
1765    /*
1766     * Find the last URL encoded in the request
1767     */
1768    tmp = subject;
1769    while ((tmp = strstr(tmp, "http://")) != NULL)
1770    {
1771       new_url = tmp++;
1772    }
1773    tmp = (new_url != NULL) ? new_url : subject;
1774    while ((tmp = strstr(tmp, "https://")) != NULL)
1775    {
1776       new_url = tmp++;
1777    }
1778
1779    if ((new_url != NULL)
1780       && (  (new_url != subject)
1781          || (0 == strncmpic(subject, "http://", 7))
1782          || (0 == strncmpic(subject, "https://", 8))
1783          ))
1784    {
1785       /*
1786        * Return new URL if we found a redirect
1787        * or if the subject already was a URL.
1788        *
1789        * The second case makes sure that we can
1790        * chain get_last_url after another redirection check
1791        * (like rewrite_url) without losing earlier redirects.
1792        */
1793       new_url = strdup(new_url);
1794       freez(subject);
1795       return new_url;
1796    }
1797
1798    freez(subject);
1799    return NULL;
1800
1801 }
1802 #endif /* def FEATURE_FAST_REDIRECTS */
1803
1804
1805 /*********************************************************************
1806  *
1807  * Function    :  redirect_url
1808  *
1809  * Description :  Checks if Privoxy should answer the request with
1810  *                a HTTP redirect and generates the redirect if
1811  *                necessary.
1812  *
1813  * Parameters  :
1814  *          1  :  csp = Current client state (buffers, headers, etc...)
1815  *
1816  * Returns     :  NULL if the request can pass, HTTP redirect otherwise.
1817  *
1818  *********************************************************************/
1819 struct http_response *redirect_url(struct client_state *csp)
1820 {
1821    struct http_response *rsp;
1822 #ifdef FEATURE_FAST_REDIRECTS
1823    /*
1824     * XXX: Do we still need FEATURE_FAST_REDIRECTS
1825     * as compile-time option? The user can easily disable
1826     * it in his action file.
1827     */
1828    char * redirect_mode;
1829 #endif /* def FEATURE_FAST_REDIRECTS */
1830    char *old_url = NULL;
1831    char *new_url = NULL;
1832    char *redirection_string;
1833
1834    if ((csp->action->flags & ACTION_REDIRECT))
1835    {
1836       redirection_string = csp->action->string[ACTION_STRING_REDIRECT];
1837
1838       /*
1839        * If the redirection string begins with 's',
1840        * assume it's a pcrs command, otherwise treat it as
1841        * properly formatted URL and use it for the redirection
1842        * directly.
1843        *
1844        * According to RFC 2616 section 14.30 the URL
1845        * has to be absolute and if the user tries:
1846        * +redirect{shit/this/will/be/parsed/as/pcrs_command.html}
1847        * she would get undefined results anyway.
1848        *
1849        */
1850
1851       if (*redirection_string == 's')
1852       {
1853          old_url = csp->http->url;
1854          new_url = rewrite_url(old_url, redirection_string);
1855       }
1856       else
1857       {
1858          log_error(LOG_LEVEL_REDIRECTS,
1859             "No pcrs command recognized, assuming that \"%s\" is already properly formatted.",
1860             redirection_string);
1861          new_url = strdup(redirection_string);
1862       }
1863    }
1864
1865 #ifdef FEATURE_FAST_REDIRECTS
1866    if ((csp->action->flags & ACTION_FAST_REDIRECTS))
1867    {
1868       redirect_mode = csp->action->string[ACTION_STRING_FAST_REDIRECTS];
1869
1870       /*
1871        * If it exists, use the previously rewritten URL as input
1872        * otherwise just use the old path.
1873        */
1874       old_url = (new_url != NULL) ? new_url : strdup(csp->http->path);
1875       new_url = get_last_url(old_url, redirect_mode);
1876       freez(old_url);
1877    }
1878
1879    /*
1880     * Disable redirect checkers, so that they
1881     * will be only run more than once if the user
1882     * also enables them through tags.
1883     *
1884     * From a performance point of view
1885     * it doesn't matter, but the duplicated
1886     * log messages are annoying.
1887     */
1888    csp->action->flags &= ~ACTION_FAST_REDIRECTS;
1889 #endif /* def FEATURE_FAST_REDIRECTS */
1890    csp->action->flags &= ~ACTION_REDIRECT;
1891
1892    /* Did any redirect action trigger? */
1893    if (new_url)
1894    {
1895       if (0 == strcmpic(new_url, csp->http->url))
1896       {
1897          log_error(LOG_LEVEL_ERROR,
1898             "New URL \"%s\" and old URL \"%s\" are the same. Redirection loop prevented.",
1899             csp->http->url, new_url);
1900             freez(new_url);
1901       }
1902       else
1903       {
1904          log_error(LOG_LEVEL_REDIRECTS, "New URL is: %s", new_url);
1905
1906          if (NULL == (rsp = alloc_http_response()))
1907          {
1908             freez(new_url);
1909             return cgi_error_memory();
1910          }
1911
1912          if ( enlist_unique_header(rsp->headers, "Location", new_url)
1913            || (NULL == (rsp->status = strdup("302 Local Redirect from Privoxy"))) )
1914          {
1915             freez(new_url);
1916             free_http_response(rsp);
1917             return cgi_error_memory();
1918          }
1919          rsp->reason = RSP_REASON_REDIRECTED;
1920          freez(new_url);
1921
1922          return finish_http_response(csp, rsp);
1923       }
1924    }
1925
1926    /* Only reached if no redirect is required */
1927    return NULL;
1928
1929 }
1930
1931
1932 #ifdef FEATURE_IMAGE_BLOCKING
1933 /*********************************************************************
1934  *
1935  * Function    :  is_imageurl
1936  *
1937  * Description :  Given a URL, decide whether it is an image or not,
1938  *                using either the info from a previous +image action
1939  *                or, #ifdef FEATURE_IMAGE_DETECT_MSIE, and the browser
1940  *                is MSIE and not on a Mac, tell from the browser's accept
1941  *                header.
1942  *
1943  * Parameters  :
1944  *          1  :  csp = Current client state (buffers, headers, etc...)
1945  *
1946  * Returns     :  True (nonzero) if URL is an image, false (0)
1947  *                otherwise
1948  *
1949  *********************************************************************/
1950 int is_imageurl(const struct client_state *csp)
1951 {
1952 #ifdef FEATURE_IMAGE_DETECT_MSIE
1953    char *tmp;
1954
1955    tmp = get_header_value(csp->headers, "User-Agent:");
1956    if (tmp && strstr(tmp, "MSIE") && !strstr(tmp, "Mac_"))
1957    {
1958       tmp = get_header_value(csp->headers, "Accept:");
1959       if (tmp && strstr(tmp, "image/gif"))
1960       {
1961          /* Client will accept HTML.  If this seems counterintuitive,
1962           * blame Microsoft.
1963           */
1964          return(0);
1965       }
1966       else
1967       {
1968          return(1);
1969       }
1970    }
1971 #endif /* def FEATURE_IMAGE_DETECT_MSIE */
1972
1973    return ((csp->action->flags & ACTION_IMAGE) != 0);
1974
1975 }
1976 #endif /* def FEATURE_IMAGE_BLOCKING */
1977
1978
1979 #ifdef FEATURE_TRUST
1980 /*********************************************************************
1981  *
1982  * Function    :  is_untrusted_url
1983  *
1984  * Description :  Should we "distrust" this URL (and block it)?
1985  *
1986  *                Yes if it matches a line in the trustfile, or if the
1987  *                    referrer matches a line starting with "+" in the
1988  *                    trustfile.
1989  *                No  otherwise.
1990  *
1991  * Parameters  :
1992  *          1  :  csp = Current client state (buffers, headers, etc...)
1993  *
1994  * Returns     :  0 => trusted, 1 => untrusted
1995  *
1996  *********************************************************************/
1997 int is_untrusted_url(const struct client_state *csp)
1998 {
1999    struct file_list *fl;
2000    struct block_spec *b;
2001    struct url_spec **trusted_url;
2002    struct http_request rhttp[1];
2003    const char * referer;
2004    jb_err err;
2005
2006    /*
2007     * If we don't have a trustlist, we trust everybody
2008     */
2009    if (((fl = csp->tlist) == NULL) || ((b  = fl->f) == NULL))
2010    {
2011       return 0;
2012    }
2013
2014    memset(rhttp, '\0', sizeof(*rhttp));
2015
2016    /*
2017     * Do we trust the request URL itself?
2018     */
2019    for (b = b->next; b ; b = b->next)
2020    {
2021       if (url_match(b->url, csp->http))
2022       {
2023          return b->reject;
2024       }
2025    }
2026
2027    if (NULL == (referer = get_header_value(csp->headers, "Referer:")))
2028    {
2029       /* no referrer was supplied */
2030       return 1;
2031    }
2032
2033
2034    /*
2035     * If not, do we maybe trust its referrer?
2036     */
2037    err = parse_http_url(referer, rhttp, REQUIRE_PROTOCOL);
2038    if (err)
2039    {
2040       return 1;
2041    }
2042
2043    for (trusted_url = csp->config->trust_list; *trusted_url != NULL; trusted_url++)
2044    {
2045       if (url_match(*trusted_url, rhttp))
2046       {
2047          /* if the URL's referrer is from a trusted referrer, then
2048           * add the target spec to the trustfile as an unblocked
2049           * domain and return 0 (which means it's OK).
2050           */
2051
2052          FILE *fp;
2053
2054          if (NULL != (fp = fopen(csp->config->trustfile, "a")))
2055          {
2056             char * path;
2057             char * path_end;
2058             char * new_entry = strdup("~");
2059
2060             string_append(&new_entry, csp->http->hostport);
2061
2062             path = csp->http->path;
2063             if ( (path[0] == '/')
2064               && (path[1] == '~')
2065               && ((path_end = strchr(path + 2, '/')) != NULL))
2066             {
2067                /* since this path points into a user's home space
2068                 * be sure to include this spec in the trustfile.
2069                 */
2070                long path_len = path_end - path; /* save offset */
2071                path = strdup(path); /* Copy string */
2072                if (path != NULL)
2073                {
2074                   path_end = path + path_len; /* regenerate ptr to new buffer */
2075                   *(path_end + 1) = '\0'; /* Truncate path after '/' */
2076                }
2077                string_join(&new_entry, path);
2078             }
2079
2080             /*
2081              * Give a reason for generating this entry.
2082              */
2083             string_append(&new_entry, " # Trusted referrer was: ");
2084             string_append(&new_entry, referer);
2085
2086             if (new_entry != NULL)
2087             {
2088                if (-1 == fprintf(fp, "%s\n", new_entry))
2089                {
2090                   log_error(LOG_LEVEL_ERROR, "Failed to append \'%s\' to trustfile \'%s\': %E",
2091                      new_entry, csp->config->trustfile);
2092                }
2093                freez(new_entry);
2094             }
2095             else
2096             {
2097                /* FIXME: No way to handle out-of memory, so mostly ignoring it */
2098                log_error(LOG_LEVEL_ERROR, "Out of memory adding pattern to trust file");
2099             }
2100
2101             fclose(fp);
2102          }
2103          else
2104          {
2105             log_error(LOG_LEVEL_ERROR, "Failed to append new entry for \'%s\' to trustfile \'%s\': %E",
2106                csp->http->hostport, csp->config->trustfile);
2107          }
2108          return 0;
2109       }
2110    }
2111
2112    return 1;
2113 }
2114 #endif /* def FEATURE_TRUST */
2115
2116
2117 /*********************************************************************
2118  *
2119  * Function    :  pcrs_filter_response
2120  *
2121  * Description :  Execute all text substitutions from all applying
2122  *                +filter actions on the text buffer that's been
2123  *                accumulated in csp->iob->buf.
2124  *
2125  * Parameters  :
2126  *          1  :  csp = Current client state (buffers, headers, etc...)
2127  *
2128  * Returns     :  a pointer to the (newly allocated) modified buffer.
2129  *                or NULL if there were no hits or something went wrong
2130  *
2131  *********************************************************************/
2132 static char *pcrs_filter_response(struct client_state *csp)
2133 {
2134    int hits=0;
2135    size_t size, prev_size;
2136
2137    char *old = NULL;
2138    char *new = NULL;
2139    pcrs_job *job;
2140
2141    struct file_list *fl;
2142    struct re_filterfile_spec *b;
2143    struct list_entry *filtername;
2144
2145    int i, found_filters = 0;
2146
2147    /*
2148     * Sanity first
2149     */
2150    if (csp->iob->cur >= csp->iob->eod)
2151    {
2152       return(NULL);
2153    }
2154
2155    /*
2156     * Need to check the set of re_filterfiles...
2157     */
2158    for (i = 0; i < MAX_AF_FILES; i++)
2159    {
2160       fl = csp->rlist[i];
2161       if (NULL != fl)
2162       {
2163          if (NULL != fl->f)
2164          {
2165            found_filters = 1;
2166            break;
2167          }
2168       }
2169    }
2170
2171    if (0 == found_filters)
2172    {
2173       log_error(LOG_LEVEL_ERROR, "Inconsistent configuration: "
2174          "content filtering enabled, but no content filters available.");
2175       return(NULL);
2176    }
2177
2178    size = (size_t)(csp->iob->eod - csp->iob->cur);
2179    old = csp->iob->cur;
2180
2181    for (i = 0; i < MAX_AF_FILES; i++)
2182    {
2183      fl = csp->rlist[i];
2184      if ((NULL == fl) || (NULL == fl->f))
2185      {
2186         /*
2187          * Either there are no filter files
2188          * left, or this filter file just
2189          * contains no valid filters.
2190          *
2191          * Continue to be sure we don't miss
2192          * valid filter files that are chained
2193          * after empty or invalid ones.
2194          */
2195         continue;
2196      }
2197    /*
2198     * For all applying +filter actions, look if a filter by that
2199     * name exists and if yes, execute it's pcrs_joblist on the
2200     * buffer.
2201     */
2202    for (b = fl->f; b; b = b->next)
2203    {
2204       if (b->type != FT_CONTENT_FILTER)
2205       {
2206          /* Skip header filters */
2207          continue;
2208       }
2209
2210       for (filtername = csp->action->multi[ACTION_MULTI_FILTER]->first;
2211            filtername ; filtername = filtername->next)
2212       {
2213          if (strcmp(b->name, filtername->str) == 0)
2214          {
2215             int current_hits = 0; /* Number of hits caused by this filter */
2216             int job_number   = 0; /* Which job we're currently executing  */
2217             int job_hits     = 0; /* How many hits the current job caused */
2218             pcrs_job *joblist = b->joblist;
2219
2220             if (b->dynamic) joblist = compile_dynamic_pcrs_job_list(csp, b);
2221
2222             if (NULL == joblist)
2223             {
2224                log_error(LOG_LEVEL_RE_FILTER, "Filter %s has empty joblist. Nothing to do.", b->name);
2225                continue;
2226             }
2227
2228             prev_size = size;
2229             /* Apply all jobs from the joblist */
2230             for (job = joblist; NULL != job; job = job->next)
2231             {
2232                job_number++;
2233                job_hits = pcrs_execute(job, old, size, &new, &size);
2234
2235                if (job_hits >= 0)
2236                {
2237                   /*
2238                    * That went well. Continue filtering
2239                    * and use the result of this job as
2240                    * input for the next one.
2241                    */
2242                   current_hits += job_hits;
2243                   if (old != csp->iob->cur)
2244                   {
2245                      freez(old);
2246                   }
2247                   old = new;
2248                }
2249                else
2250                {
2251                   /*
2252                    * This job caused an unexpected error. Inform the user
2253                    * and skip the rest of the jobs in this filter. We could
2254                    * continue with the next job, but usually the jobs
2255                    * depend on each other or are similar enough to
2256                    * fail for the same reason.
2257                    *
2258                    * At the moment our pcrs expects the error codes of pcre 3.4,
2259                    * but newer pcre versions can return additional error codes.
2260                    * As a result pcrs_strerror()'s error message might be
2261                    * "Unknown error ...", therefore we print the numerical value
2262                    * as well.
2263                    *
2264                    * XXX: Is this important enough for LOG_LEVEL_ERROR or
2265                    * should we use LOG_LEVEL_RE_FILTER instead?
2266                    */
2267                   log_error(LOG_LEVEL_ERROR, "Skipped filter \'%s\' after job number %u: %s (%d)",
2268                      b->name, job_number, pcrs_strerror(job_hits), job_hits);
2269                   break;
2270                }
2271             }
2272
2273             if (b->dynamic) pcrs_free_joblist(joblist);
2274
2275             log_error(LOG_LEVEL_RE_FILTER,
2276                "filtering %s%s (size %d) with \'%s\' produced %d hits (new size %d).",
2277                csp->http->hostport, csp->http->path, prev_size, b->name, current_hits, size);
2278
2279             hits += current_hits;
2280          }
2281       }
2282    }
2283    }
2284
2285    /*
2286     * If there were no hits, destroy our copy and let
2287     * chat() use the original in csp->iob
2288     */
2289    if (!hits)
2290    {
2291       freez(new);
2292       return(NULL);
2293    }
2294
2295    csp->flags |= CSP_FLAG_MODIFIED;
2296    csp->content_length = size;
2297    IOB_RESET(csp);
2298
2299    return(new);
2300
2301 }
2302
2303
2304 /*********************************************************************
2305  *
2306  * Function    :  gif_deanimate_response
2307  *
2308  * Description :  Deanimate the GIF image that has been accumulated in
2309  *                csp->iob->buf, set csp->content_length to the modified
2310  *                size and raise the CSP_FLAG_MODIFIED flag.
2311  *
2312  * Parameters  :
2313  *          1  :  csp = Current client state (buffers, headers, etc...)
2314  *
2315  * Returns     :  a pointer to the (newly allocated) modified buffer.
2316  *                or NULL in case something went wrong.
2317  *
2318  *********************************************************************/
2319 static char *gif_deanimate_response(struct client_state *csp)
2320 {
2321    struct binbuffer *in, *out;
2322    char *p;
2323    size_t size;
2324
2325    size = (size_t)(csp->iob->eod - csp->iob->cur);
2326
2327    if (  (NULL == (in =  (struct binbuffer *)zalloc(sizeof *in )))
2328       || (NULL == (out = (struct binbuffer *)zalloc(sizeof *out))) )
2329    {
2330       log_error(LOG_LEVEL_DEANIMATE, "failed! (no mem)");
2331       return NULL;
2332    }
2333
2334    in->buffer = csp->iob->cur;
2335    in->size = size;
2336
2337    if (gif_deanimate(in, out, strncmp("last", csp->action->string[ACTION_STRING_DEANIMATE], 4)))
2338    {
2339       log_error(LOG_LEVEL_DEANIMATE, "failed! (gif parsing)");
2340       freez(in);
2341       buf_free(out);
2342       return(NULL);
2343    }
2344    else
2345    {
2346       if ((int)size == out->offset)
2347       {
2348          log_error(LOG_LEVEL_DEANIMATE, "GIF not changed.");
2349       }
2350       else
2351       {
2352          log_error(LOG_LEVEL_DEANIMATE, "Success! GIF shrunk from %d bytes to %d.", size, out->offset);
2353       }
2354       csp->content_length = out->offset;
2355       csp->flags |= CSP_FLAG_MODIFIED;
2356       p = out->buffer;
2357       freez(in);
2358       freez(out);
2359       return(p);
2360    }
2361
2362 }
2363
2364
2365 /*********************************************************************
2366  *
2367  * Function    :  get_filter_function
2368  *
2369  * Description :  Decides which content filter function has
2370  *                to be applied (if any).
2371  *
2372  * Parameters  :
2373  *          1  :  csp = Current client state (buffers, headers, etc...)
2374  *
2375  * Returns     :  The content filter function to run, or
2376  *                NULL if no content filter is active
2377  *
2378  *********************************************************************/
2379 filter_function_ptr get_filter_function(struct client_state *csp)
2380 {
2381    filter_function_ptr filter_function = NULL;
2382
2383    /*
2384     * Are we enabling text mode by force?
2385     */
2386    if (csp->action->flags & ACTION_FORCE_TEXT_MODE)
2387    {
2388       /*
2389        * Do we really have to?
2390        */
2391       if (csp->content_type & CT_TEXT)
2392       {
2393          log_error(LOG_LEVEL_HEADER, "Text mode is already enabled.");
2394       }
2395       else
2396       {
2397          csp->content_type |= CT_TEXT;
2398          log_error(LOG_LEVEL_HEADER, "Text mode enabled by force. Take cover!");
2399       }
2400    }
2401
2402    if (!(csp->content_type & CT_DECLARED))
2403    {
2404       /*
2405        * The server didn't bother to declare a MIME-Type.
2406        * Assume it's text that can be filtered.
2407        *
2408        * This also regulary happens with 304 responses,
2409        * therefore logging anything here would cause
2410        * too much noise.
2411        */
2412       csp->content_type |= CT_TEXT;
2413    }
2414
2415    /*
2416     * Choose the applying filter function based on
2417     * the content type and action settings.
2418     */
2419    if ((csp->content_type & CT_TEXT) &&
2420        (csp->rlist != NULL) &&
2421        (!list_is_empty(csp->action->multi[ACTION_MULTI_FILTER])))
2422    {
2423       filter_function = pcrs_filter_response;
2424    }
2425    else if ((csp->content_type & CT_GIF)  &&
2426             (csp->action->flags & ACTION_DEANIMATE))
2427    {
2428       filter_function = gif_deanimate_response;
2429    }
2430
2431    return filter_function;
2432 }
2433
2434
2435 /*********************************************************************
2436  *
2437  * Function    :  remove_chunked_transfer_coding
2438  *
2439  * Description :  In-situ remove the "chunked" transfer coding as defined
2440  *                in rfc2616 from a buffer.
2441  *
2442  * Parameters  :
2443  *          1  :  buffer = Pointer to the text buffer
2444  *          2  :  size =  In: Number of bytes to be processed,
2445  *                       Out: Number of bytes after de-chunking.
2446  *                       (undefined in case of errors)
2447  *
2448  * Returns     :  JB_ERR_OK for success,
2449  *                JB_ERR_PARSE otherwise
2450  *
2451  *********************************************************************/
2452 static jb_err remove_chunked_transfer_coding(char *buffer, size_t *size)
2453 {
2454    size_t newsize = 0;
2455    unsigned int chunksize = 0;
2456    char *from_p, *to_p;
2457
2458    assert(buffer);
2459    from_p = to_p = buffer;
2460
2461    if (sscanf(buffer, "%x", &chunksize) != 1)
2462    {
2463       log_error(LOG_LEVEL_ERROR, "Invalid first chunksize while stripping \"chunked\" transfer coding");
2464       return JB_ERR_PARSE;
2465    }
2466
2467    while (chunksize > 0U)
2468    {
2469       if (NULL == (from_p = strstr(from_p, "\r\n")))
2470       {
2471          log_error(LOG_LEVEL_ERROR, "Parse error while stripping \"chunked\" transfer coding");
2472          return JB_ERR_PARSE;
2473       }
2474
2475       if ((newsize += chunksize) >= *size)
2476       {
2477          log_error(LOG_LEVEL_ERROR,
2478             "Chunk size %d exceeds buffer size %d in  \"chunked\" transfer coding",
2479             chunksize, *size);
2480          return JB_ERR_PARSE;
2481       }
2482       from_p += 2;
2483
2484       memmove(to_p, from_p, (size_t) chunksize);
2485       to_p = buffer + newsize;
2486       from_p += chunksize + 2;
2487
2488       if (sscanf(from_p, "%x", &chunksize) != 1)
2489       {
2490          log_error(LOG_LEVEL_INFO, "Invalid \"chunked\" transfer encoding detected and ignored.");
2491          break;
2492       }
2493    }
2494
2495    /* XXX: Should get its own loglevel. */
2496    log_error(LOG_LEVEL_RE_FILTER, "De-chunking successful. Shrunk from %d to %d", *size, newsize);
2497
2498    *size = newsize;
2499
2500    return JB_ERR_OK;
2501
2502 }
2503
2504
2505 /*********************************************************************
2506  *
2507  * Function    :  prepare_for_filtering
2508  *
2509  * Description :  If necessary, de-chunks and decompresses
2510  *                the content so it can get filterd.
2511  *
2512  * Parameters  :
2513  *          1  :  csp = Current client state (buffers, headers, etc...)
2514  *
2515  * Returns     :  JB_ERR_OK for success,
2516  *                JB_ERR_PARSE otherwise
2517  *
2518  *********************************************************************/
2519 static jb_err prepare_for_filtering(struct client_state *csp)
2520 {
2521    jb_err err = JB_ERR_OK;
2522
2523    /*
2524     * If the body has a "chunked" transfer-encoding,
2525     * get rid of it, adjusting size and iob->eod
2526     */
2527    if (csp->flags & CSP_FLAG_CHUNKED)
2528    {
2529       size_t size = (size_t)(csp->iob->eod - csp->iob->cur);
2530
2531       log_error(LOG_LEVEL_RE_FILTER, "Need to de-chunk first");
2532       err = remove_chunked_transfer_coding(csp->iob->cur, &size);
2533       if (JB_ERR_OK == err)
2534       {
2535          csp->iob->eod = csp->iob->cur + size;
2536          csp->flags |= CSP_FLAG_MODIFIED;
2537       }
2538       else
2539       {
2540          return JB_ERR_PARSE;
2541       }
2542    }
2543
2544 #ifdef FEATURE_ZLIB
2545    /*
2546     * If the body has a supported transfer-encoding,
2547     * decompress it, adjusting size and iob->eod.
2548     */
2549    if (csp->content_type & (CT_GZIP|CT_DEFLATE))
2550    {
2551       if (0 == csp->iob->eod - csp->iob->cur)
2552       {
2553          /* Nothing left after de-chunking. */
2554          return JB_ERR_OK;
2555       }
2556
2557       err = decompress_iob(csp);
2558
2559       if (JB_ERR_OK == err)
2560       {
2561          csp->flags |= CSP_FLAG_MODIFIED;
2562          csp->content_type &= ~CT_TABOO;
2563       }
2564       else
2565       {
2566          /*
2567           * Unset CT_GZIP and CT_DEFLATE to remember not
2568           * to modify the Content-Encoding header later.
2569           */
2570          csp->content_type &= ~CT_GZIP;
2571          csp->content_type &= ~CT_DEFLATE;
2572       }
2573    }
2574 #endif
2575
2576    return err;
2577 }
2578
2579
2580 /*********************************************************************
2581  *
2582  * Function    :  execute_content_filter
2583  *
2584  * Description :  Executes a given content filter.
2585  *
2586  * Parameters  :
2587  *          1  :  csp = Current client state (buffers, headers, etc...)
2588  *          2  :  content_filter = The filter function to execute
2589  *
2590  * Returns     :  Pointer to the modified buffer, or
2591  *                NULL if filtering failed or wasn't necessary.
2592  *
2593  *********************************************************************/
2594 char *execute_content_filter(struct client_state *csp, filter_function_ptr content_filter)
2595 {
2596    if (0 == csp->iob->eod - csp->iob->cur)
2597    {
2598       /*
2599        * No content (probably status code 301, 302 ...),
2600        * no filtering necessary.
2601        */
2602       return NULL;
2603    }
2604
2605    if (JB_ERR_OK != prepare_for_filtering(csp))
2606    {
2607       /*
2608        * failed to de-chunk or decompress.
2609        */
2610       return NULL;
2611    }
2612
2613    if (0 == csp->iob->eod - csp->iob->cur)
2614    {
2615       /*
2616        * Clown alarm: chunked and/or compressed nothing delivered.
2617        */
2618       return NULL;
2619    }
2620
2621    return ((*content_filter)(csp));
2622 }
2623
2624
2625 /*********************************************************************
2626  *
2627  * Function    :  get_url_actions
2628  *
2629  * Description :  Gets the actions for this URL.
2630  *
2631  * Parameters  :
2632  *          1  :  csp = Current client state (buffers, headers, etc...)
2633  *          2  :  http = http_request request for blocked URLs
2634  *
2635  * Returns     :  N/A
2636  *
2637  *********************************************************************/
2638 void get_url_actions(struct client_state *csp, struct http_request *http)
2639 {
2640    struct file_list *fl;
2641    struct url_actions *b;
2642    int i;
2643
2644    init_current_action(csp->action);
2645
2646    for (i = 0; i < MAX_AF_FILES; i++)
2647    {
2648       if (((fl = csp->actions_list[i]) == NULL) || ((b = fl->f) == NULL))
2649       {
2650          return;
2651       }
2652
2653       apply_url_actions(csp->action, http, b);
2654    }
2655
2656    return;
2657 }
2658
2659
2660 /*********************************************************************
2661  *
2662  * Function    :  apply_url_actions
2663  *
2664  * Description :  Applies a list of URL actions.
2665  *
2666  * Parameters  :
2667  *          1  :  action = Destination.
2668  *          2  :  http = Current URL
2669  *          3  :  b = list of URL actions to apply
2670  *
2671  * Returns     :  N/A
2672  *
2673  *********************************************************************/
2674 void apply_url_actions(struct current_action_spec *action,
2675                        struct http_request *http,
2676                        struct url_actions *b)
2677 {
2678    if (b == NULL)
2679    {
2680       /* Should never happen */
2681       return;
2682    }
2683
2684    for (b = b->next; NULL != b; b = b->next)
2685    {
2686       if (url_match(b->url, http))
2687       {
2688          merge_current_action(action, b->action);
2689       }
2690    }
2691 }
2692
2693
2694 /*********************************************************************
2695  *
2696  * Function    :  get_forward_override_settings
2697  *
2698  * Description :  Returns forward settings as specified with the
2699  *                forward-override{} action. forward-override accepts
2700  *                forward lines similar to the one used in the
2701  *                configuration file, but without the URL pattern.
2702  *
2703  *                For example:
2704  *
2705  *                   forward / .
2706  *
2707  *                in the configuration file can be replaced with
2708  *                the action section:
2709  *
2710  *                 {+forward-override{forward .}}
2711  *                 /
2712  *
2713  * Parameters  :
2714  *          1  :  csp = Current client state (buffers, headers, etc...)
2715  *
2716  * Returns     :  Pointer to forwarding structure in case of success.
2717  *                Invalid syntax is fatal.
2718  *
2719  *********************************************************************/
2720 const static struct forward_spec *get_forward_override_settings(struct client_state *csp)
2721 {
2722    const char *forward_override_line = csp->action->string[ACTION_STRING_FORWARD_OVERRIDE];
2723    char forward_settings[BUFFER_SIZE];
2724    char *http_parent = NULL;
2725    /* variable names were chosen for consistency reasons. */
2726    struct forward_spec *fwd = NULL;
2727    int vec_count;
2728    char *vec[3];
2729
2730    assert(csp->action->flags & ACTION_FORWARD_OVERRIDE);
2731    /* Should be enforced by load_one_actions_file() */
2732    assert(strlen(forward_override_line) < sizeof(forward_settings) - 1);
2733
2734    /* Create a copy ssplit can modify */
2735    strlcpy(forward_settings, forward_override_line, sizeof(forward_settings));
2736
2737    if (NULL != csp->fwd)
2738    {
2739       /*
2740        * XXX: Currently necessary to prevent memory
2741        * leaks when the show-url-info cgi page is visited.
2742        */
2743       unload_forward_spec(csp->fwd);
2744    }
2745
2746    /*
2747     * allocate a new forward node, valid only for
2748     * the lifetime of this request. Save its location
2749     * in csp as well, so sweep() can free it later on.
2750     */
2751    fwd = csp->fwd = zalloc(sizeof(*fwd));
2752    if (NULL == fwd)
2753    {
2754       log_error(LOG_LEVEL_FATAL,
2755          "can't allocate memory for forward-override{%s}", forward_override_line);
2756       /* Never get here - LOG_LEVEL_FATAL causes program exit */
2757       return NULL;
2758    }
2759
2760    vec_count = ssplit(forward_settings, " \t", vec, SZ(vec), 1, 1);
2761    if ((vec_count == 2) && !strcasecmp(vec[0], "forward"))
2762    {
2763       fwd->type = SOCKS_NONE;
2764
2765       /* Parse the parent HTTP proxy host:port */
2766       http_parent = vec[1];
2767
2768    }
2769    else if (vec_count == 3)
2770    {
2771       char *socks_proxy = NULL;
2772
2773       if  (!strcasecmp(vec[0], "forward-socks4"))
2774       {
2775          fwd->type = SOCKS_4;
2776          socks_proxy = vec[1];
2777       }
2778       else if (!strcasecmp(vec[0], "forward-socks4a"))
2779       {
2780          fwd->type = SOCKS_4A;
2781          socks_proxy = vec[1];
2782       }
2783       else if (!strcasecmp(vec[0], "forward-socks5"))
2784       {
2785          fwd->type = SOCKS_5;
2786          socks_proxy = vec[1];
2787       }
2788
2789       if (NULL != socks_proxy)
2790       {
2791          /* Parse the SOCKS proxy host[:port] */
2792          fwd->gateway_host = strdup(socks_proxy);
2793
2794          if (NULL != (socks_proxy = strchr(fwd->gateway_host, ':')))
2795          {
2796             *socks_proxy++ = '\0';
2797             fwd->gateway_port = (int)strtol(socks_proxy, NULL, 0);
2798          }
2799
2800          if (fwd->gateway_port <= 0)
2801          {
2802             fwd->gateway_port = 1080;
2803          }
2804
2805          http_parent = vec[2];
2806       }
2807    }
2808
2809    if (NULL == http_parent)
2810    {
2811       log_error(LOG_LEVEL_FATAL,
2812          "Invalid forward-override syntax in: %s", forward_override_line);
2813       /* Never get here - LOG_LEVEL_FATAL causes program exit */
2814    }
2815
2816    /* Parse http forwarding settings */
2817    if (strcmp(http_parent, ".") != 0)
2818    {
2819       fwd->forward_host = strdup(http_parent);
2820
2821       if (NULL != (http_parent = strchr(fwd->forward_host, ':')))
2822       {
2823          *http_parent++ = '\0';
2824          fwd->forward_port = (int)strtol(http_parent, NULL, 0);
2825       }
2826
2827       if (fwd->forward_port <= 0)
2828       {
2829          fwd->forward_port = 8000;
2830       }
2831    }
2832
2833    assert (NULL != fwd);
2834
2835    log_error(LOG_LEVEL_CONNECT,
2836       "Overriding forwarding settings based on \'%s\'", forward_override_line);
2837
2838    return fwd;
2839 }
2840
2841
2842 /*********************************************************************
2843  *
2844  * Function    :  forward_url
2845  *
2846  * Description :  Should we forward this to another proxy?
2847  *
2848  * Parameters  :
2849  *          1  :  csp = Current client state (buffers, headers, etc...)
2850  *          2  :  http = http_request request for current URL
2851  *
2852  * Returns     :  Pointer to forwarding information.
2853  *
2854  *********************************************************************/
2855 const struct forward_spec *forward_url(struct client_state *csp,
2856                                        const struct http_request *http)
2857 {
2858    static const struct forward_spec fwd_default[1] = { FORWARD_SPEC_INITIALIZER };
2859    struct forward_spec *fwd = csp->config->forward;
2860
2861    if (csp->action->flags & ACTION_FORWARD_OVERRIDE)
2862    {
2863       return get_forward_override_settings(csp);
2864    }
2865
2866    if (fwd == NULL)
2867    {
2868       return fwd_default;
2869    }
2870
2871    while (fwd != NULL)
2872    {
2873       if (url_match(fwd->url, http))
2874       {
2875          return fwd;
2876       }
2877       fwd = fwd->next;
2878    }
2879
2880    return fwd_default;
2881 }
2882
2883
2884 /*********************************************************************
2885  *
2886  * Function    :  direct_response
2887  *
2888  * Description :  Check if Max-Forwards == 0 for an OPTIONS or TRACE
2889  *                request and if so, return a HTTP 501 to the client.
2890  *
2891  *                FIXME: I have a stupid name and I should handle the
2892  *                requests properly. Still, what we do here is rfc-
2893  *                compliant, whereas ignoring or forwarding are not.
2894  *
2895  * Parameters  :
2896  *          1  :  csp = Current client state (buffers, headers, etc...)
2897  *
2898  * Returns     :  http_response if , NULL if nonmatch or handler fail
2899  *
2900  *********************************************************************/
2901 struct http_response *direct_response(struct client_state *csp)
2902 {
2903    struct http_response *rsp;
2904    struct list_entry *p;
2905
2906    if ((0 == strcmpic(csp->http->gpc, "trace"))
2907       || (0 == strcmpic(csp->http->gpc, "options")))
2908    {
2909       for (p = csp->headers->first; (p != NULL) ; p = p->next)
2910       {
2911          if (!strncmpic("Max-Forwards:", p->str, 13))
2912          {
2913             unsigned int max_forwards;
2914
2915             /*
2916              * If it's a Max-Forwards value of zero,
2917              * we have to intercept the request.
2918              */
2919             if (1 == sscanf(p->str+12, ": %u", &max_forwards) && max_forwards == 0)
2920             {
2921                /*
2922                 * FIXME: We could handle at least TRACE here,
2923                 * but that would require a verbatim copy of
2924                 * the request which we don't have anymore
2925                 */
2926                 log_error(LOG_LEVEL_HEADER,
2927                   "Detected header \'%s\' in OPTIONS or TRACE request. Returning 501.",
2928                   p->str);
2929
2930                /* Get mem for response or fail*/
2931                if (NULL == (rsp = alloc_http_response()))
2932                {
2933                   return cgi_error_memory();
2934                }
2935
2936                if (NULL == (rsp->status = strdup("501 Not Implemented")))
2937                {
2938                   free_http_response(rsp);
2939                   return cgi_error_memory();
2940                }
2941
2942                rsp->is_static = 1;
2943                rsp->reason = RSP_REASON_UNSUPPORTED;
2944
2945                return(finish_http_response(csp, rsp));
2946             }
2947          }
2948       }
2949    }
2950    return NULL;
2951 }
2952
2953
2954 /*********************************************************************
2955  *
2956  * Function    :  content_filters_enabled
2957  *
2958  * Description :  Checks whether there are any content filters
2959  *                enabled for the current request.
2960  *
2961  * Parameters  :
2962  *          1  :  action = Action spec to check.
2963  *
2964  * Returns     :  TRUE for yes, FALSE otherwise
2965  *
2966  *********************************************************************/
2967 int content_filters_enabled(const struct current_action_spec *action)
2968 {
2969    return ((action->flags & ACTION_DEANIMATE) ||
2970       !list_is_empty(action->multi[ACTION_MULTI_FILTER]));
2971 }
2972
2973 /*
2974   Local Variables:
2975   tab-width: 3
2976   end:
2977
2978   vim:softtabstop=3 shiftwidth=3
2979 */