9ad0341a1e7045560471b297f9a1a38920fda957
[privoxy.git] / src / parsers.c
1 const char parsers_rcs[] = "$Id: parsers.c,v 2.3 2002/12/28 03:58:19 david__schmidt Exp $";
2 /*********************************************************************
3  *
4  * File        :  $Source: /cvsroot/ijbswa/current/src/parsers.c,v $
5  *
6  * Purpose     :  Declares functions to parse/crunch headers and pages.
7  *                Functions declared include:
8  *                   `add_to_iob', `client_cookie_adder', `client_from',
9  *                   `client_referrer', `client_send_cookie', `client_ua',
10  *                   `client_uagent', `client_x_forwarded',
11  *                   `client_x_forwarded_adder', `client_xtra_adder',
12  *                   `content_type', `crumble', `destroy_list', `enlist',
13  *                   `flush_socket', ``get_header', `sed',
14  *                   and `server_set_cookie'.
15  *
16  * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
17  *                Privoxy team. http://www.privoxy.org/
18  *
19  *                Based on the Internet Junkbuster originally written
20  *                by and Copyright (C) 1997 Anonymous Coders and
21  *                Junkbusters Corporation.  http://www.junkbusters.com
22  *
23  *                This program is free software; you can redistribute it
24  *                and/or modify it under the terms of the GNU General
25  *                Public License as published by the Free Software
26  *                Foundation; either version 2 of the License, or (at
27  *                your option) any later version.
28  *
29  *                This program is distributed in the hope that it will
30  *                be useful, but WITHOUT ANY WARRANTY; without even the
31  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
32  *                PARTICULAR PURPOSE.  See the GNU General Public
33  *                License for more details.
34  *
35  *                The GNU General Public License should be included with
36  *                this file.  If not, you can view it at
37  *                http://www.gnu.org/copyleft/gpl.html
38  *                or write to the Free Software Foundation, Inc., 59
39  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
40  *
41  * Revisions   :
42  *    $Log: parsers.c,v $
43  *    Revision 2.3  2002/12/28 03:58:19  david__schmidt
44  *    Initial drop of dashboard instrumentation - enabled with
45  *    --enable-activity-console
46  *
47  *    Revision 2.2  2002/11/10 04:20:38  hal9
48  *    Fix typo: supressed -> suppressed
49  *
50  *    Revision 2.1  2002/09/11 11:23:59  oes
51  *    Fixed logging of cookies: Killed incoming cookies now logged; incoming/outgoing cookies now distinguished in log
52  *
53  *    Revision 2.0  2002/06/04 14:34:21  jongfoster
54  *    Moving source files to src/
55  *
56  *    Revision 1.56  2002/05/12 15:34:22  jongfoster
57  *    Fixing typo in a comment
58  *
59  *    Revision 1.55  2002/05/08 16:01:07  oes
60  *    Optimized add_to_iob:
61  *     - Use realloc instead of malloc(), memcpy(), free()
62  *     - Expand to powers of two if possible, to get
63  *       O(log n) reallocs instead of O(n).
64  *     - Moved check for buffer limit here from chat
65  *     - Report failure via returncode
66  *
67  *    Revision 1.54  2002/04/02 15:03:16  oes
68  *    Tiny code cosmetics
69  *
70  *    Revision 1.53  2002/03/26 22:29:55  swa
71  *    we have a new homepage!
72  *
73  *    Revision 1.52  2002/03/24 13:25:43  swa
74  *    name change related issues
75  *
76  *    Revision 1.51  2002/03/13 00:27:05  jongfoster
77  *    Killing warnings
78  *
79  *    Revision 1.50  2002/03/12 01:45:35  oes
80  *    More verbose logging
81  *
82  *    Revision 1.49  2002/03/09 20:03:52  jongfoster
83  *    - Making various functions return int rather than size_t.
84  *      (Undoing a recent change).  Since size_t is unsigned on
85  *      Windows, functions like read_socket that return -1 on
86  *      error cannot return a size_t.
87  *
88  *      THIS WAS A MAJOR BUG - it caused frequent, unpredictable
89  *      crashes, and also frequently caused JB to jump to 100%
90  *      CPU and stay there.  (Because it thought it had just
91  *      read ((unsigned)-1) == 4Gb of data...)
92  *
93  *    - The signature of write_socket has changed, it now simply
94  *      returns success=0/failure=nonzero.
95  *
96  *    - Trying to get rid of a few warnings --with-debug on
97  *      Windows, I've introduced a new type "jb_socket".  This is
98  *      used for the socket file descriptors.  On Windows, this
99  *      is SOCKET (a typedef for unsigned).  Everywhere else, it's
100  *      an int.  The error value can't be -1 any more, so it's
101  *      now JB_INVALID_SOCKET (which is -1 on UNIX, and in
102  *      Windows it maps to the #define INVALID_SOCKET.)
103  *
104  *    - The signature of bind_port has changed.
105  *
106  *    Revision 1.48  2002/03/07 03:46:53  oes
107  *    Fixed compiler warnings etc
108  *
109  *    Revision 1.47  2002/02/20 23:15:13  jongfoster
110  *    Parsing functions now handle out-of-memory gracefully by returning
111  *    an error code.
112  *
113  *    Revision 1.46  2002/01/17 21:03:47  jongfoster
114  *    Moving all our URL and URL pattern parsing code to urlmatch.c.
115  *
116  *    Revision 1.45  2002/01/09 14:33:03  oes
117  *    Added support for localtime_r.
118  *
119  *    Revision 1.44  2001/12/14 01:22:54  steudten
120  *    Remove 'user:pass@' from 'proto://user:pass@host' for the
121  *    new added header 'Host: ..'. (See Req ID 491818)
122  *
123  *    Revision 1.43  2001/11/23 00:26:38  jongfoster
124  *    Fixing two really stupid errors in my previous commit
125  *
126  *    Revision 1.42  2001/11/22 21:59:30  jongfoster
127  *    Adding code to handle +no-cookies-keep
128  *
129  *    Revision 1.41  2001/11/05 23:43:05  steudten
130  *    Add time+date to log files.
131  *
132  *    Revision 1.40  2001/10/26 20:13:09  jongfoster
133  *    ctype.h is needed in Windows, too.
134  *
135  *    Revision 1.39  2001/10/26 17:40:04  oes
136  *    Introduced get_header_value()
137  *    Removed http->user_agent, csp->referrer and csp->accept_types
138  *    Removed client_accept()
139  *
140  *    Revision 1.38  2001/10/25 03:40:48  david__schmidt
141  *    Change in porting tactics: OS/2's EMX porting layer doesn't allow multiple
142  *    threads to call select() simultaneously.  So, it's time to do a real, live,
143  *    native OS/2 port.  See defines for __EMX__ (the porting layer) vs. __OS2__
144  *    (native). Both versions will work, but using __OS2__ offers multi-threading.
145  *
146  *    Revision 1.37  2001/10/23 21:36:02  jongfoster
147  *    Documenting sed()'s error behaviou (doc change only)
148  *
149  *    Revision 1.36  2001/10/13 12:51:51  joergs
150  *    Removed client_host, (was only required for the old 2.0.2-11 http://noijb.
151  *    force-load), instead crumble Host: and add it (again) in client_host_adder
152  *    (in case we get a HTTP/1.0 request without Host: header and forward it to
153  *    a HTTP/1.1 server/proxy).
154  *
155  *    Revision 1.35  2001/10/09 22:39:21  jongfoster
156  *    assert.h is also required under Win32, so moving out of #ifndef _WIN32
157  *    block.
158  *
159  *    Revision 1.34  2001/10/07 18:50:55  oes
160  *    Added server_content_encoding, renamed server_transfer_encoding
161  *
162  *    Revision 1.33  2001/10/07 18:04:49  oes
163  *    Changed server_http11 to server_http and its pattern to "HTTP".
164  *      Additional functionality: it now saves the HTTP status into
165  *      csp->http->status and sets CT_TABOO for Status 206 (partial range)
166  *
167  *    Revision 1.32  2001/10/07 15:43:28  oes
168  *    Removed FEATURE_DENY_GZIP and replaced it with client_accept_encoding,
169  *       client_te and client_accept_encoding_adder, triggered by the new
170  *       +no-compression action. For HTTP/1.1 the Accept-Encoding header is
171  *       changed to allow only identity and chunked, and the TE header is
172  *       crunched. For HTTP/1.0, Accept-Encoding is crunched.
173  *
174  *    parse_http_request no longer does anything than parsing. The rewriting
175  *      of http->cmd and version mangling are gone. It now also recognizes
176  *      the put and delete methods and saves the url in http->url. Removed
177  *      unused variable.
178  *
179  *    renamed content_type and content_length to have the server_ prefix
180  *
181  *    server_content_type now only works if csp->content_type != CT_TABOO
182  *
183  *    added server_transfer_encoding, which
184  *      - Sets CT_TABOO to prohibit filtering if encoding compresses
185  *      - Raises the CSP_FLAG_CHUNKED flag if Encoding is "chunked"
186  *      - Change from "chunked" to "identity" if body was chunked
187  *        but has been de-chunked for filtering.
188  *
189  *    added server_content_md5 which crunches any Content-MD5 headers
190  *      if the body was modified.
191  *
192  *    made server_http11 conditional on +downgrade action
193  *
194  *    Replaced 6 boolean members of csp with one bitmap (csp->flags)
195  *
196  *    Revision 1.31  2001/10/05 14:25:02  oes
197  *    Crumble Keep-Alive from Server
198  *
199  *    Revision 1.30  2001/09/29 12:56:03  joergs
200  *    IJB now changes HTTP/1.1 to HTTP/1.0 in requests and answers.
201  *
202  *    Revision 1.29  2001/09/24 21:09:24  jongfoster
203  *    Fixing 2 memory leaks that Guy spotted, where the paramater to
204  *    enlist() was not being free()d.
205  *
206  *    Revision 1.28  2001/09/22 16:32:28  jongfoster
207  *    Removing unused #includes.
208  *
209  *    Revision 1.27  2001/09/20 15:45:25  steudten
210  *
211  *    add casting from size_t to int for printf()
212  *    remove local variable shadow s2
213  *
214  *    Revision 1.26  2001/09/16 17:05:14  jongfoster
215  *    Removing unused #include showarg.h
216  *
217  *    Revision 1.25  2001/09/16 13:21:27  jongfoster
218  *    Changes to use new list functions.
219  *
220  *    Revision 1.24  2001/09/13 23:05:50  jongfoster
221  *    Changing the string paramater to the header parsers a "const".
222  *
223  *    Revision 1.23  2001/09/12 18:08:19  steudten
224  *
225  *    In parse_http_request() header rewriting miss the host value, so
226  *    from http://www.mydomain.com the result was just " / " not
227  *    http://www.mydomain.com/ in case we forward.
228  *
229  *    Revision 1.22  2001/09/10 10:58:53  oes
230  *    Silenced compiler warnings
231  *
232  *    Revision 1.21  2001/07/31 14:46:00  oes
233  *     - Persistant connections now suppressed
234  *     - sed() no longer appends empty header to csp->headers
235  *
236  *    Revision 1.20  2001/07/30 22:08:36  jongfoster
237  *    Tidying up #defines:
238  *    - All feature #defines are now of the form FEATURE_xxx
239  *    - Permanently turned off WIN_GUI_EDIT
240  *    - Permanently turned on WEBDAV and SPLIT_PROXY_ARGS
241  *
242  *    Revision 1.19  2001/07/25 17:21:54  oes
243  *    client_uagent now saves copy of User-Agent: header value
244  *
245  *    Revision 1.18  2001/07/13 14:02:46  oes
246  *     - Included fix to repair broken HTTP requests that
247  *       don't contain a path, not even '/'.
248  *     - Removed all #ifdef PCRS
249  *     - content_type now always inspected and classified as
250  *       text, gif or other.
251  *     - formatting / comments
252  *
253  *    Revision 1.17  2001/06/29 21:45:41  oes
254  *    Indentation, CRLF->LF, Tab-> Space
255  *
256  *    Revision 1.16  2001/06/29 13:32:42  oes
257  *    - Fixed a comment
258  *    - Adapted free_http_request
259  *    - Removed logentry from cancelled commit
260  *
261  *    Revision 1.15  2001/06/03 19:12:38  oes
262  *    deleted const struct interceptors
263  *
264  *    Revision 1.14  2001/06/01 18:49:17  jongfoster
265  *    Replaced "list_share" with "list" - the tiny memory gain was not
266  *    worth the extra complexity.
267  *
268  *    Revision 1.13  2001/05/31 21:30:33  jongfoster
269  *    Removed list code - it's now in list.[ch]
270  *    Renamed "permission" to "action", and changed many features
271  *    to use the actions file rather than the global config.
272  *
273  *    Revision 1.12  2001/05/31 17:33:13  oes
274  *
275  *    CRLF -> LF
276  *
277  *    Revision 1.11  2001/05/29 20:11:19  joergs
278  *    '/ * inside comment' warning removed.
279  *
280  *    Revision 1.10  2001/05/29 09:50:24  jongfoster
281  *    Unified blocklist/imagelist/permissionslist.
282  *    File format is still under discussion, but the internal changes
283  *    are (mostly) done.
284  *
285  *    Also modified interceptor behaviour:
286  *    - We now intercept all URLs beginning with one of the following
287  *      prefixes (and *only* these prefixes):
288  *        * http://i.j.b/
289  *        * http://ijbswa.sf.net/config/
290  *        * http://ijbswa.sourceforge.net/config/
291  *    - New interceptors "home page" - go to http://i.j.b/ to see it.
292  *    - Internal changes so that intercepted and fast redirect pages
293  *      are not replaced with an image.
294  *    - Interceptors now have the option to send a binary page direct
295  *      to the client. (i.e. ijb-send-banner uses this)
296  *    - Implemented show-url-info interceptor.  (Which is why I needed
297  *      the above interceptors changes - a typical URL is
298  *      "http://i.j.b/show-url-info?url=www.somesite.com/banner.gif".
299  *      The previous mechanism would not have intercepted that, and
300  *      if it had been intercepted then it then it would have replaced
301  *      it with an image.)
302  *
303  *    Revision 1.9  2001/05/28 17:26:33  jongfoster
304  *    Fixing segfault if last header was crunched.
305  *    Fixing Windows build (snprintf() is _snprintf() under Win32, but we
306  *    can use the cross-platform sprintf() instead.)
307  *
308  *    Revision 1.8  2001/05/27 22:17:04  oes
309  *
310  *    - re_process_buffer no longer writes the modified buffer
311  *      to the client, which was very ugly. It now returns the
312  *      buffer, which it is then written by chat.
313  *
314  *    - content_length now adjusts the Content-Length: header
315  *      for modified documents rather than crunch()ing it.
316  *      (Length info in csp->content_length, which is 0 for
317  *      unmodified documents)
318  *
319  *    - For this to work, sed() is called twice when filtering.
320  *
321  *    Revision 1.7  2001/05/27 13:19:06  oes
322  *    Patched Joergs solution for the content-length in.
323  *
324  *    Revision 1.6  2001/05/26 13:39:32  jongfoster
325  *    Only crunches Content-Length header if applying RE filtering.
326  *    Without this fix, Microsoft Windows Update wouldn't work.
327  *
328  *    Revision 1.5  2001/05/26 00:28:36  jongfoster
329  *    Automatic reloading of config file.
330  *    Removed obsolete SIGHUP support (Unix) and Reload menu option (Win32).
331  *    Most of the global variables have been moved to a new
332  *    struct configuration_spec, accessed through csp->config->globalname
333  *    Most of the globals remaining are used by the Win32 GUI.
334  *
335  *    Revision 1.4  2001/05/22 18:46:04  oes
336  *
337  *    - Enabled filtering banners by size rather than URL
338  *      by adding patterns that replace all standard banner
339  *      sizes with the "Junkbuster" gif to the re_filterfile
340  *
341  *    - Enabled filtering WebBugs by providing a pattern
342  *      which kills all 1x1 images
343  *
344  *    - Added support for PCRE_UNGREEDY behaviour to pcrs,
345  *      which is selected by the (nonstandard and therefore
346  *      capital) letter 'U' in the option string.
347  *      It causes the quantifiers to be ungreedy by default.
348  *      Appending a ? turns back to greedy (!).
349  *
350  *    - Added a new interceptor ijb-send-banner, which
351  *      sends back the "Junkbuster" gif. Without imagelist or
352  *      MSIE detection support, or if tinygif = 1, or the
353  *      URL isn't recognized as an imageurl, a lame HTML
354  *      explanation is sent instead.
355  *
356  *    - Added new feature, which permits blocking remote
357  *      script redirects and firing back a local redirect
358  *      to the browser.
359  *      The feature is conditionally compiled, i.e. it
360  *      can be disabled with --disable-fast-redirects,
361  *      plus it must be activated by a "fast-redirects"
362  *      line in the config file, has its own log level
363  *      and of course wants to be displayed by show-proxy-args
364  *      Note: Boy, all the #ifdefs in 1001 locations and
365  *      all the fumbling with configure.in and acconfig.h
366  *      were *way* more work than the feature itself :-(
367  *
368  *    - Because a generic redirect template was needed for
369  *      this, tinygif = 3 now uses the same.
370  *
371  *    - Moved GIFs, and other static HTTP response templates
372  *      to project.h
373  *
374  *    - Some minor fixes
375  *
376  *    - Removed some >400 CRs again (Jon, you really worked
377  *      a lot! ;-)
378  *
379  *    Revision 1.3  2001/05/20 01:21:20  jongfoster
380  *    Version 2.9.4 checkin.
381  *    - Merged popupfile and cookiefile, and added control over PCRS
382  *      filtering, in new "permissionsfile".
383  *    - Implemented LOG_LEVEL_FATAL, so that if there is a configuration
384  *      file error you now get a message box (in the Win32 GUI) rather
385  *      than the program exiting with no explanation.
386  *    - Made killpopup use the PCRS MIME-type checking and HTTP-header
387  *      skipping.
388  *    - Removed tabs from "config"
389  *    - Moved duplicated url parsing code in "loaders.c" to a new funcition.
390  *    - Bumped up version number.
391  *
392  *    Revision 1.2  2001/05/17 23:02:36  oes
393  *     - Made referrer option accept 'L' as a substitute for 'ยง'
394  *
395  *    Revision 1.1.1.1  2001/05/15 13:59:01  oes
396  *    Initial import of version 2.9.3 source tree
397  *
398  *
399  *********************************************************************/
400 \f
401
402 #include "config.h"
403
404 #ifndef _WIN32
405 #include <stdio.h>
406 #include <sys/types.h>
407 #endif
408
409 #include <stdlib.h>
410 #include <ctype.h>
411 #include <assert.h>
412 #include <string.h>
413
414 #if !defined(_WIN32) && !defined(__OS2__)
415 #include <unistd.h>
416 #endif
417
418 #include "project.h"
419 #include "list.h"
420 #include "parsers.h"
421 #include "encode.h"
422 #include "ssplit.h"
423 #include "errlog.h"
424 #include "jbsockets.h"
425 #include "miscutil.h"
426 #include "list.h"
427 #ifdef FEATURE_ACTIVITY_CONSOLE
428 #include "stats.h"
429 #endif /* def FEATURE_ACTIVITY_CONSOLE */
430
431 const char parsers_h_rcs[] = PARSERS_H_VERSION;
432
433 /* Fix a problem with Solaris.  There should be no effect on other
434  * platforms.
435  * Solaris's isspace() is a macro which uses it's argument directly
436  * as an array index.  Therefore we need to make sure that high-bit
437  * characters generate +ve values, and ideally we also want to make
438  * the argument match the declared parameter type of "int".
439  *
440  * Why did they write a character function that can't take a simple
441  * "char" argument?  Doh!
442  */
443 #define ijb_isupper(__X) isupper((int)(unsigned char)(__X))
444 #define ijb_tolower(__X) tolower((int)(unsigned char)(__X))
445
446
447 const struct parsers client_patterns[] = {
448    { "referer:",                 8,    client_referrer },
449    { "user-agent:",              11,   client_uagent },
450    { "ua-",                      3,    client_ua },
451    { "from:",                    5,    client_from },
452    { "cookie:",                  7,    client_send_cookie },
453    { "x-forwarded-for:",         16,   client_x_forwarded },
454    { "Accept-Encoding:",         16,   client_accept_encoding },
455    { "TE:",                      3,    client_te },
456    { "Host:",                     5,   crumble },
457 /* { "if-modified-since:",       18,   crumble }, */
458    { "Keep-Alive:",              11,   crumble },
459    { "connection:",              11,   crumble },
460    { "proxy-connection:",        17,   crumble },
461    { NULL,                       0,    NULL }
462 };
463
464
465 const struct parsers server_patterns[] = {
466    { "HTTP",                4, server_http },
467    { "set-cookie:",        11, server_set_cookie },
468    { "connection:",        11, crumble },
469    { "Content-Type:",      13, server_content_type },
470    { "Content-Length:",    15, server_content_length },
471    { "Content-MD5:",       12, server_content_md5 },
472    { "Content-Encoding:",  17, server_content_encoding },
473    { "Transfer-Encoding:", 18, server_transfer_coding },
474    { "Keep-Alive:",        11, crumble },
475    { NULL, 0, NULL }
476 };
477
478
479 const add_header_func_ptr add_client_headers[] = {
480    client_host_adder,
481    client_cookie_adder,
482    client_x_forwarded_adder,
483    client_xtra_adder,
484    client_accept_encoding_adder,
485    connection_close_adder,
486    NULL
487 };
488
489
490 const add_header_func_ptr add_server_headers[] = {
491    connection_close_adder,
492    NULL
493 };
494
495
496 /*********************************************************************
497  *
498  * Function    :  flush_socket
499  *
500  * Description :  Write any pending "buffered" content.
501  *
502  * Parameters  :
503  *          1  :  fd = file descriptor of the socket to read
504  *          2  :  csp = Current client state (buffers, headers, etc...)
505  *
506  * Returns     :  On success, the number of bytes written are returned (zero
507  *                indicates nothing was written).  On error, -1 is returned,
508  *                and errno is set appropriately.  If count is zero and the
509  *                file descriptor refers to a regular file, 0 will be
510  *                returned without causing any other effect.  For a special
511  *                file, the results are not portable.
512  *
513  *********************************************************************/
514 int flush_socket(jb_socket fd, struct client_state *csp)
515 {
516    struct iob *iob = csp->iob;
517    int len = iob->eod - iob->cur;
518
519    if (len <= 0)
520    {
521       return(0);
522    }
523
524    if (write_socket(fd, iob->cur, (size_t)len))
525    {
526       return(-1);
527    }
528    iob->eod = iob->cur = iob->buf;
529    return(len);
530
531 }
532
533
534 /*********************************************************************
535  *
536  * Function    :  add_to_iob
537  *
538  * Description :  Add content to the buffered page, expanding the
539  *                buffer if necessary.
540  *
541  * Parameters  :
542  *          1  :  csp = Current client state (buffers, headers, etc...)
543  *          2  :  buf = holds the content to be added to the page
544  *          3  :  n = number of bytes to be added
545  *
546  * Returns     :  JB_ERR_OK on success, JB_ERR_MEMORY if out-of-memory
547  *                or buffer limit reached.
548  *
549  *********************************************************************/
550 jb_err add_to_iob(struct client_state *csp, char *buf, int n)
551 {
552    struct iob *iob = csp->iob;
553    size_t used, offset, need, want;
554    char *p;
555
556    if (n <= 0) return JB_ERR_OK;
557
558    used   = iob->eod - iob->buf;
559    offset = iob->cur - iob->buf;
560    need   = used + n + 1;
561
562    /*
563     * If the buffer can't hold the new data, extend it first.
564     * Use the next power of two if possible, else use the actual need.
565     */
566    if (need > csp->config->buffer_limit)
567    {
568       log_error(LOG_LEVEL_ERROR, "Buffer limit reached while extending the buffer (iob)");
569       return JB_ERR_MEMORY;
570    }
571
572    if (need > iob->size)
573    {
574       for (want = csp->iob->size ? csp->iob->size : 512; want <= need;) want *= 2;
575       
576       if (want <= csp->config->buffer_limit && NULL != (p = (char *)realloc(iob->buf, want)))
577       {
578          iob->size = want;
579       }
580       else if (NULL != (p = (char *)realloc(iob->buf, need)))
581       {
582          iob->size = need;
583       }
584       else
585       {
586          log_error(LOG_LEVEL_ERROR, "Extending the buffer (iob) failed: %E");
587          return JB_ERR_MEMORY;
588       }
589
590       /* Update the iob pointers */
591       iob->cur = p + offset;
592       iob->eod = p + used;
593       iob->buf = p;
594    }
595
596    /* copy the new data into the iob buffer */
597    memcpy(iob->eod, buf, (size_t)n);
598
599    /* point to the end of the data */
600    iob->eod += n;
601
602    /* null terminate == cheap insurance */
603    *iob->eod = '\0';
604
605    return JB_ERR_OK;
606
607 }
608
609
610 /*********************************************************************
611  *
612  * Function    :  get_header
613  *
614  * Description :  This (odd) routine will parse the csp->iob
615  *
616  * Parameters  :
617  *          1  :  csp = Current client state (buffers, headers, etc...)
618  *
619  * Returns     :  Any one of the following:
620  *
621  * 1) a pointer to a dynamically allocated string that contains a header line
622  * 2) NULL  indicating that the end of the header was reached
623  * 3) ""    indicating that the end of the iob was reached before finding
624  *          a complete header line.
625  *
626  *********************************************************************/
627 char *get_header(struct client_state *csp)
628 {
629    struct iob *iob;
630    char *p, *q, *ret;
631    iob = csp->iob;
632
633    if ((iob->cur == NULL)
634       || ((p = strchr(iob->cur, '\n')) == NULL))
635    {
636       return(""); /* couldn't find a complete header */
637    }
638
639    *p = '\0';
640
641    ret = strdup(iob->cur);
642    if (ret == NULL)
643    {
644       /* FIXME No way to handle error properly */
645       log_error(LOG_LEVEL_FATAL, "Out of memory in get_header()");
646    }
647
648    iob->cur = p+1;
649
650    if ((q = strchr(ret, '\r')) != NULL) *q = '\0';
651
652    /* is this a blank line (i.e. the end of the header) ? */
653    if (*ret == '\0')
654    {
655       freez(ret);
656       return(NULL);
657    }
658
659    return(ret);
660
661 }
662
663
664 /*********************************************************************
665  *
666  * Function    :  get_header_value
667  *
668  * Description :  Get the value of a given header from a chained list
669  *                of header lines or return NULL if no such header is
670  *                present in the list.
671  *
672  * Parameters  :
673  *          1  :  header_list = pointer to list
674  *          2  :  header_name = string with name of header to look for.
675  *                              Trailing colon required, capitalization
676  *                              doesn't matter.
677  *
678  * Returns     :  NULL if not found, else value of header
679  *
680  *********************************************************************/
681 char *get_header_value(const struct list *header_list, const char *header_name)
682 {
683    struct list_entry *cur_entry;
684    char *ret = NULL;
685    size_t length = 0;
686
687    assert(header_list);
688    assert(header_name);
689    length = strlen(header_name);
690
691    for (cur_entry = header_list->first; cur_entry ; cur_entry = cur_entry->next)
692    {
693       if (cur_entry->str)
694       {
695          if (!strncmpic(cur_entry->str, header_name, length))
696          {
697             /*
698              * Found: return pointer to start of value
699              */
700             ret = (char *) (cur_entry->str + length);
701             while (*ret && ijb_isspace(*ret)) ret++;
702             return(ret);
703          }
704       }
705    }
706
707    /* 
708     * Not found
709     */
710    return NULL;
711
712 }
713
714 /*********************************************************************
715  *
716  * Function    :  sed
717  *
718  * Description :  add, delete or modify lines in the HTTP header streams.
719  *                On entry, it receives a linked list of headers space
720  *                that was allocated dynamically (both the list nodes
721  *                and the header contents).
722  *
723  *                As a side effect it frees the space used by the original
724  *                header lines.
725  *
726  * Parameters  :
727  *          1  :  pats = list of patterns to match against headers
728  *          2  :  more_headers = list of functions to add more
729  *                headers (client or server)
730  *          3  :  csp = Current client state (buffers, headers, etc...)
731  *
732  * Returns     :  Single pointer to a fully formed header, or NULL
733  *                on out-of-memory error.
734  *
735  *********************************************************************/
736 char *sed(const struct parsers pats[],
737           const add_header_func_ptr more_headers[],
738           struct client_state *csp)
739 {
740    struct list_entry *p;
741    const struct parsers *v;
742    const add_header_func_ptr *f;
743    jb_err err = JB_ERR_OK;
744
745    for (v = pats; (err == JB_ERR_OK) && (v->str != NULL) ; v++)
746    {
747       for (p = csp->headers->first; (err == JB_ERR_OK) && (p != NULL) ; p = p->next)
748       {
749          /* Header crunch()ed in previous run? -> ignore */
750          if (p->str == NULL) continue;
751
752          if (v == pats) log_error(LOG_LEVEL_HEADER, "scan: %s", p->str);
753
754          if (strncmpic(p->str, v->str, v->len) == 0)
755          {
756             err = v->parser(csp, (char **)&(p->str));
757          }
758       }
759    }
760
761    /* place any additional headers on the csp->headers list */
762    for (f = more_headers; (err == JB_ERR_OK) && (*f) ; f++)
763    {
764       err = (*f)(csp);
765    }
766
767    if (err != JB_ERR_OK)
768    {
769       return NULL;
770    }
771
772    return list_to_text(csp->headers);
773 }
774
775
776 /* here begins the family of parser functions that reformat header lines */
777
778
779 /*********************************************************************
780  *
781  * Function    :  crumble
782  *
783  * Description :  This is called if a header matches a pattern to "crunch"
784  *
785  * Parameters  :
786  *          1  :  csp = Current client state (buffers, headers, etc...)
787  *          2  :  header = On input, pointer to header to modify.
788  *                On output, pointer to the modified header, or NULL
789  *                to remove the header.  This function frees the
790  *                original string if necessary.
791  *
792  * Returns     :  JB_ERR_OK on success, or
793  *                JB_ERR_MEMORY on out-of-memory error.
794  *
795  *********************************************************************/
796 jb_err crumble(struct client_state *csp, char **header)
797 {
798    log_error(LOG_LEVEL_HEADER, "crunch!");
799    freez(*header);
800    return JB_ERR_OK;
801 }
802
803
804 /*********************************************************************
805  *
806  * Function    :  server_content_type
807  *
808  * Description :  Set the content-type for filterable types (text/.*,
809  *                javascript and image/gif) unless filtering has been
810  *                forbidden (CT_TABOO) while parsing earlier headers.
811  *
812  * Parameters  :
813  *          1  :  csp = Current client state (buffers, headers, etc...)
814  *          2  :  header = On input, pointer to header to modify.
815  *                On output, pointer to the modified header, or NULL
816  *                to remove the header.  This function frees the
817  *                original string if necessary.
818  *
819  * Returns     :  JB_ERR_OK on success, or
820  *                JB_ERR_MEMORY on out-of-memory error.
821  *
822  *********************************************************************/
823 jb_err server_content_type(struct client_state *csp, char **header)
824 {
825    if (csp->content_type != CT_TABOO)
826    {
827       if (strstr(*header, " text/")
828        || strstr(*header, "application/x-javascript"))
829          csp->content_type = CT_TEXT;
830       else if (strstr(*header, " image/gif"))
831          csp->content_type = CT_GIF;
832       else
833          csp->content_type = 0;
834    }
835
836    return JB_ERR_OK;
837 }
838
839
840 /*********************************************************************
841  *
842  * Function    :  server_transfer_coding
843  *
844  * Description :  - Prohibit filtering (CT_TABOO) if transfer coding compresses
845  *                - Raise the CSP_FLAG_CHUNKED flag if coding is "chunked"
846  *                - Change from "chunked" to "identity" if body was chunked
847  *                  but has been de-chunked for filtering.
848  *
849  * Parameters  :
850  *          1  :  csp = Current client state (buffers, headers, etc...)
851  *          2  :  header = On input, pointer to header to modify.
852  *                On output, pointer to the modified header, or NULL
853  *                to remove the header.  This function frees the
854  *                original string if necessary.
855  *
856  * Returns     :  JB_ERR_OK on success, or
857  *                JB_ERR_MEMORY on out-of-memory error.
858  *
859  *********************************************************************/
860 jb_err server_transfer_coding(struct client_state *csp, char **header)
861 {
862    /*
863     * Turn off pcrs and gif filtering if body compressed
864     */
865    if (strstr(*header, "gzip") || strstr(*header, "compress") || strstr(*header, "deflate"))
866    {
867       csp->content_type = CT_TABOO;
868    }
869
870    /*
871     * Raise flag if body chunked
872     */
873    if (strstr(*header, "chunked"))
874    {
875       csp->flags |= CSP_FLAG_CHUNKED;
876
877       /*
878        * If the body was modified, it has been
879        * de-chunked first, so adjust the header:
880        */
881       if (csp->flags & CSP_FLAG_MODIFIED)
882       {
883          freez(*header);
884          *header = strdup("Transfer-Encoding: identity");
885          return (header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
886       }
887    }
888
889    return JB_ERR_OK;
890 }
891
892
893 /*********************************************************************
894  *
895  * Function    :  server_content_encoding
896  *
897  * Description :  Prohibit filtering (CT_TABOO) if content encoding compresses
898  *
899  * Parameters  :
900  *          1  :  csp = Current client state (buffers, headers, etc...)
901  *          2  :  header = On input, pointer to header to modify.
902  *                On output, pointer to the modified header, or NULL
903  *                to remove the header.  This function frees the
904  *                original string if necessary.
905  *
906  * Returns     :  JB_ERR_OK on success, or
907  *                JB_ERR_MEMORY on out-of-memory error.
908  *
909  *********************************************************************/
910 jb_err server_content_encoding(struct client_state *csp, char **header)
911 {
912    /*
913     * Turn off pcrs and gif filtering if body compressed
914     */
915    if (strstr(*header, "gzip") || strstr(*header, "compress") || strstr(*header, "deflate"))
916    {
917       csp->content_type = CT_TABOO;
918    }
919
920    return JB_ERR_OK;
921
922 }
923
924
925 /*********************************************************************
926  *
927  * Function    :  server_content_length
928  *
929  * Description :  Adjust Content-Length header if we modified
930  *                the body.
931  *
932  * Parameters  :
933  *          1  :  csp = Current client state (buffers, headers, etc...)
934  *          2  :  header = On input, pointer to header to modify.
935  *                On output, pointer to the modified header, or NULL
936  *                to remove the header.  This function frees the
937  *                original string if necessary.
938  *
939  * Returns     :  JB_ERR_OK on success, or
940  *                JB_ERR_MEMORY on out-of-memory error.
941  *
942  *********************************************************************/
943 jb_err server_content_length(struct client_state *csp, char **header)
944 {
945    if (csp->content_length != 0) /* Content length has been modified */
946    {
947       freez(*header);
948       *header = (char *) zalloc(100);
949       if (*header == NULL)
950       {
951          return JB_ERR_MEMORY;
952       }
953
954       sprintf(*header, "Content-Length: %d", (int) csp->content_length);
955
956       log_error(LOG_LEVEL_HEADER, "Adjust Content-Length to %d", (int) csp->content_length);
957    }
958
959    return JB_ERR_OK;
960 }
961
962
963 /*********************************************************************
964  *
965  * Function    :  server_content_md5
966  *
967  * Description :  Crumble any Content-MD5 headers if the document was
968  *                modified. FIXME: Should we re-compute instead?
969  *
970  * Parameters  :
971  *          1  :  csp = Current client state (buffers, headers, etc...)
972  *          2  :  header = On input, pointer to header to modify.
973  *                On output, pointer to the modified header, or NULL
974  *                to remove the header.  This function frees the
975  *                original string if necessary.
976  *
977  * Returns     :  JB_ERR_OK on success, or
978  *                JB_ERR_MEMORY on out-of-memory error.
979  *
980  *********************************************************************/
981 jb_err server_content_md5(struct client_state *csp, char **header)
982 {
983    if (csp->flags & CSP_FLAG_MODIFIED)
984    {
985       log_error(LOG_LEVEL_HEADER, "Crunching Content-MD5");
986       freez(*header);
987    }
988
989    return JB_ERR_OK;
990 }
991
992
993 /*********************************************************************
994  *
995  * Function    :  client_accept_encoding
996  *
997  * Description :  Rewrite the client's Accept-Encoding header so that
998  *                if doesn't allow compression, if the action applies.
999  *                Note: For HTTP/1.0 the absence of the header is enough.
1000  *
1001  * Parameters  :
1002  *          1  :  csp = Current client state (buffers, headers, etc...)
1003  *          2  :  header = On input, pointer to header to modify.
1004  *                On output, pointer to the modified header, or NULL
1005  *                to remove the header.  This function frees the
1006  *                original string if necessary.
1007  *
1008  * Returns     :  JB_ERR_OK on success, or
1009  *                JB_ERR_MEMORY on out-of-memory error.
1010  *
1011  *********************************************************************/
1012 jb_err client_accept_encoding(struct client_state *csp, char **header)
1013 {
1014    if ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
1015    {
1016       log_error(LOG_LEVEL_HEADER, "Suppressed offer to compress content");
1017
1018       freez(*header);
1019       if (!strcmpic(csp->http->ver, "HTTP/1.1"))
1020       {
1021          *header = strdup("Accept-Encoding: identity;q=1.0, *;q=0");
1022          if (*header == NULL)
1023          {
1024             return JB_ERR_MEMORY;
1025          }
1026       }
1027    }
1028
1029    return JB_ERR_OK;
1030 }
1031
1032
1033 /*********************************************************************
1034  *
1035  * Function    :  client_te
1036  *
1037  * Description :  Rewrite the client's TE header so that
1038  *                if doesn't allow compression, if the action applies.
1039  *
1040  * Parameters  :
1041  *          1  :  csp = Current client state (buffers, headers, etc...)
1042  *          2  :  header = On input, pointer to header to modify.
1043  *                On output, pointer to the modified header, or NULL
1044  *                to remove the header.  This function frees the
1045  *                original string if necessary.
1046  *
1047  * Returns     :  JB_ERR_OK on success, or
1048  *                JB_ERR_MEMORY on out-of-memory error.
1049  *
1050  *********************************************************************/
1051 jb_err client_te(struct client_state *csp, char **header)
1052 {
1053    if ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
1054    {
1055       freez(*header);
1056       log_error(LOG_LEVEL_HEADER, "Suppressed offer to compress transfer");
1057    }
1058
1059    return JB_ERR_OK;
1060 }
1061
1062 /*********************************************************************
1063  *
1064  * Function    :  client_referrer
1065  *
1066  * Description :  Handle the "referer" config setting properly.
1067  *                Called from `sed'.
1068  *
1069  * Parameters  :
1070  *          1  :  csp = Current client state (buffers, headers, etc...)
1071  *          2  :  header = On input, pointer to header to modify.
1072  *                On output, pointer to the modified header, or NULL
1073  *                to remove the header.  This function frees the
1074  *                original string if necessary.
1075  *
1076  * Returns     :  JB_ERR_OK on success, or
1077  *                JB_ERR_MEMORY on out-of-memory error.
1078  *
1079  *********************************************************************/
1080 jb_err client_referrer(struct client_state *csp, char **header)
1081 {
1082    const char *newval;
1083
1084 #ifdef FEATURE_FORCE_LOAD
1085    /* Since the referrer can include the prefix even
1086     * even if the request itself is non-forced, we must
1087     * clean it unconditionally
1088     */
1089    strclean(*header, FORCE_PREFIX);
1090 #endif /* def FEATURE_FORCE_LOAD */
1091
1092    /*
1093     * Are we sending referer?
1094     */
1095    if ((csp->action->flags & ACTION_HIDE_REFERER) == 0)
1096    {
1097       return JB_ERR_OK;
1098    }
1099
1100    freez(*header);
1101
1102    newval = csp->action->string[ACTION_STRING_REFERER];
1103
1104 #ifdef FEATURE_ACTIVITY_CONSOLE
1105    /* Otherwise, we're doing something with the referer. */
1106    accumulate_stats(STATS_REFERER, 1);
1107 #endif /* def FEATURE_ACTIVITY_CONSOLE */
1108
1109    if ((newval == NULL) || (0 == strcmpic(newval, "block")) )
1110    {
1111       /*
1112        * Blocking referer
1113        */
1114       log_error(LOG_LEVEL_HEADER, "crunch!");
1115       return JB_ERR_OK;
1116    }
1117    else if (0 == strncmpic(newval, "http://", 7))
1118    {
1119       /*
1120        * We have a specific (fixed) referer we want to send.
1121        */
1122       log_error(LOG_LEVEL_HEADER, "modified");
1123
1124       *header = strdup("Referer: ");
1125       string_append(header, newval);
1126
1127       return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
1128    }
1129    else
1130    {
1131       /*
1132        * Forge a referer as http://[hostname:port of REQUEST]/
1133        * to fool stupid checks for in-site links
1134        */
1135       if (0 != strcmpic(newval, "forge"))
1136       {
1137          /*
1138           * Invalid choice - but forge is probably the best default.
1139           */
1140          log_error(LOG_LEVEL_ERROR, "Bad parameter: +referer{%s}", newval);
1141       }
1142
1143       *header = strdup("Referer: http://");
1144       string_append(header, csp->http->hostport);
1145       string_append(header, "/");
1146       log_error(LOG_LEVEL_HEADER, "crunch+forge to %s", *header);
1147       
1148       return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
1149    }
1150 }
1151
1152
1153 /*********************************************************************
1154  *
1155  * Function    :  client_uagent
1156  *
1157  * Description :  Handle the "user-agent" config setting properly
1158  *                and remember its original value to enable browser
1159  *                bug workarounds. Called from `sed'.
1160  *
1161  * Parameters  :
1162  *          1  :  csp = Current client state (buffers, headers, etc...)
1163  *          2  :  header = On input, pointer to header to modify.
1164  *                On output, pointer to the modified header, or NULL
1165  *                to remove the header.  This function frees the
1166  *                original string if necessary.
1167  *
1168  * Returns     :  JB_ERR_OK on success, or
1169  *                JB_ERR_MEMORY on out-of-memory error.
1170  *
1171  *********************************************************************/
1172 jb_err client_uagent(struct client_state *csp, char **header)
1173 {
1174    const char *newval;
1175
1176    if ((csp->action->flags & ACTION_HIDE_USER_AGENT) == 0)
1177    {
1178       return JB_ERR_OK;
1179    }
1180
1181    newval = csp->action->string[ACTION_STRING_USER_AGENT];
1182    if (newval == NULL)
1183    {
1184       return JB_ERR_OK;
1185    }
1186
1187    log_error(LOG_LEVEL_HEADER, "modified");
1188
1189    freez(*header);
1190    *header = strdup("User-Agent: ");
1191    string_append(header, newval);
1192
1193    return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
1194 }
1195
1196
1197 /*********************************************************************
1198  *
1199  * Function    :  client_ua
1200  *
1201  * Description :  Handle "ua-" headers properly.  Called from `sed'.
1202  *
1203  * Parameters  :
1204  *          1  :  csp = Current client state (buffers, headers, etc...)
1205  *          2  :  header = On input, pointer to header to modify.
1206  *                On output, pointer to the modified header, or NULL
1207  *                to remove the header.  This function frees the
1208  *                original string if necessary.
1209  *
1210  * Returns     :  JB_ERR_OK on success, or
1211  *                JB_ERR_MEMORY on out-of-memory error.
1212  *
1213  *********************************************************************/
1214 jb_err client_ua(struct client_state *csp, char **header)
1215 {
1216    if ((csp->action->flags & ACTION_HIDE_USER_AGENT) != 0)
1217    {
1218 #ifdef FEATURE_ACTIVITY_CONSOLE
1219       accumulate_stats(STATS_CLIENT_UA, 1);
1220 #endif /* def FEATURE_ACTIVITY_CONSOLE */
1221       log_error(LOG_LEVEL_HEADER, "crunch!");
1222       freez(*header);
1223    }
1224
1225    return JB_ERR_OK;
1226 }
1227
1228
1229 /*********************************************************************
1230  *
1231  * Function    :  client_from
1232  *
1233  * Description :  Handle the "from" config setting properly.
1234  *                Called from `sed'.
1235  *
1236  * Parameters  :
1237  *          1  :  csp = Current client state (buffers, headers, etc...)
1238  *          2  :  header = On input, pointer to header to modify.
1239  *                On output, pointer to the modified header, or NULL
1240  *                to remove the header.  This function frees the
1241  *                original string if necessary.
1242  *
1243  * Returns     :  JB_ERR_OK on success, or
1244  *                JB_ERR_MEMORY on out-of-memory error.
1245  *
1246  *********************************************************************/
1247 jb_err client_from(struct client_state *csp, char **header)
1248 {
1249    const char *newval;
1250
1251    if ((csp->action->flags & ACTION_HIDE_FROM) == 0)
1252    {
1253       return JB_ERR_OK;
1254    }
1255
1256 #ifdef FEATURE_ACTIVITY_CONSOLE
1257    /* Otherwise, we're doing something with it. */
1258    accumulate_stats(STATS_CLIENT_FROM, 1);
1259 #endif /* def FEATURE_ACTIVITY_CONSOLE */
1260    freez(*header);
1261
1262    newval = csp->action->string[ACTION_STRING_FROM];
1263
1264    /*
1265     * Are we blocking the e-mail address?
1266     */
1267    if ((newval == NULL) || (0 == strcmpic(newval, "block")) )
1268    {
1269       log_error(LOG_LEVEL_HEADER, "crunch!");
1270       return JB_ERR_OK;
1271    }
1272
1273    log_error(LOG_LEVEL_HEADER, " modified");
1274
1275    *header = strdup("From: ");
1276    string_append(header, newval);
1277
1278    return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
1279 }
1280
1281
1282 /*********************************************************************
1283  *
1284  * Function    :  client_send_cookie
1285  *
1286  * Description :  Handle the "cookie" header properly.  Called from `sed'.
1287  *                If cookie is accepted, add it to the cookie_list,
1288  *                else we crunch it.  Mmmmmmmmmmm ... cookie ......
1289  *
1290  * Parameters  :
1291  *          1  :  csp = Current client state (buffers, headers, etc...)
1292  *          2  :  header = On input, pointer to header to modify.
1293  *                On output, pointer to the modified header, or NULL
1294  *                to remove the header.  This function frees the
1295  *                original string if necessary.
1296  *
1297  * Returns     :  JB_ERR_OK on success, or
1298  *                JB_ERR_MEMORY on out-of-memory error.
1299  *
1300  *********************************************************************/
1301 jb_err client_send_cookie(struct client_state *csp, char **header)
1302 {
1303    jb_err result = JB_ERR_OK;
1304
1305    if ((csp->action->flags & ACTION_NO_COOKIE_READ) == 0)
1306    {
1307       /* strlen("cookie: ") == 8 */
1308       result = enlist(csp->cookie_list, *header + 8);
1309    }
1310    else
1311    {
1312       log_error(LOG_LEVEL_HEADER, "Crunched outgoing cookie -- yum!");
1313    }
1314
1315    /*
1316     * Always remove the cookie here.  The cookie header
1317     * will be sent at the end of the header.
1318     */
1319    freez(*header);
1320
1321    return result;
1322 }
1323
1324
1325 /*********************************************************************
1326  *
1327  * Function    :  client_x_forwarded
1328  *
1329  * Description :  Handle the "x-forwarded-for" config setting properly,
1330  *                also used in the add_client_headers list.  Called from `sed'.
1331  *
1332  * Parameters  :
1333  *          1  :  csp = Current client state (buffers, headers, etc...)
1334  *          2  :  header = On input, pointer to header to modify.
1335  *                On output, pointer to the modified header, or NULL
1336  *                to remove the header.  This function frees the
1337  *                original string if necessary.
1338  *
1339  * Returns     :  JB_ERR_OK on success, or
1340  *                JB_ERR_MEMORY on out-of-memory error.
1341  *
1342  *********************************************************************/
1343 jb_err client_x_forwarded(struct client_state *csp, char **header)
1344 {
1345    if ((csp->action->flags & ACTION_HIDE_FORWARDED) == 0)
1346    {
1347       /* Save it so we can re-add it later */
1348       freez(csp->x_forwarded);
1349       csp->x_forwarded = *header;
1350
1351       /*
1352        * Always set *header = NULL, since this information
1353        * will be sent at the end of the header.
1354        */
1355       *header = NULL;
1356    }
1357    else
1358    {
1359       freez(*header);
1360 #ifdef FEATURE_ACTIVITY_CONSOLE
1361       accumulate_stats(STATS_CLIENT_X_FORWARDED, 1);
1362 #endif /* def FEATURE_ACTIVITY_CONSOLE */
1363       log_error(LOG_LEVEL_HEADER, " crunch!");
1364    }
1365
1366    return JB_ERR_OK;
1367 }
1368
1369 /* the following functions add headers directly to the header list */
1370
1371 /*********************************************************************
1372  *
1373  * Function    :  client_host_adder
1374  *
1375  * Description :  (re)adds the host header. Called from `sed'.
1376  *
1377  * Parameters  :
1378  *          1  :  csp = Current client state (buffers, headers, etc...)
1379  *
1380  * Returns     :  JB_ERR_OK on success, or
1381  *                JB_ERR_MEMORY on out-of-memory error.
1382  *
1383  *********************************************************************/
1384 jb_err client_host_adder(struct client_state *csp)
1385 {
1386    char *p;
1387    char *pos;
1388    jb_err err;
1389
1390    if ( !csp->http->hostport || !*(csp->http->hostport))
1391    {
1392       return JB_ERR_OK;
1393    }
1394
1395    p = strdup("Host: ");
1396    /*
1397    ** remove 'user:pass@' from 'proto://user:pass@host'
1398    */
1399    if ( (pos = strchr( csp->http->hostport, '@')) != NULL )
1400    {
1401        string_append(&p, pos+1);
1402    }
1403    else
1404    {
1405       string_append(&p, csp->http->hostport);
1406    }
1407
1408    if (p == NULL)
1409    {
1410       return JB_ERR_MEMORY;
1411    }
1412
1413    log_error(LOG_LEVEL_HEADER, "addh: %s", p);
1414
1415    err = enlist(csp->headers, p);
1416
1417    freez(p);
1418
1419    return err;
1420 }
1421
1422
1423 /*********************************************************************
1424  *
1425  * Function    :  client_cookie_adder
1426  *
1427  * Description :  Used in the add_client_headers list.  Called from `sed'.
1428  *
1429  * Parameters  :
1430  *          1  :  csp = Current client state (buffers, headers, etc...)
1431  *
1432  * Returns     :  JB_ERR_OK on success, or
1433  *                JB_ERR_MEMORY on out-of-memory error.
1434  *
1435  *********************************************************************/
1436 jb_err client_cookie_adder(struct client_state *csp)
1437 {
1438    struct list_entry *lst;
1439    char *tmp;
1440    struct list_entry *list1 = csp->cookie_list->first;
1441    struct list_entry *list2 = csp->action->multi[ACTION_MULTI_WAFER]->first;
1442    int first_cookie = 1;
1443    jb_err err;
1444
1445    if ((list1 == NULL) && (list2 == NULL))
1446    {
1447       /* Nothing to do */
1448       return JB_ERR_OK;
1449    }
1450
1451    tmp = strdup("Cookie: ");
1452
1453    for (lst = list1; lst ; lst = lst->next)
1454    {
1455       if (first_cookie)
1456       {
1457          first_cookie = 0;
1458       }
1459       else
1460       {
1461          string_append(&tmp, "; ");
1462       }
1463       string_append(&tmp, lst->str);
1464    }
1465
1466    for (lst = list2;  lst ; lst = lst->next)
1467    {
1468       if (first_cookie)
1469       {
1470          first_cookie = 0;
1471       }
1472       else
1473       {
1474          string_append(&tmp, "; ");
1475       }
1476       string_join(&tmp, cookie_encode(lst->str));
1477    }
1478
1479    if (tmp == NULL)
1480    {
1481       return JB_ERR_MEMORY;
1482    }
1483
1484    log_error(LOG_LEVEL_HEADER, "addh: %s", tmp);
1485    err = enlist(csp->headers, tmp);
1486    free(tmp);
1487    return err;
1488 }
1489
1490
1491 /*********************************************************************
1492  *
1493  * Function    :  client_accept_encoding_adder
1494  *
1495  * Description :  Add an Accept-Encoding header to the client's request
1496  *                that disables compression if the action applies, and
1497  *                the header is not already there. Called from `sed'.
1498  *                Note: For HTTP/1.0, the absence of the header is enough.
1499  *
1500  * Parameters  :
1501  *          1  :  csp = Current client state (buffers, headers, etc...)
1502  *
1503  * Returns     :  JB_ERR_OK on success, or
1504  *                JB_ERR_MEMORY on out-of-memory error.
1505  *
1506  *********************************************************************/
1507 jb_err client_accept_encoding_adder(struct client_state *csp)
1508 {
1509    if (   ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
1510        && (!strcmpic(csp->http->ver, "HTTP/1.1")) )
1511    {
1512       return enlist_unique(csp->headers, "Accept-Encoding: identity;q=1.0, *;q=0", 16);
1513    }
1514
1515    return JB_ERR_OK;
1516 }
1517
1518
1519 /*********************************************************************
1520  *
1521  * Function    :  client_xtra_adder
1522  *
1523  * Description :  Used in the add_client_headers list.  Called from `sed'.
1524  *
1525  * Parameters  :
1526  *          1  :  csp = Current client state (buffers, headers, etc...)
1527  *
1528  * Returns     :  JB_ERR_OK on success, or
1529  *                JB_ERR_MEMORY on out-of-memory error.
1530  *
1531  *********************************************************************/
1532 jb_err client_xtra_adder(struct client_state *csp)
1533 {
1534    struct list_entry *lst;
1535    jb_err err;
1536
1537    for (lst = csp->action->multi[ACTION_MULTI_ADD_HEADER]->first;
1538         lst ; lst = lst->next)
1539    {
1540       log_error(LOG_LEVEL_HEADER, "addh: %s", lst->str);
1541       err = enlist(csp->headers, lst->str);
1542       if (err)
1543       {
1544          return err;
1545       }
1546
1547    }
1548
1549    return JB_ERR_OK;
1550 }
1551
1552
1553 /*********************************************************************
1554  *
1555  * Function    :  client_x_forwarded_adder
1556  *
1557  * Description :  Used in the add_client_headers list.  Called from `sed'.
1558  *
1559  * Parameters  :
1560  *          1  :  csp = Current client state (buffers, headers, etc...)
1561  *
1562  * Returns     :  JB_ERR_OK on success, or
1563  *                JB_ERR_MEMORY on out-of-memory error.
1564  *
1565  *********************************************************************/
1566 jb_err client_x_forwarded_adder(struct client_state *csp)
1567 {
1568    char *p = NULL;
1569    jb_err err;
1570
1571    if ((csp->action->flags & ACTION_HIDE_FORWARDED) != 0)
1572    {
1573       return JB_ERR_OK;
1574    }
1575
1576    if (csp->x_forwarded)
1577    {
1578       p = strdup(csp->x_forwarded);
1579       string_append(&p, ", ");
1580    }
1581    else
1582    {
1583       p = strdup("X-Forwarded-For: ");
1584    }
1585    string_append(&p, csp->ip_addr_str);
1586
1587    if (p == NULL)
1588    {
1589       return JB_ERR_MEMORY;
1590    }
1591
1592    log_error(LOG_LEVEL_HEADER, "addh: %s", p);
1593    err = enlist(csp->headers, p);
1594    free(p);
1595
1596    return err;
1597 }
1598
1599
1600 /*********************************************************************
1601  *
1602  * Function    :  connection_close_adder
1603  *
1604  * Description :  Adds a "Connection: close" header to csp->headers
1605  *                as a temporary fix for the needed but missing HTTP/1.1
1606  *                support. Called from `sed'.
1607  *                FIXME: This whole function shouldn't be neccessary!
1608  *
1609  * Parameters  :
1610  *          1  :  csp = Current client state (buffers, headers, etc...)
1611  *
1612  * Returns     :  JB_ERR_OK on success, or
1613  *                JB_ERR_MEMORY on out-of-memory error.
1614  *
1615  *********************************************************************/
1616 jb_err connection_close_adder(struct client_state *csp)
1617 {
1618    return enlist(csp->headers, "Connection: close");
1619 }
1620
1621
1622 /*********************************************************************
1623  *
1624  * Function    :  server_http
1625  *
1626  * Description :  - Save the HTTP Status into csp->http->status
1627  *                - Set CT_TABOO to prevent filtering if the answer
1628  *                  is a partial range (HTTP status 206)
1629  *                - Rewrite HTTP/1.1 answers to HTTP/1.0 if +downgrade
1630  *                  action applies.
1631  *
1632  * Parameters  :
1633  *          1  :  csp = Current client state (buffers, headers, etc...)
1634  *          2  :  header = On input, pointer to header to modify.
1635  *                On output, pointer to the modified header, or NULL
1636  *                to remove the header.  This function frees the
1637  *                original string if necessary.
1638  *
1639  * Returns     :  JB_ERR_OK on success, or
1640  *                JB_ERR_MEMORY on out-of-memory error.
1641  *
1642  *********************************************************************/
1643 jb_err server_http(struct client_state *csp, char **header)
1644 {
1645    sscanf(*header, "HTTP/%*d.%*d %d", &(csp->http->status));
1646    if (csp->http->status == 206)
1647    {
1648       csp->content_type = CT_TABOO;
1649    }
1650
1651    if ((csp->action->flags & ACTION_DOWNGRADE) != 0)
1652    {
1653       (*header)[7] = '0';
1654       log_error(LOG_LEVEL_HEADER, "Downgraded answer to HTTP/1.0");
1655    }
1656
1657    return JB_ERR_OK;
1658 }
1659
1660
1661 /*********************************************************************
1662  *
1663  * Function    :  server_set_cookie
1664  *
1665  * Description :  Handle the server "cookie" header properly.
1666  *                Log cookie to the jar file.  Then "crunch" it,
1667  *                or accept it.  Called from `sed'.
1668  *
1669  * Parameters  :
1670  *          1  :  csp = Current client state (buffers, headers, etc...)
1671  *          2  :  header = On input, pointer to header to modify.
1672  *                On output, pointer to the modified header, or NULL
1673  *                to remove the header.  This function frees the
1674  *                original string if necessary.
1675  *
1676  * Returns     :  JB_ERR_OK on success, or
1677  *                JB_ERR_MEMORY on out-of-memory error.
1678  *
1679  *********************************************************************/
1680 jb_err server_set_cookie(struct client_state *csp, char **header)
1681 {
1682 #ifdef FEATURE_COOKIE_JAR
1683    if (csp->config->jar)
1684    {
1685       /*
1686        * Write timestamp into outbuf.
1687        *
1688        * Complex because not all OSs have tm_gmtoff or
1689        * the %z field in strftime()
1690        */
1691       char tempbuf[ BUFFER_SIZE ];
1692       time_t now; 
1693       struct tm tm_now; 
1694       time (&now); 
1695 #ifdef HAVE_LOCALTIME_R
1696       tm_now = *localtime_r(&now, &tm_now);
1697 #else
1698       tm_now = *localtime (&now); 
1699 #endif
1700       strftime(tempbuf, BUFFER_SIZE-6, "%b %d %H:%M:%S ", &tm_now); 
1701
1702       /* strlen("set-cookie: ") = 12 */
1703       fprintf(csp->config->jar, "%s %s\t%s\n", tempbuf, csp->http->host, *header + 12);
1704    }
1705 #endif /* def FEATURE_COOKIE_JAR */
1706
1707    if ((csp->action->flags & ACTION_NO_COOKIE_SET) != 0)
1708    {
1709       log_error(LOG_LEVEL_HEADER, "Crunched incoming cookie -- yum!");
1710 #ifdef FEATURE_ACTIVITY_CONSOLE
1711       accumulate_stats(STATS_COOKIE, 1);
1712 #endif /* def FEATURE_ACTIVITY_CONSOLE */
1713       return crumble(csp, header);
1714    }
1715    else if ((csp->action->flags & ACTION_NO_COOKIE_KEEP) != 0)
1716    {
1717       /* Flag whether or not to log a message */
1718       int changed = 0;
1719
1720       /* A variable to store the tag we're working on */
1721       char *cur_tag;
1722
1723       /* Skip "Set-Cookie:" (11 characters) in header */
1724       cur_tag = *header + 11;
1725
1726       /* skip whitespace between "Set-Cookie:" and value */
1727       while (*cur_tag && ijb_isspace(*cur_tag))
1728       {
1729          cur_tag++;
1730       }
1731
1732       /* Loop through each tag in the cookie */
1733       while (*cur_tag)
1734       {
1735          /* Find next tag */
1736          char *next_tag = strchr(cur_tag, ';');
1737          if (next_tag != NULL)
1738          {
1739             /* Skip the ';' character itself */
1740             next_tag++;
1741
1742             /* skip whitespace ";" and start of tag */
1743             while (*next_tag && ijb_isspace(*next_tag))
1744             {
1745                next_tag++;
1746             }
1747          }
1748          else
1749          {
1750             /* "Next tag" is the end of the string */
1751             next_tag = cur_tag + strlen(cur_tag);
1752          }
1753
1754          /* Is this the "Expires" tag? */
1755          if (strncmpic(cur_tag, "expires=", 8) == 0)
1756          {
1757             /* Delete the tag by copying the rest of the string over it.
1758              * (Note that we cannot just use "strcpy(cur_tag, next_tag)",
1759              * since the behaviour of strcpy is undefined for overlapping
1760              * strings.)
1761              */
1762             memmove(cur_tag, next_tag, strlen(next_tag) + 1);
1763
1764             /* That changed the header, need to issue a log message */
1765             changed = 1;
1766
1767             /* Note that the next tag has now been moved to *cur_tag,
1768              * so we do not need to update the cur_tag pointer.
1769              */
1770          }
1771          else
1772          {
1773             /* Move on to next cookie tag */
1774             cur_tag = next_tag;
1775          }
1776       }
1777
1778       if (changed)
1779       {
1780          log_error(LOG_LEVEL_HEADER, "Changed cookie to a temporary one.");
1781       }
1782    }
1783
1784    return JB_ERR_OK;
1785 }
1786
1787
1788 #ifdef FEATURE_FORCE_LOAD
1789 /*********************************************************************
1790  *
1791  * Function    :  strclean
1792  *
1793  * Description :  In-Situ-Eliminate all occurances of substring in
1794  *                string
1795  *
1796  * Parameters  :
1797  *          1  :  string = string to clean
1798  *          2  :  substring = substring to eliminate
1799  *
1800  * Returns     :  Number of eliminations
1801  *
1802  *********************************************************************/
1803 int strclean(const char *string, const char *substring)
1804 {
1805    int hits = 0, len = strlen(substring);
1806    char *pos, *p;
1807
1808    while((pos = strstr(string, substring)) != NULL)
1809    {
1810       p = pos + len;
1811       do
1812       {
1813          *(p - len) = *p;
1814       }
1815       while (*p++ != '\0');
1816
1817       hits++;
1818    }
1819
1820    return(hits);
1821 }
1822 #endif /* def FEATURE_FORCE_LOAD */
1823
1824
1825 /*
1826   Local Variables:
1827   tab-width: 3
1828   end:
1829 */