-const char parsers_rcs[] = "$Id: parsers.c,v 1.91 2007/02/24 12:27:32 fabiankeil Exp $";
+const char parsers_rcs[] = "$Id: parsers.c,v 1.151 2009/02/15 14:46:35 fabiankeil Exp $";
/*********************************************************************
*
* File : $Source: /cvsroot/ijbswa/current/parsers.c,v $
* `client_uagent', `client_x_forwarded',
* `client_x_forwarded_adder', `client_xtra_adder',
* `content_type', `crumble', `destroy_list', `enlist',
- * `flush_socket', ``get_header', `sed', `filter_server_header'
- * `filter_client_header', `filter_header', `crunch_server_header',
+ * `flush_socket', ``get_header', `sed', `filter_header'
* `server_content_encoding', `server_content_disposition',
* `server_last_modified', `client_accept_language',
* `crunch_client_header', `client_if_modified_since',
* `client_if_none_match', `get_destination_from_headers',
- * `parse_header_time' and `server_set_cookie'.
+ * `parse_header_time', `decompress_iob' and `server_set_cookie'.
*
- * Copyright : Written by and Copyright (C) 2001-2007 the SourceForge
+ * Copyright : Written by and Copyright (C) 2001-2009 the
* Privoxy team. http://www.privoxy.org/
*
* Based on the Internet Junkbuster originally written
*
* Revisions :
* $Log: parsers.c,v $
+ * Revision 1.151 2009/02/15 14:46:35 fabiankeil
+ * Don't let hide-referrer{conditional-*}} pass
+ * Referer headers without http URLs.
+ *
+ * Revision 1.150 2008/12/04 18:12:19 fabiankeil
+ * Fix some cparser warnings.
+ *
+ * Revision 1.149 2008/11/21 18:39:53 fabiankeil
+ * In case of CONNECT requests there's no point
+ * in trying to keep the connection alive.
+ *
+ * Revision 1.148 2008/11/16 12:43:49 fabiankeil
+ * Turn keep-alive support into a runtime feature
+ * that is disabled by setting keep-alive-timeout
+ * to a negative value.
+ *
+ * Revision 1.147 2008/11/04 17:20:31 fabiankeil
+ * HTTP/1.1 responses without Connection
+ * header imply keep-alive. Act accordingly.
+ *
+ * Revision 1.146 2008/10/12 16:46:35 fabiankeil
+ * Remove obsolete warning about delayed delivery with chunked
+ * transfer encoding and FEATURE_CONNECTION_KEEP_ALIVE enabled.
+ *
+ * Revision 1.145 2008/10/09 18:21:41 fabiankeil
+ * Flush work-in-progress changes to keep outgoing connections
+ * alive where possible. Incomplete and mostly #ifdef'd out.
+ *
+ * Revision 1.144 2008/09/21 13:59:33 fabiankeil
+ * Treat unknown change-x-forwarded-for parameters as fatal errors.
+ *
+ * Revision 1.143 2008/09/21 13:36:52 fabiankeil
+ * If change-x-forwarded-for{add} is used and the client
+ * sends multiple X-Forwarded-For headers, append the client's
+ * IP address to each one of them. "Traditionally" we would
+ * lose all but the last one.
+ *
+ * Revision 1.142 2008/09/20 10:04:33 fabiankeil
+ * Remove hide-forwarded-for-headers action which has
+ * been obsoleted by change-x-forwarded-for{block}.
+ *
+ * Revision 1.141 2008/09/19 15:26:28 fabiankeil
+ * Add change-x-forwarded-for{} action to block or add
+ * X-Forwarded-For headers. Mostly based on code removed
+ * before 3.0.7.
+ *
+ * Revision 1.140 2008/09/12 17:51:43 fabiankeil
+ * - A few style fixes.
+ * - Remove a pointless cast.
+ *
+ * Revision 1.139 2008/09/04 08:13:58 fabiankeil
+ * Prepare for critical sections on Windows by adding a
+ * layer of indirection before the pthread mutex functions.
+ *
+ * Revision 1.138 2008/08/30 12:03:07 fabiankeil
+ * Remove FEATURE_COOKIE_JAR.
+ *
+ * Revision 1.137 2008/05/30 15:50:08 fabiankeil
+ * Remove questionable micro-optimizations
+ * whose usefulness has never been measured.
+ *
+ * Revision 1.136 2008/05/26 16:02:24 fabiankeil
+ * s@Insufficent@Insufficient@
+ *
+ * Revision 1.135 2008/05/21 20:12:10 fabiankeil
+ * The whole point of strclean() is to modify the
+ * first parameter, so don't mark it immutable,
+ * even though the compiler lets us get away with it.
+ *
+ * Revision 1.134 2008/05/21 19:27:25 fabiankeil
+ * As the wafer actions are gone, we can stop including encode.h.
+ *
+ * Revision 1.133 2008/05/21 15:50:47 fabiankeil
+ * Ditch cast from (char **) to (char **).
+ *
+ * Revision 1.132 2008/05/21 15:47:14 fabiankeil
+ * Streamline sed()'s prototype and declare
+ * the header parse and add structures static.
+ *
+ * Revision 1.131 2008/05/20 20:13:30 fabiankeil
+ * Factor update_server_headers() out of sed(), ditch the
+ * first_run hack and make server_patterns_light static.
+ *
+ * Revision 1.130 2008/05/19 17:18:04 fabiankeil
+ * Wrap memmove() calls in string_move()
+ * to document the purpose in one place.
+ *
+ * Revision 1.129 2008/05/17 14:02:07 fabiankeil
+ * Normalize linear header white space.
+ *
+ * Revision 1.128 2008/05/16 16:39:03 fabiankeil
+ * If a header is split across multiple lines,
+ * merge them to a single line before parsing them.
+ *
+ * Revision 1.127 2008/05/10 13:23:38 fabiankeil
+ * Don't provide get_header() with the whole client state
+ * structure when it only needs access to csp->iob.
+ *
+ * Revision 1.126 2008/05/03 16:40:45 fabiankeil
+ * Change content_filters_enabled()'s parameter from
+ * csp->action to action so it can be also used in the
+ * CGI code. Don't bother checking if there are filters
+ * loaded, as that's somewhat besides the point.
+ *
+ * Revision 1.125 2008/04/17 14:40:49 fabiankeil
+ * Provide get_http_time() with the buffer size so it doesn't
+ * have to blindly assume that the buffer is big enough.
+ *
+ * Revision 1.124 2008/04/16 16:38:21 fabiankeil
+ * Don't pass the whole csp structure to flush_socket()
+ * when it only needs a file descriptor and a buffer.
+ *
+ * Revision 1.123 2008/03/29 12:13:46 fabiankeil
+ * Remove send-wafer and send-vanilla-wafer actions.
+ *
+ * Revision 1.122 2008/03/28 15:13:39 fabiankeil
+ * Remove inspect-jpegs action.
+ *
+ * Revision 1.121 2008/01/05 21:37:03 fabiankeil
+ * Let client_range() also handle Request-Range headers
+ * which apparently are still supported by many servers.
+ *
+ * Revision 1.120 2008/01/04 17:43:45 fabiankeil
+ * Improve the warning messages that get logged if the action files
+ * "enable" filters but no filters of that type have been loaded.
+ *
+ * Revision 1.119 2007/12/28 18:32:51 fabiankeil
+ * In server_content_type():
+ * - Don't require leading white space when detecting image content types.
+ * - Change '... not replaced ...' message to sound less crazy if the text
+ * type actually is 'text/plain'.
+ * - Mark the 'text/plain == binary data' assumption for removal.
+ * - Remove a bunch of trailing white space.
+ *
+ * Revision 1.118 2007/12/28 16:56:35 fabiankeil
+ * Minor server_content_disposition() changes:
+ * - Don't regenerate the header name all lower-case.
+ * - Some white space fixes.
+ * - Remove useless log message in case of ENOMEM.
+ *
+ * Revision 1.117 2007/12/06 18:11:50 fabiankeil
+ * Garbage-collect the code to add a X-Forwarded-For
+ * header as it seems to be mostly used by accident.
+ *
+ * Revision 1.116 2007/12/01 13:04:22 fabiankeil
+ * Fix a crash on mingw32 with some Last Modified times in the future.
+ *
+ * Revision 1.115 2007/11/02 16:52:50 fabiankeil
+ * Remove a "can't happen" error block which, over
+ * time, mutated into a "guaranteed to happen" block.
+ *
+ * Revision 1.114 2007/10/19 16:56:26 fabiankeil
+ * - Downgrade "Buffer limit reached" message to LOG_LEVEL_INFO.
+ * - Use shiny new content_filters_enabled() in client_range().
+ *
+ * Revision 1.113 2007/10/10 17:29:57 fabiankeil
+ * I forgot about Poland.
+ *
+ * Revision 1.112 2007/10/09 16:38:40 fabiankeil
+ * Remove Range and If-Range headers if content filtering is enabled.
+ *
+ * Revision 1.111 2007/10/04 18:07:00 fabiankeil
+ * Move ACTION_VANILLA_WAFER handling from jcc's chat() into
+ * client_cookie_adder() to make sure send-vanilla-wafer can be
+ * controlled through tags (and thus regression-tested).
+ *
+ * Revision 1.110 2007/09/29 10:42:37 fabiankeil
+ * - Remove "scanning headers for" log message again.
+ * - Some more whitespace fixes.
+ *
+ * Revision 1.109 2007/09/08 14:25:48 fabiankeil
+ * Refactor client_referrer() and add conditional-forge parameter.
+ *
+ * Revision 1.108 2007/08/28 18:21:03 fabiankeil
+ * A bunch of whitespace fixes, pointy hat to me.
+ *
+ * Revision 1.107 2007/08/28 18:16:32 fabiankeil
+ * Fix possible memory corruption in server_http, make sure it's not
+ * executed for ordinary server headers and mark some problems for later.
+ *
+ * Revision 1.106 2007/08/18 14:30:32 fabiankeil
+ * Let content-type-overwrite{} honour force-text-mode again.
+ *
+ * Revision 1.105 2007/08/11 14:49:49 fabiankeil
+ * - Add prototpyes for the header parsers and make them static.
+ * - Comment out client_accept_encoding_adder() which isn't used right now.
+ *
+ * Revision 1.104 2007/07/14 07:38:19 fabiankeil
+ * Move the ACTION_FORCE_TEXT_MODE check out of
+ * server_content_type(). Signal other functions
+ * whether or not a content type has been declared.
+ * Part of the fix for BR#1750917.
+ *
+ * Revision 1.103 2007/06/01 16:31:54 fabiankeil
+ * Change sed() to return a jb_err in preparation for forward-override{}.
+ *
+ * Revision 1.102 2007/05/27 12:39:32 fabiankeil
+ * Adjust "X-Filter: No" to disable dedicated header filters.
+ *
+ * Revision 1.101 2007/05/14 10:16:41 fabiankeil
+ * Streamline client_cookie_adder().
+ *
+ * Revision 1.100 2007/04/30 15:53:11 fabiankeil
+ * Make sure filters with dynamic jobs actually use them.
+ *
+ * Revision 1.99 2007/04/30 15:06:26 fabiankeil
+ * - Introduce dynamic pcrs jobs that can resolve variables.
+ * - Remove unnecessary update_action_bits_for_all_tags() call.
+ *
+ * Revision 1.98 2007/04/17 18:32:10 fabiankeil
+ * - Make tagging based on tags set by earlier taggers
+ * of the same kind possible.
+ * - Log whether or not new tags cause action bits updates
+ * (in which case a matching tag-pattern section exists).
+ * - Log if the user tries to set a tag that is already set.
+ *
+ * Revision 1.97 2007/04/15 16:39:21 fabiankeil
+ * Introduce tags as alternative way to specify which
+ * actions apply to a request. At the moment tags can be
+ * created based on client and server headers.
+ *
+ * Revision 1.96 2007/04/12 12:53:58 fabiankeil
+ * Log a warning if the content is compressed, filtering is
+ * enabled and Privoxy was compiled without zlib support.
+ * Closes FR#1673938.
+ *
+ * Revision 1.95 2007/03/25 14:26:40 fabiankeil
+ * - Fix warnings when compiled with glibc.
+ * - Don't use crumble() for cookie crunching.
+ * - Move cookie time parsing into parse_header_time().
+ * - Let parse_header_time() return a jb_err code
+ * instead of a pointer that can only be used to
+ * check for NULL anyway.
+ *
+ * Revision 1.94 2007/03/21 12:23:53 fabiankeil
+ * - Add better protection against malicious gzip headers.
+ * - Stop logging the first hundred bytes of decompressed content.
+ * It looks like it's working and there is always debug 16.
+ * - Log the content size after decompression in decompress_iob()
+ * instead of pcrs_filter_response().
+ *
+ * Revision 1.93 2007/03/20 15:21:44 fabiankeil
+ * - Use dedicated header filter actions instead of abusing "filter".
+ * Replace "filter-client-headers" and "filter-client-headers"
+ * with "server-header-filter" and "client-header-filter".
+ * - Remove filter_client_header() and filter_client_header(),
+ * filter_header() now checks the shiny new
+ * CSP_FLAG_CLIENT_HEADER_PARSING_DONE flag instead.
+ *
+ * Revision 1.92 2007/03/05 13:25:32 fabiankeil
+ * - Cosmetical changes for LOG_LEVEL_RE_FILTER messages.
+ * - Handle "Cookie:" and "Connection:" headers a bit smarter
+ * (don't crunch them just to recreate them later on).
+ * - Add another non-standard time format for the cookie
+ * expiration date detection.
+ * - Fix a valgrind warning.
+ *
* Revision 1.91 2007/02/24 12:27:32 fabiankeil
* Improve cookie expiration date detection.
*
#include <ctype.h>
#include <assert.h>
#include <string.h>
+
+#ifdef __GLIBC__
+/*
+ * Convince GNU's libc to provide a strptime prototype.
+ */
+#define __USE_XOPEN
+#endif /*__GLIBC__ */
#include <time.h>
#ifdef FEATURE_ZLIB
#endif /* def FEATURE_PTHREAD */
#include "list.h"
#include "parsers.h"
-#include "encode.h"
#include "ssplit.h"
#include "errlog.h"
#include "jbsockets.h"
#include "miscutil.h"
#include "list.h"
+#include "actions.h"
+#include "filters.h"
#ifndef HAVE_STRPTIME
#include "strptime.h"
/* Fix a problem with Solaris. There should be no effect on other
* platforms.
- * Solaris's isspace() is a macro which uses it's argument directly
+ * Solaris's isspace() is a macro which uses its argument directly
* as an array index. Therefore we need to make sure that high-bit
* characters generate +ve values, and ideally we also want to make
* the argument match the declared parameter type of "int".
#define ijb_isupper(__X) isupper((int)(unsigned char)(__X))
#define ijb_tolower(__X) tolower((int)(unsigned char)(__X))
+static char *get_header_line(struct iob *iob);
+static jb_err scan_headers(struct client_state *csp);
+static jb_err header_tagger(struct client_state *csp, char *header);
+static jb_err parse_header_time(const char *header_time, time_t *result);
+
+static jb_err crumble (struct client_state *csp, char **header);
+static jb_err filter_header (struct client_state *csp, char **header);
+static jb_err client_connection (struct client_state *csp, char **header);
+static jb_err client_referrer (struct client_state *csp, char **header);
+static jb_err client_uagent (struct client_state *csp, char **header);
+static jb_err client_ua (struct client_state *csp, char **header);
+static jb_err client_from (struct client_state *csp, char **header);
+static jb_err client_send_cookie (struct client_state *csp, char **header);
+static jb_err client_x_forwarded (struct client_state *csp, char **header);
+static jb_err client_accept_encoding (struct client_state *csp, char **header);
+static jb_err client_te (struct client_state *csp, char **header);
+static jb_err client_max_forwards (struct client_state *csp, char **header);
+static jb_err client_host (struct client_state *csp, char **header);
+static jb_err client_if_modified_since (struct client_state *csp, char **header);
+static jb_err client_accept_language (struct client_state *csp, char **header);
+static jb_err client_if_none_match (struct client_state *csp, char **header);
+static jb_err crunch_client_header (struct client_state *csp, char **header);
+static jb_err client_x_filter (struct client_state *csp, char **header);
+static jb_err client_range (struct client_state *csp, char **header);
+static jb_err server_set_cookie (struct client_state *csp, char **header);
+static jb_err server_connection (struct client_state *csp, char **header);
+static jb_err server_content_type (struct client_state *csp, char **header);
+static jb_err server_adjust_content_length(struct client_state *csp, char **header);
+static jb_err server_content_md5 (struct client_state *csp, char **header);
+static jb_err server_content_encoding (struct client_state *csp, char **header);
+static jb_err server_transfer_coding (struct client_state *csp, char **header);
+static jb_err server_http (struct client_state *csp, char **header);
+static jb_err crunch_server_header (struct client_state *csp, char **header);
+static jb_err server_last_modified (struct client_state *csp, char **header);
+static jb_err server_content_disposition(struct client_state *csp, char **header);
+
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+static jb_err server_save_content_length(struct client_state *csp, char **header);
+#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
+
+static jb_err client_host_adder (struct client_state *csp);
+static jb_err client_xtra_adder (struct client_state *csp);
+static jb_err client_x_forwarded_for_adder(struct client_state *csp);
+static jb_err client_connection_header_adder(struct client_state *csp);
+static jb_err server_connection_close_adder(struct client_state *csp);
+
+static jb_err create_forged_referrer(char **header, const char *hostport);
+static jb_err create_fake_referrer(char **header, const char *fake_referrer);
+static jb_err handle_conditional_hide_referrer_parameter(char **header,
+ const char *host, const int parameter_conditional_block);
+static const char *get_appropiate_connection_header(const struct client_state *csp);
+
+/*
+ * List of functions to run on a list of headers.
+ */
+struct parsers
+{
+ /** The header prefix to match */
+ const char *str;
+
+ /** The length of the prefix to match */
+ const size_t len;
+
+ /** The function to apply to this line */
+ const parser_func_ptr parser;
+};
-const struct parsers client_patterns[] = {
+static const struct parsers client_patterns[] = {
{ "referer:", 8, client_referrer },
{ "user-agent:", 11, client_uagent },
{ "ua-", 3, client_ua },
{ "Host:", 5, client_host },
{ "if-modified-since:", 18, client_if_modified_since },
{ "Keep-Alive:", 11, crumble },
- { "connection:", 11, connection },
+ { "connection:", 11, client_connection },
{ "proxy-connection:", 17, crumble },
{ "max-forwards:", 13, client_max_forwards },
{ "Accept-Language:", 16, client_accept_language },
{ "if-none-match:", 14, client_if_none_match },
+ { "Range:", 6, client_range },
+ { "Request-Range:", 14, client_range },
+ { "If-Range:", 9, client_range },
{ "X-Filter:", 9, client_x_filter },
{ "*", 0, crunch_client_header },
- { "*", 0, filter_client_header },
+ { "*", 0, filter_header },
{ NULL, 0, NULL }
};
-const struct parsers server_patterns[] = {
- { "HTTP", 4, server_http },
+static const struct parsers server_patterns[] = {
+ { "HTTP/", 5, server_http },
{ "set-cookie:", 11, server_set_cookie },
- { "connection:", 11, connection },
+ { "connection:", 11, server_connection },
{ "Content-Type:", 13, server_content_type },
{ "Content-MD5:", 12, server_content_md5 },
{ "Content-Encoding:", 17, server_content_encoding },
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+ { "Content-Length:", 15, server_save_content_length },
+#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
{ "Transfer-Encoding:", 18, server_transfer_coding },
{ "Keep-Alive:", 11, crumble },
{ "content-disposition:", 20, server_content_disposition },
{ "Last-Modified:", 14, server_last_modified },
{ "*", 0, crunch_server_header },
- { "*", 0, filter_server_header },
- { NULL, 0, NULL }
-};
-
-const struct parsers server_patterns_light[] = {
- { "Content-Length:", 15, server_content_length },
- { "Transfer-Encoding:", 18, server_transfer_coding },
-#ifdef FEATURE_ZLIB
- { "Content-Encoding:", 17, server_content_encoding },
-#endif /* def FEATURE_ZLIB */
- { NULL, 0, NULL }
+ { "*", 0, filter_header },
+ { NULL, 0, NULL }
};
-const add_header_func_ptr add_client_headers[] = {
+static const add_header_func_ptr add_client_headers[] = {
client_host_adder,
- client_cookie_adder,
- client_x_forwarded_adder,
+ client_x_forwarded_for_adder,
client_xtra_adder,
/* Temporarily disabled: client_accept_encoding_adder, */
- connection_close_adder,
+ client_connection_header_adder,
NULL
};
-
-const add_header_func_ptr add_server_headers[] = {
- connection_close_adder,
+static const add_header_func_ptr add_server_headers[] = {
+ server_connection_close_adder,
NULL
};
*
* Parameters :
* 1 : fd = file descriptor of the socket to read
- * 2 : csp = Current client state (buffers, headers, etc...)
+ * 2 : iob = The I/O buffer to flush, usually csp->iob.
*
* Returns : On success, the number of bytes written are returned (zero
* indicates nothing was written). On error, -1 is returned,
* file, the results are not portable.
*
*********************************************************************/
-int flush_socket(jb_socket fd, struct client_state *csp)
+int flush_socket(jb_socket fd, struct iob *iob)
{
- struct iob *iob = csp->iob;
int len = iob->eod - iob->cur;
if (len <= 0)
*/
if (need > csp->config->buffer_limit)
{
- log_error(LOG_LEVEL_ERROR, "Buffer limit reached while extending the buffer (iob)");
+ log_error(LOG_LEVEL_INFO,
+ "Buffer limit reached while extending the buffer (iob). Needed: %d. Limit: %d",
+ need, csp->config->buffer_limit);
return JB_ERR_MEMORY;
}
char *cur; /* Current iob position (to keep the original
* iob->cur unmodified if we return early) */
size_t bufsize; /* allocated size of the new buffer */
+ size_t old_size; /* Content size before decompression */
size_t skip_size; /* Number of bytes at the beginning of the iob
that we should NOT decompress. */
int status; /* return status of the inflate() call */
z_stream zstr; /* used by calls to zlib */
+ assert(csp->iob->cur - csp->iob->buf > 0);
+ assert(csp->iob->eod - csp->iob->cur > 0);
+
bufsize = csp->iob->size;
skip_size = (size_t)(csp->iob->cur - csp->iob->buf);
+ old_size = (size_t)(csp->iob->eod - csp->iob->cur);
cur = csp->iob->cur;
- if (bufsize < 10)
+ if (bufsize < (size_t)10)
{
/*
* This is to protect the parsing of gzipped data,
* but it should(?) be valid for deflated data also.
*/
- log_error (LOG_LEVEL_ERROR, "Buffer too small decompressing iob");
+ log_error(LOG_LEVEL_ERROR, "Buffer too small decompressing iob");
return JB_ERR_COMPRESS;
}
|| (*cur++ != (char)0x8b)
|| (*cur++ != Z_DEFLATED))
{
- log_error (LOG_LEVEL_ERROR, "Invalid gzip header when decompressing");
+ log_error(LOG_LEVEL_ERROR, "Invalid gzip header when decompressing");
return JB_ERR_COMPRESS;
}
else
if (flags & 0xe0)
{
/* The gzip header has reserved bits set; bail out. */
- log_error (LOG_LEVEL_ERROR, "Invalid gzip header flags when decompressing");
+ log_error(LOG_LEVEL_ERROR, "Invalid gzip header flags when decompressing");
return JB_ERR_COMPRESS;
}
cur += 6;
skip_bytes = *cur++;
skip_bytes = *cur++ << 8;
- assert(skip_bytes == *csp->iob->cur-2 + ((*csp->iob->cur-1) << 8));
+ assert(skip_bytes == *csp->iob->cur - 2 + ((*csp->iob->cur - 1) << 8));
/*
* The number of bytes to skip should be positive
* and we'd like to stay in the buffer.
*/
- if((skip_bytes < 0) || (skip_bytes >= (csp->iob->eod - cur)))
+ if ((skip_bytes < 0) || (skip_bytes >= (csp->iob->eod - cur)))
{
- log_error (LOG_LEVEL_ERROR,
+ log_error(LOG_LEVEL_ERROR,
"Unreasonable amount of bytes to skip (%d). Stopping decompression",
skip_bytes);
return JB_ERR_COMPRESS;
}
- log_error (LOG_LEVEL_INFO,
+ log_error(LOG_LEVEL_INFO,
"Skipping %d bytes for gzip compression. Does this sound right?",
skip_bytes);
cur += skip_bytes;
/* Skip the filename if necessary. */
if (flags & 0x08)
{
- /* A null-terminated string follows. */
- while (*cur++);
+ /* A null-terminated string is supposed to follow. */
+ while (*cur++ && (cur < csp->iob->eod));
+
}
/* Skip the comment if necessary. */
if (flags & 0x10)
{
- while (*cur++);
+ /* A null-terminated string is supposed to follow. */
+ while (*cur++ && (cur < csp->iob->eod));
}
/* Skip the CRC if necessary. */
{
cur += 2;
}
+
+ if (cur >= csp->iob->eod)
+ {
+ /*
+ * If the current position pointer reached or passed
+ * the buffer end, we were obviously tricked to skip
+ * too much.
+ */
+ log_error(LOG_LEVEL_ERROR,
+ "Malformed gzip header detected. Aborting decompression.");
+ return JB_ERR_COMPRESS;
+ }
}
}
else if (csp->content_type & CT_DEFLATE)
* XXX: The debug level should be lowered
* before the next stable release.
*/
- log_error (LOG_LEVEL_INFO, "Decompressing deflated iob: %d", *cur);
+ log_error(LOG_LEVEL_INFO, "Decompressing deflated iob: %d", *cur);
/*
* In theory (that is, according to RFC 1950), deflate-compressed
* data should begin with a two-byte zlib header and have an
}
else
{
- log_error (LOG_LEVEL_ERROR,
+ log_error(LOG_LEVEL_ERROR,
"Unable to determine compression format for decompression");
return JB_ERR_COMPRESS;
}
*/
if (inflateInit2 (&zstr, -MAX_WBITS) != Z_OK)
{
- log_error (LOG_LEVEL_ERROR, "Error initializing decompression");
+ log_error(LOG_LEVEL_ERROR, "Error initializing decompression");
return JB_ERR_COMPRESS;
}
* We don't modify the existing iob yet, so in case there
* is error in decompression we can recover gracefully.
*/
- buf = zalloc (bufsize);
+ buf = zalloc(bufsize);
if (NULL == buf)
{
- log_error (LOG_LEVEL_ERROR, "Out of memory decompressing iob");
+ log_error(LOG_LEVEL_ERROR, "Out of memory decompressing iob");
return JB_ERR_MEMORY;
}
*/
assert(zstr.avail_out == tmpbuf + bufsize - (char *)zstr.next_out);
assert((char *)zstr.next_out == tmpbuf + ((char *)oldnext_out - buf));
- assert(zstr.avail_out > 0);
+ assert(zstr.avail_out > 0U);
buf = tmpbuf;
}
&& (csp->iob->cur <= csp->iob->eod)
&& (csp->iob->eod <= csp->iob->buf + csp->iob->size))
{
- char t = csp->iob->cur[100];
- csp->iob->cur[100] = '\0';
- /*
- * XXX: The debug level should be lowered
- * before the next stable release.
- */
- log_error(LOG_LEVEL_INFO, "Sucessfully decompressed: %s", csp->iob->cur);
- csp->iob->cur[100] = t;
- return JB_ERR_OK;
+ const size_t new_size = (size_t)(csp->iob->eod - csp->iob->cur);
+ if (new_size > (size_t)0)
+ {
+ log_error(LOG_LEVEL_RE_FILTER,
+ "Decompression successful. Old size: %d, new size: %d.",
+ old_size, new_size);
+ }
+ else
+ {
+ /* zlib thinks this is OK, so lets do the same. */
+ log_error(LOG_LEVEL_INFO, "Decompression didn't result in any content.");
+ }
}
else
{
return JB_ERR_COMPRESS;
}
+ return JB_ERR_OK;
+
}
#endif /* defined(FEATURE_ZLIB) */
+/*********************************************************************
+ *
+ * Function : string_move
+ *
+ * Description : memmove wrapper to move the last part of a string
+ * towards the beginning, overwriting the part in
+ * the middle. strlcpy() can't be used here as the
+ * strings overlap.
+ *
+ * Parameters :
+ * 1 : dst = Destination to overwrite
+ * 2 : src = Source to move.
+ *
+ * Returns : N/A
+ *
+ *********************************************************************/
+static void string_move(char *dst, char *src)
+{
+ assert(dst < src);
+
+ /* +1 to copy the terminating nul as well. */
+ memmove(dst, src, strlen(src)+1);
+}
+
+
+/*********************************************************************
+ *
+ * Function : normalize_lws
+ *
+ * Description : Reduces unquoted linear white space in headers
+ * to a single space in accordance with RFC 2616 2.2.
+ * This simplifies parsing and filtering later on.
+ *
+ * XXX: Remove log messages before
+ * the next stable release?
+ *
+ * Parameters :
+ * 1 : header = A header with linear white space to reduce.
+ *
+ * Returns : N/A
+ *
+ *********************************************************************/
+static void normalize_lws(char *header)
+{
+ char *p = header;
+
+ while (*p != '\0')
+ {
+ if (ijb_isspace(*p) && ijb_isspace(*(p+1)))
+ {
+ char *q = p+1;
+
+ while (ijb_isspace(*q))
+ {
+ q++;
+ }
+ log_error(LOG_LEVEL_HEADER, "Reducing white space in '%s'", header);
+ string_move(p+1, q);
+ }
+
+ if (*p == '\t')
+ {
+ log_error(LOG_LEVEL_HEADER,
+ "Converting tab to space in '%s'", header);
+ *p = ' ';
+ }
+ else if (*p == '"')
+ {
+ char *end_of_token = strstr(p+1, "\"");
+
+ if (NULL != end_of_token)
+ {
+ /* Don't mess with quoted text. */
+ p = end_of_token;
+ }
+ else
+ {
+ log_error(LOG_LEVEL_HEADER,
+ "Ignoring single quote in '%s'", header);
+ }
+ }
+ p++;
+ }
+
+ p = strchr(header, ':');
+ if ((p != NULL) && (p != header) && ijb_isspace(*(p-1)))
+ {
+ /*
+ * There's still space before the colon.
+ * We don't want it.
+ */
+ string_move(p-1, p);
+ }
+}
+
+
/*********************************************************************
*
* Function : get_header
*
* Description : This (odd) routine will parse the csp->iob
+ * to get the next complete header.
*
* Parameters :
- * 1 : csp = Current client state (buffers, headers, etc...)
+ * 1 : iob = The I/O buffer to parse, usually csp->iob.
+ *
+ * Returns : Any one of the following:
+ *
+ * 1) a pointer to a dynamically allocated string that contains a header line
+ * 2) NULL indicating that the end of the header was reached
+ * 3) "" indicating that the end of the iob was reached before finding
+ * a complete header line.
+ *
+ *********************************************************************/
+char *get_header(struct iob *iob)
+{
+ char *header;
+
+ header = get_header_line(iob);
+
+ if ((header == NULL) || (*header == '\0'))
+ {
+ /*
+ * No complete header read yet, tell the client.
+ */
+ return header;
+ }
+
+ while ((iob->cur[0] == ' ') || (iob->cur[0] == '\t'))
+ {
+ /*
+ * Header spans multiple lines, append the next one.
+ */
+ char *continued_header;
+
+ continued_header = get_header_line(iob);
+ if ((continued_header == NULL) || (*continued_header == '\0'))
+ {
+ /*
+ * No complete header read yet, return what we got.
+ * XXX: Should "unread" header instead.
+ */
+ log_error(LOG_LEVEL_INFO,
+ "Failed to read a multi-line header properly: '%s'",
+ header);
+ break;
+ }
+
+ if (JB_ERR_OK != string_join(&header, continued_header))
+ {
+ log_error(LOG_LEVEL_FATAL,
+ "Out of memory while appending multiple headers.");
+ }
+ else
+ {
+ /* XXX: remove before next stable release. */
+ log_error(LOG_LEVEL_HEADER,
+ "Merged multiple header lines to: '%s'",
+ header);
+ }
+ }
+
+ normalize_lws(header);
+
+ return header;
+
+}
+
+
+/*********************************************************************
+ *
+ * Function : get_header_line
+ *
+ * Description : This (odd) routine will parse the csp->iob
+ * to get the next header line.
+ *
+ * Parameters :
+ * 1 : iob = The I/O buffer to parse, usually csp->iob.
*
* Returns : Any one of the following:
*
* a complete header line.
*
*********************************************************************/
-char *get_header(struct client_state *csp)
+static char *get_header_line(struct iob *iob)
{
- struct iob *iob;
char *p, *q, *ret;
- iob = csp->iob;
if ((iob->cur == NULL)
|| ((p = strchr(iob->cur, '\n')) == NULL))
if (ret == NULL)
{
/* FIXME No way to handle error properly */
- log_error(LOG_LEVEL_FATAL, "Out of memory in get_header()");
+ log_error(LOG_LEVEL_FATAL, "Out of memory in get_header_line()");
}
+ assert(ret != NULL);
iob->cur = p+1;
if (*ret == '\0')
{
freez(ret);
- return(NULL);
+ return NULL;
}
- return(ret);
+ return ret;
}
/*
* Found: return pointer to start of value
*/
- ret = (char *) (cur_entry->str + length);
+ ret = cur_entry->str + length;
while (*ret && ijb_isspace(*ret)) ret++;
- return(ret);
+ return ret;
}
}
}
}
+
+/*********************************************************************
+ *
+ * Function : scan_headers
+ *
+ * Description : Scans headers, applies tags and updates action bits.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns : JB_ERR_OK
+ *
+ *********************************************************************/
+static jb_err scan_headers(struct client_state *csp)
+{
+ struct list_entry *h; /* Header */
+ jb_err err = JB_ERR_OK;
+
+ for (h = csp->headers->first; (err == JB_ERR_OK) && (h != NULL) ; h = h->next)
+ {
+ /* Header crunch()ed in previous run? -> ignore */
+ if (h->str == NULL) continue;
+ log_error(LOG_LEVEL_HEADER, "scan: %s", h->str);
+ err = header_tagger(csp, h->str);
+ }
+
+ return err;
+}
+
+
/*********************************************************************
*
* Function : sed
* header lines.
*
* Parameters :
- * 1 : pats = list of patterns to match against headers
- * 2 : more_headers = list of functions to add more
- * headers (client or server)
- * 3 : csp = Current client state (buffers, headers, etc...)
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : filter_server_headers = Boolean to switch between
+ * server and header filtering.
*
- * Returns : Single pointer to a fully formed header, or NULL
- * on out-of-memory error.
+ * Returns : JB_ERR_OK in case off success, or
+ * JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-char *sed(const struct parsers pats[],
- const add_header_func_ptr more_headers[],
- struct client_state *csp)
+jb_err sed(struct client_state *csp, int filter_server_headers)
{
+ /* XXX: use more descriptive names. */
struct list_entry *p;
const struct parsers *v;
const add_header_func_ptr *f;
jb_err err = JB_ERR_OK;
- int first_run;
-
- /*
- * If filtering is enabled, sed is run twice,
- * but most of the work needs to be done only once.
- */
- first_run = (more_headers != NULL ) ? 1 : 0;
- if (first_run) /* Parse and print */
+ if (filter_server_headers)
{
- log_error(LOG_LEVEL_HEADER, "scanning headers for: %s", csp->http->url);
- for (v = pats; (err == JB_ERR_OK) && (v->str != NULL) ; v++)
- {
- for (p = csp->headers->first; (err == JB_ERR_OK) && (p != NULL) ; p = p->next)
- {
- /* Header crunch()ed in previous run? -> ignore */
- if (p->str == NULL) continue;
+ v = server_patterns;
+ f = add_server_headers;
+ }
+ else
+ {
+ v = client_patterns;
+ f = add_client_headers;
+ }
- if (v == pats) log_error(LOG_LEVEL_HEADER, "scan: %s", p->str);
+ scan_headers(csp);
- /* Does the current parser handle this header? */
- if ((strncmpic(p->str, v->str, v->len) == 0) || (v->len == CHECK_EVERY_HEADER_REMAINING))
- {
- err = v->parser(csp, (char **)&(p->str));
- }
- }
- }
- /* place any additional headers on the csp->headers list */
- for (f = more_headers; (err == JB_ERR_OK) && (*f) ; f++)
- {
- err = (*f)(csp);
- }
- }
- else /* Parse only */
+ while ((err == JB_ERR_OK) && (v->str != NULL))
{
- /*
- * The second run is only needed if the body was modified
- * and the content-lenght has changed.
- */
- if (strncmpic(csp->http->cmd, "HEAD", 4))
+ for (p = csp->headers->first; (err == JB_ERR_OK) && (p != NULL); p = p->next)
{
- /*XXX: Code duplication */
- for (v = pats; (err == JB_ERR_OK) && (v->str != NULL) ; v++)
- {
- for (p = csp->headers->first; (err == JB_ERR_OK) && (p != NULL) ; p = p->next)
- {
- /* Header crunch()ed in previous run? -> ignore */
- if (p->str == NULL) continue;
+ /* Header crunch()ed in previous run? -> ignore */
+ if (p->str == NULL) continue;
- /* Does the current parser handle this header? */
- if (strncmpic(p->str, v->str, v->len) == 0)
- {
- err = v->parser(csp, (char **)&(p->str));
- }
- }
+ /* Does the current parser handle this header? */
+ if ((strncmpic(p->str, v->str, v->len) == 0) ||
+ (v->len == CHECK_EVERY_HEADER_REMAINING))
+ {
+ err = v->parser(csp, &(p->str));
}
}
+ v++;
}
- if (err != JB_ERR_OK)
+ /* place additional headers on the csp->headers list */
+ while ((err == JB_ERR_OK) && (*f))
{
- return NULL;
+ err = (*f)(csp);
+ f++;
}
- return list_to_text(csp->headers);
+ return err;
}
-/* here begins the family of parser functions that reformat header lines */
-
/*********************************************************************
*
- * Function : filter_server_header
+ * Function : update_server_headers
*
- * Description : Checks if server header filtering is enabled.
- * If it is, filter_header is called to do the work.
+ * Description : Updates server headers after the body has been modified.
*
* Parameters :
* 1 : csp = Current client state (buffers, headers, etc...)
- * 2 : header = On input, pointer to header to modify.
- * On output, pointer to the modified header, or NULL
- * to remove the header. This function frees the
- * original string if necessary.
*
- * Returns : JB_ERR_OK on success and always succeeds
+ * Returns : JB_ERR_OK in case off success, or
+ * JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err filter_server_header(struct client_state *csp, char **header)
+jb_err update_server_headers(struct client_state *csp)
{
- if (csp->action->flags & ACTION_FILTER_SERVER_HEADERS)
+ jb_err err = JB_ERR_OK;
+
+ static const struct parsers server_patterns_light[] = {
+ { "Content-Length:", 15, server_adjust_content_length },
+ { "Transfer-Encoding:", 18, server_transfer_coding },
+#ifdef FEATURE_ZLIB
+ { "Content-Encoding:", 17, server_content_encoding },
+#endif /* def FEATURE_ZLIB */
+ { NULL, 0, NULL }
+ };
+
+ if (strncmpic(csp->http->cmd, "HEAD", 4))
{
- filter_header(csp, header);
+ const struct parsers *v;
+ struct list_entry *p;
+
+ for (v = server_patterns_light; (err == JB_ERR_OK) && (v->str != NULL); v++)
+ {
+ for (p = csp->headers->first; (err == JB_ERR_OK) && (p != NULL); p = p->next)
+ {
+ /* Header crunch()ed in previous run? -> ignore */
+ if (p->str == NULL) continue;
+
+ /* Does the current parser handle this header? */
+ if (strncmpic(p->str, v->str, v->len) == 0)
+ {
+ err = v->parser(csp, (char **)&(p->str));
+ }
+ }
+ }
}
- return(JB_ERR_OK);
+
+ return err;
}
+
/*********************************************************************
*
- * Function : filter_client_header
+ * Function : header_tagger
+ *
+ * Description : Executes all text substitutions from applying
+ * tag actions and saves the result as tag.
*
- * Description : Checks if client header filtering is enabled.
- * If it is, filter_header is called to do the work.
+ * XXX: Shares enough code with filter_header() and
+ * pcrs_filter_response() to warrant some helper functions.
*
* Parameters :
* 1 : csp = Current client state (buffers, headers, etc...)
- * 2 : header = On input, pointer to header to modify.
- * On output, pointer to the modified header, or NULL
- * to remove the header. This function frees the
- * original string if necessary.
+ * 2 : header = Header that is used as tagger input
*
* Returns : JB_ERR_OK on success and always succeeds
*
*********************************************************************/
-jb_err filter_client_header(struct client_state *csp, char **header)
+static jb_err header_tagger(struct client_state *csp, char *header)
{
- if (csp->action->flags & ACTION_FILTER_CLIENT_HEADERS)
- {
- filter_header(csp, header);
- }
- return(JB_ERR_OK);
-}
+ int wanted_filter_type;
+ int multi_action_index;
+ int i;
+ pcrs_job *job;
-/*********************************************************************
- *
+ struct file_list *fl;
+ struct re_filterfile_spec *b;
+ struct list_entry *tag_name;
+
+ int found_filters = 0;
+ const size_t header_length = strlen(header);
+
+ if (csp->flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
+ {
+ wanted_filter_type = FT_SERVER_HEADER_TAGGER;
+ multi_action_index = ACTION_MULTI_SERVER_HEADER_TAGGER;
+ }
+ else
+ {
+ wanted_filter_type = FT_CLIENT_HEADER_TAGGER;
+ multi_action_index = ACTION_MULTI_CLIENT_HEADER_TAGGER;
+ }
+
+ /* Check if there are any filters */
+ for (i = 0; i < MAX_AF_FILES; i++)
+ {
+ fl = csp->rlist[i];
+ if (NULL != fl)
+ {
+ if (NULL != fl->f)
+ {
+ found_filters = 1;
+ break;
+ }
+ }
+ }
+
+ if (0 == found_filters)
+ {
+ log_error(LOG_LEVEL_ERROR, "Inconsistent configuration: "
+ "tagging enabled, but no taggers available.");
+ return JB_ERR_OK;
+ }
+
+ for (i = 0; i < MAX_AF_FILES; i++)
+ {
+ fl = csp->rlist[i];
+ if ((NULL == fl) || (NULL == fl->f))
+ {
+ /*
+ * Either there are no filter files
+ * left, or this filter file just
+ * contains no valid filters.
+ *
+ * Continue to be sure we don't miss
+ * valid filter files that are chained
+ * after empty or invalid ones.
+ */
+ continue;
+ }
+
+ /* For all filters, */
+ for (b = fl->f; b; b = b->next)
+ {
+ if (b->type != wanted_filter_type)
+ {
+ /* skip the ones we don't care about, */
+ continue;
+ }
+ /* leaving only taggers that could apply, of which we use the ones, */
+ for (tag_name = csp->action->multi[multi_action_index]->first;
+ NULL != tag_name; tag_name = tag_name->next)
+ {
+ /* that do apply, and */
+ if (strcmp(b->name, tag_name->str) == 0)
+ {
+ char *modified_tag = NULL;
+ char *tag = header;
+ size_t size = header_length;
+ pcrs_job *joblist = b->joblist;
+
+ if (b->dynamic) joblist = compile_dynamic_pcrs_job_list(csp, b);
+
+ if (NULL == joblist)
+ {
+ log_error(LOG_LEVEL_RE_FILTER,
+ "Tagger %s has empty joblist. Nothing to do.", b->name);
+ continue;
+ }
+
+ /* execute their pcrs_joblist on the header. */
+ for (job = joblist; NULL != job; job = job->next)
+ {
+ const int hits = pcrs_execute(job, tag, size, &modified_tag, &size);
+
+ if (0 < hits)
+ {
+ /* Success, continue with the modified version. */
+ if (tag != header)
+ {
+ freez(tag);
+ }
+ tag = modified_tag;
+ }
+ else
+ {
+ /* Tagger doesn't match */
+ if (0 > hits)
+ {
+ /* Regex failure, log it but continue anyway. */
+ assert(NULL != header);
+ log_error(LOG_LEVEL_ERROR,
+ "Problems with tagger \'%s\' and header \'%s\': %s",
+ b->name, *header, pcrs_strerror(hits));
+ }
+ freez(modified_tag);
+ }
+ }
+
+ if (b->dynamic) pcrs_free_joblist(joblist);
+
+ /* If this tagger matched */
+ if (tag != header)
+ {
+ if (0 == size)
+ {
+ /*
+ * There is to technical limitation which makes
+ * it impossible to use empty tags, but I assume
+ * no one would do it intentionally.
+ */
+ freez(tag);
+ log_error(LOG_LEVEL_INFO,
+ "Tagger \'%s\' created an empty tag. Ignored.",
+ b->name);
+ continue;
+ }
+
+ if (!list_contains_item(csp->tags, tag))
+ {
+ if (JB_ERR_OK != enlist(csp->tags, tag))
+ {
+ log_error(LOG_LEVEL_ERROR,
+ "Insufficient memory to add tag \'%s\', "
+ "based on tagger \'%s\' and header \'%s\'",
+ tag, b->name, *header);
+ }
+ else
+ {
+ char *action_message;
+ /*
+ * update the action bits right away, to make
+ * tagging based on tags set by earlier taggers
+ * of the same kind possible.
+ */
+ if (update_action_bits_for_tag(csp, tag))
+ {
+ action_message = "Action bits updated accordingly.";
+ }
+ else
+ {
+ action_message = "No action bits update necessary.";
+ }
+
+ log_error(LOG_LEVEL_HEADER,
+ "Tagger \'%s\' added tag \'%s\'. %s",
+ b->name, tag, action_message);
+ }
+ }
+ else
+ {
+ /* XXX: Is this log-worthy? */
+ log_error(LOG_LEVEL_HEADER,
+ "Tagger \'%s\' didn't add tag \'%s\'. "
+ "Tag already present", b->name, tag);
+ }
+ freez(tag);
+ } /* if the tagger matched */
+ } /* if the tagger applies */
+ } /* for every tagger that could apply */
+ } /* for all filters */
+ } /* for all filter files */
+
+ return JB_ERR_OK;
+}
+
+/* here begins the family of parser functions that reformat header lines */
+
+/*********************************************************************
+ *
* Function : filter_header
*
* Description : Executes all text substitutions from all applying
- * +filter actions on the header.
+ * +(server|client)-header-filter actions on the header.
* Most of the code was copied from pcrs_filter_response,
* including the rather short variable names
*
* Returns : JB_ERR_OK on success and always succeeds
*
*********************************************************************/
-jb_err filter_header(struct client_state *csp, char **header)
+static jb_err filter_header(struct client_state *csp, char **header)
{
int hits=0;
int matches;
struct list_entry *filtername;
int i, found_filters = 0;
+ int wanted_filter_type;
+ int multi_action_index;
+
+ if (csp->flags & CSP_FLAG_NO_FILTERING)
+ {
+ return JB_ERR_OK;
+ }
+
+ if (csp->flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
+ {
+ wanted_filter_type = FT_SERVER_HEADER_FILTER;
+ multi_action_index = ACTION_MULTI_SERVER_HEADER_FILTER;
+ }
+ else
+ {
+ wanted_filter_type = FT_CLIENT_HEADER_FILTER;
+ multi_action_index = ACTION_MULTI_CLIENT_HEADER_FILTER;
+ }
/*
* Need to check the set of re_filterfiles...
if (0 == found_filters)
{
- log_error(LOG_LEVEL_ERROR, "Unable to get current state of regexp filtering.");
- return(JB_ERR_OK);
+ log_error(LOG_LEVEL_ERROR, "Inconsistent configuration: "
+ "header filtering enabled, but no matching filters available.");
+ return JB_ERR_OK;
}
for (i = 0; i < MAX_AF_FILES; i++)
*/
for (b = fl->f; b; b = b->next)
{
- for (filtername = csp->action->multi[ACTION_MULTI_FILTER]->first;
+ if (b->type != wanted_filter_type)
+ {
+ /* Skip other filter types */
+ continue;
+ }
+
+ for (filtername = csp->action->multi[multi_action_index]->first;
filtername ; filtername = filtername->next)
{
if (strcmp(b->name, filtername->str) == 0)
{
int current_hits = 0;
+ pcrs_job *joblist = b->joblist;
- if ( NULL == b->joblist )
+ if (b->dynamic) joblist = compile_dynamic_pcrs_job_list(csp, b);
+
+ if (NULL == joblist)
{
log_error(LOG_LEVEL_RE_FILTER, "Filter %s has empty joblist. Nothing to do.", b->name);
continue;
*header, size, b->name);
/* Apply all jobs from the joblist */
- for (job = b->joblist; NULL != job; job = job->next)
+ for (job = joblist; NULL != job; job = job->next)
{
matches = pcrs_execute(job, *header, size, &newheader, &size);
if ( 0 < matches )
/* RegEx failure */
log_error(LOG_LEVEL_ERROR, "Filtering \'%s\' with \'%s\' didn't work out: %s",
*header, b->name, pcrs_strerror(matches));
- if( newheader != NULL)
+ if (newheader != NULL)
{
log_error(LOG_LEVEL_ERROR, "Freeing what's left: %s", newheader);
freez(newheader);
}
}
}
+
+ if (b->dynamic) pcrs_free_joblist(joblist);
+
log_error(LOG_LEVEL_RE_FILTER, "... produced %d hits (new size %d).", current_hits, size);
hits += current_hits;
}
freez(*header);
}
- return(JB_ERR_OK);
+ return JB_ERR_OK;
}
/*********************************************************************
*
- * Function : connection
+ * Function : server_connection
*
* Description : Makes sure that the value of the Connection: header
- * is "close" and signals connection_close_adder
+ * is "close" and signals server_connection_close_adder
* to do nothing.
*
* Parameters :
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err connection(struct client_state *csp, char **header)
+static jb_err server_connection(struct client_state *csp, char **header)
{
char *old_header = *header;
/* Do we have a 'Connection: close' header? */
if (strcmpic(*header, "Connection: close"))
{
- /* No, create one */
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+ if ((csp->config->feature_flags &
+ RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
+ && !strcmpic(*header, "Connection: keep-alive"))
+ {
+ /* Remember to keep the connection alive. */
+ csp->flags |= CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE;
+ }
+#endif /* FEATURE_CONNECTION_KEEP_ALIVE */
+
*header = strdup("Connection: close");
if (header == NULL)
{
freez(old_header);
}
- /* Signal connection_close_adder() to return early. */
- if (csp->flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
- {
- csp->flags |= CSP_FLAG_SERVER_CONNECTION_CLOSE_SET;
- }
- else
+ /* Signal server_connection_close_adder() to return early. */
+ csp->flags |= CSP_FLAG_SERVER_CONNECTION_CLOSE_SET;
+
+ return JB_ERR_OK;
+}
+
+/*********************************************************************
+ *
+ * Function : client_connection
+ *
+ * Description : Makes sure a proper "Connection:" header is
+ * set and signals connection_header_adder
+ * to do nothing.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : header = On input, pointer to header to modify.
+ * On output, pointer to the modified header, or NULL
+ * to remove the header. This function frees the
+ * original string if necessary.
+ *
+ * Returns : JB_ERR_OK on success, or
+ * JB_ERR_MEMORY on out-of-memory error.
+ *
+ *********************************************************************/
+static jb_err client_connection(struct client_state *csp, char **header)
+{
+ char *old_header = *header;
+ const char *wanted_header = get_appropiate_connection_header(csp);
+
+ if (strcmpic(*header, wanted_header))
{
- csp->flags |= CSP_FLAG_CLIENT_CONNECTION_CLOSE_SET;
+ *header = strdup(wanted_header);
+ if (header == NULL)
+ {
+ return JB_ERR_MEMORY;
+ }
+ log_error(LOG_LEVEL_HEADER,
+ "Replaced: \'%s\' with \'%s\'", old_header, *header);
+ freez(old_header);
}
+ /* Signal client_connection_close_adder() to return early. */
+ csp->flags |= CSP_FLAG_CLIENT_CONNECTION_HEADER_SET;
+
return JB_ERR_OK;
}
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err crumble(struct client_state *csp, char **header)
+static jb_err crumble(struct client_state *csp, char **header)
{
+ (void)csp;
log_error(LOG_LEVEL_HEADER, "crumble crunched: %s!", *header);
freez(*header);
return JB_ERR_OK;
}
+
/*********************************************************************
*
* Function : crunch_server_header
* Returns : JB_ERR_OK on success and always succeeds
*
*********************************************************************/
-jb_err crunch_server_header(struct client_state *csp, char **header)
+static jb_err crunch_server_header(struct client_state *csp, char **header)
{
const char *crunch_pattern;
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err server_content_type(struct client_state *csp, char **header)
+static jb_err server_content_type(struct client_state *csp, char **header)
{
/* Remove header if it isn't the first Content-Type header */
- if(csp->content_type && (csp->content_type != CT_TABOO))
+ if ((csp->content_type & CT_DECLARED))
{
/*
* Another, slightly slower, way to see if
return JB_ERR_OK;
}
+ /*
+ * Signal that the Content-Type has been set.
+ */
+ csp->content_type |= CT_DECLARED;
+
if (!(csp->content_type & CT_TABOO))
{
- if ((strstr(*header, " text/") && !strstr(*header, "plain"))
+ /*
+ * XXX: The assumption that text/plain is a sign of
+ * binary data seems to be somewhat unreasonable nowadays
+ * and should be dropped after 3.0.8 is out.
+ */
+ if ((strstr(*header, "text/") && !strstr(*header, "plain"))
|| strstr(*header, "xml")
|| strstr(*header, "application/x-javascript"))
{
csp->content_type |= CT_TEXT;
}
- else if (strstr(*header, " image/gif"))
+ else if (strstr(*header, "image/gif"))
{
csp->content_type |= CT_GIF;
}
- else if (strstr(*header, " image/jpeg"))
- {
- csp->content_type |= CT_JPEG;
- }
- else
- {
- csp->content_type = 0;
- }
- }
- /*
- * Are we enabling text mode by force?
- */
- if (csp->action->flags & ACTION_FORCE_TEXT_MODE)
- {
- /*
- * Do we really have to?
- */
- if (csp->content_type & CT_TEXT)
- {
- log_error(LOG_LEVEL_HEADER, "Text mode is already enabled.");
- }
- else
- {
- csp->content_type |= CT_TEXT;
- log_error(LOG_LEVEL_HEADER, "Text mode enabled by force. Take cover!");
- }
}
+
/*
* Are we messing with the content type?
- */
+ */
if (csp->action->flags & ACTION_CONTENT_TYPE_OVERWRITE)
- {
+ {
/*
* Make sure the user doesn't accidently
* change the content type of binary documents.
- */
- if (csp->content_type & CT_TEXT)
- {
+ */
+ if ((csp->content_type & CT_TEXT) || (csp->action->flags & ACTION_FORCE_TEXT_MODE))
+ {
freez(*header);
*header = strdup("Content-Type: ");
string_append(header, csp->action->string[ACTION_STRING_CONTENT_TYPE]);
if (header == NULL)
- {
+ {
log_error(LOG_LEVEL_HEADER, "Insufficient memory to replace Content-Type!");
return JB_ERR_MEMORY;
}
}
else
{
- log_error(LOG_LEVEL_HEADER, "%s not replaced. It doesn't look like text. "
- "Enable force-text-mode if you know what you're doing.", *header);
+ log_error(LOG_LEVEL_HEADER, "%s not replaced. "
+ "It doesn't look like a content type that should be filtered. "
+ "Enable force-text-mode if you know what you're doing.", *header);
}
- }
+ }
+
return JB_ERR_OK;
}
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err server_transfer_coding(struct client_state *csp, char **header)
+static jb_err server_transfer_coding(struct client_state *csp, char **header)
{
/*
* Turn off pcrs and gif filtering if body compressed
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err server_content_encoding(struct client_state *csp, char **header)
+static jb_err server_content_encoding(struct client_state *csp, char **header)
{
#ifdef FEATURE_ZLIB
if ((csp->flags & CSP_FLAG_MODIFIED)
* Body is compressed, turn off pcrs and gif filtering.
*/
csp->content_type |= CT_TABOO;
+
+ /*
+ * Log a warning if the user expects the content to be filtered.
+ */
+ if ((csp->rlist != NULL) &&
+ (!list_is_empty(csp->action->multi[ACTION_MULTI_FILTER])))
+ {
+ log_error(LOG_LEVEL_INFO,
+ "Compressed content detected, content filtering disabled. "
+ "Consider recompiling Privoxy with zlib support or "
+ "enable the prevent-compression action.");
+ }
}
-#endif /* !defined(FEATURE_ZLIB) */
+#endif /* defined(FEATURE_ZLIB) */
return JB_ERR_OK;
/*********************************************************************
*
- * Function : server_content_length
+ * Function : server_adjust_content_length
*
* Description : Adjust Content-Length header if we modified
* the body.
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err server_content_length(struct client_state *csp, char **header)
+static jb_err server_adjust_content_length(struct client_state *csp, char **header)
{
const size_t max_header_length = 80;
}
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+/*********************************************************************
+ *
+ * Function : server_save_content_length
+ *
+ * Description : Save the Content-Length sent by the server.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : header = On input, pointer to header to modify.
+ * On output, pointer to the modified header, or NULL
+ * to remove the header. This function frees the
+ * original string if necessary.
+ *
+ * Returns : JB_ERR_OK on success, or
+ * JB_ERR_MEMORY on out-of-memory error.
+ *
+ *********************************************************************/
+static jb_err server_save_content_length(struct client_state *csp, char **header)
+{
+ unsigned int content_length = 0;
+
+ assert(*(*header+14) == ':');
+
+ if (1 != sscanf(*header+14, ": %u", &content_length))
+ {
+ log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header);
+ freez(*header);
+ }
+ else
+ {
+ csp->expected_content_length = content_length;
+ csp->flags |= CSP_FLAG_CONTENT_LENGTH_SET;
+ }
+
+ return JB_ERR_OK;
+}
+#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
+
+
/*********************************************************************
*
* Function : server_content_md5
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err server_content_md5(struct client_state *csp, char **header)
+static jb_err server_content_md5(struct client_state *csp, char **header)
{
if (csp->flags & CSP_FLAG_MODIFIED)
{
return JB_ERR_OK;
}
+
/*********************************************************************
*
* Function : server_content_disposition
*
- * Description : If enabled, blocks or modifies the "content-disposition" header.
+ * Description : If enabled, blocks or modifies the "Content-Disposition" header.
* Called from `sed'.
*
* Parameters :
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err server_content_disposition(struct client_state *csp, char **header)
+static jb_err server_content_disposition(struct client_state *csp, char **header)
{
const char *newval;
/*
- * Are we messing with the content-disposition header?
+ * Are we messing with the Content-Disposition header?
*/
if ((csp->action->flags & ACTION_HIDE_CONTENT_DISPOSITION) == 0)
{
- /*Me tinks not*/
+ /* Me tinks not */
return JB_ERR_OK;
}
newval = csp->action->string[ACTION_STRING_CONTENT_DISPOSITION];
- if ((newval == NULL) || (0 == strcmpic(newval, "block")) )
+ if ((newval == NULL) || (0 == strcmpic(newval, "block")))
{
/*
* Blocking content-disposition header
else
{
/*
- * Replacing content-disposition header
+ * Replacing Content-Disposition header
*/
freez(*header);
- *header = strdup("content-disposition: ");
- string_append(header, newval);
+ *header = strdup("Content-Disposition: ");
+ string_append(header, newval);
- if (*header == NULL)
+ if (*header != NULL)
{
- log_error(LOG_LEVEL_HEADER, "Insufficent memory. content-disposition header not fully replaced.");
- }
- else
- {
- log_error(LOG_LEVEL_HEADER, "content-disposition header crunched and replaced with: %s", *header);
+ log_error(LOG_LEVEL_HEADER,
+ "Content-Disposition header crunched and replaced with: %s", *header);
}
}
return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
}
+
/*********************************************************************
*
* Function : server_last_modified
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err server_last_modified(struct client_state *csp, char **header)
+static jb_err server_last_modified(struct client_state *csp, char **header)
{
const char *newval;
char buf[BUFFER_SIZE];
/*
* Setting Last-Modified Header to now.
*/
- get_http_time(0, buf);
+ get_http_time(0, buf, sizeof(buf));
freez(*header);
*header = strdup("Last-Modified: ");
string_append(header, buf);
if (*header == NULL)
{
- log_error(LOG_LEVEL_HEADER, "Insufficent memory. Last-Modified header got lost, boohoo.");
+ log_error(LOG_LEVEL_HEADER, "Insufficient memory. Last-Modified header got lost, boohoo.");
}
else
{
}
else if (0 == strcmpic(newval, "randomize"))
{
+ const char *header_time = *header + sizeof("Last-Modified:");
+
log_error(LOG_LEVEL_HEADER, "Randomizing: %s", *header);
now = time(NULL);
#ifdef HAVE_GMTIME_R
timeptr = gmtime_r(&now, &gmt);
#elif FEATURE_PTHREAD
- pthread_mutex_lock(&gmtime_mutex);
+ privoxy_mutex_lock(&gmtime_mutex);
timeptr = gmtime(&now);
- pthread_mutex_unlock(&gmtime_mutex);
+ privoxy_mutex_unlock(&gmtime_mutex);
#else
timeptr = gmtime(&now);
#endif
- if ((timeptr = parse_header_time(*header, &last_modified)) == NULL)
+ if (JB_ERR_OK != parse_header_time(header_time, &last_modified))
{
- log_error(LOG_LEVEL_HEADER, "Couldn't parse: %s (crunching!)", *header);
+ log_error(LOG_LEVEL_HEADER, "Couldn't parse: %s in %s (crunching!)", header_time, *header);
freez(*header);
}
else
rtime = (long int)difftime(now, last_modified);
if (rtime)
{
+ int negative = 0;
+
+ if (rtime < 0)
+ {
+ rtime *= -1;
+ negative = 1;
+ log_error(LOG_LEVEL_HEADER, "Server time in the future.");
+ }
rtime = pick_from_range(rtime);
+ if (negative) rtime *= -1;
last_modified += rtime;
#ifdef HAVE_GMTIME_R
timeptr = gmtime_r(&last_modified, &gmt);
#elif FEATURE_PTHREAD
- pthread_mutex_lock(&gmtime_mutex);
+ privoxy_mutex_lock(&gmtime_mutex);
timeptr = gmtime(&last_modified);
- pthread_mutex_unlock(&gmtime_mutex);
+ privoxy_mutex_unlock(&gmtime_mutex);
#else
timeptr = gmtime(&last_modified);
#endif
if (*header == NULL)
{
- log_error(LOG_LEVEL_ERROR, "Insufficent memory, header crunched without replacement.");
+ log_error(LOG_LEVEL_ERROR, "Insufficient memory, header crunched without replacement.");
return JB_ERR_MEMORY;
}
- if(LOG_LEVEL_HEADER & debug) /* Save cycles if the user isn't interested. */
- {
- days = rtime / (3600 * 24);
- hours = rtime / 3600 % 24;
- minutes = rtime / 60 % 60;
- seconds = rtime % 60;
-
- log_error(LOG_LEVEL_HEADER, "Randomized: %s (added %d da%s %d hou%s %d minut%s %d second%s",
- *header, days, (days == 1) ? "y" : "ys", hours, (hours == 1) ? "r" : "rs",
- minutes, (minutes == 1) ? "e" : "es", seconds, (seconds == 1) ? ")" : "s)");
- }
+ days = rtime / (3600 * 24);
+ hours = rtime / 3600 % 24;
+ minutes = rtime / 60 % 60;
+ seconds = rtime % 60;
+
+ log_error(LOG_LEVEL_HEADER,
+ "Randomized: %s (added %d da%s %d hou%s %d minut%s %d second%s",
+ *header, days, (days == 1) ? "y" : "ys", hours, (hours == 1) ? "r" : "rs",
+ minutes, (minutes == 1) ? "e" : "es", seconds, (seconds == 1) ? ")" : "s)");
}
else
{
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_accept_encoding(struct client_state *csp, char **header)
+static jb_err client_accept_encoding(struct client_state *csp, char **header)
{
if ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
{
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_te(struct client_state *csp, char **header)
+static jb_err client_te(struct client_state *csp, char **header)
{
if ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
{
return JB_ERR_OK;
}
+
/*********************************************************************
*
* Function : client_referrer
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_referrer(struct client_state *csp, char **header)
+static jb_err client_referrer(struct client_state *csp, char **header)
{
- const char *newval;
- const char *host;
- char *referer;
- size_t hostlenght;
+ const char *parameter;
+ /* booleans for parameters we have to check multiple times */
+ int parameter_conditional_block;
+ int parameter_conditional_forge;
#ifdef FEATURE_FORCE_LOAD
- /* Since the referrer can include the prefix even
+ /*
+ * Since the referrer can include the prefix even
* if the request itself is non-forced, we must
- * clean it unconditionally
+ * clean it unconditionally.
+ *
+ * XXX: strclean is too broad
*/
strclean(*header, FORCE_PREFIX);
#endif /* def FEATURE_FORCE_LOAD */
- /*
- * Are we sending referer?
- */
if ((csp->action->flags & ACTION_HIDE_REFERER) == 0)
{
+ /* Nothing left to do */
return JB_ERR_OK;
}
- newval = csp->action->string[ACTION_STRING_REFERER];
+ parameter = csp->action->string[ACTION_STRING_REFERER];
+ assert(parameter != NULL);
+ parameter_conditional_block = (0 == strcmpic(parameter, "conditional-block"));
+ parameter_conditional_forge = (0 == strcmpic(parameter, "conditional-forge"));
- if ((0 != strcmpic(newval, "conditional-block")))
- {
- freez(*header);
- }
- if ((newval == NULL) || (0 == strcmpic(newval, "block")) )
+ if (!parameter_conditional_block && !parameter_conditional_forge)
{
/*
- * Blocking referer
+ * As conditional-block and conditional-forge are the only
+ * parameters that rely on the original referrer, we can
+ * remove it now for all the others.
*/
+ freez(*header);
+ }
+
+ if (0 == strcmpic(parameter, "block"))
+ {
log_error(LOG_LEVEL_HEADER, "Referer crunched!");
return JB_ERR_OK;
}
- else if (0 == strcmpic(newval, "conditional-block"))
+ else if (parameter_conditional_block || parameter_conditional_forge)
{
- /*
- * Block referer if host has changed.
- */
+ return handle_conditional_hide_referrer_parameter(header,
+ csp->http->hostport, parameter_conditional_block);
+ }
+ else if (0 == strcmpic(parameter, "forge"))
+ {
+ return create_forged_referrer(header, csp->http->hostport);
+ }
+ else
+ {
+ /* interpret parameter as user-supplied referer to fake */
+ return create_fake_referrer(header, parameter);
+ }
+}
- if (NULL == (host = strdup(csp->http->hostport)))
- {
- freez(*header);
- log_error(LOG_LEVEL_HEADER, "Referer crunched! Couldn't allocate memory for temporary host copy.");
- return JB_ERR_MEMORY;
- }
- if (NULL == (referer = strdup(*header)))
- {
- freez(*header);
- freez(host);
- log_error(LOG_LEVEL_HEADER, "Referer crunched! Couldn't allocate memory for temporary referer copy.");
- return JB_ERR_MEMORY;
- }
- hostlenght = strlen(host);
- if ( hostlenght < (strlen(referer)-17) ) /*referer begins with 'Referer: http[s]://'*/
- {
- /*Shorten referer to make sure the referer is blocked
- *if www.example.org/www.example.com-shall-see-the-referer/
- *links to www.example.com/
- */
- referer[hostlenght+17] = '\0';
- }
- if ( 0 == strstr(referer, host)) /*Host has changed*/
- {
- log_error(LOG_LEVEL_HEADER, "New host is: %s. Crunching %s!", host, *header);
- freez(*header);
- }
- else
- {
- log_error(LOG_LEVEL_HEADER, "%s (not modified, still on %s)", *header, host);
- }
- freez(referer);
- freez(host);
- return JB_ERR_OK;
- }
- else if (0 != strcmpic(newval, "forge"))
- {
- /*
- * We have a specific (fixed) referer we want to send.
- */
- if ((0 != strncmpic(newval, "http://", 7)) && (0 != strncmpic(newval, "https://", 8)))
- {
- log_error(LOG_LEVEL_HEADER, "Parameter: +referrer{%s} is a bad idea, but I don't care.", newval);
- }
- *header = strdup("Referer: ");
- string_append(header, newval);
- log_error(LOG_LEVEL_HEADER, "Referer overwritten with: %s", *header);
-
- return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
- }
- else
- {
- /*
- * Forge a referer as http://[hostname:port of REQUEST]/
- * to fool stupid checks for in-site links
- */
-
- *header = strdup("Referer: http://");
- string_append(header, csp->http->hostport);
- string_append(header, "/");
- log_error(LOG_LEVEL_HEADER, "Referer forged to: %s", *header);
-
- return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
- }
-}
/*********************************************************************
*
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_accept_language(struct client_state *csp, char **header)
+static jb_err client_accept_language(struct client_state *csp, char **header)
{
const char *newval;
if (*header == NULL)
{
log_error(LOG_LEVEL_ERROR,
- "Insufficent memory. Accept-Language header crunched without replacement.");
+ "Insufficient memory. Accept-Language header crunched without replacement.");
}
else
{
return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
}
+
/*********************************************************************
*
* Function : crunch_client_header
* Returns : JB_ERR_OK on success and always succeeds
*
*********************************************************************/
-jb_err crunch_client_header(struct client_state *csp, char **header)
+static jb_err crunch_client_header(struct client_state *csp, char **header)
{
const char *crunch_pattern;
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_uagent(struct client_state *csp, char **header)
+static jb_err client_uagent(struct client_state *csp, char **header)
{
const char *newval;
return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK;
}
+
/*********************************************************************
*
* Function : client_ua
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_ua(struct client_state *csp, char **header)
+static jb_err client_ua(struct client_state *csp, char **header)
{
if ((csp->action->flags & ACTION_HIDE_USER_AGENT) != 0)
{
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_from(struct client_state *csp, char **header)
+static jb_err client_from(struct client_state *csp, char **header)
{
const char *newval;
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_send_cookie(struct client_state *csp, char **header)
+static jb_err client_send_cookie(struct client_state *csp, char **header)
{
if (csp->action->flags & ACTION_NO_COOKIE_READ)
{
*********************************************************************/
jb_err client_x_forwarded(struct client_state *csp, char **header)
{
- if ((csp->action->flags & ACTION_HIDE_FORWARDED) == 0)
+ if (0 != (csp->action->flags & ACTION_CHANGE_X_FORWARDED_FOR))
{
- /* Save it so we can re-add it later */
- freez(csp->x_forwarded);
- csp->x_forwarded = *header;
+ const char *parameter = csp->action->string[ACTION_STRING_CHANGE_X_FORWARDED_FOR];
- /*
- * Always set *header = NULL, since this information
- * will be sent at the end of the header.
- */
- *header = NULL;
- }
- else
- {
- freez(*header);
- log_error(LOG_LEVEL_HEADER, "crunched x-forwarded-for!");
+ if (0 == strcmpic(parameter, "block"))
+ {
+ freez(*header);
+ log_error(LOG_LEVEL_HEADER, "crunched x-forwarded-for!");
+ }
+ else if (0 == strcmpic(parameter, "add"))
+ {
+ string_append(header, ", ");
+ string_append(header, csp->ip_addr_str);
+
+ if (*header == NULL)
+ {
+ return JB_ERR_MEMORY;
+ }
+ log_error(LOG_LEVEL_HEADER,
+ "Appended client IP address to %s", *header);
+ csp->flags |= CSP_FLAG_X_FORWARDED_FOR_APPENDED;
+ }
+ else
+ {
+ log_error(LOG_LEVEL_FATAL,
+ "Invalid change-x-forwarded-for parameter: '%s'", parameter);
+ }
}
return JB_ERR_OK;
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_max_forwards(struct client_state *csp, char **header)
+static jb_err client_max_forwards(struct client_state *csp, char **header)
{
int max_forwards;
(0 == strcmpic(csp->http->gpc, "options")))
{
assert(*(*header+12) == ':');
- if (1 == sscanf(*header+12, ": %u", &max_forwards))
+ if (1 == sscanf(*header+12, ": %d", &max_forwards))
{
if (max_forwards > 0)
{
- snprintf(*header, strlen(*header)+1, "Max-Forwards: %u", --max_forwards);
- log_error(LOG_LEVEL_HEADER, "Max-Forwards value for %s request reduced to %u.",
+ snprintf(*header, strlen(*header)+1, "Max-Forwards: %d", --max_forwards);
+ log_error(LOG_LEVEL_HEADER,
+ "Max-Forwards value for %s request reduced to %d.",
csp->http->gpc, max_forwards);
}
else if (max_forwards < 0)
log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header);
freez(*header);
}
- else
- {
- /*
- * Not supposed to be reached. direct_response() which
- * was already called earlier in chat() should have
- * intercepted the request.
- */
- log_error(LOG_LEVEL_ERROR,
- "Non-intercepted %s request with Max-Forwards zero!", csp->http->gpc);
- assert(max_forwards != 0);
- }
}
else
{
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_host(struct client_state *csp, char **header)
+static jb_err client_host(struct client_state *csp, char **header)
{
char *p, *q;
return JB_ERR_OK;
}
+
/*********************************************************************
*
* Function : client_if_modified_since
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_if_modified_since(struct client_state *csp, char **header)
+static jb_err client_if_modified_since(struct client_state *csp, char **header)
{
char newheader[50];
#ifdef HAVE_GMTIME_R
}
else /* add random value */
{
- if ((timeptr = parse_header_time(*header, &tm)) == NULL)
+ const char *header_time = *header + sizeof("If-Modified-Since:");
+
+ if (JB_ERR_OK != parse_header_time(header_time, &tm))
{
- log_error(LOG_LEVEL_HEADER, "Couldn't parse: %s (crunching!)", *header);
+ log_error(LOG_LEVEL_HEADER, "Couldn't parse: %s in %s (crunching!)", header_time, *header);
freez(*header);
}
else
{
rtime = strtol(newval, &endptr, 0);
- if(rtime)
+ if (rtime)
{
log_error(LOG_LEVEL_HEADER, "Randomizing: %s (random range: %d minut%s)",
*header, rtime, (rtime == 1 || rtime == -1) ? "e": "es");
- if(rtime < 0)
+ if (rtime < 0)
{
rtime *= -1;
negative = 1;
#ifdef HAVE_GMTIME_R
timeptr = gmtime_r(&tm, &gmt);
#elif FEATURE_PTHREAD
- pthread_mutex_lock(&gmtime_mutex);
+ privoxy_mutex_lock(&gmtime_mutex);
timeptr = gmtime(&tm);
- pthread_mutex_unlock(&gmtime_mutex);
+ privoxy_mutex_unlock(&gmtime_mutex);
#else
timeptr = gmtime(&tm);
#endif
if (*header == NULL)
{
- log_error(LOG_LEVEL_HEADER, "Insufficent memory, header crunched without replacement.");
+ log_error(LOG_LEVEL_HEADER, "Insufficient memory, header crunched without replacement.");
return JB_ERR_MEMORY;
}
- if(LOG_LEVEL_HEADER & debug) /* Save cycles if the user isn't interested. */
- {
- hours = rtime / 3600;
- minutes = rtime / 60 % 60;
- seconds = rtime % 60;
+ hours = rtime / 3600;
+ minutes = rtime / 60 % 60;
+ seconds = rtime % 60;
- log_error(LOG_LEVEL_HEADER, "Randomized: %s (%s %d hou%s %d minut%s %d second%s",
- *header, (negative) ? "subtracted" : "added", hours, (hours == 1) ? "r" : "rs",
- minutes, (minutes == 1) ? "e" : "es", seconds, (seconds == 1) ? ")" : "s)");
- }
+ log_error(LOG_LEVEL_HEADER,
+ "Randomized: %s (%s %d hou%s %d minut%s %d second%s",
+ *header, (negative) ? "subtracted" : "added", hours,
+ (hours == 1) ? "r" : "rs", minutes, (minutes == 1) ? "e" : "es",
+ seconds, (seconds == 1) ? ")" : "s)");
}
}
}
return JB_ERR_OK;
}
+
/*********************************************************************
*
* Function : client_if_none_match
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_if_none_match(struct client_state *csp, char **header)
+static jb_err client_if_none_match(struct client_state *csp, char **header)
{
if (csp->action->flags & ACTION_CRUNCH_IF_NONE_MATCH)
{
return JB_ERR_OK;
}
+
/*********************************************************************
*
* Function : client_x_filter
}
else
{
- csp->content_type = CT_TABOO;
- csp->action->flags &= ~ACTION_FILTER_SERVER_HEADERS;
- csp->action->flags &= ~ACTION_FILTER_CLIENT_HEADERS;
+ csp->content_type = CT_TABOO; /* XXX: This hack shouldn't be necessary */
+ csp->flags |= CSP_FLAG_NO_FILTERING;
log_error(LOG_LEVEL_HEADER, "Accepted the client's request to fetch without filtering.");
}
log_error(LOG_LEVEL_HEADER, "Crunching %s", *header);
return JB_ERR_OK;
}
+
+/*********************************************************************
+ *
+ * Function : client_range
+ *
+ * Description : Removes Range, Request-Range and If-Range headers if
+ * content filtering is enabled. If the client's version
+ * of the document has been altered by Privoxy, the server
+ * could interpret the range differently than the client
+ * intended in which case the user could end up with
+ * corrupted content.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : header = On input, pointer to header to modify.
+ * On output, pointer to the modified header, or NULL
+ * to remove the header. This function frees the
+ * original string if necessary.
+ *
+ * Returns : JB_ERR_OK
+ *
+ *********************************************************************/
+static jb_err client_range(struct client_state *csp, char **header)
+{
+ if (content_filters_enabled(csp->action))
+ {
+ log_error(LOG_LEVEL_HEADER, "Content filtering is enabled."
+ " Crunching: \'%s\' to prevent range-mismatch problems.", *header);
+ freez(*header);
+ }
+
+ return JB_ERR_OK;
+}
+
/* the following functions add headers directly to the header list */
/*********************************************************************
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_host_adder(struct client_state *csp)
+static jb_err client_host_adder(struct client_state *csp)
{
char *p;
jb_err err;
}
-/*********************************************************************
- *
- * Function : client_cookie_adder
- *
- * Description : Used in the add_client_headers list. Called from `sed'.
- *
- * XXX: Remove csp->cookie_list which is no longer used.
- *
- * Parameters :
- * 1 : csp = Current client state (buffers, headers, etc...)
- *
- * Returns : JB_ERR_OK on success, or
- * JB_ERR_MEMORY on out-of-memory error.
- *
- *********************************************************************/
-jb_err client_cookie_adder(struct client_state *csp)
-{
- struct list_entry *lst;
- char *tmp;
- struct list_entry *list1 = csp->cookie_list->first;
- struct list_entry *list2 = csp->action->multi[ACTION_MULTI_WAFER]->first;
- int first_cookie = 1;
- jb_err err;
-
- if ((list1 == NULL) && (list2 == NULL))
- {
- /* Nothing to do */
- return JB_ERR_OK;
- }
-
- tmp = strdup("Cookie: ");
-
- for (lst = list1; lst ; lst = lst->next)
- {
- if (first_cookie)
- {
- first_cookie = 0;
- }
- else
- {
- string_append(&tmp, "; ");
- }
- string_append(&tmp, lst->str);
- }
-
- for (lst = list2; lst ; lst = lst->next)
- {
- if (first_cookie)
- {
- first_cookie = 0;
- }
- else
- {
- string_append(&tmp, "; ");
- }
- string_join(&tmp, cookie_encode(lst->str));
- }
-
- if (tmp == NULL)
- {
- return JB_ERR_MEMORY;
- }
-
- log_error(LOG_LEVEL_HEADER, "addh: %s", tmp);
- err = enlist(csp->headers, tmp);
- free(tmp);
- return err;
-}
-
-
+#if 0
/*********************************************************************
*
* Function : client_accept_encoding_adder
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_accept_encoding_adder(struct client_state *csp)
+static jb_err client_accept_encoding_adder(struct client_state *csp)
{
- assert(0); /* Not in use */
-
if ( ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
&& (!strcmpic(csp->http->ver, "HTTP/1.1")) )
{
return JB_ERR_OK;
}
+#endif
/*********************************************************************
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_xtra_adder(struct client_state *csp)
+static jb_err client_xtra_adder(struct client_state *csp)
{
struct list_entry *lst;
jb_err err;
/*********************************************************************
*
- * Function : client_x_forwarded_adder
+ * Function : client_x_forwarded_for_adder
*
* Description : Used in the add_client_headers list. Called from `sed'.
*
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err client_x_forwarded_adder(struct client_state *csp)
+static jb_err client_x_forwarded_for_adder(struct client_state *csp)
{
- char *p = NULL;
+ char *header = NULL;
jb_err err;
- if ((csp->action->flags & ACTION_HIDE_FORWARDED) != 0)
+ if (!((csp->action->flags & ACTION_CHANGE_X_FORWARDED_FOR)
+ && (0 == strcmpic(csp->action->string[ACTION_STRING_CHANGE_X_FORWARDED_FOR], "add")))
+ || (csp->flags & CSP_FLAG_X_FORWARDED_FOR_APPENDED))
{
+ /*
+ * If we aren't adding X-Forwarded-For headers,
+ * or we already appended an existing X-Forwarded-For
+ * header, there's nothing left to do here.
+ */
return JB_ERR_OK;
}
- if (csp->x_forwarded)
- {
- p = strdup(csp->x_forwarded);
- string_append(&p, ", ");
- }
- else
- {
- p = strdup("X-Forwarded-For: ");
- }
- string_append(&p, csp->ip_addr_str);
+ header = strdup("X-Forwarded-For: ");
+ string_append(&header, csp->ip_addr_str);
- if (p == NULL)
+ if (header == NULL)
{
return JB_ERR_MEMORY;
}
- log_error(LOG_LEVEL_HEADER, "addh: %s", p);
- err = enlist(csp->headers, p);
- free(p);
+ log_error(LOG_LEVEL_HEADER, "addh: %s", header);
+ err = enlist(csp->headers, header);
+ freez(header);
return err;
}
/*********************************************************************
*
- * Function : connection_close_adder
+ * Function : server_connection_close_adder
*
* Description : "Temporary" fix for the needed but missing HTTP/1.1
* support. Adds a "Connection: close" header to csp->headers
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err connection_close_adder(struct client_state *csp)
+static jb_err server_connection_close_adder(struct client_state *csp)
{
const unsigned int flags = csp->flags;
+ const char *response_status_line = csp->headers->first->str;
+
+ if ((flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
+ && (flags & CSP_FLAG_SERVER_CONNECTION_CLOSE_SET))
+ {
+ return JB_ERR_OK;
+ }
/*
- * Return right away if
- *
- * - we're parsing server headers and the server header
- * "Connection: close" is already set, or if
- *
- * - we're parsing client headers and the client header
- * "Connection: close" is already set.
+ * XXX: if we downgraded the response, this check will fail.
*/
- if ((flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE
- && flags & CSP_FLAG_SERVER_CONNECTION_CLOSE_SET)
- ||(!(flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
- && flags & CSP_FLAG_CLIENT_CONNECTION_CLOSE_SET))
+ if ((csp->config->feature_flags &
+ RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
+ && (NULL != response_status_line)
+ && !strncmpic(response_status_line, "HTTP/1.1", 8))
{
- return JB_ERR_OK;
+ log_error(LOG_LEVEL_HEADER, "A HTTP/1.1 response "
+ "without Connection header implies keep-alive.");
+ csp->flags |= CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE;
}
log_error(LOG_LEVEL_HEADER, "Adding: Connection: close");
}
+/*********************************************************************
+ *
+ * Function : client_connection_header_adder
+ *
+ * Description : Adds a proper "Connection:" header to csp->headers
+ * unless the header was already present. Called from `sed'.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns : JB_ERR_OK on success, or
+ * JB_ERR_MEMORY on out-of-memory error.
+ *
+ *********************************************************************/
+static jb_err client_connection_header_adder(struct client_state *csp)
+{
+ const unsigned int flags = csp->flags;
+ const char *wanted_header = get_appropiate_connection_header(csp);
+
+ if (!(flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
+ && (flags & CSP_FLAG_CLIENT_CONNECTION_HEADER_SET))
+ {
+ return JB_ERR_OK;
+ }
+
+ log_error(LOG_LEVEL_HEADER, "Adding: %s", wanted_header);
+
+ return enlist(csp->headers, wanted_header);
+}
+
+
/*********************************************************************
*
* Function : server_http
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err server_http(struct client_state *csp, char **header)
+static jb_err server_http(struct client_state *csp, char **header)
{
- /* Signal that were now parsing server headers. */
- csp->flags |= CSP_FLAG_CLIENT_HEADER_PARSING_DONE;
-
sscanf(*header, "HTTP/%*d.%*d %d", &(csp->http->status));
if (csp->http->status == 206)
{
if ((csp->action->flags & ACTION_DOWNGRADE) != 0)
{
- (*header)[7] = '0';
- log_error(LOG_LEVEL_HEADER, "Downgraded answer to HTTP/1.0");
+ /* XXX: Should we do a real validity check here? */
+ if (strlen(*header) > 8)
+ {
+ (*header)[7] = '0';
+ log_error(LOG_LEVEL_HEADER, "Downgraded answer to HTTP/1.0");
+ }
+ else
+ {
+ /*
+ * XXX: Should we block the request or
+ * enlist a valid status code line here?
+ */
+ log_error(LOG_LEVEL_INFO, "Malformed server response detected. "
+ "Downgrading to HTTP/1.0 impossible.");
+ }
}
return JB_ERR_OK;
* JB_ERR_MEMORY on out-of-memory error.
*
*********************************************************************/
-jb_err server_set_cookie(struct client_state *csp, char **header)
+static jb_err server_set_cookie(struct client_state *csp, char **header)
{
time_t now;
time_t cookie_time;
- struct tm tm_now;
- struct tm tm_cookie;
- time(&now);
-
-#ifdef FEATURE_COOKIE_JAR
- if (csp->config->jar)
- {
- /*
- * Write timestamp into outbuf.
- *
- * Complex because not all OSs have tm_gmtoff or
- * the %z field in strftime()
- */
- char tempbuf[ BUFFER_SIZE ];
-
-#ifdef HAVE_LOCALTIME_R
- tm_now = *localtime_r(&now, &tm_now);
-#elif FEATURE_PTHREAD
- pthread_mutex_lock(&localtime_mutex);
- tm_now = *localtime (&now);
- pthread_mutex_unlock(&localtime_mutex);
-#else
- tm_now = *localtime (&now);
-#endif
- strftime(tempbuf, BUFFER_SIZE-6, "%b %d %H:%M:%S ", &tm_now);
- /* strlen("set-cookie: ") = 12 */
- fprintf(csp->config->jar, "%s %s\t%s\n", tempbuf, csp->http->host, *header + 12);
- }
-#endif /* def FEATURE_COOKIE_JAR */
+ time(&now);
if ((csp->action->flags & ACTION_NO_COOKIE_SET) != 0)
{
- log_error(LOG_LEVEL_HEADER, "Crunched incoming cookie -- yum!");
- return crumble(csp, header);
+ log_error(LOG_LEVEL_HEADER, "Crunching incoming cookie: %s", *header);
+ freez(*header);
}
else if ((csp->action->flags & ACTION_NO_COOKIE_KEEP) != 0)
{
*/
if ((strncmpic(cur_tag, "expires=", 8) == 0) && *(cur_tag + 8))
{
- char *match;
- const char *expiration_date = cur_tag + 8; /* Skip "[Ee]xpires=" */
- memset(&tm_cookie, 0, sizeof(tm_cookie));
- /*
- * Try the valid time formats we know about.
- *
- * XXX: This should be moved to parse_header_time().
- *
- * XXX: Maybe the log messages should be removed
- * for the next stable release. They just exist to
- * see which time format gets the most hits and
- * should be checked for first.
- */
- if (NULL != (match = strptime(expiration_date, "%a, %e-%b-%y %H:%M:%S ", &tm_cookie)))
- {
- /* 22-Feb-2008 12:01:18 GMT */
- log_error(LOG_LEVEL_HEADER,
- "cookie \'%s\' send by %s appears to be using time format 1.",
- *header, csp->http->url);
- }
- else if (NULL != (match = strptime(expiration_date, "%A, %e-%b-%Y %H:%M:%S ", &tm_cookie)))
- {
- /* Tue, 02-Jun-2037 20:00:00 GMT */
- log_error(LOG_LEVEL_HEADER,
- "cookie \'%s\' send by %s appears to be using time format 2.",
- *header, csp->http->url);
- }
- else if (NULL != (match = strptime(expiration_date, "%a, %e-%b-%Y %H:%M:%S ", &tm_cookie)))
- {
- /* Tuesday, 02-Jun-2037 20:00:00 GMT */
- /*
- * On FreeBSD this is never reached because it's handled
- * by "format 2" as well. I am, however, not sure if all
- * strptime() implementations behave that way.
- */
- log_error(LOG_LEVEL_HEADER,
- "cookie \'%s\' send by %s appears to be using time format 3.",
- *header, csp->http->url);
- }
- else if (NULL != (match = strptime(expiration_date, "%a, %e %b %Y %H:%M:%S ", &tm_cookie)))
- {
- /* Fri, 22 Feb 2008 19:20:05 GMT */
- log_error(LOG_LEVEL_HEADER,
- "cookie \'%s\' send by %s appears to be using time format 4.",
- *header, csp->http->url);
- }
- else if (NULL != (match = strptime(expiration_date, "%A %b %e %H:%M:%S %Y", &tm_cookie)))
- {
- /* Thu Mar 08 23:00:00 2007 GMT */
- log_error(LOG_LEVEL_HEADER,
- "cookie \'%s\' send by %s appears to be using time format 5.",
- *header, csp->http->url);
- }
+ char *expiration_date = cur_tag + 8; /* Skip "[Ee]xpires=" */
- /* Did any of them match? */
- if (NULL == match)
+ /* Did we detect the date properly? */
+ if (JB_ERR_OK != parse_header_time(expiration_date, &cookie_time))
{
/*
* Nope, treat it as if it was still valid.
*/
log_error(LOG_LEVEL_ERROR,
"Can't parse \'%s\', send by %s. Unsupported time format?", cur_tag, csp->http->url);
- memmove(cur_tag, next_tag, strlen(next_tag) + 1);
+ string_move(cur_tag, next_tag);
changed = 1;
}
else
* anyway, which in many cases will be shorter
* than a browser session.
*/
- cookie_time = timegm(&tm_cookie);
if (cookie_time - now < 0)
{
log_error(LOG_LEVEL_HEADER,
/*
* Still valid, delete expiration date by copying
* the rest of the string over it.
- *
- * (Note that we cannot just use "strcpy(cur_tag, next_tag)",
- * since the behaviour of strcpy is undefined for overlapping
- * strings.)
*/
- memmove(cur_tag, next_tag, strlen(next_tag) + 1);
+ string_move(cur_tag, next_tag);
/* That changed the header, need to issue a log message */
changed = 1;
* Returns : Number of eliminations
*
*********************************************************************/
-int strclean(const char *string, const char *substring)
+int strclean(char *string, const char *substring)
{
int hits = 0;
size_t len;
}
#endif /* def FEATURE_FORCE_LOAD */
+
/*********************************************************************
*
* Function : parse_header_time
*
- * Description : Transforms time inside a HTTP header into
- * the usual time format.
+ * Description : Parses time formats used in HTTP header strings
+ * to get the numerical respresentation.
*
* Parameters :
- * 1 : header = header to parse
- * 2 : tm = storage for the resulting time in seconds
+ * 1 : header_time = HTTP header time as string.
+ * 2 : result = storage for header_time in seconds
*
- * Returns : Time struct containing the header time, or
- * NULL in case of a parsing problems.
+ * Returns : JB_ERR_OK if the time format was recognized, or
+ * JB_ERR_PARSE otherwise.
*
*********************************************************************/
-struct tm *parse_header_time(char *header, time_t *tm) {
-
- char * timestring;
+static jb_err parse_header_time(const char *header_time, time_t *result)
+{
struct tm gmt;
- struct tm * timeptr;
/*
- * Initializing gmt to prevent time zone offsets.
+ * Zero out gmt to prevent time zone offsets.
*
* While this is only necessary on some platforms
* (mingw32 for example), I don't know how to
* detect these automatically and doing it everywhere
* shouldn't hurt.
*/
- time(tm);
-#ifdef HAVE_LOCALTIME_R
- gmt = *localtime_r(tm, &gmt);
-#elif FEATURE_PTHREAD
- pthread_mutex_lock(&localtime_mutex);
- gmt = *localtime(tm);
- pthread_mutex_unlock(&localtime_mutex);
-#else
- gmt = *localtime(tm);
-#endif
-
- /* Skipping header name */
- timestring = strstr(header, ": ");
- if (strptime(timestring, ": %a, %d %b %Y %H:%M:%S", &gmt) == NULL)
- {
- timeptr = NULL;
- }
- else
+ memset(&gmt, 0, sizeof(gmt));
+
+ /* Tue, 02 Jun 2037 20:00:00 */
+ if ((NULL == strptime(header_time, "%a, %d %b %Y %H:%M:%S", &gmt))
+ /* Tue, 02-Jun-2037 20:00:00 */
+ && (NULL == strptime(header_time, "%a, %d-%b-%Y %H:%M:%S", &gmt))
+ /* Tue, 02-Jun-37 20:00:00 */
+ && (NULL == strptime(header_time, "%a, %d-%b-%y %H:%M:%S", &gmt))
+ /* Tuesday, 02-Jun-2037 20:00:00 */
+ && (NULL == strptime(header_time, "%A, %d-%b-%Y %H:%M:%S", &gmt))
+ /* Tuesday Jun 02 20:00:00 2037 */
+ && (NULL == strptime(header_time, "%A %b %d %H:%M:%S %Y", &gmt)))
{
- *tm = timegm(&gmt);
- timeptr = &gmt;
+ return JB_ERR_PARSE;
}
- return(timeptr);
+
+ *result = timegm(&gmt);
+
+ return JB_ERR_OK;
}
+
/*********************************************************************
*
* Function : get_destination_from_headers
}
+/*********************************************************************
+ *
+ * Function : create_forged_referrer
+ *
+ * Description : Helper for client_referrer to forge a referer as
+ * 'http://[hostname:port/' to fool stupid
+ * checks for in-site links
+ *
+ * Parameters :
+ * 1 : header = Pointer to header pointer
+ * 2 : hostport = Host and optionally port as string
+ *
+ * Returns : JB_ERR_OK in case of success, or
+ * JB_ERR_MEMORY in case of memory problems.
+ *
+ *********************************************************************/
+static jb_err create_forged_referrer(char **header, const char *hostport)
+{
+ assert(NULL == *header);
+
+ *header = strdup("Referer: http://");
+ string_append(header, hostport);
+ string_append(header, "/");
+
+ if (NULL == *header)
+ {
+ return JB_ERR_MEMORY;
+ }
+
+ log_error(LOG_LEVEL_HEADER, "Referer forged to: %s", *header);
+
+ return JB_ERR_OK;
+
+}
+
+
+/*********************************************************************
+ *
+ * Function : create_fake_referrer
+ *
+ * Description : Helper for client_referrer to create a fake referrer
+ * based on a string supplied by the user.
+ *
+ * Parameters :
+ * 1 : header = Pointer to header pointer
+ * 2 : hosthost = Referrer to fake
+ *
+ * Returns : JB_ERR_OK in case of success, or
+ * JB_ERR_MEMORY in case of memory problems.
+ *
+ *********************************************************************/
+static jb_err create_fake_referrer(char **header, const char *fake_referrer)
+{
+ assert(NULL == *header);
+
+ if ((0 != strncmpic(fake_referrer, "http://", 7)) && (0 != strncmpic(fake_referrer, "https://", 8)))
+ {
+ log_error(LOG_LEVEL_HEADER,
+ "Parameter: +hide-referrer{%s} is a bad idea, but I don't care.", fake_referrer);
+ }
+ *header = strdup("Referer: ");
+ string_append(header, fake_referrer);
+
+ if (NULL == *header)
+ {
+ return JB_ERR_MEMORY;
+ }
+
+ log_error(LOG_LEVEL_HEADER, "Referer replaced with: %s", *header);
+
+ return JB_ERR_OK;
+
+}
+
+
+/*********************************************************************
+ *
+ * Function : handle_conditional_hide_referrer_parameter
+ *
+ * Description : Helper for client_referrer to crunch or forge
+ * the referrer header if the host has changed.
+ *
+ * Parameters :
+ * 1 : header = Pointer to header pointer
+ * 2 : host = The target host (may include the port)
+ * 3 : parameter_conditional_block = Boolean to signal
+ * if we're in conditional-block mode. If not set,
+ * we're in conditional-forge mode.
+ *
+ * Returns : JB_ERR_OK in case of success, or
+ * JB_ERR_MEMORY in case of memory problems.
+ *
+ *********************************************************************/
+static jb_err handle_conditional_hide_referrer_parameter(char **header,
+ const char *host, const int parameter_conditional_block)
+{
+ char *referer = strdup(*header);
+ const size_t hostlenght = strlen(host);
+ const char *referer_url = NULL;
+
+ if (NULL == referer)
+ {
+ freez(*header);
+ return JB_ERR_MEMORY;
+ }
+
+ /* referer begins with 'Referer: http[s]://' */
+ if ((hostlenght+17) < strlen(referer))
+ {
+ /*
+ * Shorten referer to make sure the referer is blocked
+ * if www.example.org/www.example.com-shall-see-the-referer/
+ * links to www.example.com/
+ */
+ referer[hostlenght+17] = '\0';
+ }
+ referer_url = strstr(referer, "http://");
+ if ((NULL == referer_url) || (NULL == strstr(referer_url, host)))
+ {
+ /* Host has changed, Referer is invalid or a https URL. */
+ if (parameter_conditional_block)
+ {
+ log_error(LOG_LEVEL_HEADER, "New host is: %s. Crunching %s!", host, *header);
+ freez(*header);
+ }
+ else
+ {
+ freez(*header);
+ freez(referer);
+ return create_forged_referrer(header, host);
+ }
+ }
+ freez(referer);
+
+ return JB_ERR_OK;
+
+}
+
+
+/*********************************************************************
+ *
+ * Function : get_appropiate_connection_header
+ *
+ * Description : Returns an appropiate Connection header
+ * depending on whether or not we try to keep
+ * the connection to the server alive.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns : Pointer to statically allocated header buffer.
+ *
+ *********************************************************************/
+static const char *get_appropiate_connection_header(const struct client_state *csp)
+{
+ static const char connection_keep_alive[] = "Connection: keep-alive";
+ static const char connection_close[] = "Connection: close";
+
+ if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
+ && (csp->http->ssl == 0))
+ {
+ return connection_keep_alive;
+ }
+ return connection_close;
+}
/*
Local Variables:
tab-width: 3