-const char jcc_rcs[] = "$Id: jcc.c,v 1.132 2007/04/25 15:15:17 fabiankeil Exp $";
+const char jcc_rcs[] = "$Id: jcc.c,v 1.136 2007/06/01 16:41:11 fabiankeil Exp $";
/*********************************************************************
*
* File : $Source: /cvsroot/ijbswa/current/jcc.c,v $
*
* Revisions :
* $Log: jcc.c,v $
+ * Revision 1.136 2007/06/01 16:41:11 fabiankeil
+ * Add forward-override{} to change the forwarding settings through
+ * action sections. This is mainly interesting to forward different
+ * clients differently (for example based on User-Agent or request
+ * origin).
+ *
+ * Revision 1.135 2007/05/24 17:03:50 fabiankeil
+ * - Let usage() mention the --chroot parameter.
+ * - Use read_socket() consistently and always leave
+ * the last buffer byte alone, even in cases where
+ * null termination (currently) doesn't matter.
+ *
+ * Revision 1.134 2007/05/16 14:59:46 fabiankeil
+ * - Fix config file loading on Unix if no config file is specified.
+ * Since r1.97 Privoxy would always interpret the last argument as
+ * config file, even if it's a valid command line option.
+ * - Abort in case of unrecognized command line options. Closes #1719696.
+ * - Remove a bunch of unnecessary strcpy() calls (yay for c&p without thinking).
+ * - Replace the remaining strcpy() and strcat() calls with strlcpy() and strcat().
+ *
+ * Revision 1.133 2007/05/04 11:23:19 fabiankeil
+ * - Don't rerun crunchers that only depend on the request URL.
+ * - Don't count redirects and CGI requests as "blocked requests".
+ *
* Revision 1.132 2007/04/25 15:15:17 fabiankeil
* Support crunching based on tags created by server-header taggers.
*
pthread_mutex_t log_mutex;
pthread_mutex_t log_init_mutex;
+#if !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R)
+pthread_mutex_t resolver_mutex;
+#endif /* !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R) */
+
#ifndef HAVE_GMTIME_R
pthread_mutex_t gmtime_mutex;
#endif /* ndef HAVE_GMTIME_R */
pthread_mutex_t localtime_mutex;
#endif /* ndef HAVE_GMTIME_R */
-#ifndef HAVE_GETHOSTBYADDR_R
-pthread_mutex_t gethostbyaddr_mutex;
-#endif /* ndef HAVE_GETHOSTBYADDR_R */
-
-#ifndef HAVE_GETHOSTBYNAME_R
-pthread_mutex_t gethostbyname_mutex;
-#endif /* ndef HAVE_GETHOSTBYNAME_R */
-
#ifndef HAVE_RANDOM
pthread_mutex_t rand_mutex;
#endif /* ndef HAVE_RANDOM */
{
if (!strncmpic(req, "GET ftp://", 10))
{
- strcpy(buf, FTP_RESPONSE);
+ strlcpy(buf, FTP_RESPONSE, sizeof(buf));
log_error(LOG_LEVEL_ERROR, "%s tried to use Privoxy as FTP proxy: %s",
csp->ip_addr_str, req);
}
else
{
- strcpy(buf, GOPHER_RESPONSE);
+ strlcpy(buf, GOPHER_RESPONSE, sizeof(buf));
log_error(LOG_LEVEL_ERROR, "%s tried to use Privoxy as gopher proxy: %s",
csp->ip_addr_str, req);
}
*********************************************************************/
jb_err get_request_destination_elsewhere(struct client_state *csp, struct list *headers)
{
- char buf[BUFFER_SIZE];
char *req;
if (!(csp->config->feature_flags & RUNTIME_FEATURE_ACCEPT_INTERCEPTED_REQUESTS))
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 400 0",
csp->ip_addr_str, csp->http->cmd);
- strcpy(buf, CHEADER);
- write_socket(csp->cfd, buf, strlen(buf));
+ write_socket(csp->cfd, CHEADER, strlen(CHEADER));
destroy_list(headers);
return JB_ERR_PARSE;
csp->ip_addr_str, csp->http->cmd, req);
freez(req);
- strcpy(buf, MISSING_DESTINATION_RESPONSE);
- write_socket(csp->cfd, buf, strlen(buf));
+ write_socket(csp->cfd, MISSING_DESTINATION_RESPONSE, strlen(MISSING_DESTINATION_RESPONSE));
destroy_list(headers);
return JB_ERR_PARSE;
log_error(LOG_LEVEL_HEADER,
"Offending request data with NULL bytes turned into \'°\' characters: %s", buf);
- strcpy(buf, NULL_BYTE_RESPONSE);
- write_socket(csp->cfd, buf, strlen(buf));
+ write_socket(csp->cfd, NULL_BYTE_RESPONSE, strlen(NULL_BYTE_RESPONSE));
/* XXX: Log correct size */
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"Invalid request\" 400 0", csp->ip_addr_str);
* Parameters :
* 1 : csp = Current client state (buffers, headers, etc...)
* 2 : fwd = The forwarding spec used for the request
+ * XXX: Should use http->fwd instead.
+ * 3 : request_line = The old request line which will be replaced.
*
* Returns : Nothing. Terminates in case of memory problems.
*
*********************************************************************/
-void build_request_line(struct client_state *csp, const struct forward_spec *fwd)
+void build_request_line(struct client_state *csp, const struct forward_spec *fwd, char **request_line)
{
struct http_request *http = csp->http;
/*
* Rebuild the request line.
- * XXX: If a http forwarder is used and the HTTP version
- * wasn't downgraded, we don't have to rebuild anything.
*/
- freez(http->cmd);
-
- http->cmd = strdup(http->gpc);
- string_append(&http->cmd, " ");
+ freez(*request_line);
+ *request_line = strdup(http->gpc);
+ string_append(request_line, " ");
if (fwd->forward_host)
{
- string_append(&http->cmd, http->url);
+ string_append(request_line, http->url);
}
else
{
- string_append(&http->cmd, http->path);
+ string_append(request_line, http->path);
}
- string_append(&http->cmd, " ");
- string_append(&http->cmd, http->ver);
+ string_append(request_line, " ");
+ string_append(request_line, http->ver);
- if (http->cmd == NULL)
+ if (*request_line == NULL)
{
log_error(LOG_LEVEL_FATAL, "Out of memory writing HTTP command");
}
- log_error(LOG_LEVEL_HEADER, "New HTTP Request-Line: %s", http->cmd);
+ log_error(LOG_LEVEL_HEADER, "New HTTP Request-Line: %s", *request_line);
}
for (;;)
{
- len = read_socket(csp->cfd, buf, sizeof(buf)-1);
+ len = read_socket(csp->cfd, buf, sizeof(buf) - 1);
if (len <= 0) break; /* error! */
if (http->cmd == NULL)
{
- strcpy(buf, CHEADER);
- write_socket(csp->cfd, buf, strlen(buf));
+ write_socket(csp->cfd, CHEADER, strlen(CHEADER));
/* XXX: Use correct size */
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"Invalid request\" 400 0", csp->ip_addr_str);
log_error(LOG_LEVEL_ERROR, "Invalid header received from %s.", csp->ip_addr_str);
{
if ( ( ( p = get_header(csp) ) != NULL) && ( *p == '\0' ) )
{
- len = read_socket(csp->cfd, buf, sizeof(buf));
+ len = read_socket(csp->cfd, buf, sizeof(buf) - 1);
if (len <= 0)
{
log_error(LOG_LEVEL_ERROR, "read from client failed: %E");
}
}
- /* decide how to route the HTTP request */
+ /*
+ * Determine the actions for this URL
+ */
+#ifdef FEATURE_TOGGLE
+ if (!(csp->flags & CSP_FLAG_TOGGLED_ON))
+ {
+ /* Most compatible set of actions (i.e. none) */
+ init_current_action(csp->action);
+ }
+ else
+#endif /* ndef FEATURE_TOGGLE */
+ {
+ url_actions(http, csp);
+ }
+
+ /*
+ * Save a copy of the original request for logging
+ */
+ http->ocmd = strdup(http->cmd);
+
+ if (http->ocmd == NULL)
+ {
+ log_error(LOG_LEVEL_FATAL, "Out of memory copying HTTP request line");
+ }
+
+ enlist(csp->headers, http->cmd);
+
+ /* Append the previously read headers */
+ list_append_list_unique(csp->headers, headers);
+ destroy_list(headers);
+
+ /*
+ * If the user has not supplied any wafers, and the user has not
+ * told us to suppress the vanilla wafer, then send the vanilla wafer.
+ */
+ if (list_is_empty(csp->action->multi[ACTION_MULTI_WAFER])
+ && ((csp->action->flags & ACTION_VANILLA_WAFER) != 0))
+ {
+ enlist(csp->action->multi[ACTION_MULTI_WAFER], VANILLA_WAFER);
+ }
- if ((fwd = forward_url(http, csp)) == NULL)
+ if (JB_ERR_OK != sed(client_patterns, add_client_headers, csp))
+ {
+ log_error(LOG_LEVEL_FATAL, "Failed to parse client headers");
+ }
+ csp->flags |= CSP_FLAG_CLIENT_HEADER_PARSING_DONE;
+
+ /* decide how to route the HTTP request */
+ if (NULL == (fwd = forward_url(http, csp)))
{
log_error(LOG_LEVEL_FATAL, "gateway spec is NULL!?!? This can't happen!");
/* Never get here - LOG_LEVEL_FATAL causes program exit */
*
*/
- /*
- * Determine the actions for this URL
- */
-#ifdef FEATURE_TOGGLE
- if (!(csp->flags & CSP_FLAG_TOGGLED_ON))
- {
- /* Most compatible set of actions (i.e. none) */
- init_current_action(csp->action);
- }
- else
-#endif /* ndef FEATURE_TOGGLE */
- {
- url_actions(http, csp);
- }
-
-
/*
* Check if a CONNECT request is allowable:
* In the absence of a +limit-connect action, allow only port 443.
}
else
{
- strcpy(buf, CFORBIDDEN);
- write_socket(csp->cfd, buf, strlen(buf));
+ write_socket(csp->cfd, CFORBIDDEN, strlen(CFORBIDDEN));
log_error(LOG_LEVEL_CONNECT, "Denying suspicious CONNECT request from %s", csp->ip_addr_str);
log_error(LOG_LEVEL_CLF, "%s - - [%T] \" \" 403 0", csp->ip_addr_str);
+
+ list_remove_all(csp->headers);
+
return;
}
}
}
-
- /*
- * Save a copy of the original request for logging
- */
- http->ocmd = strdup(http->cmd);
-
- if (http->ocmd == NULL)
- {
- log_error(LOG_LEVEL_FATAL, "Out of memory copying HTTP request line");
- }
-
- /*
- * (Re)build the HTTP request for non-SSL requests.
- */
if (http->ssl == 0)
{
- build_request_line(csp, fwd);
+ freez(csp->headers->first->str);
+ build_request_line(csp, fwd, &csp->headers->first->str);
}
- enlist(csp->headers, http->cmd);
-
- /* Append the previously read headers */
- list_append_list_unique(csp->headers, headers);
- destroy_list(headers);
- /*
- * If the user has not supplied any wafers, and the user has not
- * told us to suppress the vanilla wafer, then send the vanilla wafer.
- */
- if (list_is_empty(csp->action->multi[ACTION_MULTI_WAFER])
- && ((csp->action->flags & ACTION_VANILLA_WAFER) != 0))
- {
- enlist(csp->action->multi[ACTION_MULTI_WAFER], VANILLA_WAFER);
- }
-
- hdr = sed(client_patterns, add_client_headers, csp);
+ hdr = list_to_text(csp->headers);
if (hdr == NULL)
{
/* FIXME Should handle error properly */
log_error(LOG_LEVEL_FATAL, "Out of memory parsing client header");
}
- csp->flags |= CSP_FLAG_CLIENT_HEADER_PARSING_DONE;
#ifdef FEATURE_KILL_POPUPS
block_popups = ((csp->action->flags & ACTION_NO_POPUPS) != 0);
/* Write the answer to the client */
- if(rsp != NULL)
+ if (rsp != NULL)
{
send_crunch_response(csp, rsp);
}
* so just send the "connect succeeded" message to the
* client, flush the rest, and get out of the way.
*/
- if (write_socket(csp->cfd, CSUCCEED, sizeof(CSUCCEED)-1))
+ if (write_socket(csp->cfd, CSUCCEED, strlen(CSUCCEED)))
{
freez(hdr);
return;
if (FD_ISSET(csp->cfd, &rfds))
{
- len = read_socket(csp->cfd, buf, sizeof(buf));
+ len = read_socket(csp->cfd, buf, sizeof(buf) - 1);
if (len <= 0)
{
csp->content_length = (size_t)(csp->iob->eod - csp->iob->cur);
}
- hdr = sed(server_patterns_light, NULL, csp);
+ if (JB_ERR_OK != sed(server_patterns_light, NULL, csp))
+ {
+ log_error(LOG_LEVEL_FATAL, "Failed to parse server headers.");
+ }
+ hdr = list_to_text(csp->headers);
if (hdr == NULL)
{
/* FIXME Should handle error properly */
int flushed;
log_error(LOG_LEVEL_ERROR, "Flushing header and buffers. Stepping back from filtering.");
-
- hdr = sed(server_patterns, add_server_headers, csp);
+ if (JB_ERR_OK != sed(server_patterns, add_server_headers, csp))
+ {
+ log_error(LOG_LEVEL_FATAL, "Failed to parse server headers.");
+ }
+ hdr = list_to_text(csp->headers);
if (hdr == NULL)
{
/*
{
log_error(LOG_LEVEL_ERROR, "Empty server or forwarder response.");
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 502 0", csp->ip_addr_str, http->cmd);
- strcpy(buf, NO_SERVER_DATA_RESPONSE);
- write_socket(csp->cfd, buf, strlen(buf));
+ write_socket(csp->cfd, NO_SERVER_DATA_RESPONSE, strlen(NO_SERVER_DATA_RESPONSE));
free_http_request(http);
return;
}
/* we have now received the entire header.
* filter it and send the result to the client
*/
-
- hdr = sed(server_patterns, add_server_headers, csp);
+ if (JB_ERR_OK != sed(server_patterns, add_server_headers, csp))
+ {
+ log_error(LOG_LEVEL_FATAL, "Failed to parse server headers.");
+ }
+ hdr = list_to_text(csp->headers);
if (hdr == NULL)
{
/* FIXME Should handle error properly */
void usage(const char *myname)
{
printf("Privoxy version " VERSION " (" HOME_PAGE_URL ")\n"
-#if !defined(unix)
- "Usage: %s [--help] [--version] [configfile]\n"
-#else
- "Usage: %s [--help] [--version] [--no-daemon] [--pidfile pidfile] [--user user[.group]] [configfile]\n"
-#endif
- "Aborting.\n", myname);
-
+ "Usage: %s "
+#if defined(unix)
+ "[--chroot] "
+#endif /* defined(unix) */
+ "[--help] "
+#if defined(unix)
+ "[--no-daemon] [--pidfile pidfile] [--user user[.group]] "
+#endif /* defined(unix) */
+ "[--version] [configfile]\n"
+ "Aborting\n", myname);
+
exit(2);
}
*
* For example older FreeBSD versions (< 6.x?)
* have no gethostbyname_r, but gethostbyname is
- * thead safe.
+ * thread safe.
+ */
+#if !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R)
+ if (!err) err = pthread_mutex_init(&resolver_mutex, 0);
+#endif /* !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R) */
+ /*
+ * XXX: should we use a single mutex for
+ * localtime() and gmtime() as well?
*/
#ifndef HAVE_GMTIME_R
if (!err) err = pthread_mutex_init(&gmtime_mutex, 0);
if (!err) err = pthread_mutex_init(&localtime_mutex, 0);
#endif /* ndef HAVE_GMTIME_R */
-#ifndef HAVE_GETHOSTBYADDR_R
- if (!err) err = pthread_mutex_init(&gethostbyaddr_mutex, 0);
-#endif /* ndef HAVE_GETHOSTBYADDR_R */
-
-#ifndef HAVE_GETHOSTBYNAME_R
- if (!err) err = pthread_mutex_init(&gethostbyname_mutex, 0);
-#endif /* ndef HAVE_GETHOSTBYNAME_R */
-
#ifndef HAVE_RANDOM
if (!err) err = pthread_mutex_init(&rand_mutex, 0);
#endif /* ndef HAVE_RANDOM */
/*
* Parse the command line arguments
+ *
+ * XXX: simply printing usage information in case of
+ * invalid arguments isn't particular user friendly.
*/
while (++argc_pos < argc)
{
{
do_chroot = 1;
}
-
#endif /* defined(unix) */
+
+ else if (argc_pos + 1 != argc)
+ {
+ /*
+ * This is neither the last command line
+ * option, nor was it recognized before,
+ * therefore it must be invalid.
+ */
+ usage(argv[0]);
+ }
+ else
+
#endif /* defined(_WIN32) && !defined(_WIN_CONSOLE) */
{
configfile = argv[argc_pos];
#if defined(unix)
if ( *configfile != '/' )
{
- char *abs_file, cwd[1024];
+ char cwd[BUFFER_SIZE];
+ char *abs_file;
+ size_t abs_file_size;
/* make config-filename absolute here */
- if ( !(getcwd(cwd, sizeof(cwd))))
+ if (NULL == getcwd(cwd, sizeof(cwd)))
{
- perror("get working dir failed");
+ perror("failed to get current working directory");
exit( 1 );
}
- if (!(basedir = strdup(cwd))
- || (!(abs_file = malloc( strlen( basedir ) + strlen( configfile ) + 5 ))))
+ /* XXX: why + 5? */
+ abs_file_size = strlen(cwd) + strlen(configfile) + 5;
+ basedir = strdup(cwd);
+
+ if (NULL == basedir ||
+ NULL == (abs_file = malloc(abs_file_size)))
{
perror("malloc failed");
exit( 1 );
}
- strcpy( abs_file, basedir );
- strcat( abs_file, "/" );
- strcat( abs_file, configfile );
+ strlcpy(abs_file, basedir, abs_file_size);
+ strlcat(abs_file, "/", abs_file_size );
+ strlcat(abs_file, configfile, abs_file_size);
configfile = abs_file;
}
#endif /* defined unix */
{
char putenv_dummy[64];
- strcpy(putenv_dummy, "HOME=/");
+ strlcpy(putenv_dummy, "HOME=/", sizeof(putenv_dummy));
if (putenv(putenv_dummy) != 0)
{
log_error(LOG_LEVEL_FATAL, "Cannot putenv(): HOME");
}
- snprintf(putenv_dummy, 64, "USER=%s", pw->pw_name);
+ snprintf(putenv_dummy, sizeof(putenv_dummy), "USER=%s", pw->pw_name);
if (putenv(putenv_dummy) != 0)
{
log_error(LOG_LEVEL_FATAL, "Cannot putenv(): USER");
projects / privoxy.git / blobdiff