int
main(int argc, char **argv)
{
struct Timer *tp;
flag = 0;
tp = tmr_create((struct timeval*) 0, timer_proc, JunkClientData, 3000000, 0);
sleep(2);
tmr_run((struct timeval*) 0);
if (flag)
{
printf("timer should not have expired\n");
exit(-1);
}
sleep(1);
tmr_run((struct timeval*) 0);
if (!flag)
{
printf("timer should have expired\n");
exit(-2);
}
tmr_destroy();
exit(0);
}
int
main( int argc, char** argv )
{
int argn;
int start;
#define START_NONE 0
#define START_PARALLEL 1
#define START_RATE 2
int start_parallel = -1, start_rate = -1;
int end;
#define END_NONE 0
#define END_FETCHES 1
#define END_SECONDS 2
int end_fetches = -1, end_seconds = -1;
int cnum;
char* url_file;
char* sip_file;
#ifdef RLIMIT_NOFILE
struct rlimit limits;
#endif /* RLIMIT_NOFILE */
fd_set rfdset;
fd_set wfdset;
struct timeval now;
int i, r;
max_connections = 64 - RESERVED_FDS; /* a guess */
#ifdef RLIMIT_NOFILE
/* Try and increase the limit on # of files to the maximum. */
if ( getrlimit( RLIMIT_NOFILE, &limits ) == 0 )
{
if ( limits.rlim_cur != limits.rlim_max )
{
if ( limits.rlim_max == RLIM_INFINITY )
limits.rlim_cur = 8192; /* arbitrary */
else if ( limits.rlim_max > limits.rlim_cur )
limits.rlim_cur = limits.rlim_max;
(void) setrlimit( RLIMIT_NOFILE, &limits );
}
max_connections = limits.rlim_cur - RESERVED_FDS;
}
#endif /* RLIMIT_NOFILE */
/* Parse args. */
argv0 = argv[0];
argn = 1;
do_checksum = do_throttle = do_verbose = do_jitter = do_proxy = 0;
throttle = THROTTLE;
sip_file = (char*) 0;
idle_secs = IDLE_SECS;
start = START_NONE;
end = END_NONE;
while ( argn < argc && argv[argn][0] == '-' && argv[argn][1] != '\0' )
{
if ( strncmp( argv[argn], "-checksum", strlen( argv[argn] ) ) == 0 )
do_checksum = 1;
else if ( strncmp( argv[argn], "-throttle", strlen( argv[argn] ) ) == 0 )
do_throttle = 1;
else if ( strncmp( argv[argn], "-Throttle", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
do_throttle = 1;
throttle = atoi( argv[++argn] ) / 10.0;
}
else if ( strncmp( argv[argn], "-verbose", strlen( argv[argn] ) ) == 0 )
do_verbose = 1;
else if ( strncmp( argv[argn], "-timeout", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
idle_secs = atoi( argv[++argn] );
else if ( strncmp( argv[argn], "-jitter", strlen( argv[argn] ) ) == 0 )
do_jitter = 1;
else if ( strncmp( argv[argn], "-parallel", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
start = START_PARALLEL;
start_parallel = atoi( argv[++argn] );
if ( start_parallel < 1 )
{
(void) fprintf(
stderr, "%s: parallel must be at least 1\n", argv0 );
exit( 1 );
}
if ( start_parallel > max_connections )
{
(void) fprintf(
stderr, "%s: parallel may be at most %d\n", argv0, max_connections );
exit( 1 );
}
}
else if ( strncmp( argv[argn], "-rate", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
start = START_RATE;
start_rate = atoi( argv[++argn] );
if ( start_rate < 1 )
{
(void) fprintf(
stderr, "%s: rate must be at least 1\n", argv0 );
exit( 1 );
}
if ( start_rate > 1000 )
{
(void) fprintf(
stderr, "%s: rate may be at most 1000\n", argv0 );
exit( 1 );
}
}
else if ( strncmp( argv[argn], "-fetches", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
end = END_FETCHES;
end_fetches = atoi( argv[++argn] );
if ( end_fetches < 1 )
{
(void) fprintf(
stderr, "%s: fetches must be at least 1\n", argv0 );
exit( 1 );
}
}
else if ( strncmp( argv[argn], "-seconds", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
end = END_SECONDS;
end_seconds = atoi( argv[++argn] );
if ( end_seconds < 1 )
{
(void) fprintf(
stderr, "%s: seconds must be at least 1\n", argv0 );
exit( 1 );
}
}
else if ( strncmp( argv[argn], "-sip", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
sip_file = argv[++argn];
#ifdef USE_SSL
else if ( strncmp( argv[argn], "-cipher", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
cipher = argv[++argn];
if ( strcasecmp( cipher, "fastsec" ) == 0 )
cipher = "RC4-MD5";
else if ( strcasecmp( cipher, "highsec" ) == 0 )
cipher = "DES-CBC3-SHA";
else if ( strcasecmp( cipher, "paranoid" ) == 0 )
cipher = "AES256-SHA";
}
#endif /* USE_SSL */
else if ( strncmp( argv[argn], "-proxy", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
char* colon;
do_proxy = 1;
proxy_hostname = argv[++argn];
colon = strchr( proxy_hostname, ':' );
if ( colon == (char*) 0 )
proxy_port = 80;
else
{
proxy_port = (unsigned short) atoi( colon + 1 );
*colon = '\0';
}
}
else
usage();
++argn;
}
if ( argn + 1 != argc )
usage();
if ( start == START_NONE || end == END_NONE )
usage();
if ( do_jitter && start != START_RATE )
usage();
url_file = argv[argn];
/* Read in and parse the URLs. */
printf("Loading url file...");
read_url_file( url_file );
printf("Total %d urls loaded.\n", num_urls);
/* Read in the source IP file, if specified. */
if ( sip_file != (char*) 0 )
read_sip_file( sip_file );
/* Initialize the connections table. */
if ( start == START_PARALLEL )
max_connections = start_parallel;
connections = (connection*) malloc_check(
max_connections * sizeof(connection) );
for ( cnum = 0; cnum < max_connections; ++cnum )
connections[cnum].conn_state = CNST_FREE;
num_connections = max_parallel = 0;
/* Initialize the HTTP status-code histogram. */
for ( i = 0; i < 1000; ++i )
http_status_counts[i] = 0;
/* Initialize the statistics. */
fetches_started = 0;
connects_completed = 0;
responses_completed = 0;
fetches_completed = 0;
total_bytes = 0;
total_connect_usecs = 0;
max_connect_usecs = 0;
min_connect_usecs = 1000000000L;
total_response_usecs = 0;
max_response_usecs = 0;
min_response_usecs = 1000000000L;
total_timeouts = 0;
total_badbytes = 0;
total_badchecksums = 0;
/* Initialize the random number generator. */
#ifdef HAVE_SRANDOMDEV
srandomdev();
#else
srandom( (int) time( (time_t*) 0 ) ^ getpid() );
#endif
/* Initialize the rest. */
tmr_init();
(void) gettimeofday( &now, (struct timezone*) 0 );
start_at = now;
if ( do_verbose )
(void) tmr_create(
&now, progress_report, JunkClientData, PROGRESS_SECS * 1000L, 1 );
if ( start == START_RATE )
{
start_interval = 1000L / start_rate;
if ( do_jitter )
{
low_interval = start_interval * 9 / 10;
high_interval = start_interval * 11 / 10;
range_interval = high_interval - low_interval + 1;
}
(void) tmr_create(
&now, start_timer, JunkClientData, start_interval, ! do_jitter );
}
if ( end == END_SECONDS )
(void) tmr_create(
&now, end_timer, JunkClientData, end_seconds * 1000L, 0 );
(void) signal( SIGPIPE, SIG_IGN );
/* Main loop. */
for (;;)
{
if ( end == END_FETCHES && fetches_completed >= end_fetches )
finish( &now );
if ( start == START_PARALLEL )
{
/* See if we need to start any new connections; but at most 10. */
for ( i = 0;
i < 10 &&
num_connections < start_parallel &&
( end != END_FETCHES || fetches_started < end_fetches );
++i )
{
start_connection( &now );
(void) gettimeofday( &now, (struct timezone*) 0 );
tmr_run( &now );
}
}
/* Build the fdsets. */
FD_ZERO( &rfdset );
FD_ZERO( &wfdset );
for ( cnum = 0; cnum < max_connections; ++cnum )
switch ( connections[cnum].conn_state )
{
case CNST_CONNECTING:
FD_SET( connections[cnum].conn_fd, &wfdset );
break;
case CNST_HEADERS:
case CNST_READING:
FD_SET( connections[cnum].conn_fd, &rfdset );
break;
}
r = select(
FD_SETSIZE, &rfdset, &wfdset, (fd_set*) 0, tmr_timeout( &now ) );
if ( r < 0 )
{
perror( "select" );
exit( 1 );
}
(void) gettimeofday( &now, (struct timezone*) 0 );
/* Service them. */
for ( cnum = 0; cnum < max_connections; ++cnum )
switch ( connections[cnum].conn_state )
{
case CNST_CONNECTING:
if ( FD_ISSET( connections[cnum].conn_fd, &wfdset ) )
handle_connect( cnum, &now, 1 );
break;
case CNST_HEADERS:
case CNST_READING:
if ( FD_ISSET( connections[cnum].conn_fd, &rfdset ) )
handle_read( cnum, &now );
break;
}
/* And run the timers. */
tmr_run( &now );
}
/* NOT_REACHED */
}
int thttpd_main(int argc, char **argv)
#endif
{
int num_ready;
int cnum;
FAR struct connect_s *conn;
FAR httpd_conn *hc;
httpd_sockaddr sa;
struct timeval tv;
#ifdef CONFIG_THTTPD_DIR
int ret;
#endif
nvdbg("THTTPD started\n");
/* Setup host address */
#ifdef CONFIG_NET_IPv6
# error "IPv6 support not yet implemented"
#else
sa.sin_family = AF_INET;
sa.sin_port = HTONS(CONFIG_THTTPD_PORT);
sa.sin_addr.s_addr = HTONL(CONFIG_THTTPD_IPADDR);
#endif
/* Initialize the fdwatch package to handle all of the configured
* socket descriptors
*/
fw = fdwatch_initialize(CONFIG_NSOCKET_DESCRIPTORS);
if (!fw)
{
ndbg("fdwatch initialization failure\n");
exit(1);
}
/* Switch directories again if requested */
#ifdef CONFIG_THTTPD_DATADIR
if (chdir(CONFIG_THTTPD_DATADIR) < 0)
{
ndbg("chdir to %s: %d\n", CONFIG_THTTPD_DATADIR, errno);
exit(1);
}
#endif
/* Initialize the timer package */
tmr_init();
/* Initialize the HTTP layer */
nvdbg("Calling httpd_initialize()\n");
hs = httpd_initialize(&sa);
if (!hs)
{
ndbg("httpd_initialize() failed\n");
exit(1);
}
/* Set up the occasional timer */
if (tmr_create(NULL, occasional, JunkClientData, CONFIG_THTTPD_OCCASIONAL_MSEC * 1000L, 1) == NULL)
{
ndbg("tmr_create(occasional) failed\n");
exit(1);
}
/* Set up the idle timer */
if (tmr_create(NULL, idle, JunkClientData, 5 * 1000L, 1) == NULL)
{
ndbg("tmr_create(idle) failed\n");
exit(1);
}
/* Initialize our connections table */
connects = NEW(struct connect_s, AVAILABLE_FDS);
if (connects == NULL)
{
ndbg("Out of memory allocating a struct connect_s\n");
exit(1);
}
for (cnum = 0; cnum < AVAILABLE_FDS; ++cnum)
{
connects[cnum].conn_state = CNST_FREE;
connects[cnum].next = &connects[cnum + 1];
connects[cnum].hc = NULL;
}
connects[AVAILABLE_FDS-1].next = NULL; /* End of link list */
free_connections = connects; /* Beginning of the link list */
if (hs != NULL)
{
if (hs->listen_fd != -1)
{
fdwatch_add_fd(fw, hs->listen_fd, NULL);
}
}
/* Main loop */
nvdbg("Entering the main loop\n");
(void)gettimeofday(&tv, NULL);
for (;;)
{
/* Do the fd watch */
num_ready = fdwatch(fw, tmr_mstimeout(&tv));
if (num_ready < 0)
{
if (errno == EINTR || errno == EAGAIN)
{
/* Not errors... try again */
continue;
}
ndbg("fdwatch failed: %d\n", errno);
exit(1);
}
(void)gettimeofday(&tv, NULL);
if (num_ready == 0)
{
/* No fd's are ready - run the timers */
tmr_run(&tv);
continue;
}
/* Is it a new connection? */
if (fdwatch_check_fd(fw, hs->listen_fd))
{
if (!handle_newconnect(&tv, hs->listen_fd))
{
/* Go around the loop and do another fdwatch, rather than
* dropping through and processing existing connections. New
* connections always get priority.
*/
continue;
}
}
/* Find the connections that need servicing */
while ((conn = (struct connect_s*)fdwatch_get_next_client_data(fw)) != (struct connect_s*)-1)
{
if (conn)
{
hc = conn->hc;
if (fdwatch_check_fd(fw, hc->conn_fd))
{
nvdbg("Handle conn_state %d\n", conn->conn_state);
switch (conn->conn_state)
{
case CNST_READING:
{
handle_read(conn, &tv);
/* If a GET request was received and a file is ready to
* be sent, then fall through to send the file.
*/
if (conn->conn_state != CNST_SENDING)
{
break;
}
}
case CNST_SENDING:
{
/* Send a file -- this really should be performed on a
* separate thread to keep the serve from locking up during
* the write.
*/
handle_send(conn, &tv);
}
break;
case CNST_LINGERING:
{
/* Linger close the connection */
handle_linger(conn, &tv);
}
break;
}
}
}
}
tmr_run(&tv);
}
/* The main loop terminated */
shut_down();
ndbg("Exiting\n");
exit(0);
}
static int handle_newconnect(struct timeval *tv, int listen_fd)
{
struct connect_s *conn;
ClientData client_data;
/* This loops until the accept() fails, trying to start new connections as
* fast as possible so we don't overrun the listen queue.
*/
nvdbg("New connection(s) on listen_fd %d\n", listen_fd);
for (;;)
{
/* Get the next free connection from the free list */
conn = free_connections;
/* Are there any free connections? */
if (!conn)
{
/* Out of connection slots. Run the timers, then the existing
* connections, and maybe we'll free up a slot by the time we get
* back here.
*/
ndbg("No free connections\n");
tmr_run(tv);
return -1;
}
/* Make the httpd_conn if necessary */
if (!conn->hc)
{
conn->hc = NEW(httpd_conn, 1);
if (conn->hc == NULL)
{
ndbg("out of memory allocating an httpd_conn\n");
exit(1);
}
conn->hc->initialized = 0;
}
/* Get the connection */
switch (httpd_get_conn(hs, listen_fd, conn->hc))
{
/* Some error happened. Run the timers, then the existing
* connections. Maybe the error will clear.
*/
case GC_FAIL:
tmr_run(tv);
return -1;
/* No more connections to accept for now */
case GC_NO_MORE:
return 0;
default:
break;
}
nvdbg("New connection fd %d\n", conn->hc->conn_fd);
/* Remove the connection entry from the free list */
conn->conn_state = CNST_READING;
free_connections = conn->next;
conn->next = NULL;
client_data.p = conn;
conn->active_at = tv->tv_sec;
conn->wakeup_timer = NULL;
conn->linger_timer = NULL;
conn->offset = 0;
/* Set the connection file descriptor to no-delay mode */
httpd_set_ndelay(conn->hc->conn_fd);
fdwatch_add_fd(fw, conn->hc->conn_fd, conn);
}
}
static int
handle_newconnect( struct timeval* tvP, int listen_fd )
{
connecttab* c;
ClientData client_data;
/* This loops until the accept() fails, trying to start new
** connections as fast as possible so we don't overrun the
** listen queue.
*/
for (;;)
{
/* Is there room in the connection table? */
if ( num_connects >= max_connects )
{
/* Out of connection slots. Run the timers, then the
** existing connections, and maybe we'll free up a slot
** by the time we get back here.
*/
tmr_run( tvP );
return 0;
}
/* Get the first free connection entry off the free list. */
if ( first_free_connect == -1 || connects[first_free_connect].conn_state != CNST_FREE )
{
return;
}
c = &connects[first_free_connect];
/* Make the httpd_conn if necessary. */
if ( c->hc == (httpd_conn*) 0 )
{
c->hc = NEW( httpd_conn, 1 );
if ( c->hc == (httpd_conn*) 0 )
{
return;
}
c->hc->initialized = 0;
c->hc->conn = c;
++httpd_conn_count;
}
/* Get the connection. */
switch ( httpd_get_conn( hs, listen_fd, c->hc ) )
{
/* Some error happened. Run the timers, then the
** existing connections. Maybe the error will clear.
*/
case GC_FAIL:
tmr_run( tvP );
return 0;
/* No more connections to accept for now. */
case GC_NO_MORE:
return 1;
}
c->conn_state = CNST_READING;
/* Pop it off the free list. */
first_free_connect = c->next_free_connect;
c->next_free_connect = -1;
++num_connects;
client_data.p = c;
c->active_at = tvP->tv_sec;
c->wakeup_timer = (Timer*) 0;
c->linger_timer = (Timer*) 0;
c->next_byte_index = 0;
/* Set the connection file descriptor to no-delay mode. */
httpd_set_ndelay( c->hc->conn_fd );
fdwatch_add_fd( c->hc->conn_fd, c, FDW_READ );
++stats_connections;
if ( num_connects > stats_simultaneous )
stats_simultaneous = num_connects;
}
}
int
thttpd_run(void)
{
char* cp;
struct passwd* pwd;
uid_t uid = 32767;
gid_t gid = 32767;
int num_ready;
int cnum;
connecttab* c;
httpd_conn* hc;
httpd_sockaddr sa4;
httpd_sockaddr sa6;
int gotv4, gotv6;
struct timeval tv;
cp = getenv( "GHTTPPORT" );
if ( cp )
port = atoi( cp );
if( port == 0 )
port = 9999;
/* Read zone info now, in case we chroot(). */
tzset();
/* Look up hostname now, in case we chroot(). */
lookup_hostname( &sa4, sizeof(sa4), &gotv4, &sa6, sizeof(sa6), &gotv6 );
if ( ! ( gotv4 || gotv6 ) )
{
memset(&sa4, 0, sizeof sa4);
gotv4 = 1;
}
/* Initialize the fdwatch package. Have to do this before chroot,
** if /dev/poll is used.
*/
max_connects = fdwatch_get_nfiles();
if ( max_connects < 0 )
{
return;
}
max_connects -= SPARE_FDS;
/* Set up to catch signals. */
#ifdef HAVE_SIGSET
(void) sigset( SIGPIPE, SIG_IGN ); /* get EPIPE instead */
#else /* HAVE_SIGSET */
(void) signal( SIGPIPE, SIG_IGN ); /* get EPIPE instead */
#endif /* HAVE_SIGSET */
/* Initialize the timer package. */
tmr_init();
/* Initialize the HTTP layer. Got to do this before giving up root,
** so that we can bind to a privileged port.
*/
hs = httpd_initialize(
hostname,
gotv4 ? &sa4 : (httpd_sockaddr*) 0, gotv6 ? &sa6 : (httpd_sockaddr*) 0,
port, cgi_pattern, cgi_limit, charset, p3p, max_age, "/", no_log,
no_symlink_check, do_vhost, do_global_passwd, url_pattern,
local_pattern, no_empty_referers );
if ( hs == (httpd_server*) 0 )
exit( 1 );
/* Set up the occasional timer. */
if ( tmr_create( (struct timeval*) 0, occasional, JunkClientData, OCCASIONAL_TIME * 1000L, 1 ) == (Timer*) 0 )
{
return;
}
/* Set up the idle timer. */
if ( tmr_create( (struct timeval*) 0, idle, JunkClientData, 5 * 1000L, 1 ) == (Timer*) 0 )
{
return;
}
start_time = stats_time = time( (time_t*) 0 );
stats_connections = 0;
stats_bytes = 0;
stats_simultaneous = 0;
/* Initialize our connections table. */
connects = NEW( connecttab, max_connects );
if ( connects == (connecttab*) 0 )
{
return;
}
for ( cnum = 0; cnum < max_connects; ++cnum )
{
connects[cnum].conn_state = CNST_FREE;
connects[cnum].next_free_connect = cnum + 1;
connects[cnum].hc = (httpd_conn*) 0;
}
connects[max_connects - 1].next_free_connect = -1; /* end of link list */
first_free_connect = 0;
num_connects = 0;
httpd_conn_count = 0;
if ( hs != (httpd_server*) 0 )
{
if ( hs->listen4_fd != -1 )
fdwatch_add_fd( hs->listen4_fd, (void*) 0, FDW_READ );
if ( hs->listen6_fd != -1 )
fdwatch_add_fd( hs->listen6_fd, (void*) 0, FDW_READ );
}
/* Main loop. */
(void) gettimeofday( &tv, (struct timezone*) 0 );
while ( ( ! terminate ) || num_connects > 0 )
{
/* Do the fd watch. */
num_ready = fdwatch( tmr_mstimeout( &tv ) );
if ( num_ready < 0 )
{
if ( errno == EINTR || errno == EAGAIN )
continue; /* try again */
return;
}
(void) gettimeofday( &tv, (struct timezone*) 0 );
if ( num_ready == 0 )
{
/* No fd's are ready - run the timers. */
tmr_run( &tv );
continue;
}
/* Is it a new connection? */
if ( hs != (httpd_server*) 0 && hs->listen6_fd != -1 &&
fdwatch_check_fd( hs->listen6_fd ) )
{
if ( handle_newconnect( &tv, hs->listen6_fd ) )
/* Go around the loop and do another fdwatch, rather than
** dropping through and processing existing connections.
** New connections always get priority.
*/
continue;
}
if ( hs != (httpd_server*) 0 && hs->listen4_fd != -1 &&
fdwatch_check_fd( hs->listen4_fd ) )
{
if ( handle_newconnect( &tv, hs->listen4_fd ) )
/* Go around the loop and do another fdwatch, rather than
** dropping through and processing existing connections.
** New connections always get priority.
*/
continue;
}
/* Find the connections that need servicing. */
while ( ( c = (connecttab*) fdwatch_get_next_client_data() ) != (connecttab*) -1 )
{
if ( c == (connecttab*) 0 )
continue;
hc = c->hc;
if ( ! fdwatch_check_fd( hc->conn_fd ) )
/* Something went wrong. */
clear_connection( c, &tv );
else
switch ( c->conn_state )
{
case CNST_READING: handle_read( c, &tv ); break;
case CNST_SENDING: handle_send( c, &tv ); break;
case CNST_LINGERING: handle_linger( c, &tv ); break;
}
}
tmr_run( &tv );
}
/* The main loop terminated. */
shut_down();
return 0;
}
int
main( int argc, char** argv )
{
char* cp;
struct passwd* pwd;
uid_t uid;
gid_t gid;
char cwd[MAXPATHLEN];
FILE* logfp;
int num_ready;
int cnum, ridx;
connecttab* c;
httpd_conn* hc;
httpd_sockaddr sa4;
httpd_sockaddr sa6;
int gotv4, gotv6;
struct timeval tv;
argv0 = argv[0];
cp = strrchr( argv0, '/' );
if ( cp != (char*) 0 )
++cp;
else
cp = argv0;
openlog( cp, LOG_NDELAY|LOG_PID, LOG_FACILITY );
/* Handle command-line arguments. */
parse_args( argc, argv );
/* Check port number. */
if ( port <= 0 )
{
syslog( LOG_CRIT, "illegal port number" );
(void) fprintf( stderr, "%s: illegal port number\n", argv0 );
exit( 1 );
}
/* Read zone info now, in case we chroot(). */
tzset();
/* Look up hostname now, in case we chroot(). */
lookup_hostname( &sa4, sizeof(sa4), &gotv4, &sa6, sizeof(sa6), &gotv6 );
if ( ! ( gotv4 || gotv6 ) )
{
syslog( LOG_ERR, "can't find any valid address" );
(void) fprintf( stderr, "%s: can't find any valid address\n", argv0 );
exit( 1 );
}
/* Throttle file. */
numthrottles = 0;
maxthrottles = 0;
throttles = (throttletab*) 0;
if ( throttlefile != (char*) 0 )
read_throttlefile( throttlefile );
/* Log file. */
if ( logfile != (char*) 0 )
{
if ( strcmp( logfile, "/dev/null" ) == 0 )
{
no_log = 1;
logfp = (FILE*) 0;
}
else
{
logfp = fopen( logfile, "a" );
if ( logfp == (FILE*) 0 )
{
syslog( LOG_CRIT, "%.80s - %m", logfile );
perror( logfile );
exit( 1 );
}
(void) fcntl( fileno( logfp ), F_SETFD, 1 );
}
}
else
logfp = (FILE*) 0;
/* Figure out uid/gid from user. */
pwd = getpwnam( user );
if ( pwd == (struct passwd*) 0 )
{
syslog( LOG_CRIT, "unknown user - '%.80s'", user );
(void) fprintf( stderr, "%s: unknown user - '%s'\n", argv0, user );
exit( 1 );
}
uid = pwd->pw_uid;
gid = pwd->pw_gid;
/* Switch directories if requested. */
if ( dir != (char*) 0 )
{
if ( chdir( dir ) < 0 )
{
syslog( LOG_CRIT, "chdir - %m" );
perror( "chdir" );
exit( 1 );
}
}
#ifdef USE_USER_DIR
else if ( getuid() == 0 )
{
/* No explicit directory was specified, we're root, and the
** USE_USER_DIR option is set - switch to the specified user's
** home dir.
*/
if ( chdir( pwd->pw_dir ) < 0 )
{
syslog( LOG_CRIT, "chdir - %m" );
perror( "chdir" );
exit( 1 );
}
}
#endif /* USE_USER_DIR */
/* Get current directory. */
(void) getcwd( cwd, sizeof(cwd) - 1 );
if ( cwd[strlen( cwd ) - 1] != '/' )
(void) strcat( cwd, "/" );
if ( ! debug )
{
/* We're not going to use stdin stdout or stderr from here on, so close
** them to save file descriptors.
*/
(void) fclose( stdin );
(void) fclose( stdout );
(void) fclose( stderr );
/* Daemonize - make ourselves a subprocess. */
#ifdef HAVE_DAEMON
if ( daemon( 1, 1 ) < 0 )
{
syslog( LOG_CRIT, "daemon - %m" );
exit( 1 );
}
#else /* HAVE_DAEMON */
switch ( fork() )
{
case 0:
break;
case -1:
syslog( LOG_CRIT, "fork - %m" );
exit( 1 );
default:
exit( 0 );
}
#ifdef HAVE_SETSID
(void) setsid();
#endif /* HAVE_SETSID */
#endif /* HAVE_DAEMON */
}
else
{
/* Even if we don't daemonize, we still want to disown our parent
** process.
*/
#ifdef HAVE_SETSID
(void) setsid();
#endif /* HAVE_SETSID */
}
if ( pidfile != (char*) 0 )
{
/* Write the PID file. */
FILE* pidfp = fopen( pidfile, "w" );
if ( pidfp == (FILE*) 0 )
{
syslog( LOG_CRIT, "%.80s - %m", pidfile );
exit( 1 );
}
(void) fprintf( pidfp, "%d\n", (int) getpid() );
(void) fclose( pidfp );
}
/* Chroot if requested. */
if ( do_chroot )
{
if ( chroot( cwd ) < 0 )
{
syslog( LOG_CRIT, "chroot - %m" );
perror( "chroot" );
exit( 1 );
}
(void) strcpy( cwd, "/" );
/* Always chdir to / after a chroot. */
if ( chdir( cwd ) < 0 )
{
syslog( LOG_CRIT, "chroot chdir - %m" );
perror( "chroot chdir" );
exit( 1 );
}
}
/* Set up to catch signals. */
(void) signal( SIGTERM, handle_term );
(void) signal( SIGINT, handle_term );
(void) signal( SIGPIPE, SIG_IGN ); /* get EPIPE instead */
(void) signal( SIGHUP, handle_hup );
got_usr1 = 0;
(void) signal( SIGUSR1, handle_usr1 );
(void) signal( SIGUSR2, handle_usr2 );
/* Initialize the timer package. */
tmr_init();
/* Initialize the HTTP layer. Got to do this before giving up root,
** so that we can bind to a privileged port.
*/
hs = httpd_initialize(
hostname,
gotv4 ? &sa4 : (httpd_sockaddr*) 0, gotv6 ? &sa6 : (httpd_sockaddr*) 0,
port, cgi_pattern, charset, cwd, no_log, logfp, no_symlink, do_vhost,
do_global_passwd, url_pattern, local_pattern, no_empty_referers );
if ( hs == (httpd_server*) 0 )
exit( 1 );
/* Set up the occasional timer. */
if ( tmr_create( (struct timeval*) 0, occasional, JunkClientData, OCCASIONAL_TIME * 1000L, 1 ) == (Timer*) 0 )
{
syslog( LOG_CRIT, "tmr_create(occasional) failed" );
exit( 1 );
}
if ( numthrottles > 0 )
{
/* Set up the throttles timer. */
if ( tmr_create( (struct timeval*) 0, update_throttles, JunkClientData, THROTTLE_TIME * 1000L, 1 ) == (Timer*) 0 )
{
syslog( LOG_CRIT, "tmr_create(update_throttles) failed" );
exit( 1 );
}
}
#ifdef STATS_TIME
/* Set up the stats timer. */
if ( tmr_create( (struct timeval*) 0, show_stats, JunkClientData, STATS_TIME * 1000L, 1 ) == (Timer*) 0 )
{
syslog( LOG_CRIT, "tmr_create(show_stats) failed" );
exit( 1 );
}
#endif /* STATS_TIME */
start_time = stats_time = time( (time_t*) 0 );
stats_connections = stats_bytes = 0L;
stats_simultaneous = 0;
/* If we're root, try to become someone else. */
if ( getuid() == 0 )
{
/* Set aux groups to null. */
if ( setgroups( 0, (const gid_t*) 0 ) < 0 )
{
syslog( LOG_CRIT, "setgroups - %m" );
exit( 1 );
}
/* Set primary group. */
if ( setgid( gid ) < 0 )
{
syslog( LOG_CRIT, "setgid - %m" );
exit( 1 );
}
/* Try setting aux groups correctly - not critical if this fails. */
if ( initgroups( user, gid ) < 0 )
syslog( LOG_WARNING, "initgroups - %m" );
#ifdef HAVE_SETLOGIN
/* Set login name. */
(void) setlogin( user );
#endif /* HAVE_SETLOGIN */
/* Set uid. */
if ( setuid( uid ) < 0 )
{
syslog( LOG_CRIT, "setuid - %m" );
exit( 1 );
}
/* Check for unnecessary security exposure. */
if ( ! do_chroot )
syslog(
LOG_CRIT,
"started as root without requesting chroot(), warning only" );
}
/* Initialize our connections table. */
maxconnects = fdwatch_get_nfiles();
if ( maxconnects < 0 )
{
syslog( LOG_CRIT, "fdwatch initialization failure" );
exit( 1 );
}
maxconnects -= SPARE_FDS;
connects = NEW( connecttab, maxconnects );
if ( connects == (connecttab*) 0 )
{
syslog( LOG_CRIT, "out of memory allocating a connecttab" );
exit( 1 );
}
for ( cnum = 0; cnum < maxconnects; ++cnum )
{
connects[cnum].conn_state = CNST_FREE;
connects[cnum].hc = (httpd_conn*) 0;
}
numconnects = 0;
httpd_conn_count = 0;
if ( hs != (httpd_server*) 0 )
{
if ( hs->listen4_fd != -1 )
fdwatch_add_fd( hs->listen4_fd, (void*) 0, FDW_READ );
if ( hs->listen6_fd != -1 )
fdwatch_add_fd( hs->listen6_fd, (void*) 0, FDW_READ );
}
/* Main loop. */
(void) gettimeofday( &tv, (struct timezone*) 0 );
while ( ( ! terminate ) || numconnects > 0 )
{
/* Do the fd watch. */
num_ready = fdwatch( tmr_mstimeout( &tv ) );
if ( num_ready < 0 )
{
if ( errno == EINTR )
continue; /* try again */
syslog( LOG_ERR, "fdwatch - %m" );
exit( 1 );
}
(void) gettimeofday( &tv, (struct timezone*) 0 );
if ( num_ready == 0 )
{
/* No fd's are ready - run the timers. */
tmr_run( &tv );
continue;
}
/* Is it a new connection? */
if ( hs != (httpd_server*) 0 && hs->listen6_fd != -1 &&
fdwatch_check_fd( hs->listen6_fd ) )
{
if ( handle_newconnect( &tv, hs->listen6_fd ) )
/* Go around the loop and do another fdwatch, rather than
** dropping through and processing existing connections.
** New connections always get priority.
*/
continue;
}
if ( hs != (httpd_server*) 0 && hs->listen4_fd != -1 &&
fdwatch_check_fd( hs->listen4_fd ) )
{
if ( handle_newconnect( &tv, hs->listen4_fd ) )
/* Go around the loop and do another fdwatch, rather than
** dropping through and processing existing connections.
** New connections always get priority.
*/
continue;
}
/* Find the connections that need servicing. */
for ( ridx = 0; ridx < num_ready; ++ridx )
{
c = (connecttab*) fdwatch_get_client_data( ridx );
if ( c == (connecttab*) 0 )
continue;
hc = c->hc;
if ( c->conn_state == CNST_READING &&
fdwatch_check_fd( hc->conn_fd ) )
handle_read( c, &tv );
else if ( c->conn_state == CNST_SENDING &&
fdwatch_check_fd( hc->conn_fd ) )
handle_send( c, &tv );
else if ( c->conn_state == CNST_LINGERING &&
fdwatch_check_fd( hc->conn_fd ) )
handle_linger( c, &tv );
}
tmr_run( &tv );
if ( got_usr1 && ! terminate )
{
terminate = 1;
if ( hs != (httpd_server*) 0 )
{
httpd_terminate( hs );
hs = (httpd_server*) 0;
}
}
}
/* The main loop terminated. */
shut_down();
syslog( LOG_NOTICE, "exiting" );
closelog();
exit( 0 );
}
static int
handle_newconnect( struct timeval* tvP, int listen_fd )
{
int cnum;
connecttab* c;
ClientData client_data;
/* This loops until the accept() fails, trying to start new
** connections as fast as possible so we don't overrun the
** listen queue.
*/
for (;;)
{
/* Is there room in the connection table? */
if ( numconnects >= maxconnects )
{
/* Out of connection slots. Run the timers, then the
** existing connections, and maybe we'll free up a slot
** by the time we get back here.
**/
syslog( LOG_WARNING, "too many connections!" );
tmr_run( tvP );
return 0;
}
/* Find a free connection entry. */
for ( cnum = 0; cnum < maxconnects; ++cnum )
if ( connects[cnum].conn_state == CNST_FREE )
break;
c = &connects[cnum];
/* Make the httpd_conn if necessary. */
if ( c->hc == (httpd_conn*) 0 )
{
c->hc = NEW( httpd_conn, 1 );
if ( c->hc == (httpd_conn*) 0 )
{
syslog( LOG_CRIT, "out of memory allocating an httpd_conn" );
exit( 1 );
}
c->hc->initialized = 0;
++httpd_conn_count;
}
/* Get the connection. */
switch ( httpd_get_conn( hs, listen_fd, c->hc ) )
{
case GC_FAIL:
case GC_NO_MORE:
return 1;
}
c->conn_state = CNST_READING;
++numconnects;
client_data.p = c;
c->idle_read_timer = tmr_create(
tvP, idle_read_connection, client_data, IDLE_READ_TIMELIMIT * 1000L,
0 );
if ( c->idle_read_timer == (Timer*) 0 )
{
syslog( LOG_CRIT, "tmr_create(idle_read_connection) failed" );
exit( 1 );
}
c->idle_send_timer = (Timer*) 0;
c->wakeup_timer = (Timer*) 0;
c->linger_timer = (Timer*) 0;
c->bytes_sent = 0;
c->numtnums = 0;
/* Set the connection file descriptor to no-delay mode. */
httpd_set_ndelay( c->hc->conn_fd );
fdwatch_add_fd( c->hc->conn_fd, c, FDW_READ );
++stats_connections;
if ( numconnects > stats_simultaneous )
stats_simultaneous = numconnects;
}
}
