-const char jcc_rcs[] = "$Id: jcc.c,v 1.51 2001/10/26 17:38:28 oes Exp $";
+const char jcc_rcs[] = "$Id: jcc.c,v 1.80 2002/03/11 22:07:05 david__schmidt Exp $";
/*********************************************************************
*
* File : $Source: /cvsroot/ijbswa/current/jcc.c,v $
*
* Revisions :
* $Log: jcc.c,v $
+ * Revision 1.80 2002/03/11 22:07:05 david__schmidt
+ * OS/2 port maintenance:
+ * - Fixed EMX build - it had decayed a little
+ * - Fixed inexplicable crash during FD_ZERO - must be due to a bad macro.
+ * substituted a memset for now.
+ *
+ * Revision 1.79 2002/03/09 20:03:52 jongfoster
+ * - Making various functions return int rather than size_t.
+ * (Undoing a recent change). Since size_t is unsigned on
+ * Windows, functions like read_socket that return -1 on
+ * error cannot return a size_t.
+ *
+ * THIS WAS A MAJOR BUG - it caused frequent, unpredictable
+ * crashes, and also frequently caused JB to jump to 100%
+ * CPU and stay there. (Because it thought it had just
+ * read ((unsigned)-1) == 4Gb of data...)
+ *
+ * - The signature of write_socket has changed, it now simply
+ * returns success=0/failure=nonzero.
+ *
+ * - Trying to get rid of a few warnings --with-debug on
+ * Windows, I've introduced a new type "jb_socket". This is
+ * used for the socket file descriptors. On Windows, this
+ * is SOCKET (a typedef for unsigned). Everywhere else, it's
+ * an int. The error value can't be -1 any more, so it's
+ * now JB_INVALID_SOCKET (which is -1 on UNIX, and in
+ * Windows it maps to the #define INVALID_SOCKET.)
+ *
+ * - The signature of bind_port has changed.
+ *
+ * Revision 1.78 2002/03/08 21:35:04 oes
+ * Added optional group supplement to --user option. Will now use default group of user if no group given
+ *
+ * Revision 1.77 2002/03/07 03:52:06 oes
+ * - Fixed compiler warnings etc
+ * - Improved handling of failed DNS lookups
+ *
+ * Revision 1.76 2002/03/06 22:54:35 jongfoster
+ * Automated function-comment nitpicking.
+ *
+ * Revision 1.75 2002/03/06 10:02:19 oes
+ * Fixed stupid bug when --user was not given
+ *
+ * Revision 1.74 2002/03/06 00:49:31 jongfoster
+ * Fixing warning on Windows
+ * Making #ifdefs that refer to the same variable consistently
+ * use #ifdef unix rather than mixing #ifdef unix & #ifndef OS2
+ *
+ * Revision 1.73 2002/03/05 23:57:30 hal9
+ * Stray character 's' on line 1618 was breaking build.
+ *
+ * Revision 1.72 2002/03/05 21:33:45 david__schmidt
+ * - Re-enable OS/2 building after new parms were added
+ * - Fix false out of memory report when resolving CGI templates when no IP
+ * address is available of failed attempt (a la no such domain)
+ *
+ * Revision 1.71 2002/03/05 18:13:56 oes
+ * Added --user option
+ *
+ * Revision 1.70 2002/03/05 04:52:42 oes
+ * Deleted non-errlog debugging code
+ *
+ * Revision 1.69 2002/03/04 23:50:00 jongfoster
+ * Splitting off bind_port() call into bind_port_helper(), with
+ * improved logging.
+ *
+ * Revision 1.68 2002/03/04 20:17:32 oes
+ * Fixed usage info
+ *
+ * Revision 1.67 2002/03/04 18:18:57 oes
+ * - Removed _DEBUG mode
+ * - Cleand up cmdline parsing
+ * - Introduced --no-daemon, --pidfile options
+ * - Cleaned up signal handling:
+ * - Terminate cleanly on INT, TERM and ABRT
+ * - Schedule logfile for re-opening on HUP
+ * - Ignore CHLD and PIPE
+ * - Leave the rest with their default handlers
+ * - Uniform handler registration
+ * - Added usage() function
+ * - Played styleguide police
+ *
+ * Revision 1.66 2002/03/03 15:06:55 oes
+ * Re-enabled automatic config reloading
+ *
+ * Revision 1.65 2002/03/03 14:49:11 oes
+ * Fixed CLF logging: Now uses client's original HTTP request
+ *
+ * Revision 1.64 2002/03/03 09:18:03 joergs
+ * Made jumbjuster work on AmigaOS again.
+ *
+ * Revision 1.63 2002/03/02 04:14:50 david__schmidt
+ * Clean up a little CRLF unpleasantness that suddenly appeared
+ *
+ * Revision 1.62 2002/02/20 23:17:23 jongfoster
+ * Detecting some out-of memory conditions and exiting with a log message.
+ *
+ * Revision 1.61 2002/01/17 21:01:52 jongfoster
+ * Moving all our URL and URL pattern parsing code to urlmatch.c.
+ *
+ * Revision 1.60 2001/12/30 14:07:32 steudten
+ * - Add signal handling (unix)
+ * - Add SIGHUP handler (unix)
+ * - Add creation of pidfile (unix)
+ * - Add action 'top' in rc file (RH)
+ * - Add entry 'SIGNALS' to manpage
+ * - Add exit message to logfile (unix)
+ *
+ * Revision 1.59 2001/12/13 14:07:18 oes
+ * Fixed Bug: 503 error page now sent OK
+ *
+ * Revision 1.58 2001/11/30 23:37:24 jongfoster
+ * Renaming the Win32 config file to config.txt - this is almost the
+ * same as the corresponding UNIX name "config"
+ *
+ * Revision 1.57 2001/11/16 00:47:43 jongfoster
+ * Changing the tty-disconnection code to use setsid().
+ *
+ * Revision 1.56 2001/11/13 20:20:54 jongfoster
+ * Tabs->spaces, fixing a bug with missing {} around an if()
+ *
+ * Revision 1.55 2001/11/13 20:14:53 jongfoster
+ * Patch for FreeBSD setpgrp() as suggested by Alexander Lazic
+ *
+ * Revision 1.54 2001/11/07 00:03:14 steudten
+ * Give reliable return value if an error
+ * occurs not just 0 with new daemon mode.
+ *
+ * Revision 1.53 2001/11/05 21:41:43 steudten
+ * Add changes to be a real daemon just for unix os.
+ * (change cwd to /, detach from controlling tty, set
+ * process group and session leader to the own process.
+ * Add DBG() Macro.
+ * Add some fatal-error log message for failed malloc().
+ * Add '-d' if compiled with 'configure --with-debug' to
+ * enable debug output.
+ *
+ * Revision 1.52 2001/10/26 20:11:20 jongfoster
+ * Fixing type mismatch
+ *
* Revision 1.51 2001/10/26 17:38:28 oes
* Cosmetics
*
# endif /* ndef __OS2__ */
# include <sys/time.h>
# include <sys/stat.h>
+# include <sys/ioctl.h>
+
+#ifdef sun
+#include <sys/termios.h>
+#endif /* sun */
+
+#ifdef unix
+#include <pwd.h>
+#include <grp.h>
+#endif
+
# include <signal.h>
# ifdef __BEOS__
#include "actions.h"
#include "cgi.h"
#include "loadcfg.h"
+#include "urlmatch.h"
const char jcc_h_rcs[] = JCC_H_VERSION;
const char project_h_rcs[] = PROJECT_H_VERSION;
+int no_daemon = 0;
struct client_state clients[1];
struct file_list files[1];
#define sleep(N) DosSleep(((N) * 100))
#endif
+#if defined(unix) || defined(__EMX__)
+const char *basedir;
+const char *pidfile = NULL;
+int received_hup_signal = 0;
+#endif /* defined unix */
/* The vanilla wafer. */
static const char VANILLA_WAFER[] =
"(copyright_or_otherwise)_applying_to_any_cookie._";
+#if !defined(_WIN32) && !defined(__OS2__) && !defined(AMIGA)
+/*********************************************************************
+ *
+ * Function : sig_handler
+ *
+ * Description : Signal handler for different signals.
+ * Exit gracefully on ABRT, TERM and INT
+ * or set a flag that will cause the errlog
+ * to be reopened by the main thread on HUP.
+ *
+ * Parameters :
+ * 1 : the_signal = the signal cause this function to call
+ *
+ * Returns : -
+ *
+ *********************************************************************/
+static void sig_handler(int the_signal)
+{
+ switch(the_signal)
+ {
+ case SIGABRT:
+ case SIGTERM:
+ case SIGINT:
+ log_error(LOG_LEVEL_INFO, "exiting by signal %d .. bye", the_signal);
+#if defined(unix)
+ unlink(pidfile);
+#endif /* unix */
+ exit(the_signal);
+ break;
+
+ case SIGHUP:
+ received_hup_signal = 1;
+ break;
+
+ default:
+ /*
+ * We shouldn't be here, unless we catch signals
+ * in main() that we can't handle here!
+ */
+ log_error(LOG_LEVEL_FATAL, "sig_handler: exiting on unexpected signal %d", the_signal);
+ }
+ return;
+
+}
+#endif
+
+
/*********************************************************************
*
* Function : chat
#define IS_ENABLED_AND IS_TOGGLED_ON_AND IS_NOT_FORCED_AND
char buf[BUFFER_SIZE];
- char *hdr, *p, *req;
+ char *hdr;
+ char *p;
+ char *req;
fd_set rfds;
- int n, maxfd, server_body;
+ int n;
+ jb_socket maxfd;
+ int server_body;
int ms_iis5_hack = 0;
int byte_count = 0;
const struct forward_spec * fwd;
struct http_request *http;
+ int len; /* for buffer sizes */
#ifdef FEATURE_KILL_POPUPS
int block_popups; /* bool, 1==will block popups */
int block_popups_now = 0; /* bool, 1==currently blocking popups */
while (FOREVER)
{
- n = read_socket(csp->cfd, buf, sizeof(buf));
+ len = read_socket(csp->cfd, buf, sizeof(buf));
- if (n <= 0) break; /* error! */
+ if (len <= 0) break; /* error! */
- add_to_iob(csp, buf, n);
+ add_to_iob(csp, buf, len);
req = get_header(csp);
* Downgrade http version from 1.1 to 1.0 if +downgrade
* action applies
*/
- if (!strcmpic(http->ver, "HTTP/1.1") && csp->action->flags & ACTION_DOWNGRADE)
+ if ( (http->ssl == 0)
+ && (!strcmpic(http->ver, "HTTP/1.1"))
+ && (csp->action->flags & ACTION_DOWNGRADE))
{
freez(http->ver);
http->ver = strdup("HTTP/1.0");
+
+ if (http->ver == NULL)
+ {
+ log_error(LOG_LEVEL_FATAL, "Out of memory downgrading HTTP version");
+ }
+ }
+
+ /*
+ * 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");
}
/*
{
freez(http->cmd);
- http->cmd = strsav(http->cmd, http->gpc);
- http->cmd = strsav(http->cmd, " ");
+ http->cmd = strdup(http->gpc);
+ string_append(&http->cmd, " ");
if (fwd->forward_host)
{
- http->cmd = strsav(http->cmd, http->url);
+ string_append(&http->cmd, http->url);
}
else
{
- http->cmd = strsav(http->cmd, http->path);
+ string_append(&http->cmd, http->path);
}
- http->cmd = strsav(http->cmd, " ");
- http->cmd = strsav(http->cmd, http->ver);
+ string_append(&http->cmd, " ");
+ string_append(&http->cmd, http->ver);
+ if (http->cmd == NULL)
+ {
+ log_error(LOG_LEVEL_FATAL, "Out of memory rewiting SSL command");
+ }
}
enlist(csp->headers, http->cmd);
#endif /* def FEATURE_KILL_POPUPS */
pcrs_filter = (csp->rlist != NULL) && /* There are expressions to be used */
- ((csp->action->flags & ACTION_FILTER) != 0);
+ (!list_is_empty(csp->action->multi[ACTION_MULTI_FILTER]));
gif_deanimate = ((csp->action->flags & ACTION_DEANIMATE) != 0);
{
if ( ( p = get_header(csp) ) && ( *p == '\0' ) )
{
- n = read_socket(csp->cfd, buf, sizeof(buf));
- if (n <= 0)
+ len = read_socket(csp->cfd, buf, sizeof(buf));
+ if (len <= 0)
{
log_error(LOG_LEVEL_ERROR, "read from client failed: %E");
return;
}
- add_to_iob(csp, buf, n);
+ add_to_iob(csp, buf, len);
continue;
}
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)))
+ ( NULL != (rsp = block_url(csp)))
/* ..or untrusted */
#ifdef FEATURE_TRUST
/* ..or a fast redirect kicked in */
#ifdef FEATURE_FAST_REDIRECTS
|| (((csp->action->flags & ACTION_FAST_REDIRECTS) != 0) &&
- (NULL != (rsp = redirect_url(csp))))
+ (NULL != (rsp = redirect_url(csp))))
#endif /* def FEATURE_FAST_REDIRECTS */
- ))
- )
+ ))
+ )
{
/* 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))
+ if (write_socket(csp->cfd, rsp->head, rsp->head_length)
+ || write_socket(csp->cfd, rsp->body, rsp->content_length))
{
log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
}
/* Log (FIXME: All intercept reasons apprear as "crunch" with Status 200) */
log_error(LOG_LEVEL_GPC, "%s%s crunch!", http->hostport, http->path);
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 3", csp->ip_addr_str, http->cmd);
+ log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 3", csp->ip_addr_str, http->ocmd);
/* Clean up and return */
free_http_response(rsp);
csp->sfd = forwarded_connect(fwd, http, csp);
- if (csp->sfd < 0)
+ if (csp->sfd == JB_INVALID_SOCKET)
{
log_error(LOG_LEVEL_CONNECT, "connect to: %s failed: %E",
http->hostport);
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);
+ csp->ip_addr_str, http->ocmd);
}
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);
+ csp->ip_addr_str, http->ocmd);
}
+
/* 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))
+ {
+ if (write_socket(csp->cfd, rsp->head, rsp->head_length)
+ || write_socket(csp->cfd, rsp->body, rsp->content_length))
{
log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
}
log_error(LOG_LEVEL_CONNECT, "OK");
hdr = sed(client_patterns, add_client_headers, csp);
+ if (hdr == NULL)
+ {
+ /* FIXME Should handle error properly */
+ log_error(LOG_LEVEL_FATAL, "Out of memory parsing client header");
+ }
+
list_remove_all(csp->headers);
if (fwd->forward_host || (http->ssl == 0))
* (along with anything else that may be in the buffer)
*/
- n = strlen(hdr);
-
- if ((write_socket(csp->sfd, hdr, n) != n)
- || (flush_socket(csp->sfd, csp ) < 0))
+ if (write_socket(csp->sfd, hdr, strlen(hdr))
+ || (flush_socket(csp->sfd, csp) < 0))
{
log_error(LOG_LEVEL_CONNECT, "write header to: %s failed: %E",
http->hostport);
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 503 0",
- csp->ip_addr_str, http->cmd);
+ csp->ip_addr_str, http->ocmd);
rsp = error_response(csp, "connect-failed", errno);
if(rsp)
{
- if ((write_socket(csp->cfd, rsp->head, n) != n)
- || (write_socket(csp->cfd, rsp->body, rsp->content_length) != rsp->content_length))
+ if (write_socket(csp->cfd, rsp->head, rsp->head_length)
+ || write_socket(csp->cfd, rsp->body, rsp->content_length))
{
log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
}
* client, flush the rest, and get out of the way.
*/
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 2\n",
- csp->ip_addr_str, http->cmd);
+ csp->ip_addr_str, http->ocmd);
- if (write_socket(csp->cfd, CSUCCEED, sizeof(CSUCCEED)-1) < 0)
+ if (write_socket(csp->cfd, CSUCCEED, sizeof(CSUCCEED)-1))
{
freez(hdr);
return;
while (FOREVER)
{
+#ifdef __OS2__
+ /*
+ * FD_ZERO here seems to point to an errant macro which crashes.
+ * So do this by hand for now...
+ */
+ memset(&rfds,0x00,sizeof(fd_set));
+#else
FD_ZERO(&rfds);
-
+#endif
FD_SET(csp->cfd, &rfds);
FD_SET(csp->sfd, &rfds);
if (FD_ISSET(csp->cfd, &rfds))
{
- n = read_socket(csp->cfd, buf, sizeof(buf));
+ len = read_socket(csp->cfd, buf, sizeof(buf));
- if (n <= 0)
+ if (len <= 0)
{
break; /* "game over, man" */
}
- if (write_socket(csp->sfd, buf, n) != n)
+ if (write_socket(csp->sfd, buf, len))
{
log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
return;
if (FD_ISSET(csp->sfd, &rfds))
{
fflush( 0 );
- n = read_socket(csp->sfd, buf, sizeof(buf) - 1);
+ len = read_socket(csp->sfd, buf, sizeof(buf) - 1);
- if (n < 0)
+ if (len < 0)
{
log_error(LOG_LEVEL_ERROR, "read from: %s failed: %E", http->host);
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 503 0",
- csp->ip_addr_str, http->cmd);
+ csp->ip_addr_str, http->ocmd);
rsp = error_response(csp, "connect-failed", errno);
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))
+ if (write_socket(csp->cfd, rsp->head, rsp->head_length)
+ || write_socket(csp->cfd, rsp->body, rsp->content_length))
{
log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
- }
- }
+ }
+ }
free_http_response(rsp);
return;
/* Add a trailing zero. This lets filter_popups
* use string operations.
*/
- buf[n] = '\0';
+ buf[len] = '\0';
#ifdef FEATURE_KILL_POPUPS
/* Filter the popups on this read. */
* doesn't generate a valid header, then we won't
* transmit anything to the client.
*/
- if (n == 0)
+ if (len == 0)
{
if (server_body || http->ssl)
}
hdr = sed(server_patterns, add_server_headers, csp);
- n = strlen(hdr);
+ if (hdr == NULL)
+ {
+ /* FIXME Should handle error properly */
+ log_error(LOG_LEVEL_FATAL, "Out of memory parsing server header");
+ }
- if ((write_socket(csp->cfd, hdr, n) != n)
- || (write_socket(csp->cfd, p != NULL ? p : csp->iob->cur, csp->content_length) != (int)csp->content_length))
+ if (write_socket(csp->cfd, hdr, strlen(hdr))
+ || write_socket(csp->cfd, p != NULL ? p : csp->iob->cur, csp->content_length))
{
log_error(LOG_LEVEL_ERROR, "write modified content to client failed: %E");
return;
* This is NOT the body, so
* Let's pretend the server just sent us a blank line.
*/
- n = sprintf(buf, "\r\n");
+ len = sprintf(buf, "\r\n");
/*
* Now, let the normal header parsing algorithm below do its
{
if (content_filter)
{
- add_to_iob(csp, buf, n);
+ add_to_iob(csp, buf, len);
/*
* If the buffer limit will be reached on the next read,
log_error(LOG_LEVEL_ERROR, "Buffer size limit reached! Flushing and stepping back.");
hdr = sed(server_patterns, add_server_headers, csp);
- n = strlen(hdr);
- byte_count += n;
+ if (hdr == NULL)
+ {
+ /* FIXME Should handle error properly */
+ log_error(LOG_LEVEL_FATAL, "Out of memory parsing server header");
+ }
- if (((write_socket(csp->cfd, hdr, n) != n)
- || (n = flush_socket(csp->cfd, csp) < 0)))
+ len = strlen(hdr);
+ byte_count += len;
+
+ if (write_socket(csp->cfd, hdr, len)
+ || (len = flush_socket(csp->cfd, csp) < 0))
{
log_error(LOG_LEVEL_CONNECT, "write header to client failed: %E");
}
freez(hdr);
- byte_count += n;
+ byte_count += len;
content_filter = NULL;
server_body = 1;
}
else
{
- if (write_socket(csp->cfd, buf, n) != n)
+ if (write_socket(csp->cfd, buf, len))
{
log_error(LOG_LEVEL_ERROR, "write to client failed: %E");
return;
}
}
- byte_count += n;
+ byte_count += len;
continue;
}
else
*/
/* buffer up the data we just read */
- add_to_iob(csp, buf, n);
+ add_to_iob(csp, buf, len);
/* get header lines from the iob */
*/
hdr = sed(server_patterns, add_server_headers, csp);
- n = strlen(hdr);
-
- /* write the server's (modified) header to
- * the client (along with anything else that
- * may be in the buffer)
- */
+ if (hdr == NULL)
+ {
+ /* FIXME Should handle error properly */
+ log_error(LOG_LEVEL_FATAL, "Out of memory parsing server header");
+ }
#ifdef FEATURE_KILL_POPUPS
/* Start blocking popups if appropriate. */
content_filter = gif_deanimate_response;
}
-
/*
* 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)))
+ if (!content_filter)
{
- log_error(LOG_LEVEL_CONNECT, "write header to client failed: %E");
-
- /* the write failed, so don't bother
- * mentioning it to the client...
- * it probably can't hear us anyway.
+ /* write the server's (modified) header to
+ * the client (along with anything else that
+ * may be in the buffer)
*/
- freez(hdr);
- return;
- }
- if(!content_filter) byte_count += n;
+ len = strlen(hdr);
+
+ if (write_socket(csp->cfd, hdr, len)
+ || (len = flush_socket(csp->cfd, csp) < 0))
+ {
+ log_error(LOG_LEVEL_CONNECT, "write header to client failed: %E");
+
+ /* the write failed, so don't bother
+ * mentioning it to the client...
+ * it probably can't hear us anyway.
+ */
+ freez(hdr);
+ return;
+ }
+
+ byte_count += len;
+ }
/* we're finished with the server's header */
}
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 %d",
- csp->ip_addr_str, http->cmd, byte_count);
+ csp->ip_addr_str, http->ocmd, byte_count);
}
chat(csp);
close_socket(csp->cfd);
- if (csp->sfd >= 0)
+ if (csp->sfd != JB_INVALID_SOCKET)
{
close_socket(csp->sfd);
}
#endif
+/*********************************************************************
+ *
+ * Function : usage
+ *
+ * Description : Print usage info & exit.
+ *
+ * Parameters : Pointer to argv[0] for identifying ourselves
+ *
+ * Returns : No. ,-)
+ *
+ *********************************************************************/
+void usage(const char *myname)
+{
+ printf("JunkBuster proxy version " VERSION " (" HOME_PAGE_URL ")\n"
+ "Usage: %s [--help] [--version] [--no-daemon] [--pidfile pidfile] [--user user[.group]] [configfile]\n"
+ "Aborting.\n", myname);
+
+ exit(2);
+
+}
+
+
/*********************************************************************
*
* Function : main
int main(int argc, const char *argv[])
#endif
{
+ int argc_pos = 0;
+#ifdef unix
+ struct passwd *pw = NULL;
+ struct group *grp = NULL;
+ char *p;
+#endif
+
+ Argc = argc;
+ Argv = argv;
+
configfile =
-#ifdef AMIGA
- "AmiTCP:db/junkbuster/config"
-#elif !defined(_WIN32)
+#if !defined(_WIN32)
"config"
#else
- "junkbstr.txt"
+ "config.txt"
#endif
;
-#if !defined(_WIN32) || defined(_WIN_CONSOLE)
- if ((argc >= 2) && (strcmp(argv[1], "--help")==0))
- {
- printf("JunkBuster proxy version " VERSION ".\n\n"
- "Usage: %s [configfile]\n\n"
- "See " HOME_PAGE_URL " for details.\n"
- "This program is distributed under the GNU GPL, version 2 or later.\n",
- argv[0]);
- exit(2);
- }
- if ((argc >= 2) && (strcmp(argv[1], "--version")==0))
+ /*
+ * Parse the command line arguments
+ */
+ while (++argc_pos < argc)
{
- printf(VERSION "\n");
- exit(2);
- }
-#endif /* !defined(_WIN32) || defined(_WIN_CONSOLE) */
+#if !defined(_WIN32) || defined(_WIN_CONSOLE)
- Argc = argc;
- Argv = argv;
+ if (strcmp(argv[argc_pos], "--help") == 0)
+ {
+ usage(argv[0]);
+ }
+
+ else if(strcmp(argv[argc_pos], "--version") == 0)
+ {
+ printf("Junkbuster version " VERSION " (" HOME_PAGE_URL ")\n");
+ exit(0);
+ }
+
+ else if (strcmp(argv[argc_pos], "--no-daemon" ) == 0)
+ {
+ no_daemon = 1;
+ }
+#if defined(unix)
+ else if (strcmp(argv[argc_pos], "--pidfile" ) == 0)
+ {
+ if (++argc_pos == argc) usage(argv[0]);
+ pidfile = strdup(argv[argc_pos]);
+ }
+
+ else if (strcmp(argv[argc_pos], "--user" ) == 0)
+ {
+ if (++argc_pos == argc) usage(argv[argc_pos]);
+
+ if ((NULL != (p = strchr(argv[argc_pos], '.'))) && *(p + 1) != '0')
+ {
+ *p++ = '\0';
+ if (NULL == (grp = getgrnam(p)))
+ {
+ log_error(LOG_LEVEL_FATAL, "Group %s not found.", p);
+ }
+ }
+
+ if (NULL == (pw = getpwnam(argv[argc_pos])))
+ {
+ log_error(LOG_LEVEL_FATAL, "User %s not found.", argv[argc_pos]);
+ }
+
+ if (p != NULL) *--p = '\0';
+ }
+#endif /* defined(unix) */
+ else
+#endif /* defined(_WIN32) && !defined(_WIN_CONSOLE) */
+ {
+ configfile = argv[argc_pos];
+ }
+
+ } /* -END- while (more arguments) */
- if (argc > 1)
+#if defined(unix)
+ if ( *configfile != '/' )
{
- configfile = argv[1];
+ char *abs_file;
+
+ /* make config-filename absolute here */
+ if ( !(basedir = getcwd( NULL, 1024 )))
+ {
+ perror("get working dir failed");
+ exit( 1 );
+ }
+
+ if ( !(abs_file = malloc( strlen( basedir ) + strlen( configfile ) + 5 )))
+ {
+ perror("malloc failed");
+ exit( 1 );
+ }
+ strcpy( abs_file, basedir );
+ strcat( abs_file, "/" );
+ strcat( abs_file, configfile );
+ configfile = abs_file;
}
+#endif /* defined unix */
+
files->next = NULL;
InitWin32();
#endif
+ /*
+ * Unix signal handling
+ *
+ * Catch the abort, interrupt and terminate signals for a graceful exit
+ * Catch the hangup signal so the errlog can be reopened.
+ * Ignore the broken pipe and child signals
+ * FIXME: Isn't ignoring the default for SIGCHLD anyway and why ignore SIGPIPE?
+ */
+#if !defined(_WIN32) && !defined(__OS2__) && !defined(AMIGA)
+{
+ int idx;
+ const int catched_signals[] = { SIGABRT, SIGTERM, SIGINT, SIGHUP, 0 };
+ const int ignored_signals[] = { SIGPIPE, SIGCHLD, 0 };
-#if !defined(_WIN32) && !defined(__OS2__)
- signal(SIGPIPE, SIG_IGN);
- signal(SIGCHLD, SIG_IGN);
+ for (idx = 0; catched_signals[idx] != 0; idx++)
+ {
+ if (signal(catched_signals[idx], sig_handler) == SIG_ERR)
+ {
+ log_error(LOG_LEVEL_FATAL, "Can't set signal-handler for signal %d: %E", catched_signals[idx]);
+ }
+ }
+ for (idx = 0; ignored_signals[idx] != 0; idx++)
+ {
+ if (signal(ignored_signals[idx], SIG_IGN) == SIG_ERR)
+ {
+ log_error(LOG_LEVEL_FATAL, "Can't set ignore-handler for signal %d: %E", ignored_signals[idx]);
+ }
+ }
+
+}
#else /* ifdef _WIN32 */
# ifdef _WIN_CONSOLE
/*
/* Initialize the CGI subsystem */
cgi_init_error_messages();
+ /*
+ * If runnig on unix and without the --nodaemon
+ * option, become a daemon. I.e. fork, detach
+ * from tty and get process group leadership
+ */
+#if defined(unix)
+{
+ pid_t pid = 0;
+#if 0
+ int fd;
+#endif
+
+ if (!no_daemon)
+ {
+ pid = fork();
+
+ if ( pid < 0 ) /* error */
+ {
+ perror("fork");
+ exit( 3 );
+ }
+ else if ( pid != 0 ) /* parent */
+ {
+ int status;
+ pid_t wpid;
+ /*
+ * must check for errors
+ * child died due to missing files aso
+ */
+ sleep( 1 );
+ wpid = waitpid( pid, &status, WNOHANG );
+ if ( wpid != 0 )
+ {
+ exit( 1 );
+ }
+ exit( 0 );
+ }
+ /* child */
+#if 1
+ /* Should be more portable, but not as well tested */
+ setsid();
+#else /* !1 */
+#ifdef __FreeBSD__
+ setpgrp(0,0);
+#else /* ndef __FreeBSD__ */
+ setpgrp();
+#endif /* ndef __FreeBSD__ */
+ fd = open("/dev/tty", O_RDONLY);
+ if ( fd )
+ {
+ /* no error check here */
+ ioctl( fd, TIOCNOTTY,0 );
+ close ( fd );
+ }
+#endif /* 1 */
+ /* FIXME: should close stderr (fd 2) here too, but the test
+ * for existence
+ * and load config file is done in listen_loop() and puts
+ * some messages on stderr there.
+ */
+
+ close( 0 );
+ close( 1 );
+ chdir("/");
+
+ } /* -END- if (!no_daemon) */
+
+ /*
+ * As soon as we have written the PID file, we can switch
+ * to the user and group ID indicated by the --user option
+ */
+ write_pid_file();
+
+ if (NULL != pw)
+ {
+ if (((NULL != grp) && setgid(grp->gr_gid)) || (setgid(pw->pw_gid)))
+ {
+ log_error(LOG_LEVEL_FATAL, "Cannot setgid(): Insufficient permissions.");
+ }
+ if (setuid(pw->pw_uid))
+ {
+ log_error(LOG_LEVEL_FATAL, "Cannot setuid(): Insufficient permissions.");
+ }
+ }
+}
+#endif /* defined unix */
+
listen_loop();
/* NOTREACHED */
}
+/*********************************************************************
+ *
+ * Function : bind_port_helper
+ *
+ * Description : Bind the listen port. Handles logging, and aborts
+ * on failure.
+ *
+ * Parameters :
+ * 1 : config = Junkbuster configuration. Specifies port
+ * to bind to.
+ *
+ * Returns : Port that was opened.
+ *
+ *********************************************************************/
+static jb_socket bind_port_helper(struct configuration_spec * config)
+{
+ int result;
+ jb_socket bfd;
+
+ if ( (config->haddr != NULL)
+ && (config->haddr[0] == '1')
+ && (config->haddr[1] == '2')
+ && (config->haddr[2] == '7')
+ && (config->haddr[3] == '.') )
+ {
+ log_error(LOG_LEVEL_INFO, "Listening on port %d for local connections only",
+ config->hport);
+ }
+ else if (config->haddr == NULL)
+ {
+ log_error(LOG_LEVEL_INFO, "Listening on port %d on all IP addresses",
+ config->hport);
+ }
+ else
+ {
+ log_error(LOG_LEVEL_INFO, "Listening on port %d on IP address %s",
+ config->hport, config->haddr);
+ }
+
+ result = bind_port(config->haddr, config->hport, &bfd);
+
+ if (result < 0)
+ {
+ switch(result)
+ {
+ case -3 :
+ log_error(LOG_LEVEL_FATAL, "can't bind to %s:%d: "
+ "There may be another junkbuster or some other "
+ "proxy running on port %d",
+ (NULL != config->haddr) ? config->haddr : "INADDR_ANY",
+ config->hport, config->hport);
+
+ case -2 :
+ log_error(LOG_LEVEL_FATAL, "can't bind to %s:%d: "
+ "The hostname is not resolvable",
+ (NULL != config->haddr) ? config->haddr : "INADDR_ANY", config->hport);
+
+ default :
+ log_error(LOG_LEVEL_FATAL, "can't bind to %s:%d: because %E",
+ (NULL != config->haddr) ? config->haddr : "INADDR_ANY", config->hport);
+ }
+
+ /* shouldn't get here */
+ return JB_INVALID_SOCKET;
+ }
+
+ config->need_bind = 0;
+
+ return bfd;
+}
+
+
/*********************************************************************
*
* Function : listen_loop
static void listen_loop(void)
{
struct client_state *csp = NULL;
- int bfd;
+ jb_socket bfd;
struct configuration_spec * config;
config = load_config();
- log_error(LOG_LEVEL_CONNECT, "bind (%s, %d)",
- config->haddr ? config->haddr : "INADDR_ANY", config->hport);
-
- bfd = bind_port(config->haddr, config->hport);
-
- if (bfd < 0)
- {
- log_error(LOG_LEVEL_FATAL, "can't bind %s:%d: %E "
- "- There may be another junkbuster or some other "
- "proxy running on port %d",
- (NULL != config->haddr) ? config->haddr : "INADDR_ANY",
- config->hport, config->hport
- );
- /* shouldn't get here */
- return;
- }
-
- config->need_bind = 0;
-
+ bfd = bind_port_helper(config);
while (FOREVER)
{
/* zombie children */
}
#endif /* !defined(FEATURE_PTHREAD) && !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) */
+
+ /*
+ * Free data that was used by died threads
+ */
sweep();
+#if defined(unix)
+ /*
+ * Re-open the errlog after HUP signal
+ */
+ if (received_hup_signal)
+ {
+ init_error_log(Argv[0], config->logfile, config->debug);
+ received_hup_signal = 0;
+ }
+#endif
+
if ( NULL == (csp = (struct client_state *) zalloc(sizeof(*csp))) )
{
log_error(LOG_LEVEL_FATAL, "malloc(%d) for csp failed: %E", sizeof(*csp));
}
csp->flags |= CSP_FLAG_ACTIVE;
- csp->sfd = -1;
+ csp->sfd = JB_INVALID_SOCKET;
csp->config = config = load_config();
close_socket(bfd);
- log_error(LOG_LEVEL_CONNECT, "bind (%s, %d)",
- config->haddr ? config->haddr : "INADDR_ANY", config->hport);
- bfd = bind_port(config->haddr, config->hport);
-
- if (bfd < 0)
- {
- log_error(LOG_LEVEL_FATAL, "can't bind %s:%d: %E "
- "- There may be another junkbuster or some other "
- "proxy running on port %d",
- (NULL != config->haddr) ? config->haddr : "INADDR_ANY",
- config->hport, config->hport
- );
- /* shouldn't get here */
- return;
- }
-
- config->need_bind = 0;
+ bfd = bind_port_helper(config);
}
log_error(LOG_LEVEL_CONNECT, "accept connection ... ");
projects / privoxy.git / blobdiff