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