c193898dc8aac357ea4980e5e6763989a8198733
[privoxy.git] / jcc.c
1 const char jcc_rcs[] = "$Id: jcc.c,v 1.224 2009/02/14 15:32:04 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-2009 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.224  2009/02/14 15:32:04  fabiankeil
37  *    Add the request URL to the timeout message in chat().
38  *    Suggested by Lee.
39  *
40  *    Revision 1.223  2009/02/09 21:21:16  fabiankeil
41  *    Now that init_log_module() is called earlier, call show_version()
42  *    later on from main() directly so it doesn't get called for --help
43  *    or --version.
44  *
45  *    Revision 1.222  2009/02/08 12:56:51  fabiankeil
46  *    Call initialize_mutexes() before init_log_module() again.
47  *    Broken since r220, might be the cause of Lee's #2579448.
48  *
49  *    Revision 1.221  2009/02/06 18:02:58  fabiankeil
50  *    When dropping privileges, also give up membership in supplementary
51  *    groups. Thanks to Matthias Drochner for reporting the problem,
52  *    providing the initial patch and testing the final version.
53  *
54  *    Revision 1.220  2009/02/04 18:29:07  fabiankeil
55  *    Initialize the log module before parsing arguments.
56  *    Thanks to Matthias Drochner for the report.
57  *
58  *    Revision 1.219  2009/01/31 16:08:21  fabiankeil
59  *    Remove redundant error check in receive_client_request().
60  *
61  *    Revision 1.218  2009/01/31 12:25:54  fabiankeil
62  *    Flatten indentation in receive_client_request().
63  *
64  *    Revision 1.217  2009/01/07 19:50:09  fabiankeil
65  *    - If the socket-timeout has been reached and the client
66  *      hasn't received any data yet, send an explanation before
67  *      closing the connection.
68  *    - In get_request_line(), signal timeouts the right way.
69  *
70  *    Revision 1.216  2008/12/24 22:13:11  ler762
71  *    fix GCC 3.4.4 warning
72  *
73  *    Revision 1.215  2008/12/24 17:06:19  fabiankeil
74  *    Keep a thread around to timeout alive connections
75  *    even if no new requests are coming in.
76  *
77  *    Revision 1.214  2008/12/20 14:53:55  fabiankeil
78  *    Add config option socket-timeout to control the time
79  *    Privoxy waits for data to arrive on a socket. Useful
80  *    in case of stale ssh tunnels or when fuzz-testing.
81  *
82  *    Revision 1.213  2008/12/15 18:45:51  fabiankeil
83  *    When logging crunches, log the whole URL, so one can easily
84  *    differentiate between vanilla HTTP and CONNECT requests.
85  *
86  *    Revision 1.212  2008/12/14 15:46:22  fabiankeil
87  *    Give crunched requests their own log level.
88  *
89  *    Revision 1.211  2008/12/06 10:05:03  fabiankeil
90  *    Downgrade "Received x bytes while expecting y." message to
91  *    LOG_LEVEL_CONNECT as it doesn't necessarily indicate an error.
92  *
93  *    Revision 1.210  2008/12/02 22:03:18  fabiankeil
94  *    Don't miscalculate byte_count if we don't get all the
95  *    server headers with one read_socket() call. With keep-alive
96  *    support enabled, this caused delays until the server closed
97  *    the connection.
98  *
99  *    Revision 1.209  2008/11/27 09:44:04  fabiankeil
100  *    Cosmetics for the last commit: Don't watch out for
101  *    the last chunk if the content isn't chunk-encoded or
102  *    if we already determined the content length previously.
103  *
104  *    Revision 1.208  2008/11/26 18:24:17  fabiankeil
105  *    Recognize that the server response is complete if the
106  *    last chunk is read together with the server headers.
107  *    Reported by Lee.
108  *
109  *    Revision 1.207  2008/11/25 17:25:16  fabiankeil
110  *    Don't convert the client-header list to text until we need to.
111  *
112  *    Revision 1.206  2008/11/23 17:00:11  fabiankeil
113  *    Some more chat() cosmetics.
114  *
115  *    Revision 1.205  2008/11/16 12:43:49  fabiankeil
116  *    Turn keep-alive support into a runtime feature
117  *    that is disabled by setting keep-alive-timeout
118  *    to a negative value.
119  *
120  *    Revision 1.204  2008/11/06 19:42:17  fabiankeil
121  *    Fix last-chunk detection hack to also apply
122  *    if buf[] contains nothing but the last-chunk.
123  *
124  *    Revision 1.203  2008/11/06 18:34:35  fabiankeil
125  *    Factor receive_client_request() and
126  *    parse_client_request() out of chat().
127  *
128  *    Revision 1.202  2008/11/02 18:40:34  fabiankeil
129  *    If we received a different amount of data than we expected,
130  *    log a warning and make sure the server socket isn't reused.
131  *
132  *    Revision 1.201  2008/11/02 16:48:20  fabiankeil
133  *    Revert revision 1.195 and try again.
134  *
135  *    Revision 1.200  2008/10/26 16:53:18  fabiankeil
136  *    Fix gcc44 warning.
137  *
138  *    Revision 1.199  2008/10/26 15:36:10  fabiankeil
139  *    Remove two debug messages with LOG_LEVEL_INFO.
140  *
141  *    Revision 1.198  2008/10/22 15:19:55  fabiankeil
142  *    Once More, With Feeling: if there is no logfile
143  *    because the user didn't specify one, we shouldn't
144  *    call init_error_log() after receiving SIGHUP either.
145  *
146  *    Revision 1.197  2008/10/20 17:02:40  fabiankeil
147  *    If SIGHUP is received while we aren't running in daemon
148  *    mode, calling init_error_log() would be a mistake.
149  *
150  *    Revision 1.196  2008/10/16 09:16:41  fabiankeil
151  *    - Fix two gcc44 conversion warnings.
152  *    - Don't bother logging the last five bytes
153  *      of the 0-chunk.
154  *
155  *    Revision 1.195  2008/10/13 16:04:37  fabiankeil
156  *    Make sure we don't try to reuse tainted server sockets.
157  *
158  *    Revision 1.194  2008/10/12 18:35:18  fabiankeil
159  *    The last commit was a bit too ambitious, apparently the content
160  *    length adjustment is only necessary if we aren't buffering.
161  *
162  *    Revision 1.193  2008/10/12 15:57:35  fabiankeil
163  *    Fix content length calculation if we read headers
164  *    and the start of the body at once. Now that we have
165  *    FEATURE_CONNECTION_KEEP_ALIVE, it actually matters.
166  *
167  *    Revision 1.192  2008/10/11 18:19:14  fabiankeil
168  *    Even more chat() cosmetics.
169  *
170  *    Revision 1.191  2008/10/11 18:00:14  fabiankeil
171  *    Reformat some comments in chat().
172  *
173  *    Revision 1.190  2008/10/11 14:58:00  fabiankeil
174  *    In case of chunk-encoded content, stop reading if
175  *    the buffer looks like it ends with the last chunk.
176  *
177  *    Revision 1.189  2008/10/11 09:53:00  fabiankeil
178  *    Let server_response_is_complete() deal properly with
179  *    content that is neither buffered nor read all at once.
180  *
181  *    Revision 1.188  2008/10/09 18:21:41  fabiankeil
182  *    Flush work-in-progress changes to keep outgoing connections
183  *    alive where possible. Incomplete and mostly #ifdef'd out.
184  *
185  *    Revision 1.187  2008/09/07 12:35:05  fabiankeil
186  *    Add mutex lock support for _WIN32.
187  *
188  *    Revision 1.186  2008/09/04 08:13:58  fabiankeil
189  *    Prepare for critical sections on Windows by adding a
190  *    layer of indirection before the pthread mutex functions.
191  *
192  *    Revision 1.185  2008/08/30 12:03:07  fabiankeil
193  *    Remove FEATURE_COOKIE_JAR.
194  *
195  *    Revision 1.184  2008/08/22 15:34:45  fabiankeil
196  *    - Silence LLVM/Clang complaint.
197  *    - Make received_hup_signal static.
198  *    - Hide definitions for basedir, pidfile and received_hup_signal
199  *      from __EMX__ as they only seem to be used in case of #ifdef unix.
200  *
201  *    Revision 1.183  2008/08/21 07:09:35  fabiankeil
202  *    Accept Shoutcast responses again. Problem reported
203  *    and fix suggested by Stefan in #2062860.
204  *
205  *    Revision 1.182  2008/06/27 11:13:56  fabiankeil
206  *    Fix possible NULL-pointer dereference reported
207  *    by din_a4 in #2003937. Pointy hat to me.
208  *
209  *    Revision 1.181  2008/05/21 15:47:15  fabiankeil
210  *    Streamline sed()'s prototype and declare
211  *    the header parse and add structures static.
212  *
213  *    Revision 1.180  2008/05/21 15:26:32  fabiankeil
214  *    - Mark csp as immutable for send_crunch_response().
215  *    - Fix comment spelling.
216  *
217  *    Revision 1.179  2008/05/20 20:13:32  fabiankeil
218  *    Factor update_server_headers() out of sed(), ditch the
219  *    first_run hack and make server_patterns_light static.
220  *
221  *    Revision 1.178  2008/05/10 13:23:38  fabiankeil
222  *    Don't provide get_header() with the whole client state
223  *    structure when it only needs access to csp->iob.
224  *
225  *    Revision 1.177  2008/05/10 11:51:12  fabiankeil
226  *    Make the "read the rest of the headers" loop a bit more readable.
227  *
228  *    Revision 1.176  2008/05/10 11:37:57  fabiankeil
229  *    - Instead of logging when the IIS5 hack is enabled, log when it fails.
230  *    - Remove useless comment.
231  *
232  *    Revision 1.175  2008/05/09 18:53:59  fabiankeil
233  *    Fix comment grammar.
234  *
235  *    Revision 1.174  2008/05/07 18:05:53  fabiankeil
236  *    Remove the pointless buffer in client_protocol_is_unsupported().
237  *
238  *    Revision 1.173  2008/05/06 15:09:00  fabiankeil
239  *    Least-effort fix for bug #1821930 (reported by Lee):
240  *    If the response doesn't look like HTTP,
241  *    tell the client and log the problem.
242  *
243  *    Revision 1.172  2008/04/16 16:38:21  fabiankeil
244  *    Don't pass the whole csp structure to flush_socket()
245  *    when it only needs a file descriptor and a buffer.
246  *
247  *    Revision 1.171  2008/03/27 18:27:25  fabiankeil
248  *    Remove kill-popups action.
249  *
250  *    Revision 1.170  2008/03/06 16:33:46  fabiankeil
251  *    If limit-connect isn't used, don't limit CONNECT requests to port 443.
252  *
253  *    Revision 1.169  2008/03/04 18:30:39  fabiankeil
254  *    Remove the treat-forbidden-connects-like-blocks action. We now
255  *    use the "blocked" page for forbidden CONNECT requests by default.
256  *
257  *    Revision 1.168  2008/03/02 12:25:25  fabiankeil
258  *    Also use shiny new connect_port_is_forbidden() in jcc.c.
259  *
260  *    Revision 1.167  2008/02/23 16:57:12  fabiankeil
261  *    Rename url_actions() to get_url_actions() and let it
262  *    use the standard parameter ordering.
263  *
264  *    Revision 1.166  2008/02/23 16:33:43  fabiankeil
265  *    Let forward_url() use the standard parameter ordering
266  *    and mark its second parameter immutable.
267  *
268  *    Revision 1.165  2008/02/02 19:36:56  fabiankeil
269  *    Remove the "Listening ... for local connections only" log message.
270  *    Whether or not remote connections are able to reach Privoxy is up
271  *    to the operating system.
272  *
273  *    Revision 1.164  2007/12/16 18:32:46  fabiankeil
274  *    Prevent the log messages for CONNECT requests to unacceptable
275  *    ports from printing the limit-connect argument as [null] if
276  *    limit-connect hasn't been explicitly enabled.
277  *
278  *    Revision 1.163  2007/12/13 01:47:11  david__schmidt
279  *    Make sure all console-mode apps get a usage() instance
280  *
281  *    Revision 1.162  2007/12/06 17:54:57  fabiankeil
282  *    Reword NO_SERVER_DATA_RESPONSE to make it harder
283  *    to misunderstand what the message is all about.
284  *
285  *    Revision 1.161  2007/12/04 19:44:22  fabiankeil
286  *    Unbreak trustfile which previously didn't work without
287  *    FEATURE_TOGGLE. Fixes BR#1843585, reported by Lee.
288  *
289  *    Revision 1.160  2007/11/29 18:00:29  fabiankeil
290  *    Plug memory leak. Spotted by Valgrind, triggered by
291  *    Privoxy-Regression-Test feeding proxyfuzz.py.
292  *
293  *    Revision 1.159  2007/11/24 14:34:09  fabiankeil
294  *    In the HTTP snipplets, refer to the client as client.
295  *
296  *    Revision 1.158  2007/11/11 16:44:17  fabiankeil
297  *    Emit a log message when activating the MS IIS5 hack.
298  *
299  *    Revision 1.157  2007/11/03 17:34:49  fabiankeil
300  *    Log the "weak randomization factor" warning only
301  *    once for mingw32 and provide some more details.
302  *
303  *    Revision 1.156  2007/11/01 18:20:58  fabiankeil
304  *    Initialize log module after initializing mutexes, future
305  *    deadlocks in that code should now work cross-platform.
306  *
307  *    Revision 1.155  2007/10/23 20:12:45  fabiankeil
308  *    Fix first CSUCCEED line to end in \r\n as required by RFC1945.
309  *    Reported by Bert van Leeuwen in BR#1818808.
310  *
311  *    Revision 1.154  2007/10/19 17:00:08  fabiankeil
312  *    Downgrade "Flushing header and buffers" message to LOG_LEVEL_INFO.
313  *
314  *    Revision 1.153  2007/10/14 14:12:41  fabiankeil
315  *    When in daemon mode, close stderr after the configuration file has been
316  *    parsed the first time. If logfile isn't set, stop logging. Fixes BR#897436.
317  *
318  *    Revision 1.152  2007/10/04 18:03:34  fabiankeil
319  *    - Fix a crash when parsing invalid requests whose first header
320  *      is rejected by get_header(). Regression (re?)introduced
321  *      in r1.143 by yours truly.
322  *    - Move ACTION_VANILLA_WAFER handling into parsers.c's
323  *      client_cookie_adder() to make sure send-vanilla-wafer can be
324  *      controlled through tags (and thus regression-tested).
325  *
326  *    Revision 1.151  2007/09/29 10:21:16  fabiankeil
327  *    - Move get_filter_function() from jcc.c to filters.c
328  *      so the filter functions can be static.
329  *    - Don't bother filtering body-less responses.
330  *
331  *    Revision 1.150  2007/09/28 16:39:29  fabiankeil
332  *    Execute content filters through execute_content_filter().
333  *
334  *    Revision 1.149  2007/09/04 15:08:48  fabiankeil
335  *    Initialize req to NULL to make sure it's defined if the
336  *    first read_socket() call fails. Reported by icmp30.
337  *
338  *    Revision 1.148  2007/08/26 16:47:13  fabiankeil
339  *    Add Stephen Gildea's --pre-chroot-nslookup patch [#1276666],
340  *    extensive comments moved to user manual.
341  *
342  *    Revision 1.147  2007/08/25 14:42:40  fabiankeil
343  *    Don't crash if a broken header filter wiped out the request line.
344  *
345  *    Revision 1.146  2007/08/20 17:09:32  fabiankeil
346  *    Fix byte_count calculation in case of flushes
347  *    and don't parse the server headers a second time.
348  *
349  *    Revision 1.145  2007/08/19 13:13:31  fabiankeil
350  *    - If there's a connection problem after we already forwarded
351  *      parts of the original content, just hang up. Fixes BR#1776724.
352  *    - Fix warnings about unused code on mingw32.
353  *    - In case of flushes, calculate the byte count
354  *      less incorrectly (I think).
355  *
356  *    Revision 1.144  2007/08/11 14:43:22  fabiankeil
357  *    Add some more prototypes for static functions.
358  *
359  *    Revision 1.143  2007/08/05 13:58:19  fabiankeil
360  *    Comment out request_contains_null_bytes() until it's used again.
361  *
362  *    Revision 1.142  2007/08/05 13:50:26  fabiankeil
363  *    #1763173 from Stefan Huehner: s@const static@static const@
364  *    and declare some more functions static.
365  *
366  *    Revision 1.141  2007/08/04 09:56:23  fabiankeil
367  *    - Log rejected CONNECT requests with LOG_LEVEL_INFO
368  *      and explain why they were rejected in the first place.
369  *    - Fix the LOG_LEVEL_CLF message for crunches of unallowed
370  *      CONNECT requests. The request line was missing.
371  *    - Add two more XXX reminders as we don't have enough already.
372  *
373  *    Revision 1.140  2007/07/21 11:51:36  fabiankeil
374  *    As Hal noticed, checking dispatch_cgi() as the last cruncher
375  *    looks like a bug if CGI requests are blocked unintentionally,
376  *    so don't do it unless the user enabled the new config option
377  *    "allow-cgi-request-crunching".
378  *
379  *    Revision 1.139  2007/07/14 07:46:41  fabiankeil
380  *    - Allow to rewrite the request destination behind the client's back.
381  *    - Turn the weird-looking unconditional for loop that
382  *      reads the client request into a conditional while loop.
383  *      Move the stuff that only runs once out of the loop.
384  *    - Move parts of chat(), server_content_type() and the
385  *      necessary stuff to fix BR#1750917 into get_filter_function().
386  *
387  *    Revision 1.138  2007/06/03 18:45:18  fabiankeil
388  *    Temporary workaround for BR#1730105.
389  *
390  *    Revision 1.137  2007/06/01 18:16:36  fabiankeil
391  *    Use the same mutex for gethostbyname() and gethostbyaddr() to prevent
392  *    deadlocks and crashes on OpenBSD and possibly other OS with neither
393  *    gethostbyname_r() nor gethostaddr_r(). Closes BR#1729174.
394  *    Thanks to Ralf Horstmann for report and solution.
395  *
396  *    Revision 1.136  2007/06/01 16:41:11  fabiankeil
397  *    Add forward-override{} to change the forwarding settings through
398  *    action sections. This is mainly interesting to forward different
399  *    clients differently (for example based on User-Agent or request
400  *    origin).
401  *
402  *    Revision 1.135  2007/05/24 17:03:50  fabiankeil
403  *    - Let usage() mention the --chroot parameter.
404  *    - Use read_socket() consistently and always leave
405  *      the last buffer byte alone, even in cases where
406  *      null termination (currently) doesn't matter.
407  *
408  *    Revision 1.134  2007/05/16 14:59:46  fabiankeil
409  *    - Fix config file loading on Unix if no config file is specified.
410  *      Since r1.97 Privoxy would always interpret the last argument as
411  *      config file, even if it's a valid command line option.
412  *    - Abort in case of unrecognized command line options. Closes #1719696.
413  *    - Remove a bunch of unnecessary strcpy() calls (yay for c&p without thinking).
414  *    - Replace the remaining strcpy() and strcat() calls with strlcpy() and strcat().
415  *
416  *    Revision 1.133  2007/05/04 11:23:19  fabiankeil
417  *    - Don't rerun crunchers that only depend on the request URL.
418  *    - Don't count redirects and CGI requests as "blocked requests".
419  *
420  *    Revision 1.132  2007/04/25 15:15:17  fabiankeil
421  *    Support crunching based on tags created by server-header taggers.
422  *
423  *    Revision 1.131  2007/04/22 13:24:50  fabiankeil
424  *    Make HTTP snippets static (again). Add a Content-Type for those
425  *    with content so the browser doesn't guess it based on the URL.
426  *
427  *    Revision 1.130  2007/04/19 13:47:34  fabiankeil
428  *    Move crunching and request line rebuilding out of chat().
429  *
430  *    Revision 1.129  2007/04/15 16:39:20  fabiankeil
431  *    Introduce tags as alternative way to specify which
432  *    actions apply to a request. At the moment tags can be
433  *    created based on client and server headers.
434  *
435  *    Revision 1.128  2007/03/25 16:55:54  fabiankeil
436  *    Don't CLF-log CONNECT requests twice.
437  *
438  *    Revision 1.127  2007/03/20 13:53:17  fabiankeil
439  *    Log the source address for ACL-related connection drops.
440  *
441  *    Revision 1.126  2007/03/17 15:20:05  fabiankeil
442  *    New config option: enforce-blocks.
443  *
444  *    Revision 1.125  2007/03/09 14:12:00  fabiankeil
445  *    - Move null byte check into separate function.
446  *    - Don't confuse the client with error pages
447  *      if a CONNECT request was already confirmed.
448  *
449  *    Revision 1.124  2007/02/23 14:59:54  fabiankeil
450  *    Speed up NULL byte escaping and only log the complete
451  *    NULL byte requests with header debugging enabled.
452  *
453  *    Revision 1.123  2007/02/21 18:42:10  fabiankeil
454  *    Answer requests that contain NULL bytes with
455  *    a custom response instead of waiting for more
456  *    data until the client eventually hangs up.
457  *
458  *    Revision 1.122  2007/02/07 11:12:02  fabiankeil
459  *    - Move delivery and logging of crunched responses
460  *      from chat() into send_crunch_response().
461  *    - Display the reason for generating http_responses.
462  *    - Log the content length for LOG_LEVEL_CLF correctly
463  *      (still incorrect for some fixed responses).
464  *    - Reword an incorrect comment about
465  *      treat-forbidden-connects-like-blocks violating
466  *      the specs.
467  *    - Add some log messages.
468  *
469  *    Revision 1.121  2007/01/27 10:52:56  fabiankeil
470  *    Move mutex initialization into separate
471  *    function and exit in case of errors.
472  *
473  *    Revision 1.120  2007/01/26 14:18:42  fabiankeil
474  *    - Start to reduce chat()'s line count and move
475  *      parts of it into separate functions.
476  *    - Add "HTTP/1.1 100 Continue" hack for BR 756734.
477  *
478  *    Revision 1.119  2007/01/25 14:02:30  fabiankeil
479  *    - Add Proxy-Agent header to HTTP snippets that are
480  *      supposed to reach HTTP clients only.
481  *    - Made a few CONNECT log messages more descriptive.
482  *    - Catch completely empty server responses (as seen
483  *      with Tor's fake ".noconnect" top level domain).
484  *    - Use shiny new "forwarding-failed" template for socks errors.
485  *
486  *    Revision 1.118  2007/01/07 07:43:43  joergs
487  *    AmigaOS4 support added.
488  *
489  *    Revision 1.117  2006/12/31 17:56:37  fabiankeil
490  *    Added config option accept-intercepted-requests
491  *    and disabled it by default.
492  *
493  *    Revision 1.116  2006/12/29 19:08:22  fabiankeil
494  *    Reverted parts of my last commit
495  *    to keep error handling working.
496  *
497  *    Revision 1.115  2006/12/29 17:38:57  fabiankeil
498  *    Fixed gcc43 conversion warnings.
499  *
500  *    Revision 1.114  2006/12/27 18:52:02  fabiankeil
501  *    Fix -pedantic ISO C warning about converting
502  *    from function pointer to object pointer.
503  *
504  *    Revision 1.113  2006/12/26 17:38:50  fabiankeil
505  *    Silence compiler warning I introduced with my last commit.
506  *
507  *    Revision 1.112  2006/12/26 17:31:41  fabiankeil
508  *    Mutex protect rand() if POSIX threading
509  *    is used, warn the user if that's not possible
510  *    and stop using it on _WIN32 where it could
511  *    cause crashes.
512  *
513  *    Revision 1.111  2006/12/23 16:15:06  fabiankeil
514  *    Don't prevent core dumps by catching SIGABRT.
515  *    It's rude and makes debugging unreasonable painful.
516  *
517  *    Revision 1.110  2006/12/13 14:52:53  etresoft
518  *    Fix build failure on MacOS X. Global symbols can be either static or extern, but not both.
519  *
520  *    Revision 1.109  2006/12/06 19:41:40  fabiankeil
521  *    Privoxy is now able to run as intercepting
522  *    proxy in combination with any packet filter
523  *    that does the port redirection. The destination
524  *    is extracted from the "Host:" header which
525  *    should be available for nearly all requests.
526  *
527  *    Moved HTTP snipplets into jcc.c.
528  *    Added error message for gopher proxy requests.
529  *
530  *    Revision 1.108  2006/11/28 15:38:51  fabiankeil
531  *    Only unlink the pidfile if it's actually used.
532  *
533  *    Change order of interception checks to make
534  *    it possible to block or redirect requests for
535  *    the cgi pages.
536  *
537  *    Revision 1.107  2006/11/13 19:05:51  fabiankeil
538  *    Make pthread mutex locking more generic. Instead of
539  *    checking for OSX and OpenBSD, check for FEATURE_PTHREAD
540  *    and use mutex locking unless there is an _r function
541  *    available. Better safe than sorry.
542  *
543  *    Fixes "./configure --disable-pthread" and should result
544  *    in less threading-related problems on pthread-using platforms,
545  *    but it still doesn't fix BR#1122404.
546  *
547  *    Revision 1.106  2006/11/06 19:58:23  fabiankeil
548  *    Move pthread.h inclusion from jcc.c to jcc.h.
549  *    Fixes build on x86-freebsd1 (FreeBSD 5.4-RELEASE).
550  *
551  *    Revision 1.105  2006/11/06 14:26:02  fabiankeil
552  *    Don't exit after receiving the second SIGHUP on Solaris.
553  *
554  *    Fixes BR 1052235, but the same problem may exist on other
555  *    systems. Once 3.0.6 is out we should use sigset()
556  *    where available and see if it breaks anything.
557  *
558  *    Revision 1.104  2006/09/23 13:26:38  roro
559  *    Replace TABs by spaces in source code.
560  *
561  *    Revision 1.103  2006/09/21 12:54:43  fabiankeil
562  *    Fix +redirect{}. Didn't work with -fast-redirects.
563  *
564  *    Revision 1.102  2006/09/06 13:03:04  fabiankeil
565  *    Respond with 400 and a short text message
566  *    if the client tries to use Privoxy as FTP proxy.
567  *
568  *    Revision 1.101  2006/09/06 09:23:37  fabiankeil
569  *    Make number of retries in case of forwarded-connect problems
570  *    a config file option (forwarded-connect-retries) and use 0 as
571  *    default.
572  *
573  *    Revision 1.100  2006/09/03 19:42:59  fabiankeil
574  *    Set random(3) seed.
575  *
576  *    Revision 1.99  2006/09/02 15:36:42  fabiankeil
577  *    Follow the OpenBSD port's lead and protect the resolve
578  *    functions on OpenBSD as well.
579  *
580  *    Revision 1.98  2006/08/24 11:01:34  fabiankeil
581  *    --user fix. Only use the user as group if no group is specified.
582  *    Solves BR 1492612. Thanks to Spinor S. and David Laight.
583  *
584  *    Revision 1.97  2006/08/18 15:23:17  david__schmidt
585  *    Windows service (re-)integration
586  *
587  *    The new args are:
588  *
589  *    --install[:service_name]
590  *    --uninstall[:service_name]
591  *    --service
592  *
593  *    They work as follows:
594  *    --install will create a service for you and then terminate.
595  *    By default the service name will be "privoxy" (without the quotes).
596  *    However you can run multiple services if you wish, just by adding
597  *    a colon and then a name (no spaces).
598  *
599  *    --uninstall follows the exact same rules a --install.
600  *
601  *    --service is used when the program is executed by the service
602  *    control manager, and in normal circumstances would never be
603  *    used as a command line argument.
604  *
605  *    Revision 1.96  2006/08/15 20:12:36  david__schmidt
606  *    Windows service integration
607  *
608  *    Revision 1.95  2006/08/03 02:46:41  david__schmidt
609  *    Incorporate Fabian Keil's patch work:
610 http://www.fabiankeil.de/sourcecode/privoxy/
611  *
612  *    Revision 1.94  2006/07/18 14:48:46  david__schmidt
613  *    Reorganizing the repository: swapping out what was HEAD (the old 3.1 branch)
614  *    with what was really the latest development (the v_3_0_branch branch)
615  *
616  *    Revision 1.92.2.16  2005/04/03 20:10:50  david__schmidt
617  *    Thanks to Jindrich Makovicka for a race condition fix for the log
618  *    file.  The race condition remains for non-pthread implementations.
619  *    Reference patch #1175720.
620  *
621  *    Revision 1.92.2.15  2004/10/03 12:53:32  david__schmidt
622  *    Add the ability to check jpeg images for invalid
623  *    lengths of comment blocks.  Defensive strategy
624  *    against the exploit:
625  *       Microsoft Security Bulletin MS04-028
626  *       Buffer Overrun in JPEG Processing (GDI+) Could
627  *       Allow Code Execution (833987)
628  *    Enabled with +inspect-jpegs in actions files.
629  *
630  *    Revision 1.92.2.14  2003/12/12 12:52:53  oes
631  *    - Fixed usage info for non-unix platforms
632  *    - Fixed small cmdline parsing bug
633  *
634  *    Revision 1.92.2.13  2003/11/27 19:20:27  oes
635  *    Diagnostics: Now preserve the returncode of pthread_create
636  *    in errno. Closes BR #775721. Thanks to Geoffrey Hausheer.
637  *
638  *    Revision 1.92.2.12  2003/07/11 11:34:19  oes
639  *    No longer ignore SIGCHLD. Fixes bug #769381
640  *
641  *    Revision 1.92.2.11  2003/05/14 12:32:02  oes
642  *    Close jarfile on graceful exit, remove stray line
643  *
644  *    Revision 1.92.2.10  2003/05/08 15:13:46  oes
645  *    Cosmetics: Killed a warning, a typo and an allocation left at exit
646  *
647  *    Revision 1.92.2.9  2003/04/03 15:08:42  oes
648  *    No longer rely on non-POSIX.1 extensions of getcwd().
649  *    Fixes bug #711001
650  *
651  *    Revision 1.92.2.8  2003/03/31 13:12:32  oes
652  *    Replaced setenv() by posix-compliant putenv()
653  *    Thanks to Neil McCalden (nmcc AT users.sf.net).
654  *
655  *    Revision 1.92.2.7  2003/03/17 16:48:59  oes
656  *    Added chroot ability, thanks to patch by Sviatoslav Sviridov
657  *
658  *    Revision 1.92.2.6  2003/03/11 11:55:00  oes
659  *    Clean-up and extension of improvements for forked mode:
660  *     - Child's return code now consists of flags RC_FLAG_*
661  *     - Reporting toggle to parent now properly #ifdef'ed
662  *     - Children now report blocking to parent. This enables
663  *       statistics in forked mode
664  *
665  *    Revision 1.92.2.5  2003/03/10 23:45:32  oes
666  *    Fixed bug #700381: Non-Threaded version now capable of being toggled.
667  *    Children now report having been toggled through _exit(17), parents
668  *    watch for that code and toggle themselves if found.
669  *
670  *    Revision 1.92.2.4  2003/03/07 03:41:04  david__schmidt
671  *    Wrapping all *_r functions (the non-_r versions of them) with 
672  *    mutex semaphores for OSX.  Hopefully this will take care of all 
673  *    of those pesky crash reports.
674  *
675  *    Revision 1.92.2.3  2003/02/28 12:53:06  oes
676  *    Fixed two mostly harmless mem leaks
677  *
678  *    Revision 1.92.2.2  2002/11/20 14:37:47  oes
679  *    Fix: Head of global clients list now initialized to NULL
680  *
681  *    Revision 1.92.2.1  2002/09/25 14:52:24  oes
682  *    Added basic support for OPTIONS and TRACE HTTP methods:
683  *     - New interceptor direct_response() added in chat().
684  *     - sed() moved to earlier in the process, so that the
685  *       Host: header is evaluated before actions and forwarding
686  *       are decided on.
687  *
688  *    Revision 1.92  2002/05/08 16:00:46  oes
689  *    Chat's buffer handling:
690  *     - Fixed bug with unchecked out-of-mem conditions
691  *       while reading client request & server headers
692  *     - No longer predict if the buffer limit will be exceeded
693  *       in the next read -- check add_to_iob's new
694  *       return code. If buffer couldn't be extended
695  *       (policy or out-of-mem) while
696  *       - reading from client: abort
697  *       - reading server headers: send error page
698  *       - buffering server body for filter: flush,
699  *         and if that fails: send error page
700  *
701  *    Revision 1.91  2002/04/08 20:35:58  swa
702  *    fixed JB spelling
703  *
704  *    Revision 1.90  2002/04/02 14:57:28  oes
705  *    Made sending wafers independent of FEATURE_COOKIE_JAR
706  *
707  *    Revision 1.89  2002/03/31 17:18:59  jongfoster
708  *    Win32 only: Enabling STRICT to fix a VC++ compile warning.
709  *
710  *    Revision 1.88  2002/03/27 14:32:43  david__schmidt
711  *    More compiler warning message maintenance
712  *
713  *    Revision 1.87  2002/03/26 22:29:54  swa
714  *    we have a new homepage!
715  *
716  *    Revision 1.86  2002/03/25 17:04:55  david__schmidt
717  *    Workaround for closing the jarfile before load_config() comes around again
718  *
719  *    Revision 1.85  2002/03/24 15:23:33  jongfoster
720  *    Name changes
721  *
722  *    Revision 1.84  2002/03/24 13:25:43  swa
723  *    name change related issues
724  *
725  *    Revision 1.83  2002/03/16 23:54:06  jongfoster
726  *    Adding graceful termination feature, to help look for memory leaks.
727  *    If you enable this (which, by design, has to be done by hand
728  *    editing config.h) and then go to http://i.j.b/die, then the program
729  *    will exit cleanly after the *next* request.  It should free all the
730  *    memory that was used.
731  *
732  *    Revision 1.82  2002/03/13 00:27:05  jongfoster
733  *    Killing warnings
734  *
735  *    Revision 1.81  2002/03/12 01:42:50  oes
736  *    Introduced modular filters
737  *
738  *    Revision 1.80  2002/03/11 22:07:05  david__schmidt
739  *    OS/2 port maintenance:
740  *    - Fixed EMX build - it had decayed a little
741  *    - Fixed inexplicable crash during FD_ZERO - must be due to a bad macro.
742  *      substituted a memset for now.
743  *
744  *    Revision 1.79  2002/03/09 20:03:52  jongfoster
745  *    - Making various functions return int rather than size_t.
746  *      (Undoing a recent change).  Since size_t is unsigned on
747  *      Windows, functions like read_socket that return -1 on
748  *      error cannot return a size_t.
749  *
750  *      THIS WAS A MAJOR BUG - it caused frequent, unpredictable
751  *      crashes, and also frequently caused JB to jump to 100%
752  *      CPU and stay there.  (Because it thought it had just
753  *      read ((unsigned)-1) == 4Gb of data...)
754  *
755  *    - The signature of write_socket has changed, it now simply
756  *      returns success=0/failure=nonzero.
757  *
758  *    - Trying to get rid of a few warnings --with-debug on
759  *      Windows, I've introduced a new type "jb_socket".  This is
760  *      used for the socket file descriptors.  On Windows, this
761  *      is SOCKET (a typedef for unsigned).  Everywhere else, it's
762  *      an int.  The error value can't be -1 any more, so it's
763  *      now JB_INVALID_SOCKET (which is -1 on UNIX, and in
764  *      Windows it maps to the #define INVALID_SOCKET.)
765  *
766  *    - The signature of bind_port has changed.
767  *
768  *    Revision 1.78  2002/03/08 21:35:04  oes
769  *    Added optional group supplement to --user option. Will now use default group of user if no group given
770  *
771  *    Revision 1.77  2002/03/07 03:52:06  oes
772  *     - Fixed compiler warnings etc
773  *     - Improved handling of failed DNS lookups
774  *
775  *    Revision 1.76  2002/03/06 22:54:35  jongfoster
776  *    Automated function-comment nitpicking.
777  *
778  *    Revision 1.75  2002/03/06 10:02:19  oes
779  *    Fixed stupid bug when --user was not given
780  *
781  *    Revision 1.74  2002/03/06 00:49:31  jongfoster
782  *    Fixing warning on Windows
783  *    Making #ifdefs that refer to the same variable consistently
784  *    use #ifdef unix rather than mixing #ifdef unix & #ifndef OS2
785  *
786  *    Revision 1.73  2002/03/05 23:57:30  hal9
787  *    Stray character 's' on line 1618 was breaking build.
788  *
789  *    Revision 1.72  2002/03/05 21:33:45  david__schmidt
790  *    - Re-enable OS/2 building after new parms were added
791  *    - Fix false out of memory report when resolving CGI templates when no IP
792  *      address is available of failed attempt (a la no such domain)
793  *
794  *    Revision 1.71  2002/03/05 18:13:56  oes
795  *    Added --user option
796  *
797  *    Revision 1.70  2002/03/05 04:52:42  oes
798  *    Deleted non-errlog debugging code
799  *
800  *    Revision 1.69  2002/03/04 23:50:00  jongfoster
801  *    Splitting off bind_port() call into bind_port_helper(), with
802  *    improved logging.
803  *
804  *    Revision 1.68  2002/03/04 20:17:32  oes
805  *    Fixed usage info
806  *
807  *    Revision 1.67  2002/03/04 18:18:57  oes
808  *    - Removed _DEBUG mode
809  *    - Cleand up cmdline parsing
810  *    - Introduced --no-daemon, --pidfile options
811  *    - Cleaned up signal handling:
812  *      - Terminate cleanly on INT, TERM and ABRT
813  *      - Schedule logfile for re-opening on HUP
814  *      - Ignore CHLD and PIPE
815  *      - Leave the rest with their default handlers
816  *      - Uniform handler registration
817  *    - Added usage() function
818  *    - Played styleguide police
819  *
820  *    Revision 1.66  2002/03/03 15:06:55  oes
821  *    Re-enabled automatic config reloading
822  *
823  *    Revision 1.65  2002/03/03 14:49:11  oes
824  *    Fixed CLF logging: Now uses client's original HTTP request
825  *
826  *    Revision 1.64  2002/03/03 09:18:03  joergs
827  *    Made jumbjuster work on AmigaOS again.
828  *
829  *    Revision 1.63  2002/03/02 04:14:50  david__schmidt
830  *    Clean up a little CRLF unpleasantness that suddenly appeared
831  *
832  *    Revision 1.62  2002/02/20 23:17:23  jongfoster
833  *    Detecting some out-of memory conditions and exiting with a log message.
834  *
835  *    Revision 1.61  2002/01/17 21:01:52  jongfoster
836  *    Moving all our URL and URL pattern parsing code to urlmatch.c.
837  *
838  *    Revision 1.60  2001/12/30 14:07:32  steudten
839  *    - Add signal handling (unix)
840  *    - Add SIGHUP handler (unix)
841  *    - Add creation of pidfile (unix)
842  *    - Add action 'top' in rc file (RH)
843  *    - Add entry 'SIGNALS' to manpage
844  *    - Add exit message to logfile (unix)
845  *
846  *    Revision 1.59  2001/12/13 14:07:18  oes
847  *    Fixed Bug: 503 error page now sent OK
848  *
849  *    Revision 1.58  2001/11/30 23:37:24  jongfoster
850  *    Renaming the Win32 config file to config.txt - this is almost the
851  *    same as the corresponding UNIX name "config"
852  *
853  *    Revision 1.57  2001/11/16 00:47:43  jongfoster
854  *    Changing the tty-disconnection code to use setsid().
855  *
856  *    Revision 1.56  2001/11/13 20:20:54  jongfoster
857  *    Tabs->spaces, fixing a bug with missing {} around an if()
858  *
859  *    Revision 1.55  2001/11/13 20:14:53  jongfoster
860  *    Patch for FreeBSD setpgrp() as suggested by Alexander Lazic
861  *
862  *    Revision 1.54  2001/11/07 00:03:14  steudten
863  *    Give reliable return value if an error
864  *    occurs not just 0 with new daemon mode.
865  *
866  *    Revision 1.53  2001/11/05 21:41:43  steudten
867  *    Add changes to be a real daemon just for unix os.
868  *    (change cwd to /, detach from controlling tty, set
869  *    process group and session leader to the own process.
870  *    Add DBG() Macro.
871  *    Add some fatal-error log message for failed malloc().
872  *    Add '-d' if compiled with 'configure --with-debug' to
873  *    enable debug output.
874  *
875  *    Revision 1.52  2001/10/26 20:11:20  jongfoster
876  *    Fixing type mismatch
877  *
878  *    Revision 1.51  2001/10/26 17:38:28  oes
879  *    Cosmetics
880  *
881  *    Revision 1.50  2001/10/25 03:40:48  david__schmidt
882  *    Change in porting tactics: OS/2's EMX porting layer doesn't allow multiple
883  *    threads to call select() simultaneously.  So, it's time to do a real, live,
884  *    native OS/2 port.  See defines for __EMX__ (the porting layer) vs. __OS2__
885  *    (native). Both versions will work, but using __OS2__ offers multi-threading.
886  *
887  *    Revision 1.49  2001/10/23 21:41:35  jongfoster
888  *    Added call to initialize the (statically-allocated of course)
889  *    "out of memory" CGI response.
890  *
891  *    Revision 1.48  2001/10/10 19:56:46  jongfoster
892  *    Moving some code that wasn't cookie-related out of an #ifdef
893  *    FEATURE_COOKIE_JAR
894  *
895  *    Revision 1.47  2001/10/10 16:44:36  oes
896  *    Added CONNECT destination port limitation check
897  *
898  *    Revision 1.46  2001/10/08 15:17:41  oes
899  *    Re-enabled SSL forwarding
900  *
901  *    Revision 1.45  2001/10/07 15:42:11  oes
902  *    Replaced 6 boolean members of csp with one bitmap (csp->flags)
903  *
904  *    Moved downgrading of the HTTP version from parse_http_request to
905  *      chat(), since we can't decide if it is necessary before we have
906  *      determined the actions for the URL. The HTTP command is now
907  *      *always* re-built so the repairs need no longer be special-cased.
908  *
909  *    filter_popups now gets a csp pointer so it can raise the new
910  *      CSP_FLAG_MODIFIED flag.
911  *
912  *    Bugfix
913  *
914  *    Added configurable size limit for the IOB. If the IOB grows so
915  *      large that the next read would exceed the limit, the header
916  *      is generated, and the header & unfiltered buffer are flushed
917  *      to the client. Chat then continues in non-buffering,
918  *      non-filtering body mode.
919  *
920  *    Revision 1.44  2001/10/02 18:13:57  oes
921  *    Ooops
922  *
923  *    Revision 1.43  2001/10/02 15:32:13  oes
924  *    Moved generation of hdr
925  *
926  *    Revision 1.42  2001/09/21 23:02:02  david__schmidt
927  *    Cleaning up 2 compiler warnings on OS/2.
928  *
929  *    Revision 1.41  2001/09/16 17:05:14  jongfoster
930  *    Removing unused #include showarg.h
931  *
932  *    Revision 1.40  2001/09/16 15:41:45  jongfoster
933  *    Fixing signed/unsigned comparison warning.
934  *
935  *    Revision 1.39  2001/09/16 13:21:27  jongfoster
936  *    Changes to use new list functions.
937  *
938  *    Revision 1.38  2001/09/16 13:01:46  jongfoster
939  *    Removing redundant function call that zeroed zalloc()'d memory.
940  *
941  *    Revision 1.37  2001/09/10 11:12:24  oes
942  *    Deleted unused variable
943  *
944  *    Revision 1.36  2001/09/10 10:56:15  oes
945  *    Silenced compiler warnings
946  *
947  *    Revision 1.35  2001/07/31 14:44:22  oes
948  *    Deleted unused size parameter from filter_popups()
949  *
950  *    Revision 1.34  2001/07/30 22:08:36  jongfoster
951  *    Tidying up #defines:
952  *    - All feature #defines are now of the form FEATURE_xxx
953  *    - Permanently turned off WIN_GUI_EDIT
954  *    - Permanently turned on WEBDAV and SPLIT_PROXY_ARGS
955  *
956  *    Revision 1.33  2001/07/29 19:32:00  jongfoster
957  *    Renaming _main() [mingw32 only] to real_main(), for ANSI compliance.
958  *
959  *    Revision 1.32  2001/07/29 18:47:05  jongfoster
960  *    Adding missing #include "loadcfg.h"
961  *
962  *    Revision 1.31  2001/07/29 12:17:48  oes
963  *    Applied pthread fix by Paul Lieverse
964  *
965  *    Revision 1.30  2001/07/25 22:57:13  jongfoster
966  *    __BEOS__ no longer overrides FEATURE_PTHREAD.
967  *    This is because FEATURE_PTHREAD will soon be widely used, so I
968  *    want to keep it simple.
969  *
970  *    Revision 1.29  2001/07/24 12:47:06  oes
971  *    Applied BeOS support update by Eugenia
972  *
973  *    Revision 1.28  2001/07/23 13:26:12  oes
974  *    Fixed bug in popup-killing for the first read that caused binary garbage to be sent between headers and body
975  *
976  *    Revision 1.27  2001/07/19 19:09:47  haroon
977  *    - Added code to take care of the situation where while processing the first
978  *      server response (which includes the server header), after finding the end
979  *      of the headers we were not looking past the end of the headers for
980  *      content modification. I enabled it for filter_popups.
981  *      Someone else should look to see if other similar operations should be
982  *      done to the discarded portion of the buffer.
983  *
984  *      Note 2001/07/20: No, the other content modification mechanisms will process
985  *                       the whole iob later anyway. --oes
986  *
987  *    Revision 1.26  2001/07/18 12:31:36  oes
988  *    cosmetics
989  *
990  *    Revision 1.25  2001/07/15 19:43:49  jongfoster
991  *    Supports POSIX threads.
992  *    Also removed some unused #includes.
993  *
994  *    Revision 1.24  2001/07/13 14:00:40  oes
995  *     - Generic content modification scheme:
996  *       Each feature has its own applicability flag that is set
997  *       from csp->action->flags.
998  *       Replaced the "filtering" int flag , by a function pointer
999  *       "content_filter" to the function that will do the content
1000  *       modification. If it is != NULL, the document will be buffered
1001  *       and processed through *content_filter, which must set
1002  *       csp->content_length and return a modified copy of the body
1003  *       or return NULL (on failiure).
1004  *     - Changed csp->is_text to the more generic bitmap csp->content_type
1005  *       which can currently take the valued CT_TEXT or CT_GIF
1006  *     - Reformatting etc
1007  *     - Removed all #ifdef PCRS
1008  *
1009  *    Revision 1.23  2001/07/02 02:28:25  iwanttokeepanon
1010  *    Added "#ifdef ACL_FILES" conditional compilation to line 1291 to exclude
1011  *    the `block_acl' call.  This prevents a compilation error when the user
1012  *    does not wish to use the "ACL" feature.
1013  *
1014  *    Revision 1.22  2001/06/29 21:45:41  oes
1015  *    Indentation, CRLF->LF, Tab-> Space
1016  *
1017  *    Revision 1.21  2001/06/29 13:29:36  oes
1018  *    - Cleaned up, improved comments
1019  *    - Unified all possible interceptors (CGI,
1020  *      block, trust, fast_redirect) in one
1021  *      place, with one (CGI) answer generation
1022  *      mechansim. Much clearer now.
1023  *    - Removed the GIF image generation, which
1024  *      is now done in filters.c:block_url()
1025  *    - Made error conditions like domain lookup
1026  *      failiure or (various) problems while talking
1027  *      to the server use cgi.c:error_response()
1028  *      instead of generating HTML/HTTP in chat() (yuck!)
1029  *    - Removed logentry from cancelled commit
1030  *
1031  *    Revision 1.20  2001/06/09 10:55:28  jongfoster
1032  *    Changing BUFSIZ ==> BUFFER_SIZE
1033  *
1034  *    Revision 1.19  2001/06/07 23:12:52  jongfoster
1035  *    Replacing function pointer in struct gateway with a directly
1036  *    called function forwarded_connect().
1037  *    Replacing struct gateway with struct forward_spec
1038  *
1039  *    Revision 1.18  2001/06/03 19:12:16  oes
1040  *    introduced new cgi handling
1041  *
1042  *    Revision 1.17  2001/06/01 20:07:23  jongfoster
1043  *    Now uses action +image-blocker{} rather than config->tinygif
1044  *
1045  *    Revision 1.16  2001/06/01 18:49:17  jongfoster
1046  *    Replaced "list_share" with "list" - the tiny memory gain was not
1047  *    worth the extra complexity.
1048  *
1049  *    Revision 1.15  2001/05/31 21:24:47  jongfoster
1050  *    Changed "permission" to "action" throughout.
1051  *    Removed DEFAULT_USER_AGENT - it must now be specified manually.
1052  *    Moved vanilla wafer check into chat(), since we must now
1053  *    decide whether or not to add it based on the URL.
1054  *
1055  *    Revision 1.14  2001/05/29 20:14:01  joergs
1056  *    AmigaOS bugfix: PCRS needs a lot of stack, stacksize for child threads
1057  *    increased.
1058  *
1059  *    Revision 1.13  2001/05/29 09:50:24  jongfoster
1060  *    Unified blocklist/imagelist/permissionslist.
1061  *    File format is still under discussion, but the internal changes
1062  *    are (mostly) done.
1063  *
1064  *    Also modified interceptor behaviour:
1065  *    - We now intercept all URLs beginning with one of the following
1066  *      prefixes (and *only* these prefixes):
1067  *        * http://i.j.b/
1068  *        * http://ijbswa.sf.net/config/
1069  *        * http://ijbswa.sourceforge.net/config/
1070  *    - New interceptors "home page" - go to http://i.j.b/ to see it.
1071  *    - Internal changes so that intercepted and fast redirect pages
1072  *      are not replaced with an image.
1073  *    - Interceptors now have the option to send a binary page direct
1074  *      to the client. (i.e. ijb-send-banner uses this)
1075  *    - Implemented show-url-info interceptor.  (Which is why I needed
1076  *      the above interceptors changes - a typical URL is
1077  *      "http://i.j.b/show-url-info?url=www.somesite.com/banner.gif".
1078  *      The previous mechanism would not have intercepted that, and
1079  *      if it had been intercepted then it then it would have replaced
1080  *      it with an image.)
1081  *
1082  *    Revision 1.12  2001/05/27 22:17:04  oes
1083  *
1084  *    - re_process_buffer no longer writes the modified buffer
1085  *      to the client, which was very ugly. It now returns the
1086  *      buffer, which it is then written by chat.
1087  *
1088  *    - content_length now adjusts the Content-Length: header
1089  *      for modified documents rather than crunch()ing it.
1090  *      (Length info in csp->content_length, which is 0 for
1091  *      unmodified documents)
1092  *
1093  *    - For this to work, sed() is called twice when filtering.
1094  *
1095  *    Revision 1.11  2001/05/26 17:27:53  jongfoster
1096  *    Added support for CLF and fixed LOG_LEVEL_LOG.
1097  *    Also did CRLF->LF fix of my previous patch.
1098  *
1099  *    Revision 1.10  2001/05/26 15:26:15  jongfoster
1100  *    ACL feature now provides more security by immediately dropping
1101  *    connections from untrusted hosts.
1102  *
1103  *    Revision 1.9  2001/05/26 00:28:36  jongfoster
1104  *    Automatic reloading of config file.
1105  *    Removed obsolete SIGHUP support (Unix) and Reload menu option (Win32).
1106  *    Most of the global variables have been moved to a new
1107  *    struct configuration_spec, accessed through csp->config->globalname
1108  *    Most of the globals remaining are used by the Win32 GUI.
1109  *
1110  *    Revision 1.8  2001/05/25 22:43:18  jongfoster
1111  *    Fixing minor memory leak and buffer overflow.
1112  *
1113  *    Revision 1.7  2001/05/25 22:34:30  jongfoster
1114  *    Hard tabs->Spaces
1115  *
1116  *    Revision 1.6  2001/05/23 00:13:58  joergs
1117  *    AmigaOS support fixed.
1118  *
1119  *    Revision 1.5  2001/05/22 18:46:04  oes
1120  *
1121  *    - Enabled filtering banners by size rather than URL
1122  *      by adding patterns that replace all standard banner
1123  *      sizes with the "Junkbuster" gif to the re_filterfile
1124  *
1125  *    - Enabled filtering WebBugs by providing a pattern
1126  *      which kills all 1x1 images
1127  *
1128  *    - Added support for PCRE_UNGREEDY behaviour to pcrs,
1129  *      which is selected by the (nonstandard and therefore
1130  *      capital) letter 'U' in the option string.
1131  *      It causes the quantifiers to be ungreedy by default.
1132  *      Appending a ? turns back to greedy (!).
1133  *
1134  *    - Added a new interceptor ijb-send-banner, which
1135  *      sends back the "Junkbuster" gif. Without imagelist or
1136  *      MSIE detection support, or if tinygif = 1, or the
1137  *      URL isn't recognized as an imageurl, a lame HTML
1138  *      explanation is sent instead.
1139  *
1140  *    - Added new feature, which permits blocking remote
1141  *      script redirects and firing back a local redirect
1142  *      to the browser.
1143  *      The feature is conditionally compiled, i.e. it
1144  *      can be disabled with --disable-fast-redirects,
1145  *      plus it must be activated by a "fast-redirects"
1146  *      line in the config file, has its own log level
1147  *      and of course wants to be displayed by show-proxy-args
1148  *      Note: Boy, all the #ifdefs in 1001 locations and
1149  *      all the fumbling with configure.in and acconfig.h
1150  *      were *way* more work than the feature itself :-(
1151  *
1152  *    - Because a generic redirect template was needed for
1153  *      this, tinygif = 3 now uses the same.
1154  *
1155  *    - Moved GIFs, and other static HTTP response templates
1156  *      to project.h
1157  *
1158  *    - Some minor fixes
1159  *
1160  *    - Removed some >400 CRs again (Jon, you really worked
1161  *      a lot! ;-)
1162  *
1163  *    Revision 1.4  2001/05/21 19:34:01  jongfoster
1164  *    Made failure to bind() a fatal error.
1165  *
1166  *    Revision 1.3  2001/05/20 01:21:20  jongfoster
1167  *    Version 2.9.4 checkin.
1168  *    - Merged popupfile and cookiefile, and added control over PCRS
1169  *      filtering, in new "permissionsfile".
1170  *    - Implemented LOG_LEVEL_FATAL, so that if there is a configuration
1171  *      file error you now get a message box (in the Win32 GUI) rather
1172  *      than the program exiting with no explanation.
1173  *    - Made killpopup use the PCRS MIME-type checking and HTTP-header
1174  *      skipping.
1175  *    - Removed tabs from "config"
1176  *    - Moved duplicated url parsing code in "loaders.c" to a new funcition.
1177  *    - Bumped up version number.
1178  *
1179  *    Revision 1.2  2001/05/17 22:34:44  oes
1180  *     - Added hint on GIF char array generation to jcc.c
1181  *     - Cleaned CRLF's from the sources and related files
1182  *     - Repaired logging for REF and FRC
1183  *
1184  *    Revision 1.1.1.1  2001/05/15 13:58:56  oes
1185  *    Initial import of version 2.9.3 source tree
1186  *
1187  *
1188  *********************************************************************/
1189 \f
1190
1191 #include "config.h"
1192
1193 #include <stdio.h>
1194 #include <sys/types.h>
1195 #include <stdlib.h>
1196 #include <string.h>
1197 #include <signal.h>
1198 #include <fcntl.h>
1199 #include <errno.h>
1200 #include <assert.h>
1201
1202 #ifdef _WIN32
1203 # ifndef FEATURE_PTHREAD
1204 #  ifndef STRICT
1205 #   define STRICT
1206 #  endif
1207 #  include <windows.h>
1208 #  include <process.h>
1209 # endif /* ndef FEATURE_PTHREAD */
1210
1211 # include "win32.h"
1212 # ifndef _WIN_CONSOLE
1213 #  include "w32log.h"
1214 # endif /* ndef _WIN_CONSOLE */
1215 # include "w32svrapi.h"
1216
1217 #else /* ifndef _WIN32 */
1218
1219 # if !defined (__OS2__)
1220 # include <unistd.h>
1221 # include <sys/wait.h>
1222 # endif /* ndef __OS2__ */
1223 # include <sys/time.h>
1224 # include <sys/stat.h>
1225 # include <sys/ioctl.h>
1226
1227 #ifdef sun
1228 #include <sys/termios.h>
1229 #endif /* sun */
1230
1231 #ifdef unix
1232 #include <pwd.h>
1233 #include <grp.h>
1234 #endif
1235
1236 # include <signal.h>
1237
1238 # ifdef __BEOS__
1239 #  include <socket.h>  /* BeOS has select() for sockets only. */
1240 #  include <OS.h>      /* declarations for threads and stuff. */
1241 # endif
1242
1243 # if defined(__EMX__) || defined(__OS2__)
1244 #  include <sys/select.h>  /* OS/2/EMX needs a little help with select */
1245 # endif
1246 # ifdef __OS2__
1247 #define INCL_DOS
1248 # include <os2.h>
1249 #define bzero(B,N) memset(B,0x00,n)
1250 # endif
1251
1252 # ifndef FD_ZERO
1253 #  include <select.h>
1254 # endif
1255
1256 #endif
1257
1258 #include "project.h"
1259 #include "list.h"
1260 #include "jcc.h"
1261 #include "filters.h"
1262 #include "loaders.h"
1263 #include "parsers.h"
1264 #include "miscutil.h"
1265 #include "errlog.h"
1266 #include "jbsockets.h"
1267 #include "gateway.h"
1268 #include "actions.h"
1269 #include "cgi.h"
1270 #include "loadcfg.h"
1271 #include "urlmatch.h"
1272
1273 const char jcc_h_rcs[] = JCC_H_VERSION;
1274 const char project_h_rcs[] = PROJECT_H_VERSION;
1275
1276 int no_daemon = 0;
1277 struct client_state  clients[1];
1278 struct file_list     files[1];
1279
1280 #ifdef FEATURE_STATISTICS
1281 int urls_read     = 0;     /* total nr of urls read inc rejected */
1282 int urls_rejected = 0;     /* total nr of urls rejected */
1283 #endif /* def FEATURE_STATISTICS */
1284
1285 #ifdef FEATURE_GRACEFUL_TERMINATION
1286 int g_terminate = 0;
1287 #endif
1288
1289 #if !defined(_WIN32) && !defined(__OS2__) && !defined(AMIGA)
1290 static void sig_handler(int the_signal);
1291 #endif
1292 static int client_protocol_is_unsupported(const struct client_state *csp, char *req);
1293 static jb_err get_request_destination_elsewhere(struct client_state *csp, struct list *headers);
1294 static jb_err get_server_headers(struct client_state *csp);
1295 static const char *crunch_reason(const struct http_response *rsp);
1296 static void send_crunch_response(const struct client_state *csp, struct http_response *rsp);
1297 static char *get_request_line(struct client_state *csp);
1298 static jb_err receive_client_request(struct client_state *csp);
1299 static jb_err parse_client_request(struct client_state *csp);
1300 static void build_request_line(struct client_state *csp, const struct forward_spec *fwd, char **request_line);
1301 static jb_err change_request_destination(struct client_state *csp);
1302 static void chat(struct client_state *csp);
1303 static void serve(struct client_state *csp);
1304 #if !defined(_WIN32) || defined(_WIN_CONSOLE)
1305 static void usage(const char *myname);
1306 #endif
1307 static void initialize_mutexes(void);
1308 static jb_socket bind_port_helper(struct configuration_spec *config);
1309 static void listen_loop(void);
1310
1311 #ifdef AMIGA
1312 void serve(struct client_state *csp);
1313 #else /* ifndef AMIGA */
1314 static void serve(struct client_state *csp);
1315 #endif /* def AMIGA */
1316
1317 #ifdef __BEOS__
1318 static int32 server_thread(void *data);
1319 #endif /* def __BEOS__ */
1320
1321 #ifdef _WIN32
1322 #define sleep(N)  Sleep(((N) * 1000))
1323 #endif
1324
1325 #ifdef __OS2__
1326 #define sleep(N)  DosSleep(((N) * 100))
1327 #endif
1328
1329 #ifdef MUTEX_LOCKS_AVAILABLE
1330 /*
1331  * XXX: Does the locking stuff really belong in this file?
1332  */
1333 privoxy_mutex_t log_mutex;
1334 privoxy_mutex_t log_init_mutex;
1335 privoxy_mutex_t connection_reuse_mutex;
1336
1337 #if !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R)
1338 privoxy_mutex_t resolver_mutex;
1339 #endif /* !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R) */
1340
1341 #ifndef HAVE_GMTIME_R
1342 privoxy_mutex_t gmtime_mutex;
1343 #endif /* ndef HAVE_GMTIME_R */
1344
1345 #ifndef HAVE_LOCALTIME_R
1346 privoxy_mutex_t localtime_mutex;
1347 #endif /* ndef HAVE_GMTIME_R */
1348
1349 #ifndef HAVE_RANDOM
1350 privoxy_mutex_t rand_mutex;
1351 #endif /* ndef HAVE_RANDOM */
1352
1353 #endif /* def MUTEX_LOCKS_AVAILABLE */
1354
1355 #if defined(unix)
1356 const char *basedir = NULL;
1357 const char *pidfile = NULL;
1358 static int received_hup_signal = 0;
1359 #endif /* defined unix */
1360
1361 /* HTTP snipplets. */
1362 static const char CSUCCEED[] =
1363    "HTTP/1.0 200 Connection established\r\n"
1364    "Proxy-Agent: Privoxy/" VERSION "\r\n\r\n";
1365
1366 static const char CHEADER[] =
1367    "HTTP/1.0 400 Invalid header received from client\r\n"
1368    "Proxy-Agent: Privoxy " VERSION "\r\n"
1369    "Content-Type: text/plain\r\n"
1370    "Connection: close\r\n\r\n"
1371    "Invalid header received from client.\r\n";
1372
1373 static const char FTP_RESPONSE[] =
1374    "HTTP/1.0 400 Invalid request received from client\r\n"
1375    "Content-Type: text/plain\r\n"
1376    "Connection: close\r\n\r\n"
1377    "Invalid request. Privoxy doesn't support FTP.\r\n";
1378
1379 static const char GOPHER_RESPONSE[] =
1380    "HTTP/1.0 400 Invalid request received from client\r\n"
1381    "Content-Type: text/plain\r\n"
1382    "Connection: close\r\n\r\n"
1383    "Invalid request. Privoxy doesn't support gopher.\r\n";
1384
1385 /* XXX: should be a template */
1386 static const char MISSING_DESTINATION_RESPONSE[] =
1387    "HTTP/1.0 400 Bad request received from client\r\n"
1388    "Proxy-Agent: Privoxy " VERSION "\r\n"
1389    "Content-Type: text/plain\r\n"
1390    "Connection: close\r\n\r\n"
1391    "Bad request. Privoxy was unable to extract the destination.\r\n";
1392
1393 /* XXX: should be a template */
1394 static const char NO_SERVER_DATA_RESPONSE[] =
1395    "HTTP/1.0 502 Server or forwarder response empty\r\n"
1396    "Proxy-Agent: Privoxy " VERSION "\r\n"
1397    "Content-Type: text/plain\r\n"
1398    "Connection: close\r\n\r\n"
1399    "Empty server or forwarder response.\r\n"
1400    "The connection has been closed but Privoxy didn't receive any data.\r\n";
1401
1402 /* XXX: should be a template */
1403 static const char INVALID_SERVER_HEADERS_RESPONSE[] =
1404    "HTTP/1.0 502 Server or forwarder response invalid\r\n"
1405    "Proxy-Agent: Privoxy " VERSION "\r\n"
1406    "Content-Type: text/plain\r\n"
1407    "Connection: close\r\n\r\n"
1408    "Bad response. The server or forwarder response doesn't look like HTTP.\r\n";
1409
1410 #if 0
1411 /* XXX: should be a template */
1412 static const char NULL_BYTE_RESPONSE[] =
1413    "HTTP/1.0 400 Bad request received from client\r\n"
1414    "Proxy-Agent: Privoxy " VERSION "\r\n"
1415    "Content-Type: text/plain\r\n"
1416    "Connection: close\r\n\r\n"
1417    "Bad request. Null byte(s) before end of request.\r\n";
1418 #endif
1419
1420 /* XXX: should be a template */
1421 static const char MESSED_UP_REQUEST_RESPONSE[] =
1422    "HTTP/1.0 400 Malformed request after rewriting\r\n"
1423    "Proxy-Agent: Privoxy " VERSION "\r\n"
1424    "Content-Type: text/plain\r\n"
1425    "Connection: close\r\n\r\n"
1426    "Bad request. Messed up with header filters.\r\n";
1427
1428 /* XXX: should be a template */
1429 static const char CONNECTION_TIMEOUT_RESPONSE[] =
1430    "HTTP/1.0 502 Connection timeout\r\n"
1431    "Proxy-Agent: Privoxy " VERSION "\r\n"
1432    "Content-Type: text/plain\r\n"
1433    "Connection: close\r\n\r\n"
1434    "The connection timed out.\r\n";
1435
1436 /* A function to crunch a response */
1437 typedef struct http_response *(*crunch_func_ptr)(struct client_state *);
1438
1439 /* Crunch function flags */
1440 #define CF_NO_FLAGS        0
1441 /* Cruncher applies to forced requests as well */
1442 #define CF_IGNORE_FORCE    1
1443 /* Crunched requests are counted for the block statistics */
1444 #define CF_COUNT_AS_REJECT 2
1445
1446 /* A crunch function and its flags */
1447 struct cruncher
1448 {
1449    const crunch_func_ptr cruncher;
1450    const int flags;
1451 };
1452
1453 static int crunch_response_triggered(struct client_state *csp, const struct cruncher crunchers[]);
1454
1455 /* Complete list of cruncher functions */
1456 static const struct cruncher crunchers_all[] = {
1457    { direct_response, CF_COUNT_AS_REJECT|CF_IGNORE_FORCE},
1458    { block_url,       CF_COUNT_AS_REJECT },
1459 #ifdef FEATURE_TRUST
1460    { trust_url,       CF_COUNT_AS_REJECT },
1461 #endif /* def FEATURE_TRUST */
1462    { redirect_url,    CF_NO_FLAGS  },
1463    { dispatch_cgi,    CF_IGNORE_FORCE},
1464    { NULL,            0 }
1465 };
1466
1467 /* Light version, used after tags are applied */
1468 static const struct cruncher crunchers_light[] = {
1469    { block_url,       CF_COUNT_AS_REJECT },
1470    { redirect_url,    CF_NO_FLAGS },
1471    { NULL,            0 }
1472 };
1473
1474
1475 /*
1476  * XXX: Don't we really mean
1477  *
1478  * #if defined(unix)
1479  *
1480  * here?
1481  */
1482 #if !defined(_WIN32) && !defined(__OS2__) && !defined(AMIGA)
1483 /*********************************************************************
1484  *
1485  * Function    :  sig_handler 
1486  *
1487  * Description :  Signal handler for different signals.
1488  *                Exit gracefully on TERM and INT
1489  *                or set a flag that will cause the errlog
1490  *                to be reopened by the main thread on HUP.
1491  *
1492  * Parameters  :
1493  *          1  :  the_signal = the signal cause this function to call
1494  *
1495  * Returns     :  - 
1496  *
1497  *********************************************************************/
1498 static void sig_handler(int the_signal)
1499 {
1500    switch(the_signal)
1501    {
1502       case SIGTERM:
1503       case SIGINT:
1504          log_error(LOG_LEVEL_INFO, "exiting by signal %d .. bye", the_signal);
1505 #if defined(unix)
1506          if(pidfile)
1507          {
1508             unlink(pidfile);
1509          }
1510 #endif /* unix */
1511          exit(the_signal);
1512          break;
1513
1514       case SIGHUP:
1515 #if defined(unix)
1516          received_hup_signal = 1;
1517 #endif
1518          break;         
1519
1520       default:
1521          /* 
1522           * We shouldn't be here, unless we catch signals
1523           * in main() that we can't handle here!
1524           */
1525          log_error(LOG_LEVEL_FATAL, "sig_handler: exiting on unexpected signal %d", the_signal);
1526    }
1527    return;
1528
1529 }
1530 #endif
1531
1532
1533 /*********************************************************************
1534  *
1535  * Function    :  client_protocol_is_unsupported
1536  *
1537  * Description :  Checks if the client used a known unsupported
1538  *                protocol and deals with it by sending an error
1539  *                response.
1540  *
1541  * Parameters  :
1542  *          1  :  csp = Current client state (buffers, headers, etc...)
1543  *          2  :  req = the first request line send by the client
1544  *
1545  * Returns     :  TRUE if an error response has been generated, or
1546  *                FALSE if the request doesn't look invalid.
1547  *
1548  *********************************************************************/
1549 static int client_protocol_is_unsupported(const struct client_state *csp, char *req)
1550 {
1551    /*
1552     * If it's a FTP or gopher request, we don't support it.
1553     *
1554     * These checks are better than nothing, but they might
1555     * not work in all configurations and some clients might
1556     * have problems digesting the answer.
1557     *
1558     * They should, however, never cause more problems than
1559     * Privoxy's old behaviour (returning the misleading HTML
1560     * error message:
1561     *
1562     * "Could not resolve http://(ftp|gopher)://example.org").
1563     */
1564    if (!strncmpic(req, "GET ftp://", 10) || !strncmpic(req, "GET gopher://", 13))
1565    {
1566       const char *response = NULL;
1567       const char *protocol = NULL;
1568
1569       if (!strncmpic(req, "GET ftp://", 10))
1570       {
1571          response = FTP_RESPONSE;
1572          protocol = "FTP";
1573       }
1574       else
1575       {
1576          response = GOPHER_RESPONSE;
1577          protocol = "GOPHER";
1578       }
1579       log_error(LOG_LEVEL_ERROR,
1580          "%s tried to use Privoxy as %s proxy: %s",
1581          csp->ip_addr_str, protocol, req);
1582       log_error(LOG_LEVEL_CLF,
1583          "%s - - [%T] \"%s\" 400 0", csp->ip_addr_str, req);
1584       freez(req);
1585       write_socket(csp->cfd, response, strlen(response));
1586
1587       return TRUE;
1588    }
1589
1590    return FALSE;
1591 }
1592
1593
1594 /*********************************************************************
1595  *
1596  * Function    :  get_request_destination_elsewhere
1597  *
1598  * Description :  If the client's request was redirected into
1599  *                Privoxy without the client's knowledge,
1600  *                the request line lacks the destination host.
1601  *
1602  *                This function tries to get it elsewhere,
1603  *                provided accept-intercepted-requests is enabled.
1604  *
1605  *                "Elsewhere" currently only means "Host: header",
1606  *                but in the future we may ask the redirecting
1607  *                packet filter to look the destination up.
1608  *
1609  *                If the destination stays unknown, an error
1610  *                response is send to the client and headers
1611  *                are freed so that chat() can return directly.
1612  *
1613  * Parameters  :
1614  *          1  :  csp = Current client state (buffers, headers, etc...)
1615  *          2  :  headers = a header list
1616  *
1617  * Returns     :  JB_ERR_OK if the destination is now known, or
1618  *                JB_ERR_PARSE if it isn't.
1619  *
1620  *********************************************************************/
1621 static jb_err get_request_destination_elsewhere(struct client_state *csp, struct list *headers)
1622 {
1623    char *req;
1624
1625    if (!(csp->config->feature_flags & RUNTIME_FEATURE_ACCEPT_INTERCEPTED_REQUESTS))
1626    {
1627       log_error(LOG_LEVEL_ERROR, "%s's request: \'%s\' is invalid."
1628          " Privoxy isn't configured to accept intercepted requests.",
1629          csp->ip_addr_str, csp->http->cmd);
1630       /* XXX: Use correct size */
1631       log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 400 0",
1632          csp->ip_addr_str, csp->http->cmd);
1633
1634       write_socket(csp->cfd, CHEADER, strlen(CHEADER));
1635       destroy_list(headers);
1636
1637       return JB_ERR_PARSE;
1638    }
1639    else if (JB_ERR_OK == get_destination_from_headers(headers, csp->http))
1640    {
1641       /* Split the domain we just got for pattern matching */
1642       init_domain_components(csp->http);
1643
1644       return JB_ERR_OK;
1645    }
1646    else
1647    {
1648       /* We can't work without destination. Go spread the news.*/
1649
1650       req = list_to_text(headers);
1651       chomp(req);
1652       /* XXX: Use correct size */
1653       log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 400 0",
1654          csp->ip_addr_str, csp->http->cmd);
1655       log_error(LOG_LEVEL_ERROR,
1656          "Privoxy was unable to get the destination for %s's request:\n%s\n%s",
1657          csp->ip_addr_str, csp->http->cmd, req);
1658       freez(req);
1659
1660       write_socket(csp->cfd, MISSING_DESTINATION_RESPONSE, strlen(MISSING_DESTINATION_RESPONSE));
1661       destroy_list(headers);
1662
1663       return JB_ERR_PARSE;
1664    }
1665    /*
1666     * TODO: If available, use PF's ioctl DIOCNATLOOK as last resort
1667     * to get the destination IP address, use it as host directly
1668     * or do a reverse DNS lookup first.
1669     */
1670 }
1671
1672
1673 /*********************************************************************
1674  *
1675  * Function    :  get_server_headers
1676  *
1677  * Description :  Parses server headers in iob and fills them
1678  *                into csp->headers so that they can later be
1679  *                handled by sed().
1680  *
1681  * Parameters  :
1682  *          1  :  csp = Current client state (buffers, headers, etc...)
1683  *
1684  * Returns     :  JB_ERR_OK if everything went fine, or
1685  *                JB_ERR_PARSE if the headers were incomplete.
1686  *
1687  *********************************************************************/
1688 static jb_err get_server_headers(struct client_state *csp)
1689 {
1690    int continue_hack_in_da_house = 0;
1691    char * header;
1692
1693    while (((header = get_header(csp->iob)) != NULL) || continue_hack_in_da_house)
1694    {
1695       if (header == NULL)
1696       {
1697          /*
1698           * continue hack in da house. Ignore the ending of
1699           * this head and continue enlisting header lines.
1700           * The reason is described below.
1701           */
1702          enlist(csp->headers, "");
1703          continue_hack_in_da_house = 0;
1704          continue;
1705       }
1706       else if (0 == strncmpic(header, "HTTP/1.1 100", 12))
1707       {
1708          /*
1709           * It's a bodyless continue response, don't
1710           * stop header parsing after reaching its end.
1711           *
1712           * As a result Privoxy will concatenate the
1713           * next response's head and parse and deliver
1714           * the headers as if they belonged to one request.
1715           *
1716           * The client will separate them because of the
1717           * empty line between them.
1718           *
1719           * XXX: What we're doing here is clearly against
1720           * the intended purpose of the continue header,
1721           * and under some conditions (HTTP/1.0 client request)
1722           * it's a standard violation.
1723           *
1724           * Anyway, "sort of against the spec" is preferable
1725           * to "always getting confused by Continue responses"
1726           * (Privoxy's behaviour before this hack was added)
1727           */
1728          log_error(LOG_LEVEL_HEADER, "Continue hack in da house.");
1729          continue_hack_in_da_house = 1;
1730       }
1731       else if (*header == '\0') 
1732       {
1733          /*
1734           * If the header is empty, but the Continue hack
1735           * isn't active, we can assume that we reached the
1736           * end of the buffer before we hit the end of the
1737           * head.
1738           *
1739           * Inform the caller an let it decide how to handle it.
1740           */
1741          return JB_ERR_PARSE;
1742       }
1743
1744       if (JB_ERR_MEMORY == enlist(csp->headers, header))
1745       {
1746          /*
1747           * XXX: Should we quit the request and return a
1748           * out of memory error page instead?
1749           */
1750          log_error(LOG_LEVEL_ERROR,
1751             "Out of memory while enlisting server headers. %s lost.",
1752             header);
1753       }
1754       freez(header);
1755    }
1756
1757    return JB_ERR_OK;
1758 }
1759
1760
1761 /*********************************************************************
1762  *
1763  * Function    :  crunch_reason
1764  *
1765  * Description :  Translates the crunch reason code into a string.
1766  *
1767  * Parameters  :
1768  *          1  :  rsp = a http_response
1769  *
1770  * Returns     :  A string with the crunch reason or an error description.
1771  *
1772  *********************************************************************/
1773 static const char *crunch_reason(const struct http_response *rsp)
1774 {
1775    char * reason = NULL;
1776
1777    assert(rsp != NULL);
1778    if (rsp == NULL)
1779    {
1780       return "Internal error while searching for crunch reason";
1781    }
1782
1783    switch (rsp->reason)
1784    {
1785       case RSP_REASON_UNSUPPORTED:
1786          reason = "Unsupported HTTP feature";
1787          break;
1788       case RSP_REASON_BLOCKED:
1789          reason = "Blocked";
1790          break;
1791       case RSP_REASON_UNTRUSTED:
1792          reason = "Untrusted";
1793          break;
1794       case RSP_REASON_REDIRECTED:
1795          reason = "Redirected";
1796          break;
1797       case RSP_REASON_CGI_CALL:
1798          reason = "CGI Call";
1799          break;
1800       case RSP_REASON_NO_SUCH_DOMAIN:
1801          reason = "DNS failure";
1802          break;
1803       case RSP_REASON_FORWARDING_FAILED:
1804          reason = "Forwarding failed";
1805          break;
1806       case RSP_REASON_CONNECT_FAILED:
1807          reason = "Connection failure";
1808          break;
1809       case RSP_REASON_OUT_OF_MEMORY:
1810          reason = "Out of memory (may mask other reasons)";
1811          break;
1812       default:
1813          reason = "No reason recorded";
1814          break;
1815    }
1816
1817    return reason;
1818 }
1819
1820
1821 /*********************************************************************
1822  *
1823  * Function    :  send_crunch_response
1824  *
1825  * Description :  Delivers already prepared response for
1826  *                intercepted requests, logs the interception
1827  *                and frees the response.
1828  *
1829  * Parameters  :
1830  *          1  :  csp = Current client state (buffers, headers, etc...)
1831  *          1  :  rsp = Fully prepared response. Will be freed on exit.
1832  *
1833  * Returns     :  Nothing.
1834  *
1835  *********************************************************************/
1836 static void send_crunch_response(const struct client_state *csp, struct http_response *rsp)
1837 {
1838       const struct http_request *http = csp->http;
1839       char status_code[4];
1840
1841       assert(rsp != NULL);
1842       assert(rsp->head != NULL);
1843
1844       if (rsp == NULL)
1845       {
1846          /*
1847           * Not supposed to happen. If it does
1848           * anyway, treat it as an unknown error.
1849           */
1850          cgi_error_unknown(csp, rsp, RSP_REASON_INTERNAL_ERROR);
1851          /* return code doesn't matter */
1852       }
1853
1854       if (rsp == NULL)
1855       {
1856          /* If rsp is still NULL, we have serious internal problems. */
1857          log_error(LOG_LEVEL_FATAL,
1858             "NULL response in send_crunch_response and cgi_error_unknown failed as well.");
1859       }
1860
1861       /*
1862        * Extract the status code from the actual head
1863        * that was send to the client. It is the only
1864        * way to get it right for all requests, including
1865        * the fixed ones for out-of-memory problems.
1866        *
1867        * A head starts like this: 'HTTP/1.1 200...'
1868        *                           0123456789|11
1869        *                                     10
1870        */
1871       status_code[0] = rsp->head[9];
1872       status_code[1] = rsp->head[10];
1873       status_code[2] = rsp->head[11];
1874       status_code[3] = '\0';
1875
1876       /* Write the answer to the client */
1877       if (write_socket(csp->cfd, rsp->head, rsp->head_length)
1878        || write_socket(csp->cfd, rsp->body, rsp->content_length))
1879       {
1880          /* There is nothing we can do about it. */
1881          log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", csp->http->host);
1882       }
1883
1884       /* Log that the request was crunched and why. */
1885       log_error(LOG_LEVEL_CRUNCH, "%s: %s", crunch_reason(rsp), http->url);
1886       log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" %s %d",
1887          csp->ip_addr_str, http->ocmd, status_code, rsp->content_length);
1888
1889       /* Clean up and return */
1890       if (cgi_error_memory() != rsp)
1891       {
1892          free_http_response(rsp);
1893       } 
1894       return;
1895 }
1896
1897
1898 #if 0
1899 /*********************************************************************
1900  *
1901  * Function    :  request_contains_null_bytes
1902  *
1903  * Description :  Checks for NULL bytes in the request and sends
1904  *                an error message to the client if any were found.
1905  *
1906  *                XXX: currently not used, see comment in chat().
1907  *
1908  * Parameters  :
1909  *          1  :  csp = Current client state (buffers, headers, etc...)
1910  *          2  :  buf = Data from the client's request to check.
1911  *          3  :  len = The data length.
1912  *
1913  * Returns     :  TRUE if the request contained one or more NULL bytes, or
1914  *                FALSE otherwise.
1915  *
1916  *********************************************************************/
1917 static int request_contains_null_bytes(const struct client_state *csp, char *buf, int len)
1918 {
1919    size_t c_len; /* Request lenght when treated as C string */
1920
1921    c_len = strlen(buf);
1922
1923    if (c_len < len)
1924    {
1925       /*
1926        * Null byte(s) found. Log the request,
1927        * return an error response and hang up.
1928        */
1929       size_t tmp_len = c_len;
1930
1931       do
1932       {
1933         /*
1934          * Replace NULL byte(s) with '°' characters
1935          * so the request can be logged as string.
1936          * XXX: Is there a better replacement character?
1937          */
1938          buf[tmp_len]='°';
1939          tmp_len += strlen(buf+tmp_len);
1940       } while (tmp_len < len);
1941
1942       log_error(LOG_LEVEL_ERROR, "%s\'s request contains at least one NULL byte "
1943          "(length=%d, strlen=%d).", csp->ip_addr_str, len, c_len);
1944       log_error(LOG_LEVEL_HEADER, 
1945          "Offending request data with NULL bytes turned into \'°\' characters: %s", buf);
1946
1947       write_socket(csp->cfd, NULL_BYTE_RESPONSE, strlen(NULL_BYTE_RESPONSE));
1948
1949       /* XXX: Log correct size */
1950       log_error(LOG_LEVEL_CLF, "%s - - [%T] \"Invalid request\" 400 0", csp->ip_addr_str);
1951
1952       return TRUE;
1953    }
1954
1955    return FALSE;
1956 }
1957 #endif
1958
1959
1960 /*********************************************************************
1961  *
1962  * Function    :  crunch_response_triggered
1963  *
1964  * Description :  Checks if the request has to be crunched,
1965  *                and delivers the crunch response if necessary.
1966  *
1967  * Parameters  :
1968  *          1  :  csp = Current client state (buffers, headers, etc...)
1969  *          2  :  crunchers = list of cruncher functions to run
1970  *
1971  * Returns     :  TRUE if the request was answered with a crunch response
1972  *                FALSE otherwise.
1973  *
1974  *********************************************************************/
1975 static int crunch_response_triggered(struct client_state *csp, const struct cruncher crunchers[])
1976 {
1977    struct http_response *rsp = NULL;
1978    const struct cruncher *c;
1979
1980    /*
1981     * If CGI request crunching is disabled,
1982     * check the CGI dispatcher out of order to
1983     * prevent unintentional blocks or redirects. 
1984     */
1985    if (!(csp->config->feature_flags & RUNTIME_FEATURE_CGI_CRUNCHING)
1986        && (NULL != (rsp = dispatch_cgi(csp))))
1987    {
1988       /* Deliver, log and free the interception response. */
1989       send_crunch_response(csp, rsp);
1990       return TRUE;
1991    }
1992
1993    for (c = crunchers; c->cruncher != NULL; c++)
1994    {
1995       /*
1996        * Check the cruncher if either Privoxy is toggled
1997        * on and the request isn't forced, or if the cruncher
1998        * applies to forced requests as well.
1999        */
2000       if (((csp->flags & CSP_FLAG_TOGGLED_ON) &&
2001           !(csp->flags & CSP_FLAG_FORCED)) ||
2002           (c->flags & CF_IGNORE_FORCE))
2003       {
2004          rsp = c->cruncher(csp);
2005          if (NULL != rsp)
2006          {
2007             /* Deliver, log and free the interception response. */
2008             send_crunch_response(csp, rsp);
2009 #ifdef FEATURE_STATISTICS
2010             if (c->flags & CF_COUNT_AS_REJECT)
2011             {
2012                csp->flags |= CSP_FLAG_REJECTED;
2013             }
2014 #endif /* def FEATURE_STATISTICS */
2015
2016             return TRUE;
2017          }
2018       }
2019    }
2020
2021    return FALSE;
2022 }
2023
2024
2025 /*********************************************************************
2026  *
2027  * Function    :  build_request_line
2028  *
2029  * Description :  Builds the HTTP request line.
2030  *
2031  *                If a HTTP forwarder is used it expects the whole URL,
2032  *                web servers only get the path.
2033  *
2034  * Parameters  :
2035  *          1  :  csp = Current client state (buffers, headers, etc...)
2036  *          2  :  fwd = The forwarding spec used for the request
2037  *                XXX: Should use http->fwd instead.
2038  *          3  :  request_line = The old request line which will be replaced.
2039  *
2040  * Returns     :  Nothing. Terminates in case of memory problems.
2041  *
2042  *********************************************************************/
2043 static void build_request_line(struct client_state *csp, const struct forward_spec *fwd, char **request_line)
2044 {
2045    struct http_request *http = csp->http;
2046
2047    assert(http->ssl == 0);
2048
2049    /*
2050     * Downgrade http version from 1.1 to 1.0
2051     * if +downgrade action applies.
2052     */
2053    if ( (csp->action->flags & ACTION_DOWNGRADE)
2054      && (!strcmpic(http->ver, "HTTP/1.1")))
2055    {
2056       freez(http->ver);
2057       http->ver = strdup("HTTP/1.0");
2058
2059       if (http->ver == NULL)
2060       {
2061          log_error(LOG_LEVEL_FATAL, "Out of memory downgrading HTTP version");
2062       }
2063    }
2064
2065    /*
2066     * Rebuild the request line.
2067     */
2068    freez(*request_line);
2069    *request_line = strdup(http->gpc);
2070    string_append(request_line, " ");
2071
2072    if (fwd->forward_host)
2073    {
2074       string_append(request_line, http->url);
2075    }
2076    else
2077    {
2078       string_append(request_line, http->path);
2079    }
2080    string_append(request_line, " ");
2081    string_append(request_line, http->ver);
2082
2083    if (*request_line == NULL)
2084    {
2085       log_error(LOG_LEVEL_FATAL, "Out of memory writing HTTP command");
2086    }
2087    log_error(LOG_LEVEL_HEADER, "New HTTP Request-Line: %s", *request_line);
2088 }
2089
2090
2091 /*********************************************************************
2092  *
2093  * Function    :  change_request_destination
2094  *
2095  * Description :  Parse a (rewritten) request line and regenerate
2096  *                the http request data.
2097  *
2098  * Parameters  :
2099  *          1  :  csp = Current client state (buffers, headers, etc...)
2100  *
2101  * Returns     :  Forwards the parse_http_request() return code.
2102  *                Terminates in case of memory problems.
2103  *
2104  *********************************************************************/
2105 static jb_err change_request_destination(struct client_state *csp)
2106 {
2107    struct http_request *http = csp->http;
2108    jb_err err;
2109
2110    log_error(LOG_LEVEL_INFO, "Rewrite detected: %s", csp->headers->first->str);
2111    free_http_request(http);
2112    err = parse_http_request(csp->headers->first->str, http, csp);
2113    if (JB_ERR_OK != err)
2114    {
2115       log_error(LOG_LEVEL_ERROR, "Couldn't parse rewritten request: %s.",
2116          jb_err_to_string(err));
2117    }
2118    else
2119    {
2120       /* XXX: ocmd is a misleading name */
2121       http->ocmd = strdup(http->cmd);
2122       if (http->ocmd == NULL)
2123       {
2124          log_error(LOG_LEVEL_FATAL,
2125             "Out of memory copying rewritten HTTP request line");
2126       }
2127    }
2128
2129    return err;
2130 }
2131
2132
2133 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
2134 /*********************************************************************
2135  *
2136  * Function    :  server_response_is_complete
2137  *
2138  * Description :  Determines whether we should stop reading
2139  *                from the server socket.
2140  *
2141  * Parameters  :
2142  *          1  :  csp = Current client state (buffers, headers, etc...)
2143  *          2  :  content_length = Length of content received so far.
2144  *
2145  * Returns     :  TRUE if the response is complete,
2146  *                FALSE otherwise.
2147  *
2148  *********************************************************************/
2149 static int server_response_is_complete(struct client_state *csp, size_t content_length)
2150 {
2151    int content_length_known = (csp->flags & CSP_FLAG_CONTENT_LENGTH_SET);
2152
2153    if (!strcmpic(csp->http->gpc, "HEAD"))
2154    {
2155       /*
2156        * "HEAD" implies no body, we are thus expecting
2157        * no content. XXX: incomplete "list" of methods?
2158        */
2159       csp->expected_content_length = 0;
2160       content_length_known = TRUE;
2161    }
2162
2163    if (csp->http->status == 304)
2164    {
2165       /*
2166        * Expect no body. XXX: incomplete "list" of status codes?
2167        */
2168       csp->expected_content_length = 0;
2169       content_length_known = TRUE;
2170    }
2171
2172    return (content_length_known && ((0 == csp->expected_content_length)
2173             || (csp->expected_content_length <= content_length)));
2174 }
2175
2176
2177 /*********************************************************************
2178  *
2179  * Function    :  wait_for_alive_connections
2180  *
2181  * Description :  Waits for alive connections to timeout.
2182  *
2183  * Parameters  :  N/A
2184  *
2185  * Returns     :  N/A
2186  *
2187  *********************************************************************/
2188 static void wait_for_alive_connections()
2189 {
2190    int connections_alive = close_unusable_connections();
2191
2192    while (0 < connections_alive)
2193    {
2194       log_error(LOG_LEVEL_CONNECT,
2195          "Waiting for %d connections to timeout.",
2196          connections_alive);
2197       sleep(60);
2198       connections_alive = close_unusable_connections();
2199    }
2200
2201    log_error(LOG_LEVEL_CONNECT, "No connections to wait for left.");
2202
2203 }
2204 #endif /* FEATURE_CONNECTION_KEEP_ALIVE */
2205
2206
2207 /*********************************************************************
2208  *
2209  * Function    :  mark_server_socket_tainted
2210  *
2211  * Description :  Makes sure we don't reuse a server socket
2212  *                (if we didn't read everything the server sent
2213  *                us reusing the socket would lead to garbage).
2214  *
2215  * Parameters  :
2216  *          1  :  csp = Current client state (buffers, headers, etc...)
2217  *
2218  * Returns     :  void.
2219  *
2220  *********************************************************************/
2221 static void mark_server_socket_tainted(struct client_state *csp)
2222 {
2223    if ((csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE))
2224    {
2225       log_error(LOG_LEVEL_CONNECT, "Unsetting keep-alive flag.");
2226       csp->flags &= ~CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE;
2227    }
2228 }
2229
2230 /*********************************************************************
2231  *
2232  * Function    :  get_request_line
2233  *
2234  * Description : Read the client request line.
2235  *
2236  * Parameters  :
2237  *          1  :  csp = Current client state (buffers, headers, etc...)
2238  *
2239  * Returns     :  Pointer to request line or NULL in case of errors.
2240  *
2241  *********************************************************************/
2242 static char *get_request_line(struct client_state *csp)
2243 {
2244    char buf[BUFFER_SIZE];
2245    char *request_line = NULL;
2246    int len;
2247
2248    memset(buf, 0, sizeof(buf));
2249
2250    do
2251    {
2252       if (!data_is_available(csp->cfd, csp->config->socket_timeout))
2253       {
2254          log_error(LOG_LEVEL_ERROR,
2255             "Stopped waiting for the request line.");
2256          write_socket(csp->cfd, CONNECTION_TIMEOUT_RESPONSE,
2257             strlen(CONNECTION_TIMEOUT_RESPONSE));
2258          return NULL;
2259       }
2260
2261       len = read_socket(csp->cfd, buf, sizeof(buf) - 1);
2262
2263       if (len <= 0) return NULL;
2264
2265       /*
2266        * If there is no memory left for buffering the
2267        * request, there is nothing we can do but hang up
2268        */
2269       if (add_to_iob(csp, buf, len))
2270       {
2271          return NULL;
2272       }
2273
2274       request_line = get_header(csp->iob);
2275
2276    } while ((NULL != request_line) && ('\0' == *request_line));
2277
2278    return request_line;
2279
2280 }
2281
2282
2283 /*********************************************************************
2284  *
2285  * Function    :  receive_client_request
2286  *
2287  * Description : Read the client's request (more precisely the
2288  *               client headers) and answer it if necessary.
2289  *
2290  *               Note that since we're not using select() we could get
2291  *               blocked here if a client connected, then didn't say
2292  *               anything!
2293  *
2294  * Parameters  :
2295  *          1  :  csp = Current client state (buffers, headers, etc...)
2296  *
2297  * Returns     :  JB_ERR_OK, JB_ERR_PARSE or JB_ERR_MEMORY
2298  *
2299  *********************************************************************/
2300 static jb_err receive_client_request(struct client_state *csp)
2301 {
2302    char buf[BUFFER_SIZE];
2303    char *p;
2304    char *req = NULL;
2305    struct http_request *http;
2306    int len;
2307    jb_err err;
2308
2309    /* Temporary copy of the client's headers before they get enlisted in csp->headers */
2310    struct list header_list;
2311    struct list *headers = &header_list;
2312
2313    http = csp->http;
2314
2315    memset(buf, 0, sizeof(buf));
2316
2317    req = get_request_line(csp);
2318    if (req == NULL)
2319    {
2320       return JB_ERR_PARSE;
2321    }
2322    assert(*req != '\0');
2323
2324    if (client_protocol_is_unsupported(csp, req))
2325    {
2326       return JB_ERR_PARSE;
2327    }
2328
2329 #ifdef FEATURE_FORCE_LOAD
2330    /*
2331     * If this request contains the FORCE_PREFIX and blocks
2332     * aren't enforced, get rid of it and set the force flag.
2333     */
2334    if (strstr(req, FORCE_PREFIX))
2335    {
2336       if (csp->config->feature_flags & RUNTIME_FEATURE_ENFORCE_BLOCKS)
2337       {
2338          log_error(LOG_LEVEL_FORCE,
2339             "Ignored force prefix in request: \"%s\".", req);
2340       }
2341       else
2342       {
2343          strclean(req, FORCE_PREFIX);
2344          log_error(LOG_LEVEL_FORCE, "Enforcing request: \"%s\".", req);
2345          csp->flags |= CSP_FLAG_FORCED;
2346       }
2347    }
2348 #endif /* def FEATURE_FORCE_LOAD */
2349
2350    err = parse_http_request(req, http, csp);
2351    freez(req);
2352    if (JB_ERR_OK != err)
2353    {
2354       write_socket(csp->cfd, CHEADER, strlen(CHEADER));
2355       /* XXX: Use correct size */
2356       log_error(LOG_LEVEL_CLF, "%s - - [%T] \"Invalid request\" 400 0", csp->ip_addr_str);
2357       log_error(LOG_LEVEL_ERROR,
2358          "Couldn't parse request line received from %s: %s",
2359          csp->ip_addr_str, jb_err_to_string(err));
2360
2361       free_http_request(http);
2362       return JB_ERR_PARSE;
2363    }
2364
2365    /* grab the rest of the client's headers */
2366    init_list(headers);
2367    for (;;)
2368    {
2369       p = get_header(csp->iob);
2370
2371       if (p == NULL)
2372       {
2373          /* There are no additional headers to read. */
2374          break;
2375       }
2376
2377       if (*p == '\0')
2378       {
2379          /*
2380           * We didn't receive a complete header
2381           * line yet, get the rest of it.
2382           */
2383          if (!data_is_available(csp->cfd, csp->config->socket_timeout))
2384          {
2385             log_error(LOG_LEVEL_ERROR,
2386                "Stopped grabbing the client headers.");
2387             return JB_ERR_PARSE;
2388          }
2389
2390          len = read_socket(csp->cfd, buf, sizeof(buf) - 1);
2391          if (len <= 0)
2392          {
2393             log_error(LOG_LEVEL_ERROR, "read from client failed: %E");
2394             destroy_list(headers);
2395             return JB_ERR_PARSE;
2396          }
2397          
2398          if (add_to_iob(csp, buf, len))
2399          {
2400             /*
2401              * If there is no memory left for buffering the
2402              * request, there is nothing we can do but hang up
2403              */
2404             destroy_list(headers);
2405             return JB_ERR_MEMORY;
2406          }
2407       }
2408       else
2409       {
2410          /*
2411           * We were able to read a complete
2412           * header and can finaly enlist it.
2413           */
2414          enlist(headers, p);
2415          freez(p);
2416       }
2417    }
2418
2419    if (http->host == NULL)
2420    {
2421       /*
2422        * If we still don't know the request destination,
2423        * the request is invalid or the client uses
2424        * Privoxy without its knowledge.
2425        */
2426       if (JB_ERR_OK != get_request_destination_elsewhere(csp, headers))
2427       {
2428          /*
2429           * Our attempts to get the request destination
2430           * elsewhere failed or Privoxy is configured
2431           * to only accept proxy requests.
2432           *
2433           * An error response has already been send
2434           * and we're done here.
2435           */
2436          return JB_ERR_PARSE;
2437       }
2438    }
2439
2440    /*
2441     * Determine the actions for this URL
2442     */
2443 #ifdef FEATURE_TOGGLE
2444    if (!(csp->flags & CSP_FLAG_TOGGLED_ON))
2445    {
2446       /* Most compatible set of actions (i.e. none) */
2447       init_current_action(csp->action);
2448    }
2449    else
2450 #endif /* ndef FEATURE_TOGGLE */
2451    {
2452       get_url_actions(csp, http);
2453    }
2454
2455    /* 
2456     * Save a copy of the original request for logging
2457     */
2458    http->ocmd = strdup(http->cmd);
2459    if (http->ocmd == NULL)
2460    {
2461       log_error(LOG_LEVEL_FATAL,
2462          "Out of memory copying HTTP request line");
2463    }
2464    enlist(csp->headers, http->cmd);
2465
2466    /* Append the previously read headers */
2467    list_append_list_unique(csp->headers, headers);
2468    destroy_list(headers);
2469
2470    return JB_ERR_OK;
2471
2472 }
2473
2474
2475 /*********************************************************************
2476  *
2477  * Function    : parse_client_request
2478  *
2479  * Description : Parses the client's request and decides what to do
2480  *               with it.
2481  *
2482  *               Note that since we're not using select() we could get
2483  *               blocked here if a client connected, then didn't say
2484  *               anything!
2485  *
2486  * Parameters  :
2487  *          1  :  csp = Current client state (buffers, headers, etc...)
2488  *
2489  * Returns     :  JB_ERR_OK or JB_ERR_PARSE
2490  *
2491  *********************************************************************/
2492 static jb_err parse_client_request(struct client_state *csp)
2493 {
2494    struct http_request *http = csp->http;
2495    jb_err err;
2496
2497    err = sed(csp, FILTER_CLIENT_HEADERS);
2498    if (JB_ERR_OK != err)
2499    {
2500       /* XXX: Should be handled in sed(). */
2501       assert(err == JB_ERR_PARSE);
2502       log_error(LOG_LEVEL_FATAL, "Failed to parse client headers.");
2503    }
2504    csp->flags |= CSP_FLAG_CLIENT_HEADER_PARSING_DONE;
2505
2506    /* Check request line for rewrites. */
2507    if ((NULL == csp->headers->first->str)
2508       || (strcmp(http->cmd, csp->headers->first->str) &&
2509          (JB_ERR_OK != change_request_destination(csp))))
2510    {
2511       /*
2512        * A header filter broke the request line - bail out.
2513        */
2514       write_socket(csp->cfd, MESSED_UP_REQUEST_RESPONSE, strlen(MESSED_UP_REQUEST_RESPONSE));
2515       /* XXX: Use correct size */
2516       log_error(LOG_LEVEL_CLF,
2517          "%s - - [%T] \"Invalid request generated\" 500 0", csp->ip_addr_str);
2518       log_error(LOG_LEVEL_ERROR,
2519          "Invalid request line after applying header filters.");
2520       free_http_request(http);
2521
2522       return JB_ERR_PARSE;
2523    }
2524
2525    return JB_ERR_OK;
2526
2527 }
2528
2529
2530 /*********************************************************************
2531  *
2532  * Function    :  chat
2533  *
2534  * Description :  Once a connection to the client has been accepted,
2535  *                this function is called (via serve()) to handle the
2536  *                main business of the communication.  When this
2537  *                function returns, the caller must close the client
2538  *                socket handle.
2539  *
2540  *                FIXME: chat is nearly thousand lines long.
2541  *                Ridiculous.
2542  *
2543  * Parameters  :
2544  *          1  :  csp = Current client state (buffers, headers, etc...)
2545  *
2546  * Returns     :  Nothing.
2547  *
2548  *********************************************************************/
2549 static void chat(struct client_state *csp)
2550 {
2551    char buf[BUFFER_SIZE];
2552    char *hdr;
2553    char *p;
2554    fd_set rfds;
2555    int n;
2556    jb_socket maxfd;
2557    int server_body;
2558    int ms_iis5_hack = 0;
2559    size_t byte_count = 0;
2560    int forwarded_connect_retries = 0;
2561    int max_forwarded_connect_retries = csp->config->forwarded_connect_retries;
2562    const struct forward_spec *fwd;
2563    struct http_request *http;
2564    int len = 0; /* for buffer sizes (and negative error codes) */
2565
2566    /* Function that does the content filtering for the current request */
2567    filter_function_ptr content_filter = NULL;
2568
2569    /* Skeleton for HTTP response, if we should intercept the request */
2570    struct http_response *rsp;
2571    struct timeval timeout;
2572
2573    memset(buf, 0, sizeof(buf));
2574    memset(&timeout, 0, sizeof(timeout));
2575    timeout.tv_sec = csp->config->socket_timeout;
2576
2577    http = csp->http;
2578
2579    if (receive_client_request(csp) != JB_ERR_OK)
2580    {
2581       return;
2582    }
2583    if (parse_client_request(csp) != JB_ERR_OK)
2584    {
2585       return;
2586    }
2587
2588    /* decide how to route the HTTP request */
2589    fwd = forward_url(csp, http);
2590    if (NULL == fwd)
2591    {
2592       log_error(LOG_LEVEL_FATAL, "gateway spec is NULL!?!?  This can't happen!");
2593       /* Never get here - LOG_LEVEL_FATAL causes program exit */
2594    }
2595
2596    /*
2597     * build the http request to send to the server
2598     * we have to do one of the following:
2599     *
2600     * create = use the original HTTP request to create a new
2601     *          HTTP request that has either the path component
2602     *          without the http://domainspec (w/path) or the
2603     *          full orininal URL (w/url)
2604     *          Note that the path and/or the HTTP version may
2605     *          have been altered by now.
2606     *
2607     * connect = Open a socket to the host:port of the server
2608     *           and short-circuit server and client socket.
2609     *
2610     * pass =  Pass the request unchanged if forwarding a CONNECT
2611     *         request to a parent proxy. Note that we'll be sending
2612     *         the CFAIL message ourselves if connecting to the parent
2613     *         fails, but we won't send a CSUCCEED message if it works,
2614     *         since that would result in a double message (ours and the
2615     *         parent's). After sending the request to the parent, we simply
2616     *         tunnel.
2617     *
2618     * here's the matrix:
2619     *                        SSL
2620     *                    0        1
2621     *                +--------+--------+
2622     *                |        |        |
2623     *             0  | create | connect|
2624     *                | w/path |        |
2625     *  Forwarding    +--------+--------+
2626     *                |        |        |
2627     *             1  | create | pass   |
2628     *                | w/url  |        |
2629     *                +--------+--------+
2630     *
2631     */
2632
2633    if (http->ssl && connect_port_is_forbidden(csp))
2634    {
2635       const char *acceptable_connect_ports =
2636          csp->action->string[ACTION_STRING_LIMIT_CONNECT];
2637       assert(NULL != acceptable_connect_ports);
2638       log_error(LOG_LEVEL_INFO, "Request from %s marked for blocking. "
2639          "limit-connect{%s} doesn't allow CONNECT requests to port %d.",
2640          csp->ip_addr_str, acceptable_connect_ports, csp->http->port);
2641       csp->action->flags |= ACTION_BLOCK;
2642       http->ssl = 0;
2643    }
2644
2645    if (http->ssl == 0)
2646    {
2647       freez(csp->headers->first->str);
2648       build_request_line(csp, fwd, &csp->headers->first->str);
2649    }
2650
2651    /*
2652     * We have a request. Check if one of the crunchers wants it.
2653     */
2654    if (crunch_response_triggered(csp, crunchers_all))
2655    {
2656       /*
2657        * Yes. The client got the crunch response
2658        * and we are done here after cleaning up.
2659        */
2660       /* XXX: why list_remove_all()? */
2661       list_remove_all(csp->headers);
2662
2663       return;
2664    }
2665
2666    log_error(LOG_LEVEL_GPC, "%s%s", http->hostport, http->path);
2667
2668    if (fwd->forward_host)
2669    {
2670       log_error(LOG_LEVEL_CONNECT, "via %s:%d to: %s",
2671          fwd->forward_host, fwd->forward_port, http->hostport);
2672    }
2673    else
2674    {
2675       log_error(LOG_LEVEL_CONNECT, "to %s", http->hostport);
2676    }
2677
2678    /* here we connect to the server, gateway, or the forwarder */
2679
2680    while ((csp->sfd = forwarded_connect(fwd, http, csp))
2681       && (errno == EINVAL)
2682       && (forwarded_connect_retries++ < max_forwarded_connect_retries))
2683    {
2684       log_error(LOG_LEVEL_ERROR,
2685          "failed request #%u to connect to %s. Trying again.",
2686          forwarded_connect_retries, http->hostport);
2687    }
2688
2689    if (csp->sfd == JB_INVALID_SOCKET)
2690    {
2691       if (fwd->type != SOCKS_NONE)
2692       {
2693          /* Socks error. */
2694          rsp = error_response(csp, "forwarding-failed", errno);
2695       }
2696       else if (errno == EINVAL)
2697       {
2698          rsp = error_response(csp, "no-such-domain", errno);
2699       }
2700       else
2701       {
2702          rsp = error_response(csp, "connect-failed", errno);
2703          log_error(LOG_LEVEL_CONNECT, "connect to: %s failed: %E",
2704             http->hostport);
2705       }
2706
2707       /* Write the answer to the client */
2708       if (rsp != NULL)
2709       {
2710          send_crunch_response(csp, rsp);
2711       }
2712
2713       return;
2714    }
2715
2716    hdr = list_to_text(csp->headers);
2717    if (hdr == NULL)
2718    {
2719       /* FIXME Should handle error properly */
2720       log_error(LOG_LEVEL_FATAL, "Out of memory parsing client header");
2721    }
2722    list_remove_all(csp->headers);
2723
2724    if (fwd->forward_host || (http->ssl == 0))
2725    {
2726       /*
2727        * Write the client's (modified) header to the server
2728        * (along with anything else that may be in the buffer)
2729        */
2730       if (write_socket(csp->sfd, hdr, strlen(hdr))
2731        || (flush_socket(csp->sfd, csp->iob) <  0))
2732       {
2733          log_error(LOG_LEVEL_CONNECT,
2734             "write header to: %s failed: %E", http->hostport);
2735
2736          rsp = error_response(csp, "connect-failed", errno);
2737          if (rsp)
2738          {
2739             send_crunch_response(csp, rsp);
2740          }
2741
2742          freez(hdr);
2743          return;
2744       }
2745    }
2746    else
2747    {
2748       /*
2749        * We're running an SSL tunnel and we're not forwarding,
2750        * so just send the "connect succeeded" message to the
2751        * client, flush the rest, and get out of the way.
2752        */
2753       if (write_socket(csp->cfd, CSUCCEED, strlen(CSUCCEED)))
2754       {
2755          freez(hdr);
2756          return;
2757       }
2758       IOB_RESET(csp);
2759    }
2760
2761    log_error(LOG_LEVEL_CONNECT, "to %s successful", http->hostport);
2762
2763    /* we're finished with the client's header */
2764    freez(hdr);
2765
2766    maxfd = (csp->cfd > csp->sfd) ? csp->cfd : csp->sfd;
2767
2768    /* pass data between the client and server
2769     * until one or the other shuts down the connection.
2770     */
2771
2772    server_body = 0;
2773
2774    for (;;)
2775    {
2776 #ifdef __OS2__
2777       /*
2778        * FD_ZERO here seems to point to an errant macro which crashes.
2779        * So do this by hand for now...
2780        */
2781       memset(&rfds,0x00,sizeof(fd_set));
2782 #else
2783       FD_ZERO(&rfds);
2784 #endif
2785       FD_SET(csp->cfd, &rfds);
2786       FD_SET(csp->sfd, &rfds);
2787
2788 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
2789       if ((csp->flags & CSP_FLAG_CHUNKED)
2790          && !(csp->flags & CSP_FLAG_CONTENT_LENGTH_SET)
2791          && ((csp->iob->eod - csp->iob->cur) >= 5)
2792          && !memcmp(csp->iob->eod-5, "0\r\n\r\n", 5))
2793       {
2794          log_error(LOG_LEVEL_CONNECT,
2795             "Looks like we read the last chunk together with "
2796             "the server headers. We better stop reading.");
2797          byte_count = (size_t)(csp->iob->eod - csp->iob->cur);
2798          csp->expected_content_length = byte_count;
2799          csp->flags |= CSP_FLAG_CONTENT_LENGTH_SET;
2800       }
2801       if (server_body && server_response_is_complete(csp, byte_count))
2802       {
2803          log_error(LOG_LEVEL_CONNECT,
2804             "Done reading from server. Expected content length: %d. "
2805             "Actual content length: %d. Most recently received: %d.",
2806             csp->expected_content_length, byte_count, len);
2807          len = 0;
2808          /*
2809           * XXX: should not jump around,
2810           * chat() is complicated enough already.
2811           */
2812          goto reading_done;
2813       }
2814 #endif  /* FEATURE_CONNECTION_KEEP_ALIVE */
2815
2816       n = select((int)maxfd+1, &rfds, NULL, NULL, &timeout);
2817
2818       if (n == 0)
2819       {
2820          log_error(LOG_LEVEL_ERROR,
2821             "Didn't receive data in time: %s", http->url);
2822          if ((byte_count == 0) && (http->ssl == 0))
2823          {
2824             write_socket(csp->cfd, CONNECTION_TIMEOUT_RESPONSE,
2825                strlen(CONNECTION_TIMEOUT_RESPONSE));
2826          }
2827          mark_server_socket_tainted(csp);
2828          return;
2829       }
2830       else if (n < 0)
2831       {
2832          log_error(LOG_LEVEL_ERROR, "select() failed!: %E");
2833          mark_server_socket_tainted(csp);
2834          return;
2835       }
2836
2837       /*
2838        * This is the body of the browser's request,
2839        * just read and write it.
2840        */
2841       if (FD_ISSET(csp->cfd, &rfds))
2842       {
2843          len = read_socket(csp->cfd, buf, sizeof(buf) - 1);
2844
2845          if (len <= 0)
2846          {
2847             /* XXX: not sure if this is necessary. */
2848             mark_server_socket_tainted(csp);
2849             break; /* "game over, man" */
2850          }
2851
2852          if (write_socket(csp->sfd, buf, (size_t)len))
2853          {
2854             log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
2855             mark_server_socket_tainted(csp);
2856             return;
2857          }
2858          continue;
2859       }
2860
2861       /*
2862        * The server wants to talk. It could be the header or the body.
2863        * If `hdr' is null, then it's the header otherwise it's the body.
2864        * FIXME: Does `hdr' really mean `host'? No.
2865        */
2866       if (FD_ISSET(csp->sfd, &rfds))
2867       {
2868          fflush(0);
2869          len = read_socket(csp->sfd, buf, sizeof(buf) - 1);
2870
2871          if (len < 0)
2872          {
2873             log_error(LOG_LEVEL_ERROR, "read from: %s failed: %E", http->host);
2874
2875             if (http->ssl && (fwd->forward_host == NULL))
2876             {
2877                /*
2878                 * Just hang up. We already confirmed the client's CONNECT
2879                 * request with status code 200 and unencrypted content is
2880                 * no longer welcome.
2881                 */
2882                log_error(LOG_LEVEL_ERROR,
2883                   "CONNECT already confirmed. Unable to tell the client about the problem.");
2884                return;
2885             }
2886             else if (byte_count)
2887             {
2888                /*
2889                 * Just hang up. We already transmitted the original headers
2890                 * and parts of the original content and therefore missed the
2891                 * chance to send an error message (without risking data corruption).
2892                 *
2893                 * XXX: we could retry with a fancy range request here.
2894                 */
2895                log_error(LOG_LEVEL_ERROR, "Already forwarded the original headers. "
2896                   "Unable to tell the client about the problem.");
2897                mark_server_socket_tainted(csp);
2898                return;
2899             }
2900
2901             rsp = error_response(csp, "connect-failed", errno);
2902             if (rsp)
2903             {
2904                send_crunch_response(csp, rsp);
2905             }
2906
2907             return;
2908          }
2909
2910 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
2911          if (csp->flags & CSP_FLAG_CHUNKED)
2912          {
2913             if ((len >= 5) && !memcmp(buf+len-5, "0\r\n\r\n", 5))
2914             {
2915                /* XXX: this is a temporary hack */
2916                log_error(LOG_LEVEL_CONNECT,
2917                   "Looks like we reached the end of the last chunk. "
2918                   "We better stop reading.");
2919                csp->expected_content_length = byte_count + (size_t)len;
2920                csp->flags |= CSP_FLAG_CONTENT_LENGTH_SET;
2921             }
2922          }
2923          reading_done:
2924 #endif  /* FEATURE_CONNECTION_KEEP_ALIVE */
2925
2926          /*
2927           * Add a trailing zero to let be able to use string operations.
2928           * XXX: do we still need this with filter_popups gone?
2929           */
2930          buf[len] = '\0';
2931
2932          /*
2933           * Normally, this would indicate that we've read
2934           * as much as the server has sent us and we can
2935           * close the client connection.  However, Microsoft
2936           * in its wisdom has released IIS/5 with a bug that
2937           * prevents it from sending the trailing \r\n in
2938           * a 302 redirect header (and possibly other headers).
2939           * To work around this if we've haven't parsed
2940           * a full header we'll append a trailing \r\n
2941           * and see if this now generates a valid one.
2942           *
2943           * This hack shouldn't have any impacts.  If we've
2944           * already transmitted the header or if this is a
2945           * SSL connection, then we won't bother with this
2946           * hack.  So we only work on partially received
2947           * headers.  If we append a \r\n and this still
2948           * doesn't generate a valid header, then we won't
2949           * transmit anything to the client.
2950           */
2951          if (len == 0)
2952          {
2953
2954             if (server_body || http->ssl)
2955             {
2956                /*
2957                 * If we have been buffering up the document,
2958                 * now is the time to apply content modification
2959                 * and send the result to the client.
2960                 */
2961                if (content_filter)
2962                {
2963                   p = execute_content_filter(csp, content_filter);
2964                   /*
2965                    * If the content filter fails, use the original
2966                    * buffer and length.
2967                    * (see p != NULL ? p : csp->iob->cur below)
2968                    */
2969                   if (NULL == p)
2970                   {
2971                      csp->content_length = (size_t)(csp->iob->eod - csp->iob->cur);
2972                   }
2973
2974                   if (JB_ERR_OK != update_server_headers(csp))
2975                   {
2976                      log_error(LOG_LEVEL_FATAL,
2977                         "Failed to update server headers. after filtering.");
2978                   }
2979
2980                   hdr = list_to_text(csp->headers);
2981                   if (hdr == NULL)
2982                   {
2983                      /* FIXME Should handle error properly */
2984                      log_error(LOG_LEVEL_FATAL, "Out of memory parsing server header");
2985                   }
2986
2987                   if (write_socket(csp->cfd, hdr, strlen(hdr))
2988                    || write_socket(csp->cfd, p != NULL ? p : csp->iob->cur, csp->content_length))
2989                   {
2990                      log_error(LOG_LEVEL_ERROR, "write modified content to client failed: %E");
2991                      freez(hdr);
2992                      freez(p);
2993                      mark_server_socket_tainted(csp);
2994                      return;
2995                   }
2996
2997                   freez(hdr);
2998                   freez(p);
2999                }
3000
3001                break; /* "game over, man" */
3002             }
3003
3004             /*
3005              * This is NOT the body, so
3006              * Let's pretend the server just sent us a blank line.
3007              */
3008             snprintf(buf, sizeof(buf), "\r\n");
3009             len = (int)strlen(buf);
3010
3011             /*
3012              * Now, let the normal header parsing algorithm below do its
3013              * job.  If it fails, we'll exit instead of continuing.
3014              */
3015
3016             ms_iis5_hack = 1;
3017          }
3018
3019          /*
3020           * If this is an SSL connection or we're in the body
3021           * of the server document, just write it to the client,
3022           * unless we need to buffer the body for later content-filtering
3023           */
3024          if (server_body || http->ssl)
3025          {
3026             if (content_filter)
3027             {
3028                /*
3029                 * If there is no memory left for buffering the content, or the buffer limit
3030                 * has been reached, switch to non-filtering mode, i.e. make & write the
3031                 * header, flush the iob and buf, and get out of the way.
3032                 */
3033                if (add_to_iob(csp, buf, len))
3034                {
3035                   size_t hdrlen;
3036                   int flushed;
3037
3038                   log_error(LOG_LEVEL_INFO,
3039                      "Flushing header and buffers. Stepping back from filtering.");
3040
3041                   hdr = list_to_text(csp->headers);
3042                   if (hdr == NULL)
3043                   {
3044                      /* 
3045                       * Memory is too tight to even generate the header.
3046                       * Send our static "Out-of-memory" page.
3047                       */
3048                      log_error(LOG_LEVEL_ERROR, "Out of memory while trying to flush.");
3049                      rsp = cgi_error_memory();
3050                      send_crunch_response(csp, rsp);
3051                      mark_server_socket_tainted(csp);
3052                      return;
3053                   }
3054                   hdrlen = strlen(hdr);
3055
3056                   if (write_socket(csp->cfd, hdr, hdrlen)
3057                    || ((flushed = flush_socket(csp->cfd, csp->iob)) < 0)
3058                    || (write_socket(csp->cfd, buf, (size_t)len)))
3059                   {
3060                      log_error(LOG_LEVEL_CONNECT,
3061                         "Flush header and buffers to client failed: %E");
3062                      freez(hdr);
3063                      mark_server_socket_tainted(csp);
3064                      return;
3065                   }
3066
3067                   /*
3068                    * Reset the byte_count to the amount of bytes
3069                    * we just flushed. len will be added a few lines below,
3070                    * hdrlen doesn't matter for LOG_LEVEL_CLF.
3071                    */
3072                   byte_count = (size_t)flushed;
3073                   freez(hdr);
3074                   content_filter = NULL;
3075                   server_body = 1;
3076                }
3077             }
3078             else
3079             {
3080                if (write_socket(csp->cfd, buf, (size_t)len))
3081                {
3082                   log_error(LOG_LEVEL_ERROR, "write to client failed: %E");
3083                   mark_server_socket_tainted(csp);
3084                   return;
3085                }
3086             }
3087             byte_count += (size_t)len;
3088             continue;
3089          }
3090          else
3091          {
3092             const char *header_start;
3093             /*
3094              * We're still looking for the end of the server's header.
3095              * Buffer up the data we just read.  If that fails, there's
3096              * little we can do but send our static out-of-memory page.
3097              */
3098             if (add_to_iob(csp, buf, len))
3099             {
3100                log_error(LOG_LEVEL_ERROR, "Out of memory while looking for end of server headers.");
3101                rsp = cgi_error_memory();
3102                send_crunch_response(csp, rsp);               
3103                mark_server_socket_tainted(csp);
3104                return;
3105             }
3106
3107             header_start = csp->iob->cur;
3108
3109             /* Convert iob into something sed() can digest */
3110             if (JB_ERR_PARSE == get_server_headers(csp))
3111             {
3112                if (ms_iis5_hack)
3113                {
3114                   /*
3115                    * Well, we tried our MS IIS/5 hack and it didn't work.
3116                    * The header is incomplete and there isn't anything
3117                    * we can do about it.
3118                    */
3119                   log_error(LOG_LEVEL_INFO,
3120                      "MS IIS5 hack didn't produce valid headers.");
3121                   break;
3122                }
3123                else
3124                {
3125                   /*
3126                    * Since we have to wait for more from the server before
3127                    * we can parse the headers we just continue here.
3128                    */
3129                   int header_offset = csp->iob->cur - header_start;
3130                   assert(csp->iob->cur >= header_start);
3131                   byte_count += (size_t)(len - header_offset);
3132                   log_error(LOG_LEVEL_CONNECT, "Continuing buffering headers. "
3133                      "byte_count: %d. header_offset: %d. len: %d.",
3134                      byte_count, header_offset, len);
3135                   continue;
3136                }
3137             }
3138
3139             /* Did we actually get anything? */
3140             if (NULL == csp->headers->first)
3141             {
3142                log_error(LOG_LEVEL_ERROR, "Empty server or forwarder response.");
3143                log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 502 0", csp->ip_addr_str, http->cmd);
3144                write_socket(csp->cfd, NO_SERVER_DATA_RESPONSE, strlen(NO_SERVER_DATA_RESPONSE));
3145                free_http_request(http);
3146                mark_server_socket_tainted(csp);
3147                return;
3148             }
3149
3150             assert(csp->headers->first->str);
3151             assert(!http->ssl);
3152             if (strncmpic(csp->headers->first->str, "HTTP", 4) &&
3153                 strncmpic(csp->headers->first->str, "ICY", 3))
3154             {
3155                /*
3156                 * It doesn't look like a HTTP (or Shoutcast) response:
3157                 * tell the client and log the problem.
3158                 */
3159                if (strlen(csp->headers->first->str) > 30)
3160                {
3161                   csp->headers->first->str[30] = '\0';
3162                }
3163                log_error(LOG_LEVEL_ERROR,
3164                   "Invalid server or forwarder response. Starts with: %s",
3165                   csp->headers->first->str);
3166                log_error(LOG_LEVEL_CLF,
3167                   "%s - - [%T] \"%s\" 502 0", csp->ip_addr_str, http->cmd);
3168                write_socket(csp->cfd, INVALID_SERVER_HEADERS_RESPONSE,
3169                   strlen(INVALID_SERVER_HEADERS_RESPONSE));
3170                free_http_request(http);
3171                mark_server_socket_tainted(csp);
3172                return;
3173             }
3174
3175             /*
3176              * We have now received the entire server header,
3177              * filter it and send the result to the client
3178              */
3179             if (JB_ERR_OK != sed(csp, FILTER_SERVER_HEADERS))
3180             {
3181                log_error(LOG_LEVEL_FATAL, "Failed to parse server headers.");
3182             }
3183             hdr = list_to_text(csp->headers);
3184             if (hdr == NULL)
3185             {
3186                /* FIXME Should handle error properly */
3187                log_error(LOG_LEVEL_FATAL, "Out of memory parsing server header");
3188             }
3189
3190             if (crunch_response_triggered(csp, crunchers_light))
3191             {
3192                /*
3193                 * One of the tags created by a server-header
3194                 * tagger triggered a crunch. We already
3195                 * delivered the crunch response to the client
3196                 * and are done here after cleaning up.
3197                 */
3198                 freez(hdr);
3199                 mark_server_socket_tainted(csp);
3200                 return;
3201             }
3202             /* Buffer and pcrs filter this if appropriate. */
3203
3204             if (!http->ssl) /* We talk plaintext */
3205             {
3206                content_filter = get_filter_function(csp);
3207             }
3208             /*
3209              * Only write if we're not buffering for content modification
3210              */
3211             if (!content_filter)
3212             {
3213                /*
3214                 * Write the server's (modified) header to
3215                 * the client (along with anything else that
3216                 * may be in the buffer)
3217                 */
3218
3219                if (write_socket(csp->cfd, hdr, strlen(hdr))
3220                 || ((len = flush_socket(csp->cfd, csp->iob)) < 0))
3221                {
3222                   log_error(LOG_LEVEL_CONNECT, "write header to client failed: %E");
3223
3224                   /*
3225                    * The write failed, so don't bother mentioning it
3226                    * to the client... it probably can't hear us anyway.
3227                    */
3228                   freez(hdr);
3229                   mark_server_socket_tainted(csp);
3230                   return;
3231                }
3232
3233                byte_count += (size_t)len;
3234             }
3235             else
3236             {
3237                /*
3238                 * XXX: the header lenght should probably
3239                 * be calculated by get_server_headers().
3240                 */
3241                int header_length = csp->iob->cur - header_start;
3242                assert(csp->iob->cur > header_start);
3243                byte_count += (size_t)(len - header_length);
3244             }
3245
3246             /* we're finished with the server's header */
3247
3248             freez(hdr);
3249             server_body = 1;
3250
3251             /*
3252              * If this was a MS IIS/5 hack then it means the server
3253              * has already closed the connection. Nothing more to read.
3254              * Time to bail.
3255              */
3256             if (ms_iis5_hack)
3257             {
3258                log_error(LOG_LEVEL_INFO,
3259                   "Closed server connection detected with MS IIS5 hack enabled.");
3260                break;
3261             }
3262          }
3263          continue;
3264       }
3265       mark_server_socket_tainted(csp);
3266       return; /* huh? we should never get here */
3267    }
3268
3269    if (csp->content_length == 0)
3270    {
3271       /*
3272        * If Privoxy didn't recalculate the Content-Lenght,
3273        * byte_count is still correct.
3274        */
3275       csp->content_length = byte_count;
3276    }
3277
3278 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
3279    if ((csp->flags & CSP_FLAG_CONTENT_LENGTH_SET)
3280       && (csp->expected_content_length != byte_count))
3281    {
3282       log_error(LOG_LEVEL_CONNECT,
3283          "Received %d bytes while expecting %d.",
3284          byte_count, csp->expected_content_length);
3285       mark_server_socket_tainted(csp);
3286    }
3287 #endif
3288
3289    log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 %d",
3290       csp->ip_addr_str, http->ocmd, csp->content_length);
3291 }
3292
3293
3294 /*********************************************************************
3295  *
3296  * Function    :  serve
3297  *
3298  * Description :  This is little more than chat.  We only "serve" to
3299  *                to close any socket that chat may have opened.
3300  *
3301  * Parameters  :
3302  *          1  :  csp = Current client state (buffers, headers, etc...)
3303  *
3304  * Returns     :  N/A
3305  *
3306  *********************************************************************/
3307 #ifdef AMIGA
3308 void serve(struct client_state *csp)
3309 #else /* ifndef AMIGA */
3310 static void serve(struct client_state *csp)
3311 #endif /* def AMIGA */
3312 {
3313    chat(csp);
3314    close_socket(csp->cfd);
3315
3316    if (csp->sfd != JB_INVALID_SOCKET)
3317    {
3318 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
3319       static int monitor_thread_running = 0;
3320
3321       if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
3322        && (csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE))
3323       {
3324          remember_connection(csp->sfd, csp->http, forward_url(csp, csp->http));
3325          privoxy_mutex_lock(&connection_reuse_mutex);
3326          if (!monitor_thread_running)
3327          {
3328             monitor_thread_running = 1;
3329             privoxy_mutex_unlock(&connection_reuse_mutex);
3330             wait_for_alive_connections();
3331             privoxy_mutex_lock(&connection_reuse_mutex);
3332             monitor_thread_running = 0;
3333          }
3334          privoxy_mutex_unlock(&connection_reuse_mutex);
3335       }
3336       else
3337       {
3338          forget_connection(csp->sfd);
3339          close_socket(csp->sfd);
3340       }
3341 #else
3342       close_socket(csp->sfd);
3343 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
3344    }
3345
3346    csp->flags &= ~CSP_FLAG_ACTIVE;
3347
3348 }
3349
3350
3351 #ifdef __BEOS__
3352 /*********************************************************************
3353  *
3354  * Function    :  server_thread
3355  *
3356  * Description :  We only exist to call `serve' in a threaded environment.
3357  *
3358  * Parameters  :
3359  *          1  :  data = Current client state (buffers, headers, etc...)
3360  *
3361  * Returns     :  Always 0.
3362  *
3363  *********************************************************************/
3364 static int32 server_thread(void *data)
3365 {
3366    serve((struct client_state *) data);
3367    return 0;
3368
3369 }
3370 #endif
3371
3372
3373 #if !defined(_WIN32) || defined(_WIN_CONSOLE)
3374 /*********************************************************************
3375  *
3376  * Function    :  usage
3377  *
3378  * Description :  Print usage info & exit.
3379  *
3380  * Parameters  :  Pointer to argv[0] for identifying ourselves
3381  *
3382  * Returns     :  No. ,-)
3383  *
3384  *********************************************************************/
3385 static void usage(const char *myname)
3386 {
3387    printf("Privoxy version " VERSION " (" HOME_PAGE_URL ")\n"
3388           "Usage: %s "
3389 #if defined(unix)
3390           "[--chroot] "
3391 #endif /* defined(unix) */
3392           "[--help] "
3393 #if defined(unix)
3394           "[--no-daemon] [--pidfile pidfile] [--pre-chroot-nslookup hostname] [--user user[.group]] "
3395 #endif /* defined(unix) */
3396           "[--version] [configfile]\n"
3397           "Aborting\n", myname);
3398
3399    exit(2);
3400
3401 }
3402 #endif /* #if !defined(_WIN32) || defined(_WIN_CONSOLE) */
3403
3404
3405 #ifdef MUTEX_LOCKS_AVAILABLE
3406 /*********************************************************************
3407  *
3408  * Function    :  privoxy_mutex_lock
3409  *
3410  * Description :  Locks a mutex.
3411  *
3412  * Parameters  :
3413  *          1  :  mutex = The mutex to lock.
3414  *
3415  * Returns     :  Void. May exit in case of errors.
3416  *
3417  *********************************************************************/
3418 void privoxy_mutex_lock(privoxy_mutex_t *mutex)
3419 {
3420 #ifdef FEATURE_PTHREAD
3421    int err = pthread_mutex_lock(mutex);
3422    if (err)
3423    {
3424       if (mutex != &log_mutex)
3425       {
3426          log_error(LOG_LEVEL_FATAL,
3427             "Mutex locking failed: %s.\n", strerror(err));
3428       }
3429       exit(1);
3430    }
3431 #else
3432    EnterCriticalSection(mutex);
3433 #endif /* def FEATURE_PTHREAD */
3434 }
3435
3436
3437 /*********************************************************************
3438  *
3439  * Function    :  privoxy_mutex_unlock
3440  *
3441  * Description :  Unlocks a mutex.
3442  *
3443  * Parameters  :
3444  *          1  :  mutex = The mutex to unlock.
3445  *
3446  * Returns     :  Void. May exit in case of errors.
3447  *
3448  *********************************************************************/
3449 void privoxy_mutex_unlock(privoxy_mutex_t *mutex)
3450 {
3451 #ifdef FEATURE_PTHREAD
3452    int err = pthread_mutex_unlock(mutex);
3453    if (err)
3454    {
3455       if (mutex != &log_mutex)
3456       {
3457          log_error(LOG_LEVEL_FATAL,
3458             "Mutex unlocking failed: %s.\n", strerror(err));
3459       }
3460       exit(1);
3461    }
3462 #else
3463    LeaveCriticalSection(mutex);
3464 #endif /* def FEATURE_PTHREAD */
3465 }
3466
3467
3468 /*********************************************************************
3469  *
3470  * Function    :  privoxy_mutex_init
3471  *
3472  * Description :  Prepares a mutex.
3473  *
3474  * Parameters  :
3475  *          1  :  mutex = The mutex to initialize.
3476  *
3477  * Returns     :  Void. May exit in case of errors.
3478  *
3479  *********************************************************************/
3480 static void privoxy_mutex_init(privoxy_mutex_t *mutex)
3481 {
3482 #ifdef FEATURE_PTHREAD
3483    int err = pthread_mutex_init(mutex, 0);
3484    if (err)
3485    {
3486       printf("Fatal error. Mutex initialization failed: %s.\n",
3487          strerror(err));
3488       exit(1);
3489    }
3490 #else
3491    InitializeCriticalSection(mutex);
3492 #endif /* def FEATURE_PTHREAD */
3493 }
3494 #endif /* def MUTEX_LOCKS_AVAILABLE */
3495
3496 /*********************************************************************
3497  *
3498  * Function    :  initialize_mutexes
3499  *
3500  * Description :  Prepares mutexes if mutex support is available.
3501  *
3502  * Parameters  :  None
3503  *
3504  * Returns     :  Void, exits in case of errors.
3505  *
3506  *********************************************************************/
3507 static void initialize_mutexes(void)
3508 {
3509 #ifdef MUTEX_LOCKS_AVAILABLE
3510    /*
3511     * Prepare global mutex semaphores
3512     */
3513    privoxy_mutex_init(&log_mutex);
3514    privoxy_mutex_init(&log_init_mutex);
3515    privoxy_mutex_init(&connection_reuse_mutex);
3516
3517    /*
3518     * XXX: The assumptions below are a bit naive
3519     * and can cause locks that aren't necessary.
3520     *
3521     * For example older FreeBSD versions (< 6.x?)
3522     * have no gethostbyname_r, but gethostbyname is
3523     * thread safe.
3524     */
3525 #if !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R)
3526    privoxy_mutex_init(&resolver_mutex);
3527 #endif /* !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R) */
3528    /*
3529     * XXX: should we use a single mutex for
3530     * localtime() and gmtime() as well?
3531     */
3532 #ifndef HAVE_GMTIME_R
3533    privoxy_mutex_init(&gmtime_mutex);
3534 #endif /* ndef HAVE_GMTIME_R */
3535
3536 #ifndef HAVE_LOCALTIME_R
3537    privoxy_mutex_init(&localtime_mutex);
3538 #endif /* ndef HAVE_GMTIME_R */
3539
3540 #ifndef HAVE_RANDOM
3541    privoxy_mutex_init(&rand_mutex);
3542 #endif /* ndef HAVE_RANDOM */
3543 #endif /* def MUTEX_LOCKS_AVAILABLE */
3544 }
3545
3546
3547 /*********************************************************************
3548  *
3549  * Function    :  main
3550  *
3551  * Description :  Load the config file and start the listen loop.
3552  *                This function is a lot more *sane* with the `load_config'
3553  *                and `listen_loop' functions; although it stills does
3554  *                a *little* too much for my taste.
3555  *
3556  * Parameters  :
3557  *          1  :  argc = Number of parameters (including $0).
3558  *          2  :  argv = Array of (char *)'s to the parameters.
3559  *
3560  * Returns     :  1 if : can't open config file, unrecognized directive,
3561  *                stats requested in multi-thread mode, can't open the
3562  *                log file, can't open the jar file, listen port is invalid,
3563  *                any load fails, and can't bind port.
3564  *
3565  *                Else main never returns, the process must be signaled
3566  *                to terminate execution.  Or, on Windows, use the
3567  *                "File", "Exit" menu option.
3568  *
3569  *********************************************************************/
3570 #ifdef __MINGW32__
3571 int real_main(int argc, const char *argv[])
3572 #else
3573 int main(int argc, const char *argv[])
3574 #endif
3575 {
3576    int argc_pos = 0;
3577    unsigned int random_seed;
3578 #ifdef unix
3579    struct passwd *pw = NULL;
3580    struct group *grp = NULL;
3581    char *p;
3582    int do_chroot = 0;
3583    char *pre_chroot_nslookup_to_load_resolver = NULL;
3584 #endif
3585
3586    Argc = argc;
3587    Argv = argv;
3588
3589    configfile =
3590 #if !defined(_WIN32)
3591    "config"
3592 #else
3593    "config.txt"
3594 #endif
3595       ;
3596
3597    /* Prepare mutexes if supported and necessary. */
3598    initialize_mutexes();
3599
3600    /* Enable logging until further notice. */
3601    init_log_module();
3602
3603    /*
3604     * Parse the command line arguments
3605     *
3606     * XXX: simply printing usage information in case of
3607     * invalid arguments isn't particularly user friendly.
3608     */
3609    while (++argc_pos < argc)
3610    {
3611 #ifdef _WIN32
3612       /* Check to see if the service must be installed or uninstalled */
3613       if (strncmp(argv[argc_pos], "--install", 9) == 0)
3614       {
3615          const char *pName = argv[argc_pos] + 9;
3616          if (*pName == ':')
3617             pName++;
3618          exit( (install_service(pName)) ? 0 : 1 );
3619       }
3620       else if (strncmp(argv[argc_pos], "--uninstall", + 11) == 0)
3621       {
3622          const char *pName = argv[argc_pos] + 11;
3623          if (*pName == ':')
3624             pName++;
3625          exit((uninstall_service(pName)) ? 0 : 1);
3626       }
3627       else if (strcmp(argv[argc_pos], "--service" ) == 0)
3628       {
3629          bRunAsService = TRUE;
3630          w32_set_service_cwd();
3631          atexit(w32_service_exit_notify);
3632       }
3633       else
3634 #endif /* defined(_WIN32) */
3635
3636
3637 #if !defined(_WIN32) || defined(_WIN_CONSOLE)
3638
3639       if (strcmp(argv[argc_pos], "--help") == 0)
3640       {
3641          usage(argv[0]);
3642       }
3643
3644       else if(strcmp(argv[argc_pos], "--version") == 0)
3645       {
3646          printf("Privoxy version " VERSION " (" HOME_PAGE_URL ")\n");
3647          exit(0);
3648       }
3649
3650 #if defined(unix)
3651
3652       else if (strcmp(argv[argc_pos], "--no-daemon" ) == 0)
3653       {
3654          no_daemon = 1;
3655       }
3656
3657       else if (strcmp(argv[argc_pos], "--pidfile" ) == 0)
3658       {
3659          if (++argc_pos == argc) usage(argv[0]);
3660          pidfile = strdup(argv[argc_pos]);
3661       }
3662
3663       else if (strcmp(argv[argc_pos], "--user" ) == 0)
3664       {
3665          if (++argc_pos == argc) usage(argv[argc_pos]);
3666
3667          if ((NULL != (p = strchr(argv[argc_pos], '.'))) && *(p + 1) != '0')
3668          {
3669             *p++ = '\0';
3670             if (NULL == (grp = getgrnam(p)))
3671             {
3672                log_error(LOG_LEVEL_FATAL, "Group %s not found.", p);
3673             }
3674          }
3675
3676          if (NULL == (pw = getpwnam(argv[argc_pos])))
3677          {
3678             log_error(LOG_LEVEL_FATAL, "User %s not found.", argv[argc_pos]);
3679          }
3680
3681          if (p != NULL) *--p = '\0';
3682       }
3683
3684       else if (strcmp(argv[argc_pos], "--pre-chroot-nslookup" ) == 0)
3685       {
3686          if (++argc_pos == argc) usage(argv[0]);
3687          pre_chroot_nslookup_to_load_resolver = strdup(argv[argc_pos]);
3688       }
3689
3690       else if (strcmp(argv[argc_pos], "--chroot" ) == 0)
3691       {
3692          do_chroot = 1;
3693       }
3694 #endif /* defined(unix) */
3695
3696       else if (argc_pos + 1 != argc)
3697       {
3698          /*
3699           * This is neither the last command line
3700           * option, nor was it recognized before,
3701           * therefore it must be invalid.
3702           */
3703          usage(argv[0]);
3704       }
3705       else
3706
3707 #endif /* defined(_WIN32) && !defined(_WIN_CONSOLE) */
3708       {
3709          configfile = argv[argc_pos];
3710       }
3711
3712    } /* -END- while (more arguments) */
3713
3714    show_version(Argv[0]);
3715
3716 #if defined(unix)
3717    if ( *configfile != '/' )
3718    {
3719       char cwd[BUFFER_SIZE];
3720       char *abs_file;
3721       size_t abs_file_size; 
3722
3723       /* make config-filename absolute here */
3724       if (NULL == getcwd(cwd, sizeof(cwd)))
3725       {
3726          perror("failed to get current working directory");
3727          exit( 1 );
3728       }
3729
3730       /* XXX: why + 5? */
3731       abs_file_size = strlen(cwd) + strlen(configfile) + 5;
3732       basedir = strdup(cwd);
3733
3734       if (NULL == basedir ||
3735           NULL == (abs_file = malloc(abs_file_size)))
3736       {
3737          perror("malloc failed");
3738          exit( 1 );
3739       }
3740       strlcpy(abs_file, basedir, abs_file_size);
3741       strlcat(abs_file, "/", abs_file_size );
3742       strlcat(abs_file, configfile, abs_file_size);
3743       configfile = abs_file;
3744    }
3745 #endif /* defined unix */
3746
3747
3748    files->next = NULL;
3749    clients->next = NULL;
3750
3751    /* XXX: factor out initialising after the next stable release. */
3752 #ifdef AMIGA
3753    InitAmiga();
3754 #elif defined(_WIN32)
3755    InitWin32();
3756 #endif
3757
3758    random_seed = (unsigned int)time(NULL);
3759 #ifdef HAVE_RANDOM
3760    srandom(random_seed);
3761 #else
3762    srand(random_seed);
3763 #endif /* ifdef HAVE_RANDOM */
3764
3765    /*
3766     * Unix signal handling
3767     *
3768     * Catch the abort, interrupt and terminate signals for a graceful exit
3769     * Catch the hangup signal so the errlog can be reopened.
3770     * Ignore the broken pipe signals (FIXME: Why?)
3771     */
3772 #if !defined(_WIN32) && !defined(__OS2__) && !defined(AMIGA)
3773 {
3774    int idx;
3775    const int catched_signals[] = { SIGTERM, SIGINT, SIGHUP, 0 };
3776    const int ignored_signals[] = { SIGPIPE, 0 };
3777
3778    for (idx = 0; catched_signals[idx] != 0; idx++)
3779    {
3780 #ifdef sun /* FIXME: Is it safe to check for HAVE_SIGSET instead? */ 
3781       if (sigset(catched_signals[idx], sig_handler) == SIG_ERR)
3782 #else
3783       if (signal(catched_signals[idx], sig_handler) == SIG_ERR)
3784 #endif /* ifdef sun */
3785       {
3786          log_error(LOG_LEVEL_FATAL, "Can't set signal-handler for signal %d: %E", catched_signals[idx]);
3787       }
3788    }
3789
3790    for (idx = 0; ignored_signals[idx] != 0; idx++)
3791    {
3792       if (signal(ignored_signals[idx], SIG_IGN) == SIG_ERR)
3793       {
3794          log_error(LOG_LEVEL_FATAL, "Can't set ignore-handler for signal %d: %E", ignored_signals[idx]);
3795       }
3796    }
3797
3798 }
3799 #else /* ifdef _WIN32 */
3800 # ifdef _WIN_CONSOLE
3801    /*
3802     * We *are* in a windows console app.
3803     * Print a verbose messages about FAQ's and such
3804     */
3805    printf("%s", win32_blurb);
3806 # endif /* def _WIN_CONSOLE */
3807 #endif /* def _WIN32 */
3808
3809
3810    /* Initialize the CGI subsystem */
3811    cgi_init_error_messages();
3812
3813    /*
3814     * If runnig on unix and without the --nodaemon
3815     * option, become a daemon. I.e. fork, detach
3816     * from tty and get process group leadership
3817     */
3818 #if defined(unix)
3819 {
3820    pid_t pid = 0;
3821 #if 0
3822    int   fd;
3823 #endif
3824
3825    if (!no_daemon)
3826    {
3827       pid  = fork();
3828
3829       if ( pid < 0 ) /* error */
3830       {
3831          perror("fork");
3832          exit( 3 );
3833       }
3834       else if ( pid != 0 ) /* parent */
3835       {
3836          int status;
3837          pid_t wpid;
3838          /*
3839           * must check for errors
3840           * child died due to missing files aso
3841           */
3842          sleep( 1 );
3843          wpid = waitpid( pid, &status, WNOHANG );
3844          if ( wpid != 0 )
3845          {
3846             exit( 1 );
3847          }
3848          exit( 0 );
3849       }
3850       /* child */
3851 #if 1
3852       /* Should be more portable, but not as well tested */
3853       setsid();
3854 #else /* !1 */
3855 #ifdef __FreeBSD__
3856       setpgrp(0,0);
3857 #else /* ndef __FreeBSD__ */
3858       setpgrp();
3859 #endif /* ndef __FreeBSD__ */
3860       fd = open("/dev/tty", O_RDONLY);
3861       if ( fd )
3862       {
3863          /* no error check here */
3864          ioctl( fd, TIOCNOTTY,0 );
3865          close ( fd );
3866       }
3867 #endif /* 1 */
3868       /*
3869        * stderr (fd 2) will be closed later on, when the
3870        * log file has been parsed.
3871        */
3872
3873       close( 0 );
3874       close( 1 );
3875       chdir("/");
3876
3877    } /* -END- if (!no_daemon) */
3878
3879    /*
3880     * As soon as we have written the PID file, we can switch
3881     * to the user and group ID indicated by the --user option
3882     */
3883    write_pid_file();
3884
3885    if (NULL != pw)
3886    {
3887       if (setgid((NULL != grp) ? grp->gr_gid : pw->pw_gid))
3888       {
3889          log_error(LOG_LEVEL_FATAL, "Cannot setgid(): Insufficient permissions.");
3890       }
3891       if (NULL != grp)
3892       {
3893          if (setgroups(1, &grp->gr_gid))
3894          {
3895             log_error(LOG_LEVEL_FATAL, "setgroups() failed: %E");
3896          }
3897       }
3898       else if (initgroups(pw->pw_name, pw->pw_gid))
3899       {
3900          log_error(LOG_LEVEL_FATAL, "initgroups() failed: %E");
3901       }
3902       if (do_chroot)
3903       {
3904          if (!pw->pw_dir)
3905          {
3906             log_error(LOG_LEVEL_FATAL, "Home directory for %s undefined", pw->pw_name);
3907          }
3908          /* Read the time zone file from /etc before doing chroot. */
3909          tzset();
3910          if (NULL != pre_chroot_nslookup_to_load_resolver
3911              && '\0' != pre_chroot_nslookup_to_load_resolver[0])
3912          {
3913             /* Initialize resolver library. */
3914             (void) resolve_hostname_to_ip(pre_chroot_nslookup_to_load_resolver);
3915          }
3916          if (chroot(pw->pw_dir) < 0)
3917          {
3918             log_error(LOG_LEVEL_FATAL, "Cannot chroot to %s", pw->pw_dir);
3919          }
3920          if (chdir ("/"))
3921          {
3922             log_error(LOG_LEVEL_FATAL, "Cannot chdir /");
3923          }
3924       }
3925       if (setuid(pw->pw_uid))
3926       {
3927          log_error(LOG_LEVEL_FATAL, "Cannot setuid(): Insufficient permissions.");
3928       }
3929       if (do_chroot)
3930       {
3931          char putenv_dummy[64];
3932
3933          strlcpy(putenv_dummy, "HOME=/", sizeof(putenv_dummy));
3934          if (putenv(putenv_dummy) != 0)
3935          {
3936             log_error(LOG_LEVEL_FATAL, "Cannot putenv(): HOME");
3937          }                
3938
3939          snprintf(putenv_dummy, sizeof(putenv_dummy), "USER=%s", pw->pw_name);
3940          if (putenv(putenv_dummy) != 0)
3941          {
3942             log_error(LOG_LEVEL_FATAL, "Cannot putenv(): USER");
3943          }
3944       }
3945    }
3946    else if (do_chroot)
3947    {
3948       log_error(LOG_LEVEL_FATAL, "Cannot chroot without --user argument.");
3949    }
3950 }
3951 #endif /* defined unix */
3952
3953 #ifdef _WIN32
3954    /* This will be FALSE unless the command line specified --service
3955     */
3956    if (bRunAsService)
3957    {
3958       /* Yup, so now we must attempt to establish a connection 
3959        * with the service dispatcher. This will only work if this
3960        * process was launched by the service control manager to
3961        * actually run as a service. If this isn't the case, i've
3962        * known it take around 30 seconds or so for the call to return.
3963        */
3964
3965       /* The StartServiceCtrlDispatcher won't return until the service is stopping */
3966       if (w32_start_service_ctrl_dispatcher(w32ServiceDispatchTable))
3967       {
3968          /* Service has run, and at this point is now being stopped, so just return */
3969          return 0;
3970       }
3971
3972 #ifdef _WIN_CONSOLE
3973       printf("Warning: Failed to connect to Service Control Dispatcher\nwhen starting as a service!\n");
3974 #endif
3975       /* An error occurred. Usually it's because --service was wrongly specified
3976        * and we were unable to connect to the Service Control Dispatcher because
3977        * it wasn't expecting us and is therefore not listening.
3978        *
3979        * For now, just continue below to call the listen_loop function.
3980        */
3981    }
3982 #endif /* def _WIN32 */
3983
3984    listen_loop();
3985
3986    /* NOTREACHED */
3987    return(-1);
3988
3989 }
3990
3991
3992 /*********************************************************************
3993  *
3994  * Function    :  bind_port_helper
3995  *
3996  * Description :  Bind the listen port.  Handles logging, and aborts
3997  *                on failure.
3998  *
3999  * Parameters  :
4000  *          1  :  config = Privoxy configuration.  Specifies port
4001  *                         to bind to.
4002  *
4003  * Returns     :  Port that was opened.
4004  *
4005  *********************************************************************/
4006 static jb_socket bind_port_helper(struct configuration_spec * config)
4007 {
4008    int result;
4009    jb_socket bfd;
4010
4011    if (config->haddr == NULL)
4012    {
4013       log_error(LOG_LEVEL_INFO, "Listening on port %d on all IP addresses",
4014                 config->hport);
4015    }
4016    else
4017    {
4018       log_error(LOG_LEVEL_INFO, "Listening on port %d on IP address %s",
4019                 config->hport, config->haddr);
4020    }
4021
4022    result = bind_port(config->haddr, config->hport, &bfd);
4023
4024    if (result < 0)
4025    {
4026       switch(result)
4027       {
4028          case -3 :
4029             log_error(LOG_LEVEL_FATAL, "can't bind to %s:%d: "
4030                "There may be another Privoxy or some other "
4031                "proxy running on port %d",
4032                (NULL != config->haddr) ? config->haddr : "INADDR_ANY",
4033                       config->hport, config->hport);
4034
4035          case -2 :
4036             log_error(LOG_LEVEL_FATAL, "can't bind to %s:%d: " 
4037                "The hostname is not resolvable",
4038                (NULL != config->haddr) ? config->haddr : "INADDR_ANY", config->hport);
4039
4040          default :
4041             log_error(LOG_LEVEL_FATAL, "can't bind to %s:%d: because %E",
4042                (NULL != config->haddr) ? config->haddr : "INADDR_ANY", config->hport);
4043       }
4044
4045       /* shouldn't get here */
4046       return JB_INVALID_SOCKET;
4047    }
4048
4049    config->need_bind = 0;
4050
4051    return bfd;
4052 }
4053
4054
4055 #ifdef _WIN32
4056 /* Without this simple workaround we get this compiler warning from _beginthread
4057  *     warning C4028: formal parameter 1 different from declaration
4058  */
4059 void w32_service_listen_loop(void *p)
4060 {
4061    listen_loop();
4062 }
4063 #endif /* def _WIN32 */
4064
4065
4066 /*********************************************************************
4067  *
4068  * Function    :  listen_loop
4069  *
4070  * Description :  bind the listen port and enter a "FOREVER" listening loop.
4071  *
4072  * Parameters  :  N/A
4073  *
4074  * Returns     :  Never.
4075  *
4076  *********************************************************************/
4077 static void listen_loop(void)
4078 {
4079    struct client_state *csp = NULL;
4080    jb_socket bfd;
4081    struct configuration_spec * config;
4082
4083    config = load_config();
4084
4085 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
4086    /*
4087     * XXX: Should be relocated once it no
4088     * longer needs to emit log messages.
4089     */
4090    initialize_reusable_connections();
4091 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
4092
4093    bfd = bind_port_helper(config);
4094
4095 #ifdef FEATURE_GRACEFUL_TERMINATION
4096    while (!g_terminate)
4097 #else
4098    for (;;)
4099 #endif
4100    {
4101 #if !defined(FEATURE_PTHREAD) && !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__)
4102       while (waitpid(-1, NULL, WNOHANG) > 0)
4103       {
4104          /* zombie children */
4105       }
4106 #endif /* !defined(FEATURE_PTHREAD) && !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) */
4107
4108       /*
4109        * Free data that was used by died threads
4110        */
4111       sweep();
4112
4113 #if defined(unix)
4114       /*
4115        * Re-open the errlog after HUP signal
4116        */
4117       if (received_hup_signal)
4118       {
4119          if (NULL != config->logfile)
4120          {
4121             init_error_log(Argv[0], config->logfile);
4122          }
4123          received_hup_signal = 0;
4124       }
4125 #endif
4126
4127       if ( NULL == (csp = (struct client_state *) zalloc(sizeof(*csp))) )
4128       {
4129          log_error(LOG_LEVEL_FATAL, "malloc(%d) for csp failed: %E", sizeof(*csp));
4130          continue;
4131       }
4132
4133       csp->flags |= CSP_FLAG_ACTIVE;
4134       csp->sfd    = JB_INVALID_SOCKET;
4135
4136       csp->config = config = load_config();
4137
4138       if ( config->need_bind )
4139       {
4140          /*
4141           * Since we were listening to the "old port", we will not see
4142           * a "listen" param change until the next IJB request.  So, at
4143           * least 1 more request must be made for us to find the new
4144           * setting.  I am simply closing the old socket and binding the
4145           * new one.
4146           *
4147           * Which-ever is correct, we will serve 1 more page via the
4148           * old settings.  This should probably be a "show-proxy-args"
4149           * request.  This should not be a so common of an operation
4150           * that this will hurt people's feelings.
4151           */
4152
4153          close_socket(bfd);
4154
4155          bfd = bind_port_helper(config);
4156       }
4157
4158       log_error(LOG_LEVEL_CONNECT, "Listening for new connections ... ");
4159
4160       if (!accept_connection(csp, bfd))
4161       {
4162          log_error(LOG_LEVEL_CONNECT, "accept failed: %E");
4163
4164 #ifdef AMIGA
4165          if(!childs)
4166          {
4167             exit(1);
4168          }
4169 #endif
4170          freez(csp);
4171          continue;
4172       }
4173       else
4174       {
4175          log_error(LOG_LEVEL_CONNECT, "accepted connection from %s", csp->ip_addr_str);
4176       }
4177
4178 #ifdef FEATURE_TOGGLE
4179       if (global_toggle_state)
4180 #endif /* def FEATURE_TOGGLE */
4181       {
4182          csp->flags |= CSP_FLAG_TOGGLED_ON;
4183       }
4184
4185       if (run_loader(csp))
4186       {
4187          log_error(LOG_LEVEL_FATAL, "a loader failed - must exit");
4188          /* Never get here - LOG_LEVEL_FATAL causes program exit */
4189       }
4190
4191 #ifdef FEATURE_ACL
4192       if (block_acl(NULL,csp))
4193       {
4194          log_error(LOG_LEVEL_CONNECT, "Connection from %s dropped due to ACL", csp->ip_addr_str);
4195          close_socket(csp->cfd);
4196          freez(csp);
4197          continue;
4198       }
4199 #endif /* def FEATURE_ACL */
4200
4201       /* add it to the list of clients */
4202       csp->next = clients->next;
4203       clients->next = csp;
4204
4205       if (config->multi_threaded)
4206       {
4207          int child_id;
4208
4209 /* this is a switch () statment in the C preprocessor - ugh */
4210 #undef SELECTED_ONE_OPTION
4211
4212 /* Use Pthreads in preference to native code */
4213 #if defined(FEATURE_PTHREAD) && !defined(SELECTED_ONE_OPTION)
4214 #define SELECTED_ONE_OPTION
4215          {
4216             pthread_t the_thread;
4217             pthread_attr_t attrs;
4218
4219             pthread_attr_init(&attrs);
4220             pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED);
4221             errno = pthread_create(&the_thread, &attrs,
4222                (void * (*)(void *))serve, csp);
4223             child_id = errno ? -1 : 0;
4224             pthread_attr_destroy(&attrs);
4225          }
4226 #endif
4227
4228 #if defined(_WIN32) && !defined(_CYGWIN) && !defined(SELECTED_ONE_OPTION)
4229 #define SELECTED_ONE_OPTION
4230          child_id = _beginthread(
4231             (void (*)(void *))serve,
4232             64 * 1024,
4233             csp);
4234 #endif
4235
4236 #if defined(__OS2__) && !defined(SELECTED_ONE_OPTION)
4237 #define SELECTED_ONE_OPTION
4238          child_id = _beginthread(
4239             (void(* _Optlink)(void*))serve,
4240             NULL,
4241             64 * 1024,
4242             csp);
4243 #endif
4244
4245 #if defined(__BEOS__) && !defined(SELECTED_ONE_OPTION)
4246 #define SELECTED_ONE_OPTION
4247          {
4248             thread_id tid = spawn_thread
4249                (server_thread, "server", B_NORMAL_PRIORITY, csp);
4250
4251             if ((tid >= 0) && (resume_thread(tid) == B_OK))
4252             {
4253                child_id = (int) tid;
4254             }
4255             else
4256             {
4257                child_id = -1;
4258             }
4259          }
4260 #endif
4261
4262 #if defined(AMIGA) && !defined(SELECTED_ONE_OPTION)
4263 #define SELECTED_ONE_OPTION
4264          csp->cfd = ReleaseSocket(csp->cfd, -1);
4265          
4266 #ifdef __amigaos4__
4267          child_id = (int)CreateNewProcTags(NP_Entry, (ULONG)server_thread,
4268                                            NP_Output, Output(),
4269                                            NP_CloseOutput, FALSE,
4270                                            NP_Name, (ULONG)"privoxy child",
4271                                            NP_Child, TRUE,
4272                                            TAG_DONE);
4273 #else
4274          child_id = (int)CreateNewProcTags(NP_Entry, (ULONG)server_thread,
4275                                            NP_Output, Output(),
4276                                            NP_CloseOutput, FALSE,
4277                                            NP_Name, (ULONG)"privoxy child",
4278                                            NP_StackSize, 200*1024,
4279                                            TAG_DONE);
4280 #endif
4281          if(0 != child_id)
4282          {
4283             childs++;
4284             ((struct Task *)child_id)->tc_UserData = csp;
4285             Signal((struct Task *)child_id, SIGF_SINGLE);
4286             Wait(SIGF_SINGLE);
4287          }
4288 #endif
4289
4290 #if !defined(SELECTED_ONE_OPTION)
4291          child_id = fork();
4292
4293          /* This block is only needed when using fork().
4294           * When using threads, the server thread was
4295           * created and run by the call to _beginthread().
4296           */
4297          if (child_id == 0)   /* child */
4298          {
4299             int rc = 0;
4300 #ifdef FEATURE_TOGGLE
4301             int inherited_toggle_state = global_toggle_state;
4302 #endif /* def FEATURE_TOGGLE */
4303
4304             serve(csp);
4305
4306             /* 
4307              * If we've been toggled or we've blocked the request, tell Mom
4308              */
4309
4310 #ifdef FEATURE_TOGGLE
4311             if (inherited_toggle_state != global_toggle_state)
4312             {
4313                rc |= RC_FLAG_TOGGLED;
4314             }
4315 #endif /* def FEATURE_TOGGLE */
4316
4317 #ifdef FEATURE_STATISTICS  
4318             if (csp->flags & CSP_FLAG_REJECTED)
4319             {
4320                rc |= RC_FLAG_BLOCKED;
4321             }
4322 #endif /* ndef FEATURE_STATISTICS */
4323
4324             _exit(rc);
4325          }
4326          else if (child_id > 0) /* parent */
4327          {
4328             /* in a fork()'d environment, the parent's
4329              * copy of the client socket and the CSP
4330              * are not used.
4331              */
4332             int child_status;
4333 #if !defined(_WIN32) && !defined(__CYGWIN__)
4334
4335             wait( &child_status );
4336
4337             /* 
4338              * Evaluate child's return code: If the child has
4339              *  - been toggled, toggle ourselves
4340              *  - blocked its request, bump up the stats counter
4341              */
4342
4343 #ifdef FEATURE_TOGGLE
4344             if (WIFEXITED(child_status) && (WEXITSTATUS(child_status) & RC_FLAG_TOGGLED))
4345             {
4346                global_toggle_state = !global_toggle_state;
4347             }
4348 #endif /* def FEATURE_TOGGLE */
4349
4350 #ifdef FEATURE_STATISTICS
4351             urls_read++;
4352             if (WIFEXITED(child_status) && (WEXITSTATUS(child_status) & RC_FLAG_BLOCKED))
4353             {
4354                urls_rejected++;
4355             }
4356 #endif /* def FEATURE_STATISTICS */ 
4357
4358 #endif /* !defined(_WIN32) && defined(__CYGWIN__) */
4359             close_socket(csp->cfd);
4360             csp->flags &= ~CSP_FLAG_ACTIVE;
4361          }
4362 #endif
4363
4364 #undef SELECTED_ONE_OPTION
4365 /* end of cpp switch () */
4366
4367          if (child_id < 0) /* failed */
4368          {
4369             char buf[BUFFER_SIZE];
4370
4371             log_error(LOG_LEVEL_ERROR, "can't fork: %E");
4372
4373             snprintf(buf , sizeof(buf), "Privoxy: can't fork: errno = %d", errno);
4374
4375             write_socket(csp->cfd, buf, strlen(buf));
4376             close_socket(csp->cfd);
4377             csp->flags &= ~CSP_FLAG_ACTIVE;
4378             sleep(5);
4379             continue;
4380          }
4381       }
4382       else
4383       {
4384          serve(csp);
4385       }
4386    }
4387
4388    /* NOTREACHED unless FEATURE_GRACEFUL_TERMINATION is defined */
4389
4390    /* Clean up.  Aim: free all memory (no leaks) */
4391 #ifdef FEATURE_GRACEFUL_TERMINATION
4392
4393    log_error(LOG_LEVEL_ERROR, "Graceful termination requested");
4394
4395    unload_current_config_file();
4396    unload_current_actions_file();
4397    unload_current_re_filterfile();
4398 #ifdef FEATURE_TRUST
4399    unload_current_trust_file();
4400 #endif
4401
4402    if (config->multi_threaded)
4403    {
4404       int i = 60;
4405       do
4406       {
4407          sleep(1);
4408          sweep();
4409       } while ((clients->next != NULL) && (--i > 0));
4410
4411       if (i <= 0)
4412       {
4413          log_error(LOG_LEVEL_ERROR, "Graceful termination failed - still some live clients after 1 minute wait.");
4414       }
4415    }
4416    sweep();
4417    sweep();
4418
4419 #if defined(unix)
4420    freez(basedir);
4421 #endif
4422    freez(configfile);
4423
4424 #if defined(_WIN32) && !defined(_WIN_CONSOLE)
4425    /* Cleanup - remove taskbar icon etc. */
4426    TermLogWindow();
4427 #endif
4428
4429    exit(0);
4430 #endif /* FEATURE_GRACEFUL_TERMINATION */
4431
4432 }
4433
4434
4435 /*
4436   Local Variables:
4437   tab-width: 3
4438   end:
4439 */