-const char jcc_rcs[] = "$Id: jcc.c,v 1.20 2001/06/09 10:55:28 jongfoster Exp $";
+const char jcc_rcs[] = "$Id: jcc.c,v 1.34 2001/07/30 22:08:36 jongfoster Exp $";
/*********************************************************************
*
* File : $Source: /cvsroot/ijbswa/current/jcc.c,v $
*
* Revisions :
* $Log: jcc.c,v $
+ * Revision 1.34 2001/07/30 22:08:36 jongfoster
+ * Tidying up #defines:
+ * - All feature #defines are now of the form FEATURE_xxx
+ * - Permanently turned off WIN_GUI_EDIT
+ * - Permanently turned on WEBDAV and SPLIT_PROXY_ARGS
+ *
+ * Revision 1.33 2001/07/29 19:32:00 jongfoster
+ * Renaming _main() [mingw32 only] to real_main(), for ANSI compliance.
+ *
+ * Revision 1.32 2001/07/29 18:47:05 jongfoster
+ * Adding missing #include "loadcfg.h"
+ *
+ * Revision 1.31 2001/07/29 12:17:48 oes
+ * Applied pthread fix by Paul Lieverse
+ *
+ * Revision 1.30 2001/07/25 22:57:13 jongfoster
+ * __BEOS__ no longer overrides FEATURE_PTHREAD.
+ * This is because FEATURE_PTHREAD will soon be widely used, so I
+ * want to keep it simple.
+ *
+ * Revision 1.29 2001/07/24 12:47:06 oes
+ * Applied BeOS support update by Eugenia
+ *
+ * Revision 1.28 2001/07/23 13:26:12 oes
+ * Fixed bug in popup-killing for the first read that caused binary garbage to be sent between headers and body
+ *
+ * Revision 1.27 2001/07/19 19:09:47 haroon
+ * - Added code to take care of the situation where while processing the first
+ * server response (which includes the server header), after finding the end
+ * of the headers we were not looking past the end of the headers for
+ * content modification. I enabled it for filter_popups.
+ * Someone else should look to see if other similar operations should be
+ * done to the discarded portion of the buffer.
+ *
+ * Note 2001/07/20: No, the other content modification mechanisms will process
+ * the whole iob later anyway. --oes
+ *
+ * Revision 1.26 2001/07/18 12:31:36 oes
+ * cosmetics
+ *
+ * Revision 1.25 2001/07/15 19:43:49 jongfoster
+ * Supports POSIX threads.
+ * Also removed some unused #includes.
+ *
+ * Revision 1.24 2001/07/13 14:00:40 oes
+ * - Generic content modification scheme:
+ * Each feature has its own applicability flag that is set
+ * from csp->action->flags.
+ * Replaced the "filtering" int flag , by a function pointer
+ * "content_filter" to the function that will do the content
+ * modification. If it is != NULL, the document will be buffered
+ * and processed through *content_filter, which must set
+ * csp->content_length and return a modified copy of the body
+ * or return NULL (on failiure).
+ * - Changed csp->is_text to the more generic bitmap csp->content_type
+ * which can currently take the valued CT_TEXT or CT_GIF
+ * - Reformatting etc
+ * - Removed all #ifdef PCRS
+ *
+ * Revision 1.23 2001/07/02 02:28:25 iwanttokeepanon
+ * Added "#ifdef ACL_FILES" conditional compilation to line 1291 to exclude
+ * the `block_acl' call. This prevents a compilation error when the user
+ * does not wish to use the "ACL" feature.
+ *
+ * Revision 1.22 2001/06/29 21:45:41 oes
+ * Indentation, CRLF->LF, Tab-> Space
+ *
+ * Revision 1.21 2001/06/29 13:29:36 oes
+ * - Cleaned up, improved comments
+ * - Unified all possible interceptors (CGI,
+ * block, trust, fast_redirect) in one
+ * place, with one (CGI) answer generation
+ * mechansim. Much clearer now.
+ * - Removed the GIF image generation, which
+ * is now done in filters.c:block_url()
+ * - Made error conditions like domain lookup
+ * failiure or (various) problems while talking
+ * to the server use cgi.c:error_response()
+ * instead of generating HTML/HTTP in chat() (yuck!)
+ * - Removed logentry from cancelled commit
+ *
* Revision 1.20 2001/06/09 10:55:28 jongfoster
* Changing BUFSIZ ==> BUFFER_SIZE
*
#include <fcntl.h>
#include <errno.h>
-#ifdef _WIN32
+#ifdef FEATURE_PTHREAD
+#include <pthread.h>
+#endif /* def FEATURE_PTHREAD */
-# include <sys/timeb.h>
-# include <windows.h>
-# include <io.h>
-# include <process.h>
-# ifdef TOGGLE
-# include <time.h>
-# endif /* def TOGGLE */
+#ifdef _WIN32
+# ifndef FEATURE_PTHREAD
+# include <windows.h>
+# include <process.h>
+# endif /* ndef FEATURE_PTHREAD */
# include "win32.h"
# ifndef _WIN_CONSOLE
#include "gateway.h"
#include "actions.h"
#include "cgi.h"
+#include "loadcfg.h"
const char jcc_h_rcs[] = JCC_H_VERSION;
const char project_h_rcs[] = PROJECT_H_VERSION;
struct client_state clients[1];
struct file_list files[1];
-#ifdef STATISTICS
+#ifdef FEATURE_STATISTICS
int urls_read = 0; /* total nr of urls read inc rejected */
int urls_rejected = 0; /* total nr of urls rejected */
-#endif /* def STATISTICS */
+#endif /* def FEATURE_STATISTICS */
static void listen_loop(void);
static void chat(struct client_state *csp)
{
/*
- * This next lines are a little ugly, but they simplifies the if statements below.
- * Basically if TOGGLE, then we want the if to test "csp->toggled_on", else we don't
- * And if FORCE_LOAD, then we want the if to test "csp->toggled_on", else we don't
+ * This next lines are a little ugly, but they simplifies the if statements
+ * below. Basically if TOGGLE, then we want the if to test "csp->toggled_on",
+ * else we don't. And if FEATURE_FORCE_LOAD, then we want the if to test
+ * "csp->toggled_on", else we don't
*/
-#ifdef TOGGLE
+#ifdef FEATURE_TOGGLE
# define IS_TOGGLED_ON_AND (csp->toggled_on) &&
-#else /* ifndef TOGGLE */
+#else /* ifndef FEATURE_TOGGLE */
# define IS_TOGGLED_ON_AND
-#endif /* ndef TOGGLE */
-#ifdef FORCE_LOAD
+#endif /* ndef FEATURE_TOGGLE */
+#ifdef FEATURE_FORCE_LOAD
# define IS_NOT_FORCED_AND (!csp->force) &&
-#else /* ifndef FORCE_LOAD */
+#else /* ifndef FEATURE_FORCE_LOAD */
# define IS_NOT_FORCED_AND
-#endif /* def FORCE_LOAD */
+#endif /* def FEATURE_FORCE_LOAD */
#define IS_ENABLED_AND IS_TOGGLED_ON_AND IS_NOT_FORCED_AND
- char buf[BUFFER_SIZE];\r
+ char buf[BUFFER_SIZE];
char *hdr, *p, *req;
char *err = NULL;
fd_set rfds;
int byte_count = 0;
const struct forward_spec * fwd;
struct http_request *http;
-#ifdef KILLPOPUPS
+#ifdef FEATURE_KILL_POPUPS
int block_popups; /* bool, 1==will block popups */
int block_popups_now = 0; /* bool, 1==currently blocking popups */
-#endif /* def KILLPOPUPS */
-#ifdef PCRS
- int pcrs_filter; /* bool, 1==will filter through pcrs */
- int filtering = 0; /* bool, 1==currently filtering through pcrs */
-#endif /* def PCRS */
+#endif /* def FEATURE_KILL_POPUPS */
+
+ int pcrs_filter; /* bool, 1==will filter through pcrs */
+ int gif_deanimate; /* bool, 1==will deanimate gifs */
+
+ /* Function that does the content filtering for the current request */
+ char *(*content_filter)() = NULL;
+
+ /* Skeleton for HTTP response, if we should intercept the request */
struct http_response *rsp;
http = csp->http;
continue; /* more to come! */
}
-#ifdef FORCE_LOAD
+#ifdef FEATURE_FORCE_LOAD
/* If this request contains the FORCE_PREFIX,
* better get rid of it now and set the force flag --oes
*/
{
csp->force = 0;
}
-#endif /* def FORCE_LOAD */
+#endif /* def FEATURE_FORCE_LOAD */
parse_http_request(req, http, csp);
freez(req);
/* decide what we're to do with cookies */
-#ifdef TOGGLE
+#ifdef FEATURE_TOGGLE
if (!csp->toggled_on)
{
/* Most compatible set of actions (i.e. none) */
init_current_action(csp->action);
}
else
-#endif /* ndef TOGGLE */
+#endif /* ndef FEATURE_TOGGLE */
{
url_actions(http, csp);
}
-#ifdef JAR_FILES
+#ifdef FEATURE_COOKIE_JAR
/*
* If we're logging cookies in a cookie jar, and the user has not
* supplied any wafers, and the user has not told us to suppress the
{
enlist(csp->action->multi[ACTION_MULTI_WAFER], VANILLA_WAFER);
}
-#endif /* def JAR_FILES */
+#endif /* def FEATURE_COOKIE_JAR */
-#ifdef KILLPOPUPS
+#ifdef FEATURE_KILL_POPUPS
block_popups = ((csp->action->flags & ACTION_NO_POPUPS) != 0);
-#endif /* def KILLPOPUPS */
-#ifdef PCRS
+#endif /* def FEATURE_KILL_POPUPS */
+
pcrs_filter = (csp->rlist != NULL) && /* There are expressions to be used */
((csp->action->flags & ACTION_FILTER) != 0);
-#endif /* def PCRS */
+ gif_deanimate = ((csp->action->flags & ACTION_DEANIMATE) != 0);
/* grab the rest of the client's headers */
if (
/* a CGI call was detected and answered */
- (NULL != (rsp = dispatch_cgi(csp)))
+ (NULL != (rsp = dispatch_cgi(csp)))
/* or we are enabled and... */
|| (IS_ENABLED_AND (
- /* ..the request was blocked */
- ( NULL != (rsp = block_url(csp)))
+ /* ..the request was blocked */
+ ( NULL != (rsp = block_url(csp)))
/* ..or untrusted */
-#ifdef TRUST_FILES
+#ifdef FEATURE_TRUST
|| ( NULL != (rsp = trust_url(csp)))
-#endif
+#endif /* def FEATURE_TRUST */
/* ..or a fast redirect kicked in */
-#ifdef FAST_REDIRECTS
+#ifdef FEATURE_FAST_REDIRECTS
|| (((csp->action->flags & ACTION_FAST_REDIRECTS) != 0) &&
- (NULL != (rsp = redirect_url(csp))))
-#endif /* def FAST_REDIRECTS */
- ))
- )
+ (NULL != (rsp = redirect_url(csp))))
+#endif /* def FEATURE_FAST_REDIRECTS */
+ ))
+ )
{
- /* Write the answer to the client */
+ /* Write the answer to the client */
if ((write_socket(csp->cfd, rsp->head, rsp->head_length) != rsp->head_length)
- || (write_socket(csp->cfd, rsp->body, rsp->content_length) != rsp->content_length))
+ || (write_socket(csp->cfd, rsp->body, rsp->content_length) != rsp->content_length))
{
log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
- }
+ }
-#ifdef STATISTICS
+#ifdef FEATURE_STATISTICS
/* Count as a rejected request */
csp->rejected = 1;
-#endif /* def STATISTICS */
+#endif /* def FEATURE_STATISTICS */
/* Log (FIXME: All intercept reasons apprear as "crunch" with Status 200) */
log_error(LOG_LEVEL_GPC, "%s%s crunch!", http->hostport, http->path);
if (errno == EINVAL)
{
- rsp = error_response(csp, "no-such-domain", errno);
+ rsp = error_response(csp, "no-such-domain", errno);
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 404 0",
csp->ip_addr_str, http->cmd);
}
else
{
- rsp = error_response(csp, "connect-failed", errno);
+ rsp = error_response(csp, "connect-failed", errno);
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 503 0",
csp->ip_addr_str, http->cmd);
}
- /* Write the answer to the client */
+ /* Write the answer to the client */
if(rsp)
- {
+ {
if ((write_socket(csp->cfd, rsp->head, rsp->head_length) != rsp->head_length)
- || (write_socket(csp->cfd, rsp->body, rsp->content_length) != rsp->content_length))
+ || (write_socket(csp->cfd, rsp->body, rsp->content_length) != rsp->content_length))
{
log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
- }
- }
+ }
+ }
free_http_response(rsp);
freez(hdr);
rsp = error_response(csp, "connect-failed", errno);
- if(rsp)
+ if(rsp)
{
if ((write_socket(csp->cfd, rsp->head, n) != n)
- || (write_socket(csp->cfd, rsp->body, rsp->content_length) != rsp->content_length))
+ || (write_socket(csp->cfd, rsp->body, rsp->content_length) != rsp->content_length))
{
log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
- }
- }
+ }
+ }
free_http_response(rsp);
freez(hdr);
/*
* The server wants to talk. It could be the header or the body.
* If `hdr' is null, then it's the header otherwise it's the body.
- * FIXME: Does `hdr' really mean `host'?
+ * FIXME: Does `hdr' really mean `host'? No.
*/
rsp = error_response(csp, "connect-failed", errno);
- if(rsp)
+ if(rsp)
{
if ((write_socket(csp->cfd, rsp->head, rsp->head_length) != rsp->head_length)
- || (write_socket(csp->cfd, rsp->body, rsp->content_length) != rsp->content_length))
+ || (write_socket(csp->cfd, rsp->body, rsp->content_length) != rsp->content_length))
{
log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
- }
- }
+ }
+ }
free_http_response(rsp);
return;
*/
buf[n] = '\0';
-#ifdef KILLPOPUPS
+#ifdef FEATURE_KILL_POPUPS
/* Filter the popups on this read. */
if (block_popups_now)
{
- filter_popups(buf, n);
+ filter_popups(buf);
}
-#endif /* def KILLPOPUPS */
+#endif /* def FEATURE_KILL_POPUPS */
/* Normally, this would indicate that we've read
* as much as the server has sent us and we can
*/
if (n == 0)
{
- /* This hack must only be enforced for headers. */
+
if (server_body || http->ssl)
{
-#ifdef PCRS
- if (filtering)
+ /*
+ * If we have been buffering up the document,
+ * now is the time to apply content modification
+ * and send the result to the client.
+ */
+ if (content_filter)
{
- p = re_process_buffer(csp);
+ /*
+ * If the content filter fails, use the original
+ * buffer and length.
+ * (see p != NULL ? p : csp->iob->cur below)
+ */
+ if (NULL == (p = (*content_filter)(csp)))
+ {
+ csp->content_length = csp->iob->eod - csp->iob->cur;
+ }
+
hdr = sed(server_patterns, add_server_headers, csp);
n = strlen(hdr);
+
if ((write_socket(csp->cfd, hdr, n) != n)
- || (write_socket(csp->cfd, p, csp->content_length) != csp->content_length))
+ || (write_socket(csp->cfd, p != NULL ? p : csp->iob->cur, csp->content_length) != csp->content_length))
{
log_error(LOG_LEVEL_CONNECT, "write modified content to client failed: %E");
return;
}
- freez(hdr);
- freez(p);
+
+ freez(hdr);
+ freez(p);
}
-#endif /* def PCRS */
+
break; /* "game over, man" */
}
- /* Let's pretend the server just sent us a blank line. */
+ /*
+ * This is NOT the body, so
+ * Let's pretend the server just sent us a blank line.
+ */
n = sprintf(buf, "\r\n");
/*
/*
* If this is an SSL connection or we're in the body
- * of the server document, just write it to the client.
+ * of the server document, just write it to the client,
+ * unless we need to buffer the body for later content-filtering
*/
if (server_body || http->ssl)
{
-#ifdef PCRS
- if (filtering)
+ if (content_filter)
{
- add_to_iob(csp, buf, n); /* Buffer the body for filtering */
+ add_to_iob(csp, buf, n);
}
else
-#endif /* def PCRS */
{
- /* just write */
if (write_socket(csp->cfd, buf, n) != n)
{
log_error(LOG_LEVEL_ERROR, "write to client failed: %E");
* may be in the buffer)
*/
-#ifdef KILLPOPUPS
+#ifdef FEATURE_KILL_POPUPS
/* Start blocking popups if appropriate. */
- if (csp->is_text && /* It's a text / * MIME-Type */
- !http->ssl && /* We talk plaintext */
- block_popups) /* Policy allows */
+ if ((csp->content_type & CT_TEXT) && /* It's a text / * MIME-Type */
+ !http->ssl && /* We talk plaintext */
+ block_popups) /* Policy allows */
{
block_popups_now = 1;
+ /*
+ * Filter the part of the body that came in the same read
+ * as the last headers:
+ */
+ filter_popups(csp->iob->cur);
}
-#endif /* def KILLPOPUPS */
+#endif /* def FEATURE_KILL_POPUPS */
-#ifdef PCRS
- /* Start re_filtering this if appropriate. */
+ /* Buffer and pcrs filter this if appropriate. */
- if (csp->is_text && /* It's a text / * MIME-Type */
- !http->ssl && /* We talk plaintext */
- pcrs_filter) /* Policy allows */
+ if ((csp->content_type & CT_TEXT) && /* It's a text / * MIME-Type */
+ !http->ssl && /* We talk plaintext */
+ pcrs_filter) /* Policy allows */
{
- filtering = 1;
+ content_filter = pcrs_filter_response;
}
-/* This next line is a little ugly, but it simplifies the if statement below. */
-/* Basically if using PCRS, we want the OR condition to require "!filtering" */
-#define NOT_FILTERING_AND !filtering &&
-
-#else /* not def PCRS */
+ /* Buffer and gif_deanimate this if appropriate. */
-#define NOT_FILTERING_AND
+ if ((csp->content_type & CT_GIF) && /* It's a image/gif MIME-Type */
+ !http->ssl && /* We talk plaintext */
+ gif_deanimate) /* Policy allows */
+ {
+ content_filter = gif_deanimate_response;
+ }
-#endif /* def PCRS */
- if (NOT_FILTERING_AND ((write_socket(csp->cfd, hdr, n) != n)
+ /*
+ * Only write if we're not buffering for content modification
+ */
+ if (!content_filter && ((write_socket(csp->cfd, hdr, n) != n)
|| (n = flush_socket(csp->cfd, csp) < 0)))
{
log_error(LOG_LEVEL_CONNECT, "write header to client failed: %E");
return;
}
- NOT_FILTERING_AND (byte_count += n);
+ !content_filter && (byte_count += n);
/* we're finished with the server's header */
#ifdef __BEOS__
-
/*********************************************************************
*
* Function : server_thread
return 0;
}
-
#endif
*
*********************************************************************/
#ifdef __MINGW32__
-int _main(int argc, const char *argv[])
+int real_main(int argc, const char *argv[])
#else
int main(int argc, const char *argv[])
#endif
while (FOREVER)
{
-#if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA)
+#if !defined(FEATURE_PTHREAD) && !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA)
while (waitpid(-1, NULL, WNOHANG) > 0)
{
/* zombie children */
}
-#endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) */
+#endif /* !defined(FEATURE_PTHREAD) && !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) */
sweep();
if ( NULL == (csp = (struct client_state *) zalloc(sizeof(*csp))) )
log_error(LOG_LEVEL_CONNECT, "OK");
}
-#if defined(TOGGLE)
+#ifdef FEATURE_TOGGLE
/* by haroon - most of credit to srt19170 */
csp->toggled_on = g_bToggleIJB;
-#endif
+#endif /* def FEATURE_TOGGLE */
if (run_loader(csp))
{
/* Never get here - LOG_LEVEL_FATAL causes program exit */
}
+#ifdef FEATURE_ACL
if (block_acl(NULL,csp))
{
log_error(LOG_LEVEL_CONNECT, "Connection dropped due to ACL");
freez(csp);
continue;
}
+#endif /* def FEATURE_ACL */
/* add it to the list of clients */
csp->next = clients->next;
/* this is a switch () statment in the C preprocessor - ugh */
#undef SELECTED_ONE_OPTION
+/* Use Pthreads in preference to native code */
+#if defined(FEATURE_PTHREAD) && !defined(SELECTED_ONE_OPTION)
+#define SELECTED_ONE_OPTION
+ {
+ pthread_t the_thread;
+ pthread_attr_t attrs;
+
+ pthread_attr_init(&attrs);
+ pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED);
+ child_id = (pthread_create(&the_thread, &attrs,
+ (void*)serve, csp) ? -1 : 0);
+ pthread_attr_destroy(&attrs);
+ }
+#endif
+
#if defined(_WIN32) && !defined(_CYGWIN) && !defined(SELECTED_ONE_OPTION)
#define SELECTED_ONE_OPTION
child_id = _beginthread(
#if !defined(SELECTED_ONE_OPTION)
child_id = fork();
-#endif
-
-#undef SELECTED_ONE_OPTION
-/* end of cpp switch () */
-
- if (child_id < 0) /* failed */
- {
- char buf[BUFFER_SIZE];
-
- log_error(LOG_LEVEL_ERROR, "can't fork: %E");
-
- sprintf(buf , "JunkBuster: can't fork: errno = %d", errno);
-
- write_socket(csp->cfd, buf, strlen(buf));
- close_socket(csp->cfd);
- csp->active = 0;
- sleep(5);
- continue;
- }
-#if !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA)
/* This block is only needed when using fork().
* When using threads, the server thread was
* created and run by the call to _beginthread().
_exit(0);
}
- else /* parent */
+ else if (child_id > 0) /* parent */
{
/* in a fork()'d environment, the parent's
* copy of the client socket and the CSP
close_socket(csp->cfd);
csp->active = 0;
}
-#endif /* !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) */
+#endif
+
+#undef SELECTED_ONE_OPTION
+/* end of cpp switch () */
+
+ if (child_id < 0) /* failed */
+ {
+ char buf[BUFFER_SIZE];
+
+ log_error(LOG_LEVEL_ERROR, "can't fork: %E");
+
+ sprintf(buf , "JunkBuster: can't fork: errno = %d", errno);
+
+ write_socket(csp->cfd, buf, strlen(buf));
+ close_socket(csp->cfd);
+ csp->active = 0;
+ sleep(5);
+ continue;
+ }
}
else
{