jcc.c

   1 const char jcc_rcs[] = "$Id: jcc.c,v 1.103 2006/09/21 12:54:43 fabiankeil Exp $";
   2 /*********************************************************************
   3  *
   4  * File        :  $Source: /cvsroot/ijbswa/current/jcc.c,v $
   5  *
   6  * Purpose     :  Main file.  Contains main() method, main loop, and
   7  *                the main connection-handling function.
   8  *
   9  * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
  10  *                Privoxy team. http://www.privoxy.org/
  11  *
  12  *                Based on the Internet Junkbuster originally written
  13  *                by and Copyright (C) 1997 Anonymous Coders and
  14  *                Junkbusters Corporation.  http://www.junkbusters.com
  15  *
  16  *                This program is free software; you can redistribute it
  17  *                and/or modify it under the terms of the GNU General
  18  *                Public License as published by the Free Software
  19  *                Foundation; either version 2 of the License, or (at
  20  *                your option) any later version.
  21  *
  22  *                This program is distributed in the hope that it will
  23  *                be useful, but WITHOUT ANY WARRANTY; without even the
  24  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  25  *                PARTICULAR PURPOSE.  See the GNU General Public
  26  *                License for more details.
  27  *
  28  *                The GNU General Public License should be included with
  29  *                this file.  If not, you can view it at
  30  *                http://www.gnu.org/copyleft/gpl.html
  31  *                or write to the Free Software Foundation, Inc., 59
  32  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  33  *
  34  * Revisions   :
  35  *    $Log: jcc.c,v $
  36  *    Revision 1.103  2006/09/21 12:54:43  fabiankeil
  37  *    Fix +redirect{}. Didn't work with -fast-redirects.
  38  *
  39  *    Revision 1.102  2006/09/06 13:03:04  fabiankeil
  40  *    Respond with 400 and a short text message
  41  *    if the client tries to use Privoxy as FTP proxy.
  42  *
  43  *    Revision 1.101  2006/09/06 09:23:37  fabiankeil
  44  *    Make number of retries in case of forwarded-connect problems
  45  *    a config file option (forwarded-connect-retries) and use 0 as
  46  *    default.
  47  *
  48  *    Revision 1.100  2006/09/03 19:42:59  fabiankeil
  49  *    Set random(3) seed.
  50  *
  51  *    Revision 1.99  2006/09/02 15:36:42  fabiankeil
  52  *    Follow the OpenBSD port's lead and protect the resolve
  53  *    functions on OpenBSD as well.
  54  *
  55  *    Revision 1.98  2006/08/24 11:01:34  fabiankeil
  56  *    --user fix. Only use the user as group if no group is specified.
  57  *    Solves BR 1492612. Thanks to Spinor S. and David Laight.
  58  *
  59  *    Revision 1.97  2006/08/18 15:23:17  david__schmidt
  60  *    Windows service (re-)integration
  61  *
  62  *    The new args are:
  63  *
  64  *    --install[:service_name]
  65  *    --uninstall[:service_name]
  66  *    --service
  67  *
  68  *    They work as follows:
  69  *    --install will create a service for you and then terminate.
  70  *    By default the service name will be "privoxy" (without the quotes).
  71  *    However you can run multiple services if you wish, just by adding
  72  *    a colon and then a name (no spaces).
  73  *
  74  *    --uninstall follows the exact same rules a --install.
  75  *
  76  *    --service is used when the program is executed by the service
  77  *    control manager, and in normal circumstances would never be
  78  *    used as a command line argument.
  79  *
  80  *    Revision 1.96  2006/08/15 20:12:36  david__schmidt
  81  *    Windows service integration
  82  *
  83  *    Revision 1.95  2006/08/03 02:46:41  david__schmidt
  84  *    Incorporate Fabian Keil's patch work:\rhttp://www.fabiankeil.de/sourcecode/privoxy/
  85  *
  86  *    Revision 1.94  2006/07/18 14:48:46  david__schmidt
  87  *    Reorganizing the repository: swapping out what was HEAD (the old 3.1 branch)
  88  *    with what was really the latest development (the v_3_0_branch branch)
  89  *
  90  *    Revision 1.92.2.16  2005/04/03 20:10:50  david__schmidt
  91  *    Thanks to Jindrich Makovicka for a race condition fix for the log
  92  *    file.  The race condition remains for non-pthread implementations.
  93  *    Reference patch #1175720.
  94  *
  95  *    Revision 1.92.2.15  2004/10/03 12:53:32  david__schmidt
  96  *    Add the ability to check jpeg images for invalid
  97  *    lengths of comment blocks.  Defensive strategy
  98  *    against the exploit:
  99  *       Microsoft Security Bulletin MS04-028
 100  *       Buffer Overrun in JPEG Processing (GDI+) Could
 101  *       Allow Code Execution (833987)
 102  *    Enabled with +inspect-jpegs in actions files.
 103  *
 104  *    Revision 1.92.2.14  2003/12/12 12:52:53  oes
 105  *    - Fixed usage info for non-unix platforms
 106  *    - Fixed small cmdline parsing bug
 107  *
 108  *    Revision 1.92.2.13  2003/11/27 19:20:27  oes
 109  *    Diagnostics: Now preserve the returncode of pthread_create
 110  *    in errno. Closes BR #775721. Thanks to Geoffrey Hausheer.
 111  *
 112  *    Revision 1.92.2.12  2003/07/11 11:34:19  oes
 113  *    No longer ignore SIGCHLD. Fixes bug #769381
 114  *
 115  *    Revision 1.92.2.11  2003/05/14 12:32:02  oes
 116  *    Close jarfile on graceful exit, remove stray line
 117  *
 118  *    Revision 1.92.2.10  2003/05/08 15:13:46  oes
 119  *    Cosmetics: Killed a warning, a typo and an allocation left at exit
 120  *
 121  *    Revision 1.92.2.9  2003/04/03 15:08:42  oes
 122  *    No longer rely on non-POSIX.1 extensions of getcwd().
 123  *    Fixes bug #711001
 124  *
 125  *    Revision 1.92.2.8  2003/03/31 13:12:32  oes
 126  *    Replaced setenv() by posix-compliant putenv()
 127  *    Thanks to Neil McCalden (nmcc AT users.sf.net).
 128  *
 129  *    Revision 1.92.2.7  2003/03/17 16:48:59  oes
 130  *    Added chroot ability, thanks to patch by Sviatoslav Sviridov
 131  *
 132  *    Revision 1.92.2.6  2003/03/11 11:55:00  oes
 133  *    Clean-up and extension of improvements for forked mode:
 134  *     - Child's return code now consists of flags RC_FLAG_*
 135  *     - Reporting toggle to parent now properly #ifdef'ed
 136  *     - Children now report blocking to parent. This enables
 137  *       statistics in forked mode
 138  *
 139  *    Revision 1.92.2.5  2003/03/10 23:45:32  oes
 140  *    Fixed bug #700381: Non-Threaded version now capable of being toggled.
 141  *    Children now report having been toggled through _exit(17), parents
 142  *    watch for that code and toggle themselves if found.
 143  *
 144  *    Revision 1.92.2.4  2003/03/07 03:41:04  david__schmidt
 145  *    Wrapping all *_r functions (the non-_r versions of them) with
 146  *    mutex semaphores for OSX.  Hopefully this will take care of all
 147  *    of those pesky crash reports.
 148  *
 149  *    Revision 1.92.2.3  2003/02/28 12:53:06  oes
 150  *    Fixed two mostly harmless mem leaks
 151  *
 152  *    Revision 1.92.2.2  2002/11/20 14:37:47  oes
 153  *    Fix: Head of global clients list now initialized to NULL
 154  *
 155  *    Revision 1.92.2.1  2002/09/25 14:52:24  oes
 156  *    Added basic support for OPTIONS and TRACE HTTP methods:
 157  *     - New interceptor direct_response() added in chat().
 158  *     - sed() moved to earlier in the process, so that the
 159  *       Host: header is evaluated before actions and forwarding
 160  *       are decided on.
 161  *
 162  *    Revision 1.92  2002/05/08 16:00:46  oes
 163  *    Chat's buffer handling:
 164  *     - Fixed bug with unchecked out-of-mem conditions
 165  *       while reading client request & server headers
 166  *     - No longer predict if the buffer limit will be exceeded
 167  *       in the next read -- check add_to_iob's new
 168  *       return code. If buffer couldn't be extended
 169  *       (policy or out-of-mem) while
 170  *       - reading from client: abort
 171  *       - reading server headers: send error page
 172  *       - buffering server body for filter: flush,
 173  *         and if that fails: send error page
 174  *
 175  *    Revision 1.91  2002/04/08 20:35:58  swa
 176  *    fixed JB spelling
 177  *
 178  *    Revision 1.90  2002/04/02 14:57:28  oes
 179  *    Made sending wafers independent of FEATURE_COOKIE_JAR
 180  *
 181  *    Revision 1.89  2002/03/31 17:18:59  jongfoster
 182  *    Win32 only: Enabling STRICT to fix a VC++ compile warning.
 183  *
 184  *    Revision 1.88  2002/03/27 14:32:43  david__schmidt
 185  *    More compiler warning message maintenance
 186  *
 187  *    Revision 1.87  2002/03/26 22:29:54  swa
 188  *    we have a new homepage!
 189  *
 190  *    Revision 1.86  2002/03/25 17:04:55  david__schmidt
 191  *    Workaround for closing the jarfile before load_config() comes around again
 192  *
 193  *    Revision 1.85  2002/03/24 15:23:33  jongfoster
 194  *    Name changes
 195  *
 196  *    Revision 1.84  2002/03/24 13:25:43  swa
 197  *    name change related issues
 198  *
 199  *    Revision 1.83  2002/03/16 23:54:06  jongfoster
 200  *    Adding graceful termination feature, to help look for memory leaks.
 201  *    If you enable this (which, by design, has to be done by hand
 202  *    editing config.h) and then go to http://i.j.b/die, then the program
 203  *    will exit cleanly after the *next* request.  It should free all the
 204  *    memory that was used.
 205  *
 206  *    Revision 1.82  2002/03/13 00:27:05  jongfoster
 207  *    Killing warnings
 208  *
 209  *    Revision 1.81  2002/03/12 01:42:50  oes
 210  *    Introduced modular filters
 211  *
 212  *    Revision 1.80  2002/03/11 22:07:05  david__schmidt
 213  *    OS/2 port maintenance:
 214  *    - Fixed EMX build - it had decayed a little
 215  *    - Fixed inexplicable crash during FD_ZERO - must be due to a bad macro.
 216  *      substituted a memset for now.
 217  *
 218  *    Revision 1.79  2002/03/09 20:03:52  jongfoster
 219  *    - Making various functions return int rather than size_t.
 220  *      (Undoing a recent change).  Since size_t is unsigned on
 221  *      Windows, functions like read_socket that return -1 on
 222  *      error cannot return a size_t.
 223  *
 224  *      THIS WAS A MAJOR BUG - it caused frequent, unpredictable
 225  *      crashes, and also frequently caused JB to jump to 100%
 226  *      CPU and stay there.  (Because it thought it had just
 227  *      read ((unsigned)-1) == 4Gb of data...)
 228  *
 229  *    - The signature of write_socket has changed, it now simply
 230  *      returns success=0/failure=nonzero.
 231  *
 232  *    - Trying to get rid of a few warnings --with-debug on
 233  *      Windows, I've introduced a new type "jb_socket".  This is
 234  *      used for the socket file descriptors.  On Windows, this
 235  *      is SOCKET (a typedef for unsigned).  Everywhere else, it's
 236  *      an int.  The error value can't be -1 any more, so it's
 237  *      now JB_INVALID_SOCKET (which is -1 on UNIX, and in
 238  *      Windows it maps to the #define INVALID_SOCKET.)
 239  *
 240  *    - The signature of bind_port has changed.
 241  *
 242  *    Revision 1.78  2002/03/08 21:35:04  oes
 243  *    Added optional group supplement to --user option. Will now use default group of user if no group given
 244  *
 245  *    Revision 1.77  2002/03/07 03:52:06  oes
 246  *     - Fixed compiler warnings etc
 247  *     - Improved handling of failed DNS lookups
 248  *
 249  *    Revision 1.76  2002/03/06 22:54:35  jongfoster
 250  *    Automated function-comment nitpicking.
 251  *
 252  *    Revision 1.75  2002/03/06 10:02:19  oes
 253  *    Fixed stupid bug when --user was not given
 254  *
 255  *    Revision 1.74  2002/03/06 00:49:31  jongfoster
 256  *    Fixing warning on Windows
 257  *    Making #ifdefs that refer to the same variable consistently
 258  *    use #ifdef unix rather than mixing #ifdef unix & #ifndef OS2
 259  *
 260  *    Revision 1.73  2002/03/05 23:57:30  hal9
 261  *    Stray character 's' on line 1618 was breaking build.
 262  *
 263  *    Revision 1.72  2002/03/05 21:33:45  david__schmidt
 264  *    - Re-enable OS/2 building after new parms were added
 265  *    - Fix false out of memory report when resolving CGI templates when no IP
 266  *      address is available of failed attempt (a la no such domain)
 267  *
 268  *    Revision 1.71  2002/03/05 18:13:56  oes
 269  *    Added --user option
 270  *
 271  *    Revision 1.70  2002/03/05 04:52:42  oes
 272  *    Deleted non-errlog debugging code
 273  *
 274  *    Revision 1.69  2002/03/04 23:50:00  jongfoster
 275  *    Splitting off bind_port() call into bind_port_helper(), with
 276  *    improved logging.
 277  *
 278  *    Revision 1.68  2002/03/04 20:17:32  oes
 279  *    Fixed usage info
 280  *
 281  *    Revision 1.67  2002/03/04 18:18:57  oes
 282  *    - Removed _DEBUG mode
 283  *    - Cleand up cmdline parsing
 284  *    - Introduced --no-daemon, --pidfile options
 285  *    - Cleaned up signal handling:
 286  *      - Terminate cleanly on INT, TERM and ABRT
 287  *      - Schedule logfile for re-opening on HUP
 288  *      - Ignore CHLD and PIPE
 289  *      - Leave the rest with their default handlers
 290  *      - Uniform handler registration
 291  *    - Added usage() function
 292  *    - Played styleguide police
 293  *
 294  *    Revision 1.66  2002/03/03 15:06:55  oes
 295  *    Re-enabled automatic config reloading
 296  *
 297  *    Revision 1.65  2002/03/03 14:49:11  oes
 298  *    Fixed CLF logging: Now uses client's original HTTP request
 299  *
 300  *    Revision 1.64  2002/03/03 09:18:03  joergs
 301  *    Made jumbjuster work on AmigaOS again.
 302  *
 303  *    Revision 1.63  2002/03/02 04:14:50  david__schmidt
 304  *    Clean up a little CRLF unpleasantness that suddenly appeared
 305  *
 306  *    Revision 1.62  2002/02/20 23:17:23  jongfoster
 307  *    Detecting some out-of memory conditions and exiting with a log message.
 308  *
 309  *    Revision 1.61  2002/01/17 21:01:52  jongfoster
 310  *    Moving all our URL and URL pattern parsing code to urlmatch.c.
 311  *
 312  *    Revision 1.60  2001/12/30 14:07:32  steudten
 313  *    - Add signal handling (unix)
 314  *    - Add SIGHUP handler (unix)
 315  *    - Add creation of pidfile (unix)
 316  *    - Add action 'top' in rc file (RH)
 317  *    - Add entry 'SIGNALS' to manpage
 318  *    - Add exit message to logfile (unix)
 319  *
 320  *    Revision 1.59  2001/12/13 14:07:18  oes
 321  *    Fixed Bug: 503 error page now sent OK
 322  *
 323  *    Revision 1.58  2001/11/30 23:37:24  jongfoster
 324  *    Renaming the Win32 config file to config.txt - this is almost the
 325  *    same as the corresponding UNIX name "config"
 326  *
 327  *    Revision 1.57  2001/11/16 00:47:43  jongfoster
 328  *    Changing the tty-disconnection code to use setsid().
 329  *
 330  *    Revision 1.56  2001/11/13 20:20:54  jongfoster
 331  *    Tabs->spaces, fixing a bug with missing {} around an if()
 332  *
 333  *    Revision 1.55  2001/11/13 20:14:53  jongfoster
 334  *    Patch for FreeBSD setpgrp() as suggested by Alexander Lazic
 335  *
 336  *    Revision 1.54  2001/11/07 00:03:14  steudten
 337  *    Give reliable return value if an error
 338  *    occurs not just 0 with new daemon mode.
 339  *
 340  *    Revision 1.53  2001/11/05 21:41:43  steudten
 341  *    Add changes to be a real daemon just for unix os.
 342  *    (change cwd to /, detach from controlling tty, set
 343  *    process group and session leader to the own process.
 344  *    Add DBG() Macro.
 345  *    Add some fatal-error log message for failed malloc().
 346  *    Add '-d' if compiled with 'configure --with-debug' to
 347  *    enable debug output.
 348  *
 349  *    Revision 1.52  2001/10/26 20:11:20  jongfoster
 350  *    Fixing type mismatch
 351  *
 352  *    Revision 1.51  2001/10/26 17:38:28  oes
 353  *    Cosmetics
 354  *
 355  *    Revision 1.50  2001/10/25 03:40:48  david__schmidt
 356  *    Change in porting tactics: OS/2's EMX porting layer doesn't allow multiple
 357  *    threads to call select() simultaneously.  So, it's time to do a real, live,
 358  *    native OS/2 port.  See defines for __EMX__ (the porting layer) vs. __OS2__
 359  *    (native). Both versions will work, but using __OS2__ offers multi-threading.
 360  *
 361  *    Revision 1.49  2001/10/23 21:41:35  jongfoster
 362  *    Added call to initialize the (statically-allocated of course)
 363  *    "out of memory" CGI response.
 364  *
 365  *    Revision 1.48  2001/10/10 19:56:46  jongfoster
 366  *    Moving some code that wasn't cookie-related out of an #ifdef
 367  *    FEATURE_COOKIE_JAR
 368  *
 369  *    Revision 1.47  2001/10/10 16:44:36  oes
 370  *    Added CONNECT destination port limitation check
 371  *
 372  *    Revision 1.46  2001/10/08 15:17:41  oes
 373  *    Re-enabled SSL forwarding
 374  *
 375  *    Revision 1.45  2001/10/07 15:42:11  oes
 376  *    Replaced 6 boolean members of csp with one bitmap (csp->flags)
 377  *
 378  *    Moved downgrading of the HTTP version from parse_http_request to
 379  *      chat(), since we can't decide if it is necessary before we have
 380  *      determined the actions for the URL. The HTTP command is now
 381  *      *always* re-built so the repairs need no longer be special-cased.
 382  *
 383  *    filter_popups now gets a csp pointer so it can raise the new
 384  *      CSP_FLAG_MODIFIED flag.
 385  *
 386  *    Bugfix
 387  *
 388  *    Added configurable size limit for the IOB. If the IOB grows so
 389  *      large that the next read would exceed the limit, the header
 390  *      is generated, and the header & unfiltered buffer are flushed
 391  *      to the client. Chat then continues in non-buffering,
 392  *      non-filtering body mode.
 393  *
 394  *    Revision 1.44  2001/10/02 18:13:57  oes
 395  *    Ooops
 396  *
 397  *    Revision 1.43  2001/10/02 15:32:13  oes
 398  *    Moved generation of hdr
 399  *
 400  *    Revision 1.42  2001/09/21 23:02:02  david__schmidt
 401  *    Cleaning up 2 compiler warnings on OS/2.
 402  *
 403  *    Revision 1.41  2001/09/16 17:05:14  jongfoster
 404  *    Removing unused #include showarg.h
 405  *
 406  *    Revision 1.40  2001/09/16 15:41:45  jongfoster
 407  *    Fixing signed/unsigned comparison warning.
 408  *
 409  *    Revision 1.39  2001/09/16 13:21:27  jongfoster
 410  *    Changes to use new list functions.
 411  *
 412  *    Revision 1.38  2001/09/16 13:01:46  jongfoster
 413  *    Removing redundant function call that zeroed zalloc()'d memory.
 414  *
 415  *    Revision 1.37  2001/09/10 11:12:24  oes
 416  *    Deleted unused variable
 417  *
 418  *    Revision 1.36  2001/09/10 10:56:15  oes
 419  *    Silenced compiler warnings
 420  *
 421  *    Revision 1.35  2001/07/31 14:44:22  oes
 422  *    Deleted unused size parameter from filter_popups()
 423  *
 424  *    Revision 1.34  2001/07/30 22:08:36  jongfoster
 425  *    Tidying up #defines:
 426  *    - All feature #defines are now of the form FEATURE_xxx
 427  *    - Permanently turned off WIN_GUI_EDIT
 428  *    - Permanently turned on WEBDAV and SPLIT_PROXY_ARGS
 429  *
 430  *    Revision 1.33  2001/07/29 19:32:00  jongfoster
 431  *    Renaming _main() [mingw32 only] to real_main(), for ANSI compliance.
 432  *
 433  *    Revision 1.32  2001/07/29 18:47:05  jongfoster
 434  *    Adding missing #include "loadcfg.h"
 435  *
 436  *    Revision 1.31  2001/07/29 12:17:48  oes
 437  *    Applied pthread fix by Paul Lieverse
 438  *
 439  *    Revision 1.30  2001/07/25 22:57:13  jongfoster
 440  *    __BEOS__ no longer overrides FEATURE_PTHREAD.
 441  *    This is because FEATURE_PTHREAD will soon be widely used, so I
 442  *    want to keep it simple.
 443  *
 444  *    Revision 1.29  2001/07/24 12:47:06  oes
 445  *    Applied BeOS support update by Eugenia
 446  *
 447  *    Revision 1.28  2001/07/23 13:26:12  oes
 448  *    Fixed bug in popup-killing for the first read that caused binary garbage to be sent between headers and body
 449  *
 450  *    Revision 1.27  2001/07/19 19:09:47  haroon
 451  *    - Added code to take care of the situation where while processing the first
 452  *      server response (which includes the server header), after finding the end
 453  *      of the headers we were not looking past the end of the headers for
 454  *      content modification. I enabled it for filter_popups.
 455  *      Someone else should look to see if other similar operations should be
 456  *      done to the discarded portion of the buffer.
 457  *
 458  *      Note 2001/07/20: No, the other content modification mechanisms will process
 459  *                       the whole iob later anyway. --oes
 460  *
 461  *    Revision 1.26  2001/07/18 12:31:36  oes
 462  *    cosmetics
 463  *
 464  *    Revision 1.25  2001/07/15 19:43:49  jongfoster
 465  *    Supports POSIX threads.
 466  *    Also removed some unused #includes.
 467  *
 468  *    Revision 1.24  2001/07/13 14:00:40  oes
 469  *     - Generic content modification scheme:
 470  *       Each feature has its own applicability flag that is set
 471  *       from csp->action->flags.
 472  *       Replaced the "filtering" int flag , by a function pointer
 473  *       "content_filter" to the function that will do the content
 474  *       modification. If it is != NULL, the document will be buffered
 475  *       and processed through *content_filter, which must set
 476  *       csp->content_length and return a modified copy of the body
 477  *       or return NULL (on failiure).
 478  *     - Changed csp->is_text to the more generic bitmap csp->content_type
 479  *       which can currently take the valued CT_TEXT or CT_GIF
 480  *     - Reformatting etc
 481  *     - Removed all #ifdef PCRS
 482  *
 483  *    Revision 1.23  2001/07/02 02:28:25  iwanttokeepanon
 484  *    Added "#ifdef ACL_FILES" conditional compilation to line 1291 to exclude
 485  *    the `block_acl' call.  This prevents a compilation error when the user
 486  *    does not wish to use the "ACL" feature.
 487  *
 488  *    Revision 1.22  2001/06/29 21:45:41  oes
 489  *    Indentation, CRLF->LF, Tab-> Space
 490  *
 491  *    Revision 1.21  2001/06/29 13:29:36  oes
 492  *    - Cleaned up, improved comments
 493  *    - Unified all possible interceptors (CGI,
 494  *      block, trust, fast_redirect) in one
 495  *      place, with one (CGI) answer generation
 496  *      mechansim. Much clearer now.
 497  *    - Removed the GIF image generation, which
 498  *      is now done in filters.c:block_url()
 499  *    - Made error conditions like domain lookup
 500  *      failiure or (various) problems while talking
 501  *      to the server use cgi.c:error_response()
 502  *      instead of generating HTML/HTTP in chat() (yuck!)
 503  *    - Removed logentry from cancelled commit
 504  *
 505  *    Revision 1.20  2001/06/09 10:55:28  jongfoster
 506  *    Changing BUFSIZ ==> BUFFER_SIZE
 507  *
 508  *    Revision 1.19  2001/06/07 23:12:52  jongfoster
 509  *    Replacing function pointer in struct gateway with a directly
 510  *    called function forwarded_connect().
 511  *    Replacing struct gateway with struct forward_spec
 512  *
 513  *    Revision 1.18  2001/06/03 19:12:16  oes
 514  *    introduced new cgi handling
 515  *
 516  *    Revision 1.17  2001/06/01 20:07:23  jongfoster
 517  *    Now uses action +image-blocker{} rather than config->tinygif
 518  *
 519  *    Revision 1.16  2001/06/01 18:49:17  jongfoster
 520  *    Replaced "list_share" with "list" - the tiny memory gain was not
 521  *    worth the extra complexity.
 522  *
 523  *    Revision 1.15  2001/05/31 21:24:47  jongfoster
 524  *    Changed "permission" to "action" throughout.
 525  *    Removed DEFAULT_USER_AGENT - it must now be specified manually.
 526  *    Moved vanilla wafer check into chat(), since we must now
 527  *    decide whether or not to add it based on the URL.
 528  *
 529  *    Revision 1.14  2001/05/29 20:14:01  joergs
 530  *    AmigaOS bugfix: PCRS needs a lot of stack, stacksize for child threads
 531  *    increased.
 532  *
 533  *    Revision 1.13  2001/05/29 09:50:24  jongfoster
 534  *    Unified blocklist/imagelist/permissionslist.
 535  *    File format is still under discussion, but the internal changes
 536  *    are (mostly) done.
 537  *
 538  *    Also modified interceptor behaviour:
 539  *    - We now intercept all URLs beginning with one of the following
 540  *      prefixes (and *only* these prefixes):
 541  *        * http://i.j.b/
 542  *        * http://ijbswa.sf.net/config/
 543  *        * http://ijbswa.sourceforge.net/config/
 544  *    - New interceptors "home page" - go to http://i.j.b/ to see it.
 545  *    - Internal changes so that intercepted and fast redirect pages
 546  *      are not replaced with an image.
 547  *    - Interceptors now have the option to send a binary page direct
 548  *      to the client. (i.e. ijb-send-banner uses this)
 549  *    - Implemented show-url-info interceptor.  (Which is why I needed
 550  *      the above interceptors changes - a typical URL is
 551  *      "http://i.j.b/show-url-info?url=www.somesite.com/banner.gif".
 552  *      The previous mechanism would not have intercepted that, and
 553  *      if it had been intercepted then it then it would have replaced
 554  *      it with an image.)
 555  *
 556  *    Revision 1.12  2001/05/27 22:17:04  oes
 557  *
 558  *    - re_process_buffer no longer writes the modified buffer
 559  *      to the client, which was very ugly. It now returns the
 560  *      buffer, which it is then written by chat.
 561  *
 562  *    - content_length now adjusts the Content-Length: header
 563  *      for modified documents rather than crunch()ing it.
 564  *      (Length info in csp->content_length, which is 0 for
 565  *      unmodified documents)
 566  *
 567  *    - For this to work, sed() is called twice when filtering.
 568  *
 569  *    Revision 1.11  2001/05/26 17:27:53  jongfoster
 570  *    Added support for CLF and fixed LOG_LEVEL_LOG.
 571  *    Also did CRLF->LF fix of my previous patch.
 572  *
 573  *    Revision 1.10  2001/05/26 15:26:15  jongfoster
 574  *    ACL feature now provides more security by immediately dropping
 575  *    connections from untrusted hosts.
 576  *
 577  *    Revision 1.9  2001/05/26 00:28:36  jongfoster
 578  *    Automatic reloading of config file.
 579  *    Removed obsolete SIGHUP support (Unix) and Reload menu option (Win32).
 580  *    Most of the global variables have been moved to a new
 581  *    struct configuration_spec, accessed through csp->config->globalname
 582  *    Most of the globals remaining are used by the Win32 GUI.
 583  *
 584  *    Revision 1.8  2001/05/25 22:43:18  jongfoster
 585  *    Fixing minor memory leak and buffer overflow.
 586  *
 587  *    Revision 1.7  2001/05/25 22:34:30  jongfoster
 588  *    Hard tabs->Spaces
 589  *
 590  *    Revision 1.6  2001/05/23 00:13:58  joergs
 591  *    AmigaOS support fixed.
 592  *
 593  *    Revision 1.5  2001/05/22 18:46:04  oes
 594  *
 595  *    - Enabled filtering banners by size rather than URL
 596  *      by adding patterns that replace all standard banner
 597  *      sizes with the "Junkbuster" gif to the re_filterfile
 598  *
 599  *    - Enabled filtering WebBugs by providing a pattern
 600  *      which kills all 1x1 images
 601  *
 602  *    - Added support for PCRE_UNGREEDY behaviour to pcrs,
 603  *      which is selected by the (nonstandard and therefore
 604  *      capital) letter 'U' in the option string.
 605  *      It causes the quantifiers to be ungreedy by default.
 606  *      Appending a ? turns back to greedy (!).
 607  *
 608  *    - Added a new interceptor ijb-send-banner, which
 609  *      sends back the "Junkbuster" gif. Without imagelist or
 610  *      MSIE detection support, or if tinygif = 1, or the
 611  *      URL isn't recognized as an imageurl, a lame HTML
 612  *      explanation is sent instead.
 613  *
 614  *    - Added new feature, which permits blocking remote
 615  *      script redirects and firing back a local redirect
 616  *      to the browser.
 617  *      The feature is conditionally compiled, i.e. it
 618  *      can be disabled with --disable-fast-redirects,
 619  *      plus it must be activated by a "fast-redirects"
 620  *      line in the config file, has its own log level
 621  *      and of course wants to be displayed by show-proxy-args
 622  *      Note: Boy, all the #ifdefs in 1001 locations and
 623  *      all the fumbling with configure.in and acconfig.h
 624  *      were *way* more work than the feature itself :-(
 625  *
 626  *    - Because a generic redirect template was needed for
 627  *      this, tinygif = 3 now uses the same.
 628  *
 629  *    - Moved GIFs, and other static HTTP response templates
 630  *      to project.h
 631  *
 632  *    - Some minor fixes
 633  *
 634  *    - Removed some >400 CRs again (Jon, you really worked
 635  *      a lot! ;-)
 636  *
 637  *    Revision 1.4  2001/05/21 19:34:01  jongfoster
 638  *    Made failure to bind() a fatal error.
 639  *
 640  *    Revision 1.3  2001/05/20 01:21:20  jongfoster
 641  *    Version 2.9.4 checkin.
 642  *    - Merged popupfile and cookiefile, and added control over PCRS
 643  *      filtering, in new "permissionsfile".
 644  *    - Implemented LOG_LEVEL_FATAL, so that if there is a configuration
 645  *      file error you now get a message box (in the Win32 GUI) rather
 646  *      than the program exiting with no explanation.
 647  *    - Made killpopup use the PCRS MIME-type checking and HTTP-header
 648  *      skipping.
 649  *    - Removed tabs from "config"
 650  *    - Moved duplicated url parsing code in "loaders.c" to a new funcition.
 651  *    - Bumped up version number.
 652  *
 653  *    Revision 1.2  2001/05/17 22:34:44  oes
 654  *     - Added hint on GIF char array generation to jcc.c
 655  *     - Cleaned CRLF's from the sources and related files
 656  *     - Repaired logging for REF and FRC
 657  *
 658  *    Revision 1.1.1.1  2001/05/15 13:58:56  oes
 659  *    Initial import of version 2.9.3 source tree
 660  *
 661  *
 662  *********************************************************************/
 663 \f
 664
 665 #include "config.h"
 666
 667 #include <stdio.h>
 668 #include <sys/types.h>
 669 #include <stdlib.h>
 670 #include <string.h>
 671 #include <signal.h>
 672 #include <fcntl.h>
 673 #include <errno.h>
 674
 675 #ifdef FEATURE_PTHREAD
 676 #include <pthread.h>
 677 #endif /* def FEATURE_PTHREAD */
 678
 679 #ifdef _WIN32
 680 # ifndef FEATURE_PTHREAD
 681 #  ifndef STRICT
 682 #   define STRICT
 683 #  endif
 684 #  include <windows.h>
 685 #  include <process.h>
 686 # endif /* ndef FEATURE_PTHREAD */
 687
 688 # include "win32.h"
 689 # ifndef _WIN_CONSOLE
 690 #  include "w32log.h"
 691 # endif /* ndef _WIN_CONSOLE */
 692 # include "w32svrapi.h"
 693
 694 #else /* ifndef _WIN32 */
 695
 696 # if !defined (__OS2__)
 697 # include <unistd.h>
 698 # include <sys/wait.h>
 699 # endif /* ndef __OS2__ */
 700 # include <sys/time.h>
 701 # include <sys/stat.h>
 702 # include <sys/ioctl.h>
 703
 704 #ifdef sun
 705 #include <sys/termios.h>
 706 #endif /* sun */
 707
 708 #ifdef unix
 709 #include <pwd.h>
 710 #include <grp.h>
 711 #endif
 712
 713 # include <signal.h>
 714
 715 # ifdef __BEOS__
 716 #  include <socket.h>  /* BeOS has select() for sockets only. */
 717 #  include <OS.h>      /* declarations for threads and stuff. */
 718 # endif
 719
 720 # if defined(__EMX__) || defined(__OS2__)
 721 #  include <sys/select.h>  /* OS/2/EMX needs a little help with select */
 722 # endif
 723 # ifdef __OS2__
 724 #define INCL_DOS
 725 # include <os2.h>
 726 #define bzero(B,N) memset(B,0x00,n)
 727 # endif
 728
 729 # ifndef FD_ZERO
 730 #  include <select.h>
 731 # endif
 732
 733 #endif
 734
 735 #include "project.h"
 736 #include "list.h"
 737 #include "jcc.h"
 738 #include "filters.h"
 739 #include "loaders.h"
 740 #include "parsers.h"
 741 #include "killpopup.h"
 742 #include "miscutil.h"
 743 #include "errlog.h"
 744 #include "jbsockets.h"
 745 #include "gateway.h"
 746 #include "actions.h"
 747 #include "cgi.h"
 748 #include "loadcfg.h"
 749 #include "urlmatch.h"
 750
 751 const char jcc_h_rcs[] = JCC_H_VERSION;
 752 const char project_h_rcs[] = PROJECT_H_VERSION;
 753
 754 int no_daemon = 0;
 755 struct client_state  clients[1];
 756 struct file_list     files[1];
 757
 758 #ifdef FEATURE_STATISTICS
 759 int urls_read     = 0;     /* total nr of urls read inc rejected */
 760 int urls_rejected = 0;     /* total nr of urls rejected */
 761 #endif /* def FEATURE_STATISTICS */
 762
 763 #ifdef FEATURE_GRACEFUL_TERMINATION
 764 int g_terminate = 0;
 765 #endif
 766
 767 static void listen_loop(void);
 768 static void chat(struct client_state *csp);
 769 #ifdef AMIGA
 770 void serve(struct client_state *csp);
 771 #else /* ifndef AMIGA */
 772 static void serve(struct client_state *csp);
 773 #endif /* def AMIGA */
 774
 775 #ifdef __BEOS__
 776 static int32 server_thread(void *data);
 777 #endif /* def __BEOS__ */
 778
 779 #ifdef _WIN32
 780 #define sleep(N)  Sleep(((N) * 1000))
 781 #endif
 782
 783 #ifdef __OS2__
 784 #define sleep(N)  DosSleep(((N) * 100))
 785 #endif
 786
 787 #if defined(OSX_DARWIN) || defined(__OpenBSD__)
 788 #ifdef OSX_DARWIN
 789 /*
 790  * Hit OSX over the head with a hammer.  Protect all *_r functions.
 791  */
 792 pthread_mutex_t gmtime_mutex;
 793 pthread_mutex_t localtime_mutex;
 794 #endif /* def OSX_DARWIN */
 795 /*
 796  * Protect only the resolve functions for OpenBSD.
 797  */
 798 pthread_mutex_t gethostbyaddr_mutex;
 799 pthread_mutex_t gethostbyname_mutex;
 800 #endif /* defined(OSX_DARWIN) || defined(__OpenBSD__) */
 801
 802 #ifdef FEATURE_PTHREAD
 803 pthread_mutex_t log_mutex;
 804 pthread_mutex_t log_init_mutex;
 805 #endif /* FEATURE_PTHREAD */
 806
 807 #if defined(unix) || defined(__EMX__)
 808 const char *basedir = NULL;
 809 const char *pidfile = NULL;
 810 int received_hup_signal = 0;
 811 #endif /* defined unix */
 812
 813 /* The vanilla wafer. */
 814 static const char VANILLA_WAFER[] =
 815    "NOTICE=TO_WHOM_IT_MAY_CONCERN_"
 816    "Do_not_send_me_any_copyrighted_information_other_than_the_"
 817    "document_that_I_am_requesting_or_any_of_its_necessary_components._"
 818    "In_particular_do_not_send_me_any_cookies_that_"
 819    "are_subject_to_a_claim_of_copyright_by_anybody._"
 820    "Take_notice_that_I_refuse_to_be_bound_by_any_license_condition_"
 821    "(copyright_or_otherwise)_applying_to_any_cookie._";
 822
 823
 824 #if !defined(_WIN32) && !defined(__OS2__) && !defined(AMIGA)
 825 /*********************************************************************
 826  *
 827  * Function    :  sig_handler
 828  *
 829  * Description :  Signal handler for different signals.
 830  *                Exit gracefully on ABRT, TERM and  INT
 831  *                or set a flag that will cause the errlog
 832  *                to be reopened by the main thread on HUP.
 833  *
 834  * Parameters  :
 835  *          1  :  the_signal = the signal cause this function to call
 836  *
 837  * Returns     :  -
 838  *
 839  *********************************************************************/
 840 static void sig_handler(int the_signal)
 841 {
 842    switch(the_signal)
 843    {
 844       case SIGABRT:
 845       case SIGTERM:
 846       case SIGINT:
 847          log_error(LOG_LEVEL_INFO, "exiting by signal %d .. bye", the_signal);
 848 #if defined(unix)
 849          unlink(pidfile);
 850 #endif /* unix */
 851          exit(the_signal);
 852          break;
 853
 854       case SIGHUP:
 855          received_hup_signal = 1;
 856          break;
 857
 858       default:
 859          /*
 860           * We shouldn't be here, unless we catch signals
 861           * in main() that we can't handle here!
 862           */
 863          log_error(LOG_LEVEL_FATAL, "sig_handler: exiting on unexpected signal %d", the_signal);
 864    }
 865    return;
 866
 867 }
 868 #endif
 869
 870
 871 /*********************************************************************
 872  *
 873  * Function    :  chat
 874  *
 875  * Description :  Once a connection to the client has been accepted,
 876  *                this function is called (via serve()) to handle the
 877  *                main business of the communication.  When this
 878  *                function returns, the caller must close the client
 879  *                socket handle.
 880  *
 881  * Parameters  :
 882  *          1  :  csp = Current client state (buffers, headers, etc...)
 883  *
 884  * Returns     :  On success, the number of bytes written are returned (zero
 885  *                indicates nothing was written).  On error, -1 is returned,
 886  *                and errno is set appropriately.  If count is zero and the
 887  *                file descriptor refers to a regular file, 0 will be
 888  *                returned without causing any other effect.  For a special
 889  *                file, the results are not portable.
 890  *
 891  *********************************************************************/
 892 static void chat(struct client_state *csp)
 893 {
 894 /*
 895  * This next lines are a little ugly, but they simplifies the if statements
 896  * below.  Basically if TOGGLE, then we want the if to test if the
 897  * CSP_FLAG_TOGGLED_ON flag ist set, else we don't.  And if FEATURE_FORCE_LOAD,
 898  * then we want the if to test for CSP_FLAG_FORCED , else we don't
 899  */
 900 #ifdef FEATURE_TOGGLE
 901 #   define IS_TOGGLED_ON_AND (csp->flags & CSP_FLAG_TOGGLED_ON) &&
 902 #else /* ifndef FEATURE_TOGGLE */
 903 #   define IS_TOGGLED_ON_AND
 904 #endif /* ndef FEATURE_TOGGLE */
 905 #ifdef FEATURE_FORCE_LOAD
 906 #   define IS_NOT_FORCED_AND !(csp->flags & CSP_FLAG_FORCED) &&
 907 #else /* ifndef FEATURE_FORCE_LOAD */
 908 #   define IS_NOT_FORCED_AND
 909 #endif /* def FEATURE_FORCE_LOAD */
 910
 911 #define IS_ENABLED_AND   IS_TOGGLED_ON_AND IS_NOT_FORCED_AND
 912
 913    char buf[BUFFER_SIZE];
 914    char *hdr;
 915    char *p;
 916    char *req;
 917    fd_set rfds;
 918    int n;
 919    jb_socket maxfd;
 920    int server_body;
 921    int ms_iis5_hack = 0;
 922    int byte_count = 0;
 923    unsigned int forwarded_connect_retries = 0;
 924    unsigned int max_forwarded_connect_retries = csp->config->forwarded_connect_retries;
 925    const struct forward_spec * fwd;
 926    struct http_request *http;
 927    int len; /* for buffer sizes */
 928 #ifdef FEATURE_KILL_POPUPS
 929    int block_popups;         /* bool, 1==will block popups */
 930    int block_popups_now = 0; /* bool, 1==currently blocking popups */
 931 #endif /* def FEATURE_KILL_POPUPS */
 932
 933    int pcrs_filter;        /* bool, 1==will filter through pcrs */
 934    int gif_deanimate;      /* bool, 1==will deanimate gifs */
 935    int jpeg_inspect;       /* bool, 1==will inspect jpegs */
 936
 937    /* Function that does the content filtering for the current request */
 938    char *(*content_filter)() = NULL;
 939
 940    /* Skeleton for HTTP response, if we should intercept the request */
 941    struct http_response *rsp;
 942
 943    http = csp->http;
 944
 945    /*
 946     * Read the client's request.  Note that since we're not using select() we
 947     * could get blocked here if a client connected, then didn't say anything!
 948     */
 949
 950    for (;;)
 951    {
 952       len = read_socket(csp->cfd, buf, sizeof(buf));
 953
 954       if (len <= 0) break;      /* error! */
 955
 956       /*
 957        * If there is no memory left for buffering the
 958        * request, there is nothing we can do but hang up
 959        */
 960       if (add_to_iob(csp, buf, len))
 961       {
 962          return;
 963       }
 964
 965       req = get_header(csp);
 966
 967       if (req == NULL)
 968       {
 969          break;    /* no HTTP request! */
 970       }
 971
 972       if (*req == '\0')
 973       {
 974          continue;   /* more to come! */
 975       }
 976
 977 #ifdef FEATURE_FORCE_LOAD
 978       /* If this request contains the FORCE_PREFIX,
 979        * better get rid of it now and set the force flag --oes
 980        */
 981
 982       if (strstr(req, FORCE_PREFIX))
 983       {
 984          strclean(req, FORCE_PREFIX);
 985          log_error(LOG_LEVEL_FORCE, "Enforcing request \"%s\".\n", req);
 986          csp->flags |= CSP_FLAG_FORCED;
 987       }
 988
 989 #endif /* def FEATURE_FORCE_LOAD */
 990
 991       parse_http_request(req, http, csp);
 992       freez(req);
 993       break;
 994    }
 995
 996    if (http->cmd == NULL)
 997    {
 998       strcpy(buf, CHEADER);
 999       write_socket(csp->cfd, buf, strlen(buf));
1000
1001       log_error(LOG_LEVEL_CLF, "%s - - [%T] \" \" 400 0", csp->ip_addr_str);
1002
1003       free_http_request(http);
1004       return;
1005    }
1006
1007    if (!strncmpic(http->cmd, "GET ftp://", 10))
1008    {
1009       strcpy(buf, FTP_RESPONSE);
1010       write_socket(csp->cfd, buf, strlen(buf));
1011
1012       log_error(LOG_LEVEL_ERROR, "%s tried to use Privoxy as FTP proxy: %s",
1013          csp->ip_addr_str, http->cmd);
1014
1015       free_http_request(http);
1016       return;
1017    }
1018
1019    /* decide how to route the HTTP request */
1020
1021    if ((fwd = forward_url(http, csp)) == NULL)
1022    {
1023       log_error(LOG_LEVEL_FATAL, "gateway spec is NULL!?!?  This can't happen!");
1024       /* Never get here - LOG_LEVEL_FATAL causes program exit */
1025    }
1026
1027    /* build the http request to send to the server
1028     * we have to do one of the following:
1029     *
1030     * create = use the original HTTP request to create a new
1031     *          HTTP request that has either the path component
1032     *          without the http://domainspec (w/path) or the
1033     *          full orininal URL (w/url)
1034     *          Note that the path and/or the HTTP version may
1035     *          have been altered by now.
1036     *
1037     * connect = Open a socket to the host:port of the server
1038     *           and short-circuit server and client socket.
1039     *
1040     * pass =  Pass the request unchanged if forwarding a CONNECT
1041     *         request to a parent proxy. Note that we'll be sending
1042     *         the CFAIL message ourselves if connecting to the parent
1043     *         fails, but we won't send a CSUCCEED message if it works,
1044     *         since that would result in a double message (ours and the
1045     *         parent's). After sending the request to the parent, we simply
1046     *         tunnel.
1047     *
1048     * here's the matrix:
1049     *                        SSL
1050     *                    0        1
1051     *                +--------+--------+
1052     *                |        |        |
1053     *             0  | create | connect|
1054     *                | w/path |        |
1055     *  Forwarding    +--------+--------+
1056     *                |        |        |
1057     *             1  | create | pass   |
1058     *                | w/url  |        |
1059     *                +--------+--------+
1060     *
1061     */
1062
1063    /*
1064     * Determine the actions for this URL
1065     */
1066 #ifdef FEATURE_TOGGLE
1067    if (!(csp->flags & CSP_FLAG_TOGGLED_ON))
1068    {
1069       /* Most compatible set of actions (i.e. none) */
1070       init_current_action(csp->action);
1071    }
1072    else
1073 #endif /* ndef FEATURE_TOGGLE */
1074    {
1075       url_actions(http, csp);
1076    }
1077
1078
1079    /*
1080     * Check if a CONNECT request is allowable:
1081     * In the absence of a +limit-connect action, allow only port 443.
1082     * If there is an action, allow whatever matches the specificaton.
1083     */
1084    if(http->ssl)
1085    {
1086       if(  ( !(csp->action->flags & ACTION_LIMIT_CONNECT) && csp->http->port != 443)
1087            || (csp->action->flags & ACTION_LIMIT_CONNECT
1088               && !match_portlist(csp->action->string[ACTION_STRING_LIMIT_CONNECT], csp->http->port)) )
1089       {
1090          if (csp->action->flags & ACTION_TREAT_FORBIDDEN_CONNECTS_LIKE_BLOCKS)
1091          {
1092             /* The response will violate the specs, but makes unblocking easier. */
1093             log_error(LOG_LEVEL_ERROR, "Marking suspicious CONNECT request from %s for blocking.",
1094                csp->ip_addr_str);
1095             csp->action->flags |= ACTION_BLOCK;
1096             http->ssl = 0;
1097          }
1098          else
1099          {
1100             strcpy(buf, CFORBIDDEN);
1101             write_socket(csp->cfd, buf, strlen(buf));
1102             log_error(LOG_LEVEL_CONNECT, "Denying suspicious CONNECT request from %s", csp->ip_addr_str);
1103             log_error(LOG_LEVEL_CLF, "%s - - [%T] \" \" 403 0", csp->ip_addr_str);
1104             return;
1105          }
1106       }
1107    }
1108
1109
1110    /*
1111     * Downgrade http version from 1.1 to 1.0 if +downgrade
1112     * action applies
1113     */
1114    if ( (http->ssl == 0)
1115      && (!strcmpic(http->ver, "HTTP/1.1"))
1116      && (csp->action->flags & ACTION_DOWNGRADE))
1117    {
1118       freez(http->ver);
1119       http->ver = strdup("HTTP/1.0");
1120
1121       if (http->ver == NULL)
1122       {
1123          log_error(LOG_LEVEL_FATAL, "Out of memory downgrading HTTP version");
1124       }
1125    }
1126
1127    /*
1128     * Save a copy of the original request for logging
1129     */
1130    http->ocmd = strdup(http->cmd);
1131
1132    if (http->ocmd == NULL)
1133    {
1134       log_error(LOG_LEVEL_FATAL, "Out of memory copying HTTP request line");
1135    }
1136
1137    /*
1138     * (Re)build the HTTP request for non-SSL requests.
1139     * If forwarding, use the whole URL, else, use only the path.
1140     */
1141    if (http->ssl == 0)
1142    {
1143       freez(http->cmd);
1144
1145       http->cmd = strdup(http->gpc);
1146       string_append(&http->cmd, " ");
1147
1148       if (fwd->forward_host)
1149       {
1150          string_append(&http->cmd, http->url);
1151       }
1152       else
1153       {
1154          string_append(&http->cmd, http->path);
1155       }
1156       string_append(&http->cmd, " ");
1157       string_append(&http->cmd, http->ver);
1158
1159       if (http->cmd == NULL)
1160       {
1161          log_error(LOG_LEVEL_FATAL, "Out of memory writing HTTP command");
1162       }
1163       log_error(LOG_LEVEL_HEADER, "New HTTP Request-Line: %s", http->cmd);
1164    }
1165    enlist(csp->headers, http->cmd);
1166
1167
1168    /*
1169     * If the user has not supplied any wafers, and the user has not
1170     * told us to suppress the vanilla wafer, then send the vanilla wafer.
1171     */
1172    if (list_is_empty(csp->action->multi[ACTION_MULTI_WAFER])
1173        && ((csp->action->flags & ACTION_VANILLA_WAFER) != 0))
1174    {
1175       enlist(csp->action->multi[ACTION_MULTI_WAFER], VANILLA_WAFER);
1176    }
1177
1178
1179 #ifdef FEATURE_KILL_POPUPS
1180    block_popups               = ((csp->action->flags & ACTION_NO_POPUPS) != 0);
1181 #endif /* def FEATURE_KILL_POPUPS */
1182
1183    pcrs_filter                = (csp->rlist != NULL) &&  /* There are expressions to be used */
1184                                 (!list_is_empty(csp->action->multi[ACTION_MULTI_FILTER]));
1185
1186    gif_deanimate              = ((csp->action->flags & ACTION_DEANIMATE) != 0);
1187
1188    jpeg_inspect               = ((csp->action->flags & ACTION_JPEG_INSPECT) != 0);
1189
1190    /* grab the rest of the client's headers */
1191
1192    for (;;)
1193    {
1194       if ( ( ( p = get_header(csp) ) != NULL) && ( *p == '\0' ) )
1195       {
1196          len = read_socket(csp->cfd, buf, sizeof(buf));
1197          if (len <= 0)
1198          {
1199             log_error(LOG_LEVEL_ERROR, "read from client failed: %E");
1200             return;
1201          }
1202
1203          /*
1204           * If there is no memory left for buffering the
1205           * request, there is nothing we can do but hang up
1206           */
1207          if (add_to_iob(csp, buf, len))
1208          {
1209             return;
1210          }
1211          continue;
1212       }
1213
1214       if (p == NULL) break;
1215
1216       enlist(csp->headers, p);
1217       freez(p);
1218    }
1219
1220    /*
1221     * We have a request. Now, check to see if we need to
1222     * intercept it, i.e. If ..
1223     */
1224
1225    if (
1226        /* We may not forward the request by rfc2616 sect 14.31 */
1227        (NULL != (rsp = direct_response(csp)))
1228
1229        /* or a CGI call was detected and answered */
1230        || (NULL != (rsp = dispatch_cgi(csp)))
1231
1232        /* or we are enabled and... */
1233        || (IS_ENABLED_AND (
1234
1235             /* ..the request was blocked */
1236           ( NULL != (rsp = block_url(csp)))
1237
1238           /* ..or untrusted */
1239 #ifdef FEATURE_TRUST
1240           || ( NULL != (rsp = trust_url(csp)))
1241 #endif /* def FEATURE_TRUST */
1242
1243           /* ..or a fast redirect kicked in */
1244 #ifdef FEATURE_FAST_REDIRECTS
1245           || ( NULL != (rsp = redirect_url(csp)))
1246 #endif /* def FEATURE_FAST_REDIRECTS */
1247           ))
1248       )
1249    {
1250       /* Write the answer to the client */
1251       if (write_socket(csp->cfd, rsp->head, rsp->head_length)
1252        || write_socket(csp->cfd, rsp->body, rsp->content_length))
1253       {
1254          log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
1255       }
1256
1257 #ifdef FEATURE_STATISTICS
1258       /* Count as a rejected request */
1259       csp->flags |= CSP_FLAG_REJECTED;
1260 #endif /* def FEATURE_STATISTICS */
1261
1262       /* Log (FIXME: All intercept reasons appear as "crunch" with Status 200) */
1263       log_error(LOG_LEVEL_GPC, "%s%s crunch!", http->hostport, http->path);
1264       log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 3", csp->ip_addr_str, http->ocmd);
1265
1266       /* Clean up and return */
1267       free_http_response(rsp);
1268       return;
1269    }
1270
1271    hdr = sed(client_patterns, add_client_headers, csp);
1272    if (hdr == NULL)
1273    {
1274       /* FIXME Should handle error properly */
1275       log_error(LOG_LEVEL_FATAL, "Out of memory parsing client header");
1276    }
1277
1278    list_remove_all(csp->headers);
1279
1280    log_error(LOG_LEVEL_GPC, "%s%s", http->hostport, http->path);
1281
1282    if (fwd->forward_host)
1283    {
1284       log_error(LOG_LEVEL_CONNECT, "via %s:%d to: %s",
1285                fwd->forward_host, fwd->forward_port, http->hostport);
1286    }
1287    else
1288    {
1289       log_error(LOG_LEVEL_CONNECT, "to %s", http->hostport);
1290    }
1291
1292    /* here we connect to the server, gateway, or the forwarder */
1293
1294    while ( (csp->sfd = forwarded_connect(fwd, http, csp))
1295          && (errno == EINVAL) && (forwarded_connect_retries++ < max_forwarded_connect_retries))
1296    {
1297       log_error(LOG_LEVEL_ERROR, "failed request #%u to connect to %s. Trying again.",
1298                 forwarded_connect_retries, http->hostport);
1299    }
1300
1301    if (csp->sfd == JB_INVALID_SOCKET)
1302    {
1303       log_error(LOG_LEVEL_CONNECT, "connect to: %s failed: %E",
1304                 http->hostport);
1305
1306       if (errno == EINVAL)
1307       {
1308          rsp = error_response(csp, "no-such-domain", errno);
1309
1310          log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 404 0",
1311                    csp->ip_addr_str, http->ocmd);
1312       }
1313       else
1314       {
1315          rsp = error_response(csp, "connect-failed", errno);
1316
1317          log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 503 0",
1318                    csp->ip_addr_str, http->ocmd);
1319       }
1320
1321
1322       /* Write the answer to the client */
1323       if(rsp)
1324       {
1325          if (write_socket(csp->cfd, rsp->head, rsp->head_length)
1326           || write_socket(csp->cfd, rsp->body, rsp->content_length))
1327          {
1328             log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
1329          }
1330       }
1331
1332       free_http_response(rsp);
1333       freez(hdr);
1334       return;
1335    }
1336
1337    log_error(LOG_LEVEL_CONNECT, "OK");
1338
1339    if (fwd->forward_host || (http->ssl == 0))
1340    {
1341       /* write the client's (modified) header to the server
1342        * (along with anything else that may be in the buffer)
1343        */
1344
1345       if (write_socket(csp->sfd, hdr, strlen(hdr))
1346        || (flush_socket(csp->sfd, csp) <  0))
1347       {
1348          log_error(LOG_LEVEL_CONNECT, "write header to: %s failed: %E",
1349                     http->hostport);
1350
1351          log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 503 0",
1352                    csp->ip_addr_str, http->ocmd);
1353
1354          rsp = error_response(csp, "connect-failed", errno);
1355
1356          if(rsp)
1357          {
1358             if (write_socket(csp->cfd, rsp->head, rsp->head_length)
1359              || write_socket(csp->cfd, rsp->body, rsp->content_length))
1360             {
1361                log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
1362             }
1363          }
1364
1365          free_http_response(rsp);
1366          freez(hdr);
1367          return;
1368       }
1369    }
1370    else
1371    {
1372       /*
1373        * We're running an SSL tunnel and we're not forwarding,
1374        * so just send the "connect succeeded" message to the
1375        * client, flush the rest, and get out of the way.
1376        */
1377       log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 2\n",
1378                 csp->ip_addr_str, http->ocmd);
1379
1380       if (write_socket(csp->cfd, CSUCCEED, sizeof(CSUCCEED)-1))
1381       {
1382          freez(hdr);
1383          return;
1384       }
1385       IOB_RESET(csp);
1386    }
1387
1388    /* we're finished with the client's header */
1389    freez(hdr);
1390
1391    maxfd = ( csp->cfd > csp->sfd ) ? csp->cfd : csp->sfd;
1392
1393    /* pass data between the client and server
1394     * until one or the other shuts down the connection.
1395     */
1396
1397    server_body = 0;
1398
1399    for (;;)
1400    {
1401 #ifdef __OS2__
1402       /*
1403        * FD_ZERO here seems to point to an errant macro which crashes.
1404        * So do this by hand for now...
1405        */
1406       memset(&rfds,0x00,sizeof(fd_set));
1407 #else
1408       FD_ZERO(&rfds);
1409 #endif
1410       FD_SET(csp->cfd, &rfds);
1411       FD_SET(csp->sfd, &rfds);
1412
1413       n = select((int)maxfd+1, &rfds, NULL, NULL, NULL);
1414
1415       if (n < 0)
1416       {
1417          log_error(LOG_LEVEL_ERROR, "select() failed!: %E");
1418          return;
1419       }
1420
1421       /* this is the body of the browser's request
1422        * just read it and write it.
1423        */
1424
1425       if (FD_ISSET(csp->cfd, &rfds))
1426       {
1427          len = read_socket(csp->cfd, buf, sizeof(buf));
1428
1429          if (len <= 0)
1430          {
1431             break; /* "game over, man" */
1432          }
1433
1434          if (write_socket(csp->sfd, buf, (size_t)len))
1435          {
1436             log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
1437             return;
1438          }
1439          continue;
1440       }
1441
1442       /*
1443        * The server wants to talk.  It could be the header or the body.
1444        * If `hdr' is null, then it's the header otherwise it's the body.
1445        * FIXME: Does `hdr' really mean `host'? No.
1446        */
1447
1448
1449       if (FD_ISSET(csp->sfd, &rfds))
1450       {
1451          fflush( 0 );
1452          len = read_socket(csp->sfd, buf, sizeof(buf) - 1);
1453
1454          if (len < 0)
1455          {
1456             log_error(LOG_LEVEL_ERROR, "read from: %s failed: %E", http->host);
1457
1458             log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 503 0",
1459                       csp->ip_addr_str, http->ocmd);
1460
1461             rsp = error_response(csp, "connect-failed", errno);
1462
1463             if(rsp)
1464             {
1465                if (write_socket(csp->cfd, rsp->head, rsp->head_length)
1466                 || write_socket(csp->cfd, rsp->body, rsp->content_length))
1467                {
1468                   log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
1469                }
1470             }
1471
1472             free_http_response(rsp);
1473             return;
1474          }
1475
1476          /* Add a trailing zero.  This lets filter_popups
1477           * use string operations.
1478           */
1479          buf[len] = '\0';
1480
1481 #ifdef FEATURE_KILL_POPUPS
1482          /* Filter the popups on this read. */
1483          if (block_popups_now)
1484          {
1485             filter_popups(buf, csp);
1486          }
1487 #endif /* def FEATURE_KILL_POPUPS */
1488
1489          /* Normally, this would indicate that we've read
1490           * as much as the server has sent us and we can
1491           * close the client connection.  However, Microsoft
1492           * in its wisdom has released IIS/5 with a bug that
1493           * prevents it from sending the trailing \r\n in
1494           * a 302 redirect header (and possibly other headers).
1495           * To work around this if we've haven't parsed
1496           * a full header we'll append a trailing \r\n
1497           * and see if this now generates a valid one.
1498           *
1499           * This hack shouldn't have any impacts.  If we've
1500           * already transmitted the header or if this is a
1501           * SSL connection, then we won't bother with this
1502           * hack.  So we only work on partially received
1503           * headers.  If we append a \r\n and this still
1504           * doesn't generate a valid header, then we won't
1505           * transmit anything to the client.
1506           */
1507          if (len == 0)
1508          {
1509
1510             if (server_body || http->ssl)
1511             {
1512                /*
1513                 * If we have been buffering up the document,
1514                 * now is the time to apply content modification
1515                 * and send the result to the client.
1516                 */
1517                if (content_filter)
1518                {
1519                   /*
1520                    * If the content filter fails, use the original
1521                    * buffer and length.
1522                    * (see p != NULL ? p : csp->iob->cur below)
1523                    */
1524                   if (NULL == (p = (*content_filter)(csp)))
1525                   {
1526                      csp->content_length = csp->iob->eod - csp->iob->cur;
1527                   }
1528
1529                   hdr = sed(server_patterns_light, NULL, csp);
1530
1531                   if (hdr == NULL)
1532                   {
1533                      /* FIXME Should handle error properly */
1534                      log_error(LOG_LEVEL_FATAL, "Out of memory parsing server header");
1535                   }
1536
1537                   if (write_socket(csp->cfd, hdr, strlen(hdr))
1538                    || write_socket(csp->cfd, p != NULL ? p : csp->iob->cur, csp->content_length))
1539                   {
1540                      log_error(LOG_LEVEL_ERROR, "write modified content to client failed: %E");
1541                      freez(hdr);
1542                      freez(p);
1543                      return;
1544                   }
1545
1546                   freez(hdr);
1547                   freez(p);
1548                }
1549
1550                break; /* "game over, man" */
1551             }
1552
1553             /*
1554              * This is NOT the body, so
1555              * Let's pretend the server just sent us a blank line.
1556              */
1557             len = sprintf(buf, "\r\n");
1558
1559             /*
1560              * Now, let the normal header parsing algorithm below do its
1561              * job.  If it fails, we'll exit instead of continuing.
1562              */
1563
1564             ms_iis5_hack = 1;
1565          }
1566
1567          /*
1568           * If this is an SSL connection or we're in the body
1569           * of the server document, just write it to the client,
1570           * unless we need to buffer the body for later content-filtering
1571           */
1572
1573          if (server_body || http->ssl)
1574          {
1575             if (content_filter)
1576             {
1577                /*
1578                 * If there is no memory left for buffering the content, or the buffer limit
1579                 * has been reached, switch to non-filtering mode, i.e. make & write the
1580                 * header, flush the iob and buf, and get out of the way.
1581                 */
1582                if (add_to_iob(csp, buf, len))
1583                {
1584                   size_t hdrlen;
1585                   int flushed;
1586
1587                   log_error(LOG_LEVEL_ERROR, "Flushing header and buffers. Stepping back from filtering.");
1588
1589                   hdr = sed(server_patterns, add_server_headers, csp);
1590                   if (hdr == NULL)
1591                   {
1592                      /*
1593                       * Memory is too tight to even generate the header.
1594                       * Send our static "Out-of-memory" page.
1595                       */
1596                      log_error(LOG_LEVEL_ERROR, "Out of memory while trying to flush.");
1597                      rsp = cgi_error_memory();
1598
1599                      if (write_socket(csp->cfd, rsp->head, rsp->head_length)
1600                          || write_socket(csp->cfd, rsp->body, rsp->content_length))
1601                      {
1602                         log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
1603                      }
1604                      return;
1605                   }
1606
1607                   hdrlen = strlen(hdr);
1608
1609                   if (write_socket(csp->cfd, hdr, hdrlen)
1610                    || ((flushed = flush_socket(csp->cfd, csp)) < 0)
1611                    || (write_socket(csp->cfd, buf, (size_t) len)))
1612                   {
1613                      log_error(LOG_LEVEL_CONNECT, "Flush header and buffers to client failed: %E");
1614
1615                      freez(hdr);
1616                      return;
1617                   }
1618
1619                   byte_count += hdrlen + flushed + len;
1620                   freez(hdr);
1621                   content_filter = NULL;
1622                   server_body = 1;
1623
1624                }
1625             }
1626             else
1627             {
1628                if (write_socket(csp->cfd, buf, (size_t)len))
1629                {
1630                   log_error(LOG_LEVEL_ERROR, "write to client failed: %E");
1631                   return;
1632                }
1633             }
1634             byte_count += len;
1635             continue;
1636          }
1637          else
1638          {
1639             /* we're still looking for the end of the
1640              * server's header ... (does that make header
1641              * parsing an "out of body experience" ?
1642              */
1643
1644             /*
1645              * buffer up the data we just read.  If that fails,
1646              * there's little we can do but send our static
1647              * out-of-memory page.
1648              */
1649             if (add_to_iob(csp, buf, len))
1650             {
1651                log_error(LOG_LEVEL_ERROR, "Out of memory while looking for end of server headers.");
1652                rsp = cgi_error_memory();
1653
1654                if (write_socket(csp->cfd, rsp->head, rsp->head_length)
1655                    || write_socket(csp->cfd, rsp->body, rsp->content_length))
1656                {
1657                   log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
1658                }
1659                return;
1660             }
1661
1662             /* get header lines from the iob */
1663
1664             while ((p = get_header(csp)) != NULL)
1665             {
1666                if (*p == '\0')
1667                {
1668                   /* see following note */
1669                   break;
1670                }
1671                enlist(csp->headers, p);
1672                freez(p);
1673             }
1674
1675             /* NOTE: there are no "empty" headers so
1676              * if the pointer `p' is not NULL we must
1677              * assume that we reached the end of the
1678              * buffer before we hit the end of the header.
1679              */
1680
1681             if (p)
1682             {
1683                if (ms_iis5_hack)
1684                {
1685                   /* Well, we tried our MS IIS/5
1686                    * hack and it didn't work.
1687                    * The header is incomplete
1688                    * and there isn't anything
1689                    * we can do about it.
1690                    */
1691                   break;
1692                }
1693                else
1694                {
1695                   /* Since we have to wait for
1696                    * more from the server before
1697                    * we can parse the headers
1698                    * we just continue here.
1699                    */
1700                   continue;
1701                }
1702             }
1703
1704             /* we have now received the entire header.
1705              * filter it and send the result to the client
1706              */
1707
1708             hdr = sed(server_patterns, add_server_headers, csp);
1709             if (hdr == NULL)
1710             {
1711                /* FIXME Should handle error properly */
1712                log_error(LOG_LEVEL_FATAL, "Out of memory parsing server header");
1713             }
1714
1715 #ifdef FEATURE_KILL_POPUPS
1716             /* Start blocking popups if appropriate. */
1717
1718             if ((csp->content_type & CT_TEXT) &&  /* It's a text / * MIME-Type */
1719                 !http->ssl    &&                  /* We talk plaintext */
1720                 block_popups)                     /* Policy allows */
1721             {
1722                block_popups_now = 1;
1723                /*
1724                 * Filter the part of the body that came in the same read
1725                 * as the last headers:
1726                 */
1727                filter_popups(csp->iob->cur, csp);
1728             }
1729
1730 #endif /* def FEATURE_KILL_POPUPS */
1731
1732             /* Buffer and pcrs filter this if appropriate. */
1733
1734             if ((csp->content_type & CT_TEXT) &&  /* It's a text / * MIME-Type */
1735                 !http->ssl    &&                  /* We talk plaintext */
1736                 pcrs_filter)                      /* Policy allows */
1737             {
1738                content_filter = pcrs_filter_response;
1739             }
1740
1741             /* Buffer and gif_deanimate this if appropriate. */
1742
1743             if ((csp->content_type & CT_GIF)  &&  /* It's an image/gif MIME-Type */
1744                 !http->ssl    &&                  /* We talk plaintext */
1745                 gif_deanimate)                    /* Policy allows */
1746             {
1747                content_filter = gif_deanimate_response;
1748             }
1749
1750             /* Buffer and jpg_inspect this if appropriate. */
1751
1752             if ((csp->content_type & CT_JPEG)  &&  /* It's an image/jpeg MIME-Type */
1753                 !http->ssl    &&                   /* We talk plaintext */
1754                 jpeg_inspect)                      /* Policy allows */
1755             {
1756                content_filter = jpeg_inspect_response;
1757             }
1758
1759             /*
1760              * Only write if we're not buffering for content modification
1761              */
1762             if (!content_filter)
1763             {
1764                /* write the server's (modified) header to
1765                 * the client (along with anything else that
1766                 * may be in the buffer)
1767                 */
1768
1769                if (write_socket(csp->cfd, hdr, strlen(hdr))
1770                 || ((len = flush_socket(csp->cfd, csp)) < 0))
1771                {
1772                   log_error(LOG_LEVEL_CONNECT, "write header to client failed: %E");
1773
1774                   /* the write failed, so don't bother
1775                    * mentioning it to the client...
1776                    * it probably can't hear us anyway.
1777                    */
1778                   freez(hdr);
1779                   return;
1780                }
1781
1782                byte_count += len;
1783             }
1784
1785             /* we're finished with the server's header */
1786
1787             freez(hdr);
1788             server_body = 1;
1789
1790             /* If this was a MS IIS/5 hack then it means
1791              * the server has already closed the
1792              * connection.  Nothing more to read.  Time
1793              * to bail.
1794              */
1795             if (ms_iis5_hack)
1796             {
1797                break;
1798             }
1799          }
1800          continue;
1801       }
1802
1803       return; /* huh? we should never get here */
1804    }
1805
1806    log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 %d",
1807              csp->ip_addr_str, http->ocmd, byte_count);
1808 }
1809
1810
1811 /*********************************************************************
1812  *
1813  * Function    :  serve
1814  *
1815  * Description :  This is little more than chat.  We only "serve" to
1816  *                to close any socket that chat may have opened.
1817  *
1818  * Parameters  :
1819  *          1  :  csp = Current client state (buffers, headers, etc...)
1820  *
1821  * Returns     :  N/A
1822  *
1823  *********************************************************************/
1824 #ifdef AMIGA
1825 void serve(struct client_state *csp)
1826 #else /* ifndef AMIGA */
1827 static void serve(struct client_state *csp)
1828 #endif /* def AMIGA */
1829 {
1830    chat(csp);
1831    close_socket(csp->cfd);
1832
1833    if (csp->sfd != JB_INVALID_SOCKET)
1834    {
1835       close_socket(csp->sfd);
1836    }
1837
1838    csp->flags &= ~CSP_FLAG_ACTIVE;
1839
1840 }
1841
1842
1843 #ifdef __BEOS__
1844 /*********************************************************************
1845  *
1846  * Function    :  server_thread
1847  *
1848  * Description :  We only exist to call `serve' in a threaded environment.
1849  *
1850  * Parameters  :
1851  *          1  :  data = Current client state (buffers, headers, etc...)
1852  *
1853  * Returns     :  Always 0.
1854  *
1855  *********************************************************************/
1856 static int32 server_thread(void *data)
1857 {
1858    serve((struct client_state *) data);
1859    return 0;
1860
1861 }
1862 #endif
1863
1864
1865 /*********************************************************************
1866  *
1867  * Function    :  usage
1868  *
1869  * Description :  Print usage info & exit.
1870  *
1871  * Parameters  :  Pointer to argv[0] for identifying ourselves
1872  *
1873  * Returns     :  No. ,-)
1874  *
1875  *********************************************************************/
1876 void usage(const char *myname)
1877 {
1878    printf("Privoxy version " VERSION " (" HOME_PAGE_URL ")\n"
1879 #if !defined(unix)
1880            "Usage: %s [--help] [--version] [configfile]\n"
1881 #else
1882            "Usage: %s [--help] [--version] [--no-daemon] [--pidfile pidfile] [--user user[.group]] [configfile]\n"
1883 #endif
1884            "Aborting.\n", myname);
1885
1886    exit(2);
1887
1888 }
1889
1890
1891 /*********************************************************************
1892  *
1893  * Function    :  main
1894  *
1895  * Description :  Load the config file and start the listen loop.
1896  *                This function is a lot more *sane* with the `load_config'
1897  *                and `listen_loop' functions; although it stills does
1898  *                a *little* too much for my taste.
1899  *
1900  * Parameters  :
1901  *          1  :  argc = Number of parameters (including $0).
1902  *          2  :  argv = Array of (char *)'s to the parameters.
1903  *
1904  * Returns     :  1 if : can't open config file, unrecognized directive,
1905  *                stats requested in multi-thread mode, can't open the
1906  *                log file, can't open the jar file, listen port is invalid,
1907  *                any load fails, and can't bind port.
1908  *
1909  *                Else main never returns, the process must be signaled
1910  *                to terminate execution.  Or, on Windows, use the
1911  *                "File", "Exit" menu option.
1912  *
1913  *********************************************************************/
1914 #ifdef __MINGW32__
1915 int real_main(int argc, const char *argv[])
1916 #else
1917 int main(int argc, const char *argv[])
1918 #endif
1919 {
1920    int argc_pos = 0;
1921 #ifdef HAVE_RANDOM
1922    unsigned int random_seed;
1923 #endif /* ifdef HAVE_RANDOM */
1924 #ifdef unix
1925    struct passwd *pw = NULL;
1926    struct group *grp = NULL;
1927    char *p;
1928    int do_chroot = 0;
1929 #endif
1930
1931    Argc = argc;
1932    Argv = argv;
1933
1934    configfile =
1935 #if !defined(_WIN32)
1936    "config"
1937 #else
1938    "config.txt"
1939 #endif
1940       ;
1941
1942    /*
1943     * Parse the command line arguments
1944     */
1945    while (++argc_pos < argc)
1946    {
1947 #ifdef _WIN32
1948       /* Check to see if the service must be installed or uninstalled */
1949       if (strncmp(argv[argc_pos], "--install", 9) == 0)
1950       {
1951          const char *pName = argv[argc_pos] + 9;
1952          if (*pName == ':')
1953             pName++;
1954          exit( (install_service(pName)) ? 0 : 1 );
1955       }
1956       else if (strncmp(argv[argc_pos], "--uninstall", + 11) == 0)
1957       {
1958          const char *pName = argv[argc_pos] + 11;
1959          if (*pName == ':')
1960             pName++;
1961          exit((uninstall_service(pName)) ? 0 : 1);
1962       }
1963       else if (strcmp(argv[argc_pos], "--service" ) == 0)
1964       {
1965          bRunAsService = TRUE;
1966          w32_set_service_cwd();
1967          atexit(w32_service_exit_notify);
1968       }
1969       else
1970 #endif /* defined(_WIN32) */
1971
1972
1973 #if !defined(_WIN32) || defined(_WIN_CONSOLE)
1974
1975       if (strcmp(argv[argc_pos], "--help") == 0)
1976       {
1977          usage(argv[0]);
1978       }
1979
1980       else if(strcmp(argv[argc_pos], "--version") == 0)
1981       {
1982          printf("Privoxy version " VERSION " (" HOME_PAGE_URL ")\n");
1983          exit(0);
1984       }
1985
1986 #if defined(unix)
1987
1988      else if (strcmp(argv[argc_pos], "--no-daemon" ) == 0)
1989       {
1990          no_daemon = 1;
1991       }
1992
1993       else if (strcmp(argv[argc_pos], "--pidfile" ) == 0)
1994       {
1995          if (++argc_pos == argc) usage(argv[0]);
1996          pidfile = strdup(argv[argc_pos]);
1997       }
1998
1999       else if (strcmp(argv[argc_pos], "--user" ) == 0)
2000       {
2001          if (++argc_pos == argc) usage(argv[argc_pos]);
2002
2003          if ((NULL != (p = strchr(argv[argc_pos], '.'))) && *(p + 1) != '0')
2004          {
2005             *p++ = '\0';
2006             if (NULL == (grp = getgrnam(p)))
2007             {
2008                log_error(LOG_LEVEL_FATAL, "Group %s not found.", p);
2009             }
2010          }
2011
2012          if (NULL == (pw = getpwnam(argv[argc_pos])))
2013          {
2014             log_error(LOG_LEVEL_FATAL, "User %s not found.", argv[argc_pos]);
2015          }
2016
2017          if (p != NULL) *--p = '\0';
2018       }
2019
2020       else if (strcmp(argv[argc_pos], "--chroot" ) == 0)
2021       {
2022          do_chroot = 1;
2023       }
2024
2025 #endif /* defined(unix) */
2026 #endif /* defined(_WIN32) && !defined(_WIN_CONSOLE) */
2027       {
2028          configfile = argv[argc_pos];
2029       }
2030
2031    } /* -END- while (more arguments) */
2032
2033 #if defined(unix)
2034    if ( *configfile != '/' )
2035    {
2036       char *abs_file, cwd[1024];
2037
2038       /* make config-filename absolute here */
2039       if ( !(getcwd(cwd, sizeof(cwd))))
2040       {
2041          perror("get working dir failed");
2042          exit( 1 );
2043       }
2044
2045       if (!(basedir = strdup(cwd))
2046       || (!(abs_file = malloc( strlen( basedir ) + strlen( configfile ) + 5 ))))
2047       {
2048          perror("malloc failed");
2049          exit( 1 );
2050       }
2051       strcpy( abs_file, basedir );
2052       strcat( abs_file, "/" );
2053       strcat( abs_file, configfile );
2054       configfile = abs_file;
2055    }
2056 #endif /* defined unix */
2057
2058
2059    files->next = NULL;
2060    clients->next = NULL;
2061
2062 #ifdef AMIGA
2063    InitAmiga();
2064 #elif defined(_WIN32)
2065    InitWin32();
2066 #endif
2067
2068 #if defined(OSX_DARWIN) || defined(__OpenBSD__)
2069    /*
2070     * Prepare global mutex semaphores
2071     */
2072 #ifdef OSX_DARWIN
2073    pthread_mutex_init(&gmtime_mutex,0);
2074    pthread_mutex_init(&localtime_mutex,0);
2075 #endif /* def OSX_DARWIN */
2076    pthread_mutex_init(&gethostbyaddr_mutex,0);
2077    pthread_mutex_init(&gethostbyname_mutex,0);
2078 #endif /* defined(OSX_DARWIN) || defined(__OpenBSD__) */
2079
2080 #ifdef FEATURE_PTHREAD
2081    pthread_mutex_init(&log_mutex,0);
2082    pthread_mutex_init(&log_init_mutex,0);
2083 #endif /* FEATURE_PTHREAD */
2084
2085 #ifdef HAVE_RANDOM
2086    random_seed = (unsigned int)time(NULL);
2087    srandom(random_seed);
2088 #endif /* ifdef HAVE_RANDOM */
2089
2090    /*
2091     * Unix signal handling
2092     *
2093     * Catch the abort, interrupt and terminate signals for a graceful exit
2094     * Catch the hangup signal so the errlog can be reopened.
2095     * Ignore the broken pipe signals (FIXME: Why?)
2096     */
2097 #if !defined(_WIN32) && !defined(__OS2__) && !defined(AMIGA)
2098 {
2099    int idx;
2100    const int catched_signals[] = { SIGABRT, SIGTERM, SIGINT, SIGHUP, 0 };
2101    const int ignored_signals[] = { SIGPIPE, 0 };
2102
2103    for (idx = 0; catched_signals[idx] != 0; idx++)
2104    {
2105       if (signal(catched_signals[idx], sig_handler) == SIG_ERR)
2106       {
2107          log_error(LOG_LEVEL_FATAL, "Can't set signal-handler for signal %d: %E", catched_signals[idx]);
2108       }
2109    }
2110
2111    for (idx = 0; ignored_signals[idx] != 0; idx++)
2112    {
2113       if (signal(ignored_signals[idx], SIG_IGN) == SIG_ERR)
2114       {
2115          log_error(LOG_LEVEL_FATAL, "Can't set ignore-handler for signal %d: %E", ignored_signals[idx]);
2116       }
2117    }
2118
2119 }
2120 #else /* ifdef _WIN32 */
2121 # ifdef _WIN_CONSOLE
2122    /*
2123     * We *are* in a windows console app.
2124     * Print a verbose messages about FAQ's and such
2125     */
2126    printf(win32_blurb);
2127 # endif /* def _WIN_CONSOLE */
2128 #endif /* def _WIN32 */
2129
2130
2131    /* Initialize the CGI subsystem */
2132    cgi_init_error_messages();
2133
2134    /*
2135     * If runnig on unix and without the --nodaemon
2136     * option, become a daemon. I.e. fork, detach
2137     * from tty and get process group leadership
2138     */
2139 #if defined(unix)
2140 {
2141    pid_t pid = 0;
2142 #if 0
2143    int   fd;
2144 #endif
2145
2146    if (!no_daemon)
2147    {
2148       pid  = fork();
2149
2150       if ( pid < 0 ) /* error */
2151       {
2152          perror("fork");
2153          exit( 3 );
2154       }
2155       else if ( pid != 0 ) /* parent */
2156       {
2157          int status;
2158          pid_t wpid;
2159          /*
2160           * must check for errors
2161           * child died due to missing files aso
2162           */
2163          sleep( 1 );
2164          wpid = waitpid( pid, &status, WNOHANG );
2165          if ( wpid != 0 )
2166          {
2167             exit( 1 );
2168          }
2169          exit( 0 );
2170       }
2171       /* child */
2172 #if 1
2173       /* Should be more portable, but not as well tested */
2174       setsid();
2175 #else /* !1 */
2176 #ifdef __FreeBSD__
2177       setpgrp(0,0);
2178 #else /* ndef __FreeBSD__ */
2179       setpgrp();
2180 #endif /* ndef __FreeBSD__ */
2181       fd = open("/dev/tty", O_RDONLY);
2182       if ( fd )
2183       {
2184          /* no error check here */
2185          ioctl( fd, TIOCNOTTY,0 );
2186          close ( fd );
2187       }
2188 #endif /* 1 */
2189       /* FIXME: should close stderr (fd 2) here too, but the test
2190        * for existence
2191        * and load config file is done in listen_loop() and puts
2192        * some messages on stderr there.
2193        */
2194
2195       close( 0 );
2196       close( 1 );
2197       chdir("/");
2198
2199    } /* -END- if (!no_daemon) */
2200
2201    /*
2202     * As soon as we have written the PID file, we can switch
2203     * to the user and group ID indicated by the --user option
2204     */
2205    write_pid_file();
2206
2207    if (NULL != pw)
2208    {
2209       if (setgid((NULL != grp) ? grp->gr_gid : pw->pw_gid))
2210       {
2211          log_error(LOG_LEVEL_FATAL, "Cannot setgid(): Insufficient permissions.");
2212       }
2213       if (do_chroot)
2214       {
2215          if (!pw->pw_dir)
2216          {
2217             log_error(LOG_LEVEL_FATAL, "Home directory for %s undefined", pw->pw_name);
2218          }
2219          if (chroot(pw->pw_dir) < 0)
2220          {
2221             log_error(LOG_LEVEL_FATAL, "Cannot chroot to %s", pw->pw_dir);
2222          }
2223          if (chdir ("/"))
2224          {
2225             log_error(LOG_LEVEL_FATAL, "Cannot chdir /");
2226          }
2227       }
2228       if (setuid(pw->pw_uid))
2229       {
2230          log_error(LOG_LEVEL_FATAL, "Cannot setuid(): Insufficient permissions.");
2231       }
2232       if (do_chroot)
2233       {
2234          char putenv_dummy[64];
2235
2236          strcpy(putenv_dummy, "HOME=/");
2237          if (putenv(putenv_dummy) != 0)
2238          {
2239             log_error(LOG_LEVEL_FATAL, "Cannot putenv(): HOME");
2240          }
2241
2242          snprintf(putenv_dummy, 64, "USER=%s", pw->pw_name);
2243          if (putenv(putenv_dummy) != 0)
2244          {
2245             log_error(LOG_LEVEL_FATAL, "Cannot putenv(): USER");
2246          }
2247       }
2248    }
2249    else if (do_chroot)
2250    {
2251       log_error(LOG_LEVEL_FATAL, "Cannot chroot without --user argument.");
2252    }
2253 }
2254 #endif /* defined unix */
2255
2256 #ifdef _WIN32
2257    /* This will be FALSE unless the command line specified --service
2258     */
2259    if (bRunAsService)
2260    {
2261       /* Yup, so now we must attempt to establish a connection
2262        * with the service dispatcher. This will only work if this
2263        * process was launched by the service control manager to
2264        * actually run as a service. If this isn't the case, i've
2265        * known it take around 30 seconds or so for the call to return.
2266        */
2267
2268       /* The StartServiceCtrlDispatcher won't return until the service is stopping */
2269       if (w32_start_service_ctrl_dispatcher(w32ServiceDispatchTable))
2270       {
2271          /* Service has run, and at this point is now being stopped, so just return */
2272          return 0;
2273       }
2274
2275 #ifdef _WIN_CONSOLE
2276       printf("Warning: Failed to connect to Service Control Dispatcher\nwhen starting as a service!\n");
2277 #endif
2278       /* An error occurred. Usually it's because --service was wrongly specified
2279        * and we were unable to connect to the Service Control Dispatcher because
2280        * it wasn't expecting us and is therefore not listening.
2281        *
2282        * For now, just continue below to call the listen_loop function.
2283        */
2284    }
2285 #endif /* def _WIN32 */
2286
2287    listen_loop();
2288
2289    /* NOTREACHED */
2290    return(-1);
2291
2292 }
2293
2294
2295 /*********************************************************************
2296  *
2297  * Function    :  bind_port_helper
2298  *
2299  * Description :  Bind the listen port.  Handles logging, and aborts
2300  *                on failure.
2301  *
2302  * Parameters  :
2303  *          1  :  config = Privoxy configuration.  Specifies port
2304  *                         to bind to.
2305  *
2306  * Returns     :  Port that was opened.
2307  *
2308  *********************************************************************/
2309 static jb_socket bind_port_helper(struct configuration_spec * config)
2310 {
2311    int result;
2312    jb_socket bfd;
2313
2314    if ( (config->haddr != NULL)
2315      && (config->haddr[0] == '1')
2316      && (config->haddr[1] == '2')
2317      && (config->haddr[2] == '7')
2318      && (config->haddr[3] == '.') )
2319    {
2320       log_error(LOG_LEVEL_INFO, "Listening on port %d for local connections only",
2321                 config->hport);
2322    }
2323    else if (config->haddr == NULL)
2324    {
2325       log_error(LOG_LEVEL_INFO, "Listening on port %d on all IP addresses",
2326                 config->hport);
2327    }
2328    else
2329    {
2330       log_error(LOG_LEVEL_INFO, "Listening on port %d on IP address %s",
2331                 config->hport, config->haddr);
2332    }
2333
2334    result = bind_port(config->haddr, config->hport, &bfd);
2335
2336    if (result < 0)
2337    {
2338       switch(result)
2339       {
2340          case -3 :
2341             log_error(LOG_LEVEL_FATAL, "can't bind to %s:%d: "
2342                "There may be another Privoxy or some other "
2343                "proxy running on port %d",
2344                (NULL != config->haddr) ? config->haddr : "INADDR_ANY",
2345                       config->hport, config->hport);
2346
2347          case -2 :
2348             log_error(LOG_LEVEL_FATAL, "can't bind to %s:%d: "
2349                "The hostname is not resolvable",
2350                (NULL != config->haddr) ? config->haddr : "INADDR_ANY", config->hport);
2351
2352          default :
2353             log_error(LOG_LEVEL_FATAL, "can't bind to %s:%d: because %E",
2354                (NULL != config->haddr) ? config->haddr : "INADDR_ANY", config->hport);
2355       }
2356
2357       /* shouldn't get here */
2358       return JB_INVALID_SOCKET;
2359    }
2360
2361    config->need_bind = 0;
2362
2363    return bfd;
2364 }
2365
2366
2367 #ifdef _WIN32
2368 /* Without this simple workaround we get this compiler warning from _beginthread
2369  *     warning C4028: formal parameter 1 different from declaration
2370  */
2371 void w32_service_listen_loop(void *p)
2372 {
2373    listen_loop();
2374 }
2375 #endif /* def _WIN32 */
2376
2377
2378 /*********************************************************************
2379  *
2380  * Function    :  listen_loop
2381  *
2382  * Description :  bind the listen port and enter a "FOREVER" listening loop.
2383  *
2384  * Parameters  :  N/A
2385  *
2386  * Returns     :  Never.
2387  *
2388  *********************************************************************/
2389 static void listen_loop(void)
2390 {
2391    struct client_state *csp = NULL;
2392    jb_socket bfd;
2393    struct configuration_spec * config;
2394
2395    config = load_config();
2396
2397    bfd = bind_port_helper(config);
2398
2399 #ifdef FEATURE_GRACEFUL_TERMINATION
2400    while (!g_terminate)
2401 #else
2402    for (;;)
2403 #endif
2404    {
2405 #if !defined(FEATURE_PTHREAD) && !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__)
2406       while (waitpid(-1, NULL, WNOHANG) > 0)
2407       {
2408          /* zombie children */
2409       }
2410 #endif /* !defined(FEATURE_PTHREAD) && !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) */
2411
2412       /*
2413        * Free data that was used by died threads
2414        */
2415       sweep();
2416
2417 #if defined(unix)
2418       /*
2419        * Re-open the errlog after HUP signal
2420        */
2421       if (received_hup_signal)
2422       {
2423          init_error_log(Argv[0], config->logfile, config->debug);
2424          received_hup_signal = 0;
2425       }
2426 #endif
2427
2428 #ifdef __OS2__
2429 #ifdef FEATURE_COOKIE_JAR
2430       /*
2431        * Need a workaround here: we have to fclose() the jarfile, or we die because it's
2432        * already open.  I think unload_configfile() is not being run, which should do
2433        * this work.  Until that can get resolved, we'll use this workaround.
2434        */
2435        if (csp)
2436          if(csp->config)
2437            if (csp->config->jar)
2438            {
2439              fclose(csp->config->jar);
2440              csp->config->jar = NULL;
2441            }
2442 #endif /* FEATURE_COOKIE_JAR */
2443 #endif /* __OS2__ */
2444
2445       if ( NULL == (csp = (struct client_state *) zalloc(sizeof(*csp))) )
2446       {
2447          log_error(LOG_LEVEL_FATAL, "malloc(%d) for csp failed: %E", sizeof(*csp));
2448          continue;
2449       }
2450
2451       csp->flags |= CSP_FLAG_ACTIVE;
2452       csp->sfd    = JB_INVALID_SOCKET;
2453
2454       csp->config = config = load_config();
2455
2456       if ( config->need_bind )
2457       {
2458          /*
2459           * Since we were listening to the "old port", we will not see
2460           * a "listen" param change until the next IJB request.  So, at
2461           * least 1 more request must be made for us to find the new
2462           * setting.  I am simply closing the old socket and binding the
2463           * new one.
2464           *
2465           * Which-ever is correct, we will serve 1 more page via the
2466           * old settings.  This should probably be a "show-proxy-args"
2467           * request.  This should not be a so common of an operation
2468           * that this will hurt people's feelings.
2469           */
2470
2471          close_socket(bfd);
2472
2473          bfd = bind_port_helper(config);
2474       }
2475
2476       log_error(LOG_LEVEL_CONNECT, "accept connection ... ");
2477
2478       if (!accept_connection(csp, bfd))
2479       {
2480          log_error(LOG_LEVEL_CONNECT, "accept failed: %E");
2481
2482 #ifdef AMIGA
2483          if(!childs)
2484          {
2485             exit(1);
2486          }
2487 #endif
2488          freez(csp);
2489          continue;
2490       }
2491       else
2492       {
2493          log_error(LOG_LEVEL_CONNECT, "OK");
2494       }
2495
2496 #ifdef FEATURE_TOGGLE
2497       if (global_toggle_state)
2498       {
2499          csp->flags |= CSP_FLAG_TOGGLED_ON;
2500       }
2501 #endif /* def FEATURE_TOGGLE */
2502
2503       if (run_loader(csp))
2504       {
2505          log_error(LOG_LEVEL_FATAL, "a loader failed - must exit");
2506          /* Never get here - LOG_LEVEL_FATAL causes program exit */
2507       }
2508
2509 #ifdef FEATURE_ACL
2510       if (block_acl(NULL,csp))
2511       {
2512          log_error(LOG_LEVEL_CONNECT, "Connection dropped due to ACL");
2513          close_socket(csp->cfd);
2514          freez(csp);
2515          continue;
2516       }
2517 #endif /* def FEATURE_ACL */
2518
2519       /* add it to the list of clients */
2520       csp->next = clients->next;
2521       clients->next = csp;
2522
2523       if (config->multi_threaded)
2524       {
2525          int child_id;
2526
2527 /* this is a switch () statment in the C preprocessor - ugh */
2528 #undef SELECTED_ONE_OPTION
2529
2530 /* Use Pthreads in preference to native code */
2531 #if defined(FEATURE_PTHREAD) && !defined(SELECTED_ONE_OPTION)
2532 #define SELECTED_ONE_OPTION
2533          {
2534             pthread_t the_thread;
2535             pthread_attr_t attrs;
2536
2537             pthread_attr_init(&attrs);
2538             pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED);
2539             errno = pthread_create(&the_thread, &attrs,
2540                (void*)serve, csp);
2541             child_id = errno ? -1 : 0;
2542             pthread_attr_destroy(&attrs);
2543          }
2544 #endif
2545
2546 #if defined(_WIN32) && !defined(_CYGWIN) && !defined(SELECTED_ONE_OPTION)
2547 #define SELECTED_ONE_OPTION
2548          child_id = _beginthread(
2549             (void (*)(void *))serve,
2550             64 * 1024,
2551             csp);
2552 #endif
2553
2554 #if defined(__OS2__) && !defined(SELECTED_ONE_OPTION)
2555 #define SELECTED_ONE_OPTION
2556          child_id = _beginthread(
2557             (void(* _Optlink)(void*))serve,
2558             NULL,
2559             64 * 1024,
2560             csp);
2561 #endif
2562
2563 #if defined(__BEOS__) && !defined(SELECTED_ONE_OPTION)
2564 #define SELECTED_ONE_OPTION
2565          {
2566             thread_id tid = spawn_thread
2567                (server_thread, "server", B_NORMAL_PRIORITY, csp);
2568
2569             if ((tid >= 0) && (resume_thread(tid) == B_OK))
2570             {
2571                child_id = (int) tid;
2572             }
2573             else
2574             {
2575                child_id = -1;
2576             }
2577          }
2578 #endif
2579
2580 #if defined(AMIGA) && !defined(SELECTED_ONE_OPTION)
2581 #define SELECTED_ONE_OPTION
2582          csp->cfd = ReleaseSocket(csp->cfd, -1);
2583
2584          if((child_id = (int)CreateNewProcTags(
2585             NP_Entry, (ULONG)server_thread,
2586             NP_Output, Output(),
2587             NP_CloseOutput, FALSE,
2588             NP_Name, (ULONG)"privoxy child",
2589             NP_StackSize, 200*1024,
2590             TAG_DONE)))
2591          {
2592             childs++;
2593             ((struct Task *)child_id)->tc_UserData = csp;
2594             Signal((struct Task *)child_id, SIGF_SINGLE);
2595             Wait(SIGF_SINGLE);
2596          }
2597 #endif
2598
2599 #if !defined(SELECTED_ONE_OPTION)
2600          child_id = fork();
2601
2602          /* This block is only needed when using fork().
2603           * When using threads, the server thread was
2604           * created and run by the call to _beginthread().
2605           */
2606          if (child_id == 0)   /* child */
2607          {
2608             int rc = 0;
2609 #ifdef FEATURE_TOGGLE
2610             int inherited_toggle_state = global_toggle_state;
2611 #endif /* def FEATURE_TOGGLE */
2612
2613             serve(csp);
2614
2615             /*
2616              * If we've been toggled or we've blocked the request, tell Mom
2617              */
2618
2619 #ifdef FEATURE_TOGGLE
2620             if (inherited_toggle_state != global_toggle_state)
2621             {
2622                rc |= RC_FLAG_TOGGLED;
2623             }
2624 #endif /* def FEATURE_TOGGLE */
2625
2626 #ifdef FEATURE_STATISTICS
2627             if (csp->flags & CSP_FLAG_REJECTED)
2628             {
2629                rc |= RC_FLAG_BLOCKED;
2630             }
2631 #endif /* ndef FEATURE_STATISTICS */
2632
2633             _exit(rc);
2634          }
2635          else if (child_id > 0) /* parent */
2636          {
2637             /* in a fork()'d environment, the parent's
2638              * copy of the client socket and the CSP
2639              * are not used.
2640              */
2641             int child_status;
2642 #if !defined(_WIN32) && !defined(__CYGWIN__)
2643
2644             wait( &child_status );
2645
2646             /*
2647              * Evaluate child's return code: If the child has
2648              *  - been toggled, toggle ourselves
2649              *  - blocked its request, bump up the stats counter
2650              */
2651
2652 #ifdef FEATURE_TOGGLE
2653             if (WIFEXITED(child_status) && (WEXITSTATUS(child_status) & RC_FLAG_TOGGLED))
2654             {
2655                global_toggle_state = !global_toggle_state;
2656             }
2657 #endif /* def FEATURE_TOGGLE */
2658
2659 #ifdef FEATURE_STATISTICS
2660             urls_read++;
2661             if (WIFEXITED(child_status) && (WEXITSTATUS(child_status) & RC_FLAG_BLOCKED))
2662             {
2663                urls_rejected++;
2664             }
2665 #endif /* def FEATURE_STATISTICS */
2666
2667 #endif /* !defined(_WIN32) && defined(__CYGWIN__) */
2668             close_socket(csp->cfd);
2669             csp->flags &= ~CSP_FLAG_ACTIVE;
2670          }
2671 #endif
2672
2673 #undef SELECTED_ONE_OPTION
2674 /* end of cpp switch () */
2675
2676          if (child_id < 0) /* failed */
2677          {
2678             char buf[BUFFER_SIZE];
2679
2680             log_error(LOG_LEVEL_ERROR, "can't fork: %E");
2681
2682             sprintf(buf , "Privoxy: can't fork: errno = %d", errno);
2683
2684             write_socket(csp->cfd, buf, strlen(buf));
2685             close_socket(csp->cfd);
2686             csp->flags &= ~CSP_FLAG_ACTIVE;
2687             sleep(5);
2688             continue;
2689          }
2690       }
2691       else
2692       {
2693          serve(csp);
2694       }
2695    }
2696
2697    /* NOTREACHED unless FEATURE_GRACEFUL_TERMINATION is defined */
2698
2699    /* Clean up.  Aim: free all memory (no leaks) */
2700 #ifdef FEATURE_GRACEFUL_TERMINATION
2701
2702    log_error(LOG_LEVEL_ERROR, "Graceful termination requested");
2703
2704    unload_current_config_file();
2705    unload_current_actions_file();
2706    unload_current_re_filterfile();
2707 #ifdef FEATURE_TRUST
2708    unload_current_trust_file();
2709 #endif
2710
2711    if (config->multi_threaded)
2712    {
2713       int i = 60;
2714       do
2715       {
2716          sleep(1);
2717          sweep();
2718       } while ((clients->next != NULL) && (--i > 0));
2719
2720       if (i <= 0)
2721       {
2722          log_error(LOG_LEVEL_ERROR, "Graceful termination failed - still some live clients after 1 minute wait.");
2723       }
2724    }
2725    sweep();
2726    sweep();
2727
2728 #if defined(unix)
2729    freez(basedir);
2730 #endif
2731    freez(configfile);
2732
2733 #ifdef FEATURE_COOKIE_JAR
2734    if (NULL != config->jar)
2735    {
2736       fclose(config->jar);
2737    }
2738 #endif
2739
2740 #if defined(_WIN32) && !defined(_WIN_CONSOLE)
2741    /* Cleanup - remove taskbar icon etc. */
2742    TermLogWindow();
2743 #endif
2744
2745    exit(0);
2746 #endif /* FEATURE_GRACEFUL_TERMINATION */
2747
2748 }
2749
2750
2751 /*
2752   Local Variables:
2753   tab-width: 3
2754   end:
2755 */