1: /* thttpd.c - tiny/turbo/throttling HTTP server
2: **
3: ** Copyright © 1995,1998,1999,2000,2001 by Jef Poskanzer <jef@mail.acme.com>.
4: ** All rights reserved.
5: **
6: ** Redistribution and use in source and binary forms, with or without
7: ** modification, are permitted provided that the following conditions
8: ** are met:
9: ** 1. Redistributions of source code must retain the above copyright
10: ** notice, this list of conditions and the following disclaimer.
11: ** 2. Redistributions in binary form must reproduce the above copyright
12: ** notice, this list of conditions and the following disclaimer in the
13: ** documentation and/or other materials provided with the distribution.
14: **
15: ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16: ** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17: ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18: ** ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19: ** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20: ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21: ** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22: ** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23: ** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24: ** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25: ** SUCH DAMAGE.
26: */
27:
28:
29: #include "config.h"
30: #include "version.h"
31:
32: #include <sys/param.h>
33: #include <sys/types.h>
34: #include <sys/time.h>
35: #include <sys/stat.h>
36: #include <sys/wait.h>
37: #include <sys/uio.h>
38:
39: #include <errno.h>
40: #ifdef HAVE_FCNTL_H
41: #include <fcntl.h>
42: #endif
43: #include <pwd.h>
44: #ifdef HAVE_GRP_H
45: #include <grp.h>
46: #endif
47: #include <signal.h>
48: #include <stdio.h>
49: #include <stdlib.h>
50: #include <string.h>
51: #include <syslog.h>
52: #ifdef TIME_WITH_SYS_TIME
53: #include <time.h>
54: #endif
55: #include <unistd.h>
56:
57: #include "fdwatch.h"
58: #include "libhttpd.h"
59: #include "mmc.h"
60: #include "timers.h"
61: #include "match.h"
62:
63: #ifndef SHUT_WR
64: #define SHUT_WR 1
65: #endif
66:
67: #ifndef HAVE_INT64T
68: typedef long long int64_t;
69: #endif
70:
71:
72: static char* argv0;
73: static int debug;
74: static unsigned short port;
75: static char* dir;
76: static char* data_dir;
77: static int do_chroot, no_log, no_symlink_check, do_vhost, do_global_passwd;
78: static char* cgi_pattern;
79: static int cgi_limit;
80: static char* url_pattern;
81: static int no_empty_referers;
82: static char* local_pattern;
83: static char* logfile;
84: static char* throttlefile;
85: static char* hostname;
86: static char* pidfile;
87: static char* user;
88: static char* charset;
89: static char* p3p;
90: static int max_age;
91:
92:
93: typedef struct {
94: char* pattern;
95: long max_limit, min_limit;
96: long rate;
97: off_t bytes_since_avg;
98: int num_sending;
99: } throttletab;
100: static throttletab* throttles;
101: static int numthrottles, maxthrottles;
102:
103: #define THROTTLE_NOLIMIT -1
104:
105:
106: typedef struct {
107: int conn_state;
108: int next_free_connect;
109: httpd_conn* hc;
110: int tnums[MAXTHROTTLENUMS]; /* throttle indexes */
111: int numtnums;
112: long max_limit, min_limit;
113: time_t started_at, active_at;
114: Timer* wakeup_timer;
115: Timer* linger_timer;
116: long wouldblock_delay;
117: off_t bytes;
118: off_t end_byte_index;
119: off_t next_byte_index;
120: } connecttab;
121: static connecttab* connects;
122: static int num_connects, max_connects, first_free_connect;
123: static int httpd_conn_count;
124:
125: /* The connection states. */
126: #define CNST_FREE 0
127: #define CNST_READING 1
128: #define CNST_SENDING 2
129: #define CNST_PAUSING 3
130: #define CNST_LINGERING 4
131:
132:
133: static httpd_server* hs = (httpd_server*) 0;
134: int terminate = 0;
135: time_t start_time, stats_time;
136: long stats_connections;
137: off_t stats_bytes;
138: int stats_simultaneous;
139:
140: static volatile int got_hup, got_usr1, watchdog_flag;
141:
142:
143: /* Forwards. */
144: static void parse_args( int argc, char** argv );
145: static void usage( void );
146: static void read_config( char* filename );
147: static void value_required( char* name, char* value );
148: static void no_value_required( char* name, char* value );
149: static char* e_strdup( char* oldstr );
150: static void lookup_hostname( httpd_sockaddr* sa4P, size_t sa4_len, int* gotv4P, httpd_sockaddr* sa6P, size_t sa6_len, int* gotv6P );
151: static void read_throttlefile( char* throttlefile );
152: static void shut_down( void );
153: static int handle_newconnect( struct timeval* tvP, int listen_fd );
154: static void handle_read( connecttab* c, struct timeval* tvP );
155: static void handle_send( connecttab* c, struct timeval* tvP );
156: static void handle_linger( connecttab* c, struct timeval* tvP );
157: static int check_throttles( connecttab* c );
158: static void clear_throttles( connecttab* c, struct timeval* tvP );
159: static void update_throttles( ClientData client_data, struct timeval* nowP );
160: static void finish_connection( connecttab* c, struct timeval* tvP );
161: static void clear_connection( connecttab* c, struct timeval* tvP );
162: static void really_clear_connection( connecttab* c, struct timeval* tvP );
163: static void idle( ClientData client_data, struct timeval* nowP );
164: static void wakeup_connection( ClientData client_data, struct timeval* nowP );
165: static void linger_clear_connection( ClientData client_data, struct timeval* nowP );
166: static void occasional( ClientData client_data, struct timeval* nowP );
167: #ifdef STATS_TIME
168: static void show_stats( ClientData client_data, struct timeval* nowP );
169: #endif /* STATS_TIME */
170: static void logstats( struct timeval* nowP );
171: static void thttpd_logstats( long secs );
172:
173:
174: /* SIGTERM and SIGINT say to exit immediately. */
175: static void
176: handle_term( int sig )
177: {
178: /* Don't need to set up the handler again, since it's a one-shot. */
179:
180: shut_down();
181: syslog( LOG_NOTICE, "exiting due to signal %d", sig );
182: closelog();
183: exit( 1 );
184: }
185:
186:
187: /* SIGCHLD - a chile process exitted, so we need to reap the zombie */
188: static void
189: handle_chld( int sig )
190: {
191: const int oerrno = errno;
192: pid_t pid;
193: int status;
194:
195: #ifndef HAVE_SIGSET
196: /* Set up handler again. */
197: (void) signal( SIGCHLD, handle_chld );
198: #endif /* ! HAVE_SIGSET */
199:
200: /* Reap defunct children until there aren't any more. */
201: for (;;)
202: {
203: #ifdef HAVE_WAITPID
204: pid = waitpid( (pid_t) -1, &status, WNOHANG );
205: #else /* HAVE_WAITPID */
206: pid = wait3( &status, WNOHANG, (struct rusage*) 0 );
207: #endif /* HAVE_WAITPID */
208: if ( (int) pid == 0 ) /* none left */
209: break;
210: if ( (int) pid < 0 )
211: {
212: if ( errno == EINTR || errno == EAGAIN )
213: continue;
214: /* ECHILD shouldn't happen with the WNOHANG option,
215: ** but with some kernels it does anyway. Ignore it.
216: */
217: if ( errno != ECHILD )
218: syslog( LOG_ERR, "child wait - %m" );
219: break;
220: }
221: /* Decrement the CGI count. Note that this is not accurate, since
222: ** each CGI can involve two or even three child processes.
223: ** Decrementing for each child means that when there is heavy CGI
224: ** activity, the count will be lower than it should be, and therefore
225: ** more CGIs will be allowed than should be.
226: */
227: if ( hs != (httpd_server*) 0 )
228: {
229: --hs->cgi_count;
230: if ( hs->cgi_count < 0 )
231: hs->cgi_count = 0;
232: }
233: }
234:
235: /* Restore previous errno. */
236: errno = oerrno;
237: }
238:
239:
240: /* SIGHUP says to re-open the log file. */
241: static void
242: handle_hup( int sig )
243: {
244: const int oerrno = errno;
245:
246: #ifndef HAVE_SIGSET
247: /* Set up handler again. */
248: (void) signal( SIGHUP, handle_hup );
249: #endif /* ! HAVE_SIGSET */
250:
251: /* Just set a flag that we got the signal. */
252: got_hup = 1;
253:
254: /* Restore previous errno. */
255: errno = oerrno;
256: }
257:
258:
259: /* SIGUSR1 says to exit as soon as all current connections are done. */
260: static void
261: handle_usr1( int sig )
262: {
263: /* Don't need to set up the handler again, since it's a one-shot. */
264:
265: if ( num_connects == 0 )
266: {
267: /* If there are no active connections we want to exit immediately
268: ** here. Not only is it faster, but without any connections the
269: ** main loop won't wake up until the next new connection.
270: */
271: shut_down();
272: syslog( LOG_NOTICE, "exiting" );
273: closelog();
274: exit( 0 );
275: }
276:
277: /* Otherwise, just set a flag that we got the signal. */
278: got_usr1 = 1;
279:
280: /* Don't need to restore old errno, since we didn't do any syscalls. */
281: }
282:
283:
284: /* SIGUSR2 says to generate the stats syslogs immediately. */
285: static void
286: handle_usr2( int sig )
287: {
288: const int oerrno = errno;
289:
290: #ifndef HAVE_SIGSET
291: /* Set up handler again. */
292: (void) signal( SIGUSR2, handle_usr2 );
293: #endif /* ! HAVE_SIGSET */
294:
295: logstats( (struct timeval*) 0 );
296:
297: /* Restore previous errno. */
298: errno = oerrno;
299: }
300:
301:
302: /* SIGALRM is used as a watchdog. */
303: static void
304: handle_alrm( int sig )
305: {
306: const int oerrno = errno;
307:
308: /* If nothing has been happening */
309: if ( ! watchdog_flag )
310: {
311: /* Try changing dirs to someplace we can write. */
312: (void) chdir( "/tmp" );
313: /* Dump core. */
314: abort();
315: }
316: watchdog_flag = 0;
317:
318: #ifndef HAVE_SIGSET
319: /* Set up handler again. */
320: (void) signal( SIGALRM, handle_alrm );
321: #endif /* ! HAVE_SIGSET */
322: /* Set up alarm again. */
323: (void) alarm( OCCASIONAL_TIME * 3 );
324:
325: /* Restore previous errno. */
326: errno = oerrno;
327: }
328:
329:
330: static void
331: re_open_logfile( void )
332: {
333: FILE* logfp;
334:
335: if ( no_log || hs == (httpd_server*) 0 )
336: return;
337:
338: /* Re-open the log file. */
339: if ( logfile != (char*) 0 && strcmp( logfile, "-" ) != 0 )
340: {
341: syslog( LOG_NOTICE, "re-opening logfile" );
342: logfp = fopen( logfile, "a" );
343: if ( logfp == (FILE*) 0 )
344: {
345: syslog( LOG_CRIT, "re-opening %.80s - %m", logfile );
346: return;
347: }
348: (void) fcntl( fileno( logfp ), F_SETFD, 1 );
349: httpd_set_logfp( hs, logfp );
350: }
351: }
352:
353:
354: int
355: main( int argc, char** argv )
356: {
357: char* cp;
358: struct passwd* pwd;
359: uid_t uid = 32767;
360: gid_t gid = 32767;
361: char cwd[MAXPATHLEN+1];
362: FILE* logfp;
363: int num_ready;
364: int cnum;
365: connecttab* c;
366: httpd_conn* hc;
367: httpd_sockaddr sa4;
368: httpd_sockaddr sa6;
369: int gotv4, gotv6;
370: struct timeval tv;
371:
372: argv0 = argv[0];
373:
374: cp = strrchr( argv0, '/' );
375: if ( cp != (char*) 0 )
376: ++cp;
377: else
378: cp = argv0;
379: openlog( cp, LOG_NDELAY|LOG_PID, LOG_FACILITY );
380:
381: /* Handle command-line arguments. */
382: parse_args( argc, argv );
383:
384: /* Read zone info now, in case we chroot(). */
385: tzset();
386:
387: /* Look up hostname now, in case we chroot(). */
388: lookup_hostname( &sa4, sizeof(sa4), &gotv4, &sa6, sizeof(sa6), &gotv6 );
389: if ( ! ( gotv4 || gotv6 ) )
390: {
391: syslog( LOG_ERR, "can't find any valid address" );
392: (void) fprintf( stderr, "%s: can't find any valid address\n", argv0 );
393: exit( 1 );
394: }
395:
396: /* Throttle file. */
397: numthrottles = 0;
398: maxthrottles = 0;
399: throttles = (throttletab*) 0;
400: if ( throttlefile != (char*) 0 )
401: read_throttlefile( throttlefile );
402:
403: /* If we're root and we're going to become another user, get the uid/gid
404: ** now.
405: */
406: if ( getuid() == 0 )
407: {
408: pwd = getpwnam( user );
409: if ( pwd == (struct passwd*) 0 )
410: {
411: syslog( LOG_CRIT, "unknown user - '%.80s'", user );
412: (void) fprintf( stderr, "%s: unknown user - '%s'\n", argv0, user );
413: exit( 1 );
414: }
415: uid = pwd->pw_uid;
416: gid = pwd->pw_gid;
417: }
418:
419: /* Log file. */
420: if ( logfile != (char*) 0 )
421: {
422: if ( strcmp( logfile, "/dev/null" ) == 0 )
423: {
424: no_log = 1;
425: logfp = (FILE*) 0;
426: }
427: else if ( strcmp( logfile, "-" ) == 0 )
428: logfp = stdout;
429: else
430: {
431: logfp = fopen( logfile, "a" );
432: if ( logfp == (FILE*) 0 )
433: {
434: syslog( LOG_CRIT, "%.80s - %m", logfile );
435: perror( logfile );
436: exit( 1 );
437: }
438: if ( logfile[0] != '/' )
439: {
440: syslog( LOG_WARNING, "logfile is not an absolute path, you may not be able to re-open it" );
441: (void) fprintf( stderr, "%s: logfile is not an absolute path, you may not be able to re-open it\n", argv0 );
442: }
443: (void) fcntl( fileno( logfp ), F_SETFD, 1 );
444: if ( getuid() == 0 )
445: {
446: /* If we are root then we chown the log file to the user we'll
447: ** be switching to.
448: */
449: if ( fchown( fileno( logfp ), uid, gid ) < 0 )
450: {
451: syslog( LOG_WARNING, "fchown logfile - %m" );
452: perror( "fchown logfile" );
453: }
454: }
455: }
456: }
457: else
458: logfp = (FILE*) 0;
459:
460: /* Switch directories if requested. */
461: if ( dir != (char*) 0 )
462: {
463: if ( chdir( dir ) < 0 )
464: {
465: syslog( LOG_CRIT, "chdir - %m" );
466: perror( "chdir" );
467: exit( 1 );
468: }
469: }
470: #ifdef USE_USER_DIR
471: else if ( getuid() == 0 )
472: {
473: /* No explicit directory was specified, we're root, and the
474: ** USE_USER_DIR option is set - switch to the specified user's
475: ** home dir.
476: */
477: if ( chdir( pwd->pw_dir ) < 0 )
478: {
479: syslog( LOG_CRIT, "chdir - %m" );
480: perror( "chdir" );
481: exit( 1 );
482: }
483: }
484: #endif /* USE_USER_DIR */
485:
486: /* Get current directory. */
487: (void) getcwd( cwd, sizeof(cwd) - 1 );
488: if ( cwd[strlen( cwd ) - 1] != '/' )
489: (void) strcat( cwd, "/" );
490:
491: if ( ! debug )
492: {
493: /* We're not going to use stdin stdout or stderr from here on, so close
494: ** them to save file descriptors.
495: */
496: (void) fclose( stdin );
497: if ( logfp != stdout )
498: (void) fclose( stdout );
499: (void) fclose( stderr );
500:
501: /* Daemonize - make ourselves a subprocess. */
502: #ifdef HAVE_DAEMON
503: if ( daemon( 1, 1 ) < 0 )
504: {
505: syslog( LOG_CRIT, "daemon - %m" );
506: exit( 1 );
507: }
508: #else /* HAVE_DAEMON */
509: switch ( fork() )
510: {
511: case 0:
512: break;
513: case -1:
514: syslog( LOG_CRIT, "fork - %m" );
515: exit( 1 );
516: default:
517: exit( 0 );
518: }
519: #ifdef HAVE_SETSID
520: (void) setsid();
521: #endif /* HAVE_SETSID */
522: #endif /* HAVE_DAEMON */
523: }
524: else
525: {
526: /* Even if we don't daemonize, we still want to disown our parent
527: ** process.
528: */
529: #ifdef HAVE_SETSID
530: (void) setsid();
531: #endif /* HAVE_SETSID */
532: }
533:
534: if ( pidfile != (char*) 0 )
535: {
536: /* Write the PID file. */
537: FILE* pidfp = fopen( pidfile, "w" );
538: if ( pidfp == (FILE*) 0 )
539: {
540: syslog( LOG_CRIT, "%.80s - %m", pidfile );
541: exit( 1 );
542: }
543: (void) fprintf( pidfp, "%d\n", (int) getpid() );
544: (void) fclose( pidfp );
545: }
546:
547: /* Initialize the fdwatch package. Have to do this before chroot,
548: ** if /dev/poll is used.
549: */
550: max_connects = fdwatch_get_nfiles();
551: if ( max_connects < 0 )
552: {
553: syslog( LOG_CRIT, "fdwatch initialization failure" );
554: exit( 1 );
555: }
556: max_connects -= SPARE_FDS;
557:
558: /* Chroot if requested. */
559: if ( do_chroot )
560: {
561: if ( chroot( cwd ) < 0 )
562: {
563: syslog( LOG_CRIT, "chroot - %m" );
564: perror( "chroot" );
565: exit( 1 );
566: }
567: /* If we're logging and the logfile's pathname begins with the
568: ** chroot tree's pathname, then elide the chroot pathname so
569: ** that the logfile pathname still works from inside the chroot
570: ** tree.
571: */
572: if ( logfile != (char*) 0 && strcmp( logfile, "-" ) != 0 )
573: {
574: if ( strncmp( logfile, cwd, strlen( cwd ) ) == 0 )
575: {
576: (void) strcpy( logfile, &logfile[strlen( cwd ) - 1] );
577: /* (We already guaranteed that cwd ends with a slash, so leaving
578: ** that slash in logfile makes it an absolute pathname within
579: ** the chroot tree.)
580: */
581: }
582: else
583: {
584: syslog( LOG_WARNING, "logfile is not within the chroot tree, you will not be able to re-open it" );
585: (void) fprintf( stderr, "%s: logfile is not within the chroot tree, you will not be able to re-open it\n", argv0 );
586: }
587: }
588: (void) strcpy( cwd, "/" );
589: /* Always chdir to / after a chroot. */
590: if ( chdir( cwd ) < 0 )
591: {
592: syslog( LOG_CRIT, "chroot chdir - %m" );
593: perror( "chroot chdir" );
594: exit( 1 );
595: }
596: }
597:
598: /* Switch directories again if requested. */
599: if ( data_dir != (char*) 0 )
600: {
601: if ( chdir( data_dir ) < 0 )
602: {
603: syslog( LOG_CRIT, "data_dir chdir - %m" );
604: perror( "data_dir chdir" );
605: exit( 1 );
606: }
607: }
608:
609: /* Set up to catch signals. */
610: #ifdef HAVE_SIGSET
611: (void) sigset( SIGTERM, handle_term );
612: (void) sigset( SIGINT, handle_term );
613: (void) sigset( SIGCHLD, handle_chld );
614: (void) sigset( SIGPIPE, SIG_IGN ); /* get EPIPE instead */
615: (void) sigset( SIGHUP, handle_hup );
616: (void) sigset( SIGUSR1, handle_usr1 );
617: (void) sigset( SIGUSR2, handle_usr2 );
618: (void) sigset( SIGALRM, handle_alrm );
619: #else /* HAVE_SIGSET */
620: (void) signal( SIGTERM, handle_term );
621: (void) signal( SIGINT, handle_term );
622: (void) signal( SIGCHLD, handle_chld );
623: (void) signal( SIGPIPE, SIG_IGN ); /* get EPIPE instead */
624: (void) signal( SIGHUP, handle_hup );
625: (void) signal( SIGUSR1, handle_usr1 );
626: (void) signal( SIGUSR2, handle_usr2 );
627: (void) signal( SIGALRM, handle_alrm );
628: #endif /* HAVE_SIGSET */
629: got_hup = 0;
630: got_usr1 = 0;
631: watchdog_flag = 0;
632: (void) alarm( OCCASIONAL_TIME * 3 );
633:
634: /* Initialize the timer package. */
635: tmr_init();
636:
637: /* Initialize the HTTP layer. Got to do this before giving up root,
638: ** so that we can bind to a privileged port.
639: */
640: hs = httpd_initialize(
641: hostname,
642: gotv4 ? &sa4 : (httpd_sockaddr*) 0, gotv6 ? &sa6 : (httpd_sockaddr*) 0,
643: port, cgi_pattern, cgi_limit, charset, p3p, max_age, cwd, no_log, logfp,
644: no_symlink_check, do_vhost, do_global_passwd, url_pattern,
645: local_pattern, no_empty_referers );
646: if ( hs == (httpd_server*) 0 )
647: exit( 1 );
648:
649: /* Set up the occasional timer. */
650: if ( tmr_create( (struct timeval*) 0, occasional, JunkClientData, OCCASIONAL_TIME * 1000L, 1 ) == (Timer*) 0 )
651: {
652: syslog( LOG_CRIT, "tmr_create(occasional) failed" );
653: exit( 1 );
654: }
655: /* Set up the idle timer. */
656: if ( tmr_create( (struct timeval*) 0, idle, JunkClientData, 5 * 1000L, 1 ) == (Timer*) 0 )
657: {
658: syslog( LOG_CRIT, "tmr_create(idle) failed" );
659: exit( 1 );
660: }
661: if ( numthrottles > 0 )
662: {
663: /* Set up the throttles timer. */
664: if ( tmr_create( (struct timeval*) 0, update_throttles, JunkClientData, THROTTLE_TIME * 1000L, 1 ) == (Timer*) 0 )
665: {
666: syslog( LOG_CRIT, "tmr_create(update_throttles) failed" );
667: exit( 1 );
668: }
669: }
670: #ifdef STATS_TIME
671: /* Set up the stats timer. */
672: if ( tmr_create( (struct timeval*) 0, show_stats, JunkClientData, STATS_TIME * 1000L, 1 ) == (Timer*) 0 )
673: {
674: syslog( LOG_CRIT, "tmr_create(show_stats) failed" );
675: exit( 1 );
676: }
677: #endif /* STATS_TIME */
678: start_time = stats_time = time( (time_t*) 0 );
679: stats_connections = 0;
680: stats_bytes = 0;
681: stats_simultaneous = 0;
682:
683: /* If we're root, try to become someone else. */
684: if ( getuid() == 0 )
685: {
686: /* Set aux groups to null. */
687: if ( setgroups( 0, (const gid_t*) 0 ) < 0 )
688: {
689: syslog( LOG_CRIT, "setgroups - %m" );
690: exit( 1 );
691: }
692: /* Set primary group. */
693: if ( setgid( gid ) < 0 )
694: {
695: syslog( LOG_CRIT, "setgid - %m" );
696: exit( 1 );
697: }
698: /* Try setting aux groups correctly - not critical if this fails. */
699: if ( initgroups( user, gid ) < 0 )
700: syslog( LOG_WARNING, "initgroups - %m" );
701: #ifdef HAVE_SETLOGIN
702: /* Set login name. */
703: (void) setlogin( user );
704: #endif /* HAVE_SETLOGIN */
705: /* Set uid. */
706: if ( setuid( uid ) < 0 )
707: {
708: syslog( LOG_CRIT, "setuid - %m" );
709: exit( 1 );
710: }
711: /* Check for unnecessary security exposure. */
712: if ( ! do_chroot )
713: syslog(
714: LOG_WARNING,
715: "started as root without requesting chroot(), warning only" );
716: }
717:
718: /* Initialize our connections table. */
719: connects = NEW( connecttab, max_connects );
720: if ( connects == (connecttab*) 0 )
721: {
722: syslog( LOG_CRIT, "out of memory allocating a connecttab" );
723: exit( 1 );
724: }
725: for ( cnum = 0; cnum < max_connects; ++cnum )
726: {
727: connects[cnum].conn_state = CNST_FREE;
728: connects[cnum].next_free_connect = cnum + 1;
729: connects[cnum].hc = (httpd_conn*) 0;
730: }
731: connects[max_connects - 1].next_free_connect = -1; /* end of link list */
732: first_free_connect = 0;
733: num_connects = 0;
734: httpd_conn_count = 0;
735:
736: if ( hs != (httpd_server*) 0 )
737: {
738: if ( hs->listen4_fd != -1 )
739: fdwatch_add_fd( hs->listen4_fd, (void*) 0, FDW_READ );
740: if ( hs->listen6_fd != -1 )
741: fdwatch_add_fd( hs->listen6_fd, (void*) 0, FDW_READ );
742: }
743:
744: /* Main loop. */
745: (void) gettimeofday( &tv, (struct timezone*) 0 );
746: while ( ( ! terminate ) || num_connects > 0 )
747: {
748: /* Do we need to re-open the log file? */
749: if ( got_hup )
750: {
751: re_open_logfile();
752: got_hup = 0;
753: }
754:
755: /* Do the fd watch. */
756: num_ready = fdwatch( tmr_mstimeout( &tv ) );
757: if ( num_ready < 0 )
758: {
759: if ( errno == EINTR || errno == EAGAIN )
760: continue; /* try again */
761: syslog( LOG_ERR, "fdwatch - %m" );
762: exit( 1 );
763: }
764: (void) gettimeofday( &tv, (struct timezone*) 0 );
765:
766: if ( num_ready == 0 )
767: {
768: /* No fd's are ready - run the timers. */
769: tmr_run( &tv );
770: continue;
771: }
772:
773: /* Is it a new connection? */
774: if ( hs != (httpd_server*) 0 && hs->listen6_fd != -1 &&
775: fdwatch_check_fd( hs->listen6_fd ) )
776: {
777: if ( handle_newconnect( &tv, hs->listen6_fd ) )
778: /* Go around the loop and do another fdwatch, rather than
779: ** dropping through and processing existing connections.
780: ** New connections always get priority.
781: */
782: continue;
783: }
784: if ( hs != (httpd_server*) 0 && hs->listen4_fd != -1 &&
785: fdwatch_check_fd( hs->listen4_fd ) )
786: {
787: if ( handle_newconnect( &tv, hs->listen4_fd ) )
788: /* Go around the loop and do another fdwatch, rather than
789: ** dropping through and processing existing connections.
790: ** New connections always get priority.
791: */
792: continue;
793: }
794:
795: /* Find the connections that need servicing. */
796: while ( ( c = (connecttab*) fdwatch_get_next_client_data() ) != (connecttab*) -1 )
797: {
798: if ( c == (connecttab*) 0 )
799: continue;
800: hc = c->hc;
801: if ( ! fdwatch_check_fd( hc->conn_fd ) )
802: /* Something went wrong. */
803: clear_connection( c, &tv );
804: else
805: switch ( c->conn_state )
806: {
807: case CNST_READING: handle_read( c, &tv ); break;
808: case CNST_SENDING: handle_send( c, &tv ); break;
809: case CNST_LINGERING: handle_linger( c, &tv ); break;
810: }
811: }
812: tmr_run( &tv );
813:
814: if ( got_usr1 && ! terminate )
815: {
816: terminate = 1;
817: if ( hs != (httpd_server*) 0 )
818: {
819: if ( hs->listen4_fd != -1 )
820: fdwatch_del_fd( hs->listen4_fd );
821: if ( hs->listen6_fd != -1 )
822: fdwatch_del_fd( hs->listen6_fd );
823: httpd_unlisten( hs );
824: }
825: }
826: }
827:
828: /* The main loop terminated. */
829: shut_down();
830: syslog( LOG_NOTICE, "exiting" );
831: closelog();
832: exit( 0 );
833: }
834:
835:
836: static void
837: parse_args( int argc, char** argv )
838: {
839: int argn;
840:
841: debug = 0;
842: port = DEFAULT_PORT;
843: dir = (char*) 0;
844: data_dir = (char*) 0;
845: #ifdef ALWAYS_CHROOT
846: do_chroot = 1;
847: #else /* ALWAYS_CHROOT */
848: do_chroot = 0;
849: #endif /* ALWAYS_CHROOT */
850: no_log = 0;
851: no_symlink_check = do_chroot;
852: #ifdef ALWAYS_VHOST
853: do_vhost = 1;
854: #else /* ALWAYS_VHOST */
855: do_vhost = 0;
856: #endif /* ALWAYS_VHOST */
857: #ifdef ALWAYS_GLOBAL_PASSWD
858: do_global_passwd = 1;
859: #else /* ALWAYS_GLOBAL_PASSWD */
860: do_global_passwd = 0;
861: #endif /* ALWAYS_GLOBAL_PASSWD */
862: #ifdef CGI_PATTERN
863: cgi_pattern = CGI_PATTERN;
864: #else /* CGI_PATTERN */
865: cgi_pattern = (char*) 0;
866: #endif /* CGI_PATTERN */
867: #ifdef CGI_LIMIT
868: cgi_limit = CGI_LIMIT;
869: #else /* CGI_LIMIT */
870: cgi_limit = 0;
871: #endif /* CGI_LIMIT */
872: url_pattern = (char*) 0;
873: no_empty_referers = 0;
874: local_pattern = (char*) 0;
875: throttlefile = (char*) 0;
876: hostname = (char*) 0;
877: logfile = (char*) 0;
878: pidfile = (char*) 0;
879: user = DEFAULT_USER;
880: charset = DEFAULT_CHARSET;
881: p3p = "";
882: max_age = -1;
883: argn = 1;
884: while ( argn < argc && argv[argn][0] == '-' )
885: {
886: if ( strcmp( argv[argn], "-V" ) == 0 )
887: {
888: (void) printf( "%s\n", SERVER_SOFTWARE );
889: exit( 0 );
890: }
891: else if ( strcmp( argv[argn], "-C" ) == 0 && argn + 1 < argc )
892: {
893: ++argn;
894: read_config( argv[argn] );
895: }
896: else if ( strcmp( argv[argn], "-p" ) == 0 && argn + 1 < argc )
897: {
898: ++argn;
899: port = (unsigned short) atoi( argv[argn] );
900: }
901: else if ( strcmp( argv[argn], "-d" ) == 0 && argn + 1 < argc )
902: {
903: ++argn;
904: dir = argv[argn];
905: }
906: else if ( strcmp( argv[argn], "-r" ) == 0 )
907: {
908: do_chroot = 1;
909: no_symlink_check = 1;
910: }
911: else if ( strcmp( argv[argn], "-nor" ) == 0 )
912: {
913: do_chroot = 0;
914: no_symlink_check = 0;
915: }
916: else if ( strcmp( argv[argn], "-dd" ) == 0 && argn + 1 < argc )
917: {
918: ++argn;
919: data_dir = argv[argn];
920: }
921: else if ( strcmp( argv[argn], "-s" ) == 0 )
922: no_symlink_check = 0;
923: else if ( strcmp( argv[argn], "-nos" ) == 0 )
924: no_symlink_check = 1;
925: else if ( strcmp( argv[argn], "-u" ) == 0 && argn + 1 < argc )
926: {
927: ++argn;
928: user = argv[argn];
929: }
930: else if ( strcmp( argv[argn], "-c" ) == 0 && argn + 1 < argc )
931: {
932: ++argn;
933: cgi_pattern = argv[argn];
934: }
935: else if ( strcmp( argv[argn], "-t" ) == 0 && argn + 1 < argc )
936: {
937: ++argn;
938: throttlefile = argv[argn];
939: }
940: else if ( strcmp( argv[argn], "-h" ) == 0 && argn + 1 < argc )
941: {
942: ++argn;
943: hostname = argv[argn];
944: }
945: else if ( strcmp( argv[argn], "-l" ) == 0 && argn + 1 < argc )
946: {
947: ++argn;
948: logfile = argv[argn];
949: }
950: else if ( strcmp( argv[argn], "-v" ) == 0 )
951: do_vhost = 1;
952: else if ( strcmp( argv[argn], "-nov" ) == 0 )
953: do_vhost = 0;
954: else if ( strcmp( argv[argn], "-g" ) == 0 )
955: do_global_passwd = 1;
956: else if ( strcmp( argv[argn], "-nog" ) == 0 )
957: do_global_passwd = 0;
958: else if ( strcmp( argv[argn], "-i" ) == 0 && argn + 1 < argc )
959: {
960: ++argn;
961: pidfile = argv[argn];
962: }
963: else if ( strcmp( argv[argn], "-T" ) == 0 && argn + 1 < argc )
964: {
965: ++argn;
966: charset = argv[argn];
967: }
968: else if ( strcmp( argv[argn], "-P" ) == 0 && argn + 1 < argc )
969: {
970: ++argn;
971: p3p = argv[argn];
972: }
973: else if ( strcmp( argv[argn], "-M" ) == 0 && argn + 1 < argc )
974: {
975: ++argn;
976: max_age = atoi( argv[argn] );
977: }
978: else if ( strcmp( argv[argn], "-D" ) == 0 )
979: debug = 1;
980: else
981: usage();
982: ++argn;
983: }
984: if ( argn != argc )
985: usage();
986: }
987:
988:
989: static void
990: usage( void )
991: {
992: (void) fprintf( stderr,
993: "usage: %s [-C configfile] [-p port] [-d dir] [-r|-nor] [-dd data_dir] [-s|-nos] [-v|-nov] [-g|-nog] [-u user] [-c cgipat] [-t throttles] [-h host] [-l logfile] [-i pidfile] [-T charset] [-P P3P] [-M maxage] [-V] [-D]\n",
994: argv0 );
995: exit( 1 );
996: }
997:
998:
999: static void
1000: read_config( char* filename )
1001: {
1002: FILE* fp;
1003: char line[10000];
1004: char* cp;
1005: char* cp2;
1006: char* name;
1007: char* value;
1008:
1009: fp = fopen( filename, "r" );
1010: if ( fp == (FILE*) 0 )
1011: {
1012: perror( filename );
1013: exit( 1 );
1014: }
1015:
1016: while ( fgets( line, sizeof(line), fp ) != (char*) 0 )
1017: {
1018: /* Trim comments. */
1019: if ( ( cp = strchr( line, '#' ) ) != (char*) 0 )
1020: *cp = '\0';
1021:
1022: /* Skip leading whitespace. */
1023: cp = line;
1024: cp += strspn( cp, " \t\n\r" );
1025:
1026: /* Split line into words. */
1027: while ( *cp != '\0' )
1028: {
1029: /* Find next whitespace. */
1030: cp2 = cp + strcspn( cp, " \t\n\r" );
1031: /* Insert EOS and advance next-word pointer. */
1032: while ( *cp2 == ' ' || *cp2 == '\t' || *cp2 == '\n' || *cp2 == '\r' )
1033: *cp2++ = '\0';
1034: /* Split into name and value. */
1035: name = cp;
1036: value = strchr( name, '=' );
1037: if ( value != (char*) 0 )
1038: *value++ = '\0';
1039: /* Interpret. */
1040: if ( strcasecmp( name, "debug" ) == 0 )
1041: {
1042: no_value_required( name, value );
1043: debug = 1;
1044: }
1045: else if ( strcasecmp( name, "port" ) == 0 )
1046: {
1047: value_required( name, value );
1048: port = (unsigned short) atoi( value );
1049: }
1050: else if ( strcasecmp( name, "dir" ) == 0 )
1051: {
1052: value_required( name, value );
1053: dir = e_strdup( value );
1054: }
1055: else if ( strcasecmp( name, "chroot" ) == 0 )
1056: {
1057: no_value_required( name, value );
1058: do_chroot = 1;
1059: no_symlink_check = 1;
1060: }
1061: else if ( strcasecmp( name, "nochroot" ) == 0 )
1062: {
1063: no_value_required( name, value );
1064: do_chroot = 0;
1065: no_symlink_check = 0;
1066: }
1067: else if ( strcasecmp( name, "data_dir" ) == 0 )
1068: {
1069: value_required( name, value );
1070: data_dir = e_strdup( value );
1071: }
1072: else if ( strcasecmp( name, "symlink" ) == 0 )
1073: {
1074: no_value_required( name, value );
1075: no_symlink_check = 0;
1076: }
1077: else if ( strcasecmp( name, "nosymlink" ) == 0 )
1078: {
1079: no_value_required( name, value );
1080: no_symlink_check = 1;
1081: }
1082: else if ( strcasecmp( name, "symlinks" ) == 0 )
1083: {
1084: no_value_required( name, value );
1085: no_symlink_check = 0;
1086: }
1087: else if ( strcasecmp( name, "nosymlinks" ) == 0 )
1088: {
1089: no_value_required( name, value );
1090: no_symlink_check = 1;
1091: }
1092: else if ( strcasecmp( name, "user" ) == 0 )
1093: {
1094: value_required( name, value );
1095: user = e_strdup( value );
1096: }
1097: else if ( strcasecmp( name, "cgipat" ) == 0 )
1098: {
1099: value_required( name, value );
1100: cgi_pattern = e_strdup( value );
1101: }
1102: else if ( strcasecmp( name, "cgilimit" ) == 0 )
1103: {
1104: value_required( name, value );
1105: cgi_limit = atoi( value );
1106: }
1107: else if ( strcasecmp( name, "urlpat" ) == 0 )
1108: {
1109: value_required( name, value );
1110: url_pattern = e_strdup( value );
1111: }
1112: else if ( strcasecmp( name, "noemptyreferers" ) == 0 )
1113: {
1114: no_value_required( name, value );
1115: no_empty_referers = 1;
1116: }
1117: else if ( strcasecmp( name, "localpat" ) == 0 )
1118: {
1119: value_required( name, value );
1120: local_pattern = e_strdup( value );
1121: }
1122: else if ( strcasecmp( name, "throttles" ) == 0 )
1123: {
1124: value_required( name, value );
1125: throttlefile = e_strdup( value );
1126: }
1127: else if ( strcasecmp( name, "host" ) == 0 )
1128: {
1129: value_required( name, value );
1130: hostname = e_strdup( value );
1131: }
1132: else if ( strcasecmp( name, "logfile" ) == 0 )
1133: {
1134: value_required( name, value );
1135: logfile = e_strdup( value );
1136: }
1137: else if ( strcasecmp( name, "vhost" ) == 0 )
1138: {
1139: no_value_required( name, value );
1140: do_vhost = 1;
1141: }
1142: else if ( strcasecmp( name, "novhost" ) == 0 )
1143: {
1144: no_value_required( name, value );
1145: do_vhost = 0;
1146: }
1147: else if ( strcasecmp( name, "globalpasswd" ) == 0 )
1148: {
1149: no_value_required( name, value );
1150: do_global_passwd = 1;
1151: }
1152: else if ( strcasecmp( name, "noglobalpasswd" ) == 0 )
1153: {
1154: no_value_required( name, value );
1155: do_global_passwd = 0;
1156: }
1157: else if ( strcasecmp( name, "pidfile" ) == 0 )
1158: {
1159: value_required( name, value );
1160: pidfile = e_strdup( value );
1161: }
1162: else if ( strcasecmp( name, "charset" ) == 0 )
1163: {
1164: value_required( name, value );
1165: charset = e_strdup( value );
1166: }
1167: else if ( strcasecmp( name, "p3p" ) == 0 )
1168: {
1169: value_required( name, value );
1170: p3p = e_strdup( value );
1171: }
1172: else if ( strcasecmp( name, "max_age" ) == 0 )
1173: {
1174: value_required( name, value );
1175: max_age = atoi( value );
1176: }
1177: else
1178: {
1179: (void) fprintf(
1180: stderr, "%s: unknown config option '%s'\n", argv0, name );
1181: exit( 1 );
1182: }
1183:
1184: /* Advance to next word. */
1185: cp = cp2;
1186: cp += strspn( cp, " \t\n\r" );
1187: }
1188: }
1189:
1190: (void) fclose( fp );
1191: }
1192:
1193:
1194: static void
1195: value_required( char* name, char* value )
1196: {
1197: if ( value == (char*) 0 )
1198: {
1199: (void) fprintf(
1200: stderr, "%s: value required for %s option\n", argv0, name );
1201: exit( 1 );
1202: }
1203: }
1204:
1205:
1206: static void
1207: no_value_required( char* name, char* value )
1208: {
1209: if ( value != (char*) 0 )
1210: {
1211: (void) fprintf(
1212: stderr, "%s: no value required for %s option\n",
1213: argv0, name );
1214: exit( 1 );
1215: }
1216: }
1217:
1218:
1219: static char*
1220: e_strdup( char* oldstr )
1221: {
1222: char* newstr;
1223:
1224: newstr = strdup( oldstr );
1225: if ( newstr == (char*) 0 )
1226: {
1227: syslog( LOG_CRIT, "out of memory copying a string" );
1228: (void) fprintf( stderr, "%s: out of memory copying a string\n", argv0 );
1229: exit( 1 );
1230: }
1231: return newstr;
1232: }
1233:
1234:
1235: static void
1236: lookup_hostname( httpd_sockaddr* sa4P, size_t sa4_len, int* gotv4P, httpd_sockaddr* sa6P, size_t sa6_len, int* gotv6P )
1237: {
1238: #ifdef USE_IPV6
1239:
1240: struct addrinfo hints;
1241: char portstr[10];
1242: int gaierr;
1243: struct addrinfo* ai;
1244: struct addrinfo* ai2;
1245: struct addrinfo* aiv6;
1246: struct addrinfo* aiv4;
1247:
1248: (void) memset( &hints, 0, sizeof(hints) );
1249: hints.ai_family = PF_UNSPEC;
1250: hints.ai_flags = AI_PASSIVE;
1251: hints.ai_socktype = SOCK_STREAM;
1252: (void) snprintf( portstr, sizeof(portstr), "%d", (int) port );
1253: if ( (gaierr = getaddrinfo( hostname, portstr, &hints, &ai )) != 0 )
1254: {
1255: syslog(
1256: LOG_CRIT, "getaddrinfo %.80s - %.80s",
1257: hostname, gai_strerror( gaierr ) );
1258: (void) fprintf(
1259: stderr, "%s: getaddrinfo %s - %s\n",
1260: argv0, hostname, gai_strerror( gaierr ) );
1261: exit( 1 );
1262: }
1263:
1264: /* Find the first IPv6 and IPv4 entries. */
1265: aiv6 = (struct addrinfo*) 0;
1266: aiv4 = (struct addrinfo*) 0;
1267: for ( ai2 = ai; ai2 != (struct addrinfo*) 0; ai2 = ai2->ai_next )
1268: {
1269: switch ( ai2->ai_family )
1270: {
1271: case AF_INET6:
1272: if ( aiv6 == (struct addrinfo*) 0 )
1273: aiv6 = ai2;
1274: break;
1275: case AF_INET:
1276: if ( aiv4 == (struct addrinfo*) 0 )
1277: aiv4 = ai2;
1278: break;
1279: }
1280: }
1281:
1282: if ( aiv6 == (struct addrinfo*) 0 )
1283: *gotv6P = 0;
1284: else
1285: {
1286: if ( sa6_len < aiv6->ai_addrlen )
1287: {
1288: syslog(
1289: LOG_CRIT, "%.80s - sockaddr too small (%lu < %lu)",
1290: hostname, (unsigned long) sa6_len,
1291: (unsigned long) aiv6->ai_addrlen );
1292: exit( 1 );
1293: }
1294: (void) memset( sa6P, 0, sa6_len );
1295: (void) memmove( sa6P, aiv6->ai_addr, aiv6->ai_addrlen );
1296: *gotv6P = 1;
1297: }
1298:
1299: if ( aiv4 == (struct addrinfo*) 0 )
1300: *gotv4P = 0;
1301: else
1302: {
1303: if ( sa4_len < aiv4->ai_addrlen )
1304: {
1305: syslog(
1306: LOG_CRIT, "%.80s - sockaddr too small (%lu < %lu)",
1307: hostname, (unsigned long) sa4_len,
1308: (unsigned long) aiv4->ai_addrlen );
1309: exit( 1 );
1310: }
1311: (void) memset( sa4P, 0, sa4_len );
1312: (void) memmove( sa4P, aiv4->ai_addr, aiv4->ai_addrlen );
1313: *gotv4P = 1;
1314: }
1315:
1316: freeaddrinfo( ai );
1317:
1318: #else /* USE_IPV6 */
1319:
1320: struct hostent* he;
1321:
1322: *gotv6P = 0;
1323:
1324: (void) memset( sa4P, 0, sa4_len );
1325: sa4P->sa.sa_family = AF_INET;
1326: if ( hostname == (char*) 0 )
1327: sa4P->sa_in.sin_addr.s_addr = htonl( INADDR_ANY );
1328: else
1329: {
1330: sa4P->sa_in.sin_addr.s_addr = inet_addr( hostname );
1331: if ( (int) sa4P->sa_in.sin_addr.s_addr == -1 )
1332: {
1333: he = gethostbyname( hostname );
1334: if ( he == (struct hostent*) 0 )
1335: {
1336: #ifdef HAVE_HSTRERROR
1337: syslog(
1338: LOG_CRIT, "gethostbyname %.80s - %.80s",
1339: hostname, hstrerror( h_errno ) );
1340: (void) fprintf(
1341: stderr, "%s: gethostbyname %s - %s\n",
1342: argv0, hostname, hstrerror( h_errno ) );
1343: #else /* HAVE_HSTRERROR */
1344: syslog( LOG_CRIT, "gethostbyname %.80s failed", hostname );
1345: (void) fprintf(
1346: stderr, "%s: gethostbyname %s failed\n", argv0, hostname );
1347: #endif /* HAVE_HSTRERROR */
1348: exit( 1 );
1349: }
1350: if ( he->h_addrtype != AF_INET )
1351: {
1352: syslog( LOG_CRIT, "%.80s - non-IP network address", hostname );
1353: (void) fprintf(
1354: stderr, "%s: %s - non-IP network address\n",
1355: argv0, hostname );
1356: exit( 1 );
1357: }
1358: (void) memmove(
1359: &sa4P->sa_in.sin_addr.s_addr, he->h_addr, he->h_length );
1360: }
1361: }
1362: sa4P->sa_in.sin_port = htons( port );
1363: *gotv4P = 1;
1364:
1365: #endif /* USE_IPV6 */
1366: }
1367:
1368:
1369: static void
1370: read_throttlefile( char* throttlefile )
1371: {
1372: FILE* fp;
1373: char buf[5000];
1374: char* cp;
1375: int len;
1376: char pattern[5000];
1377: long max_limit, min_limit;
1378: struct timeval tv;
1379:
1380: fp = fopen( throttlefile, "r" );
1381: if ( fp == (FILE*) 0 )
1382: {
1383: syslog( LOG_CRIT, "%.80s - %m", throttlefile );
1384: perror( throttlefile );
1385: exit( 1 );
1386: }
1387:
1388: (void) gettimeofday( &tv, (struct timezone*) 0 );
1389:
1390: while ( fgets( buf, sizeof(buf), fp ) != (char*) 0 )
1391: {
1392: /* Nuke comments. */
1393: cp = strchr( buf, '#' );
1394: if ( cp != (char*) 0 )
1395: *cp = '\0';
1396:
1397: /* Nuke trailing whitespace. */
1398: len = strlen( buf );
1399: while ( len > 0 &&
1400: ( buf[len-1] == ' ' || buf[len-1] == '\t' ||
1401: buf[len-1] == '\n' || buf[len-1] == '\r' ) )
1402: buf[--len] = '\0';
1403:
1404: /* Ignore empty lines. */
1405: if ( len == 0 )
1406: continue;
1407:
1408: /* Parse line. */
1409: if ( sscanf( buf, " %4900[^ \t] %ld-%ld", pattern, &min_limit, &max_limit ) == 3 )
1410: {}
1411: else if ( sscanf( buf, " %4900[^ \t] %ld", pattern, &max_limit ) == 2 )
1412: min_limit = 0;
1413: else
1414: {
1415: syslog( LOG_CRIT,
1416: "unparsable line in %.80s - %.80s", throttlefile, buf );
1417: (void) fprintf( stderr,
1418: "%s: unparsable line in %.80s - %.80s\n",
1419: argv0, throttlefile, buf );
1420: continue;
1421: }
1422:
1423: /* Nuke any leading slashes in pattern. */
1424: if ( pattern[0] == '/' )
1425: (void) strcpy( pattern, &pattern[1] );
1426: while ( ( cp = strstr( pattern, "|/" ) ) != (char*) 0 )
1427: (void) strcpy( cp + 1, cp + 2 );
1428:
1429: /* Check for room in throttles. */
1430: if ( numthrottles >= maxthrottles )
1431: {
1432: if ( maxthrottles == 0 )
1433: {
1434: maxthrottles = 100; /* arbitrary */
1435: throttles = NEW( throttletab, maxthrottles );
1436: }
1437: else
1438: {
1439: maxthrottles *= 2;
1440: throttles = RENEW( throttles, throttletab, maxthrottles );
1441: }
1442: if ( throttles == (throttletab*) 0 )
1443: {
1444: syslog( LOG_CRIT, "out of memory allocating a throttletab" );
1445: (void) fprintf(
1446: stderr, "%s: out of memory allocating a throttletab\n",
1447: argv0 );
1448: exit( 1 );
1449: }
1450: }
1451:
1452: /* Add to table. */
1453: throttles[numthrottles].pattern = e_strdup( pattern );
1454: throttles[numthrottles].max_limit = max_limit;
1455: throttles[numthrottles].min_limit = min_limit;
1456: throttles[numthrottles].rate = 0;
1457: throttles[numthrottles].bytes_since_avg = 0;
1458: throttles[numthrottles].num_sending = 0;
1459:
1460: ++numthrottles;
1461: }
1462: (void) fclose( fp );
1463: }
1464:
1465:
1466: static void
1467: shut_down( void )
1468: {
1469: int cnum;
1470: struct timeval tv;
1471:
1472: (void) gettimeofday( &tv, (struct timezone*) 0 );
1473: logstats( &tv );
1474: for ( cnum = 0; cnum < max_connects; ++cnum )
1475: {
1476: if ( connects[cnum].conn_state != CNST_FREE )
1477: httpd_close_conn( connects[cnum].hc, &tv );
1478: if ( connects[cnum].hc != (httpd_conn*) 0 )
1479: {
1480: httpd_destroy_conn( connects[cnum].hc );
1481: free( (void*) connects[cnum].hc );
1482: --httpd_conn_count;
1483: connects[cnum].hc = (httpd_conn*) 0;
1484: }
1485: }
1486: if ( hs != (httpd_server*) 0 )
1487: {
1488: httpd_server* ths = hs;
1489: hs = (httpd_server*) 0;
1490: if ( ths->listen4_fd != -1 )
1491: fdwatch_del_fd( ths->listen4_fd );
1492: if ( ths->listen6_fd != -1 )
1493: fdwatch_del_fd( ths->listen6_fd );
1494: httpd_terminate( ths );
1495: }
1496: mmc_destroy();
1497: tmr_destroy();
1498: free( (void*) connects );
1499: if ( throttles != (throttletab*) 0 )
1500: free( (void*) throttles );
1501: }
1502:
1503:
1504: static int
1505: handle_newconnect( struct timeval* tvP, int listen_fd )
1506: {
1507: connecttab* c;
1508: ClientData client_data;
1509:
1510: /* This loops until the accept() fails, trying to start new
1511: ** connections as fast as possible so we don't overrun the
1512: ** listen queue.
1513: */
1514: for (;;)
1515: {
1516: /* Is there room in the connection table? */
1517: if ( num_connects >= max_connects )
1518: {
1519: /* Out of connection slots. Run the timers, then the
1520: ** existing connections, and maybe we'll free up a slot
1521: ** by the time we get back here.
1522: */
1523: syslog( LOG_WARNING, "too many connections!" );
1524: tmr_run( tvP );
1525: return 0;
1526: }
1527: /* Get the first free connection entry off the free list. */
1528: if ( first_free_connect == -1 || connects[first_free_connect].conn_state != CNST_FREE )
1529: {
1530: syslog( LOG_CRIT, "the connects free list is messed up" );
1531: exit( 1 );
1532: }
1533: c = &connects[first_free_connect];
1534: /* Make the httpd_conn if necessary. */
1535: if ( c->hc == (httpd_conn*) 0 )
1536: {
1537: c->hc = NEW( httpd_conn, 1 );
1538: if ( c->hc == (httpd_conn*) 0 )
1539: {
1540: syslog( LOG_CRIT, "out of memory allocating an httpd_conn" );
1541: exit( 1 );
1542: }
1543: c->hc->initialized = 0;
1544: ++httpd_conn_count;
1545: }
1546:
1547: /* Get the connection. */
1548: switch ( httpd_get_conn( hs, listen_fd, c->hc ) )
1549: {
1550: /* Some error happened. Run the timers, then the
1551: ** existing connections. Maybe the error will clear.
1552: */
1553: case GC_FAIL:
1554: tmr_run( tvP );
1555: return 0;
1556:
1557: /* No more connections to accept for now. */
1558: case GC_NO_MORE:
1559: return 1;
1560: }
1561: c->conn_state = CNST_READING;
1562: /* Pop it off the free list. */
1563: first_free_connect = c->next_free_connect;
1564: c->next_free_connect = -1;
1565: ++num_connects;
1566: client_data.p = c;
1567: c->active_at = tvP->tv_sec;
1568: c->wakeup_timer = (Timer*) 0;
1569: c->linger_timer = (Timer*) 0;
1570: c->next_byte_index = 0;
1571: c->numtnums = 0;
1572:
1573: /* Set the connection file descriptor to no-delay mode. */
1574: httpd_set_ndelay( c->hc->conn_fd );
1575:
1576: fdwatch_add_fd( c->hc->conn_fd, c, FDW_READ );
1577:
1578: ++stats_connections;
1579: if ( num_connects > stats_simultaneous )
1580: stats_simultaneous = num_connects;
1581: }
1582: }
1583:
1584:
1585: static void
1586: handle_read( connecttab* c, struct timeval* tvP )
1587: {
1588: int sz;
1589: ClientData client_data;
1590: httpd_conn* hc = c->hc;
1591:
1592: /* Is there room in our buffer to read more bytes? */
1593: if ( hc->read_idx >= hc->read_size )
1594: {
1595: if ( hc->read_size > 5000 )
1596: {
1597: httpd_send_err( hc, 400, httpd_err400title, "", httpd_err400form, "" );
1598: finish_connection( c, tvP );
1599: return;
1600: }
1601: httpd_realloc_str(
1602: &hc->read_buf, &hc->read_size, hc->read_size + 1000 );
1603: }
1604:
1605: /* Read some more bytes. */
1606: sz = read(
1607: hc->conn_fd, &(hc->read_buf[hc->read_idx]),
1608: hc->read_size - hc->read_idx );
1609: if ( sz == 0 )
1610: {
1611: httpd_send_err( hc, 400, httpd_err400title, "", httpd_err400form, "" );
1612: finish_connection( c, tvP );
1613: return;
1614: }
1615: if ( sz < 0 )
1616: {
1617: /* Ignore EINTR and EAGAIN. Also ignore EWOULDBLOCK. At first glance
1618: ** you would think that connections returned by fdwatch as readable
1619: ** should never give an EWOULDBLOCK; however, this apparently can
1620: ** happen if a packet gets garbled.
1621: */
1622: if ( errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK )
1623: return;
1624: httpd_send_err(
1625: hc, 400, httpd_err400title, "", httpd_err400form, "" );
1626: finish_connection( c, tvP );
1627: return;
1628: }
1629: hc->read_idx += sz;
1630: c->active_at = tvP->tv_sec;
1631:
1632: /* Do we have a complete request yet? */
1633: switch ( httpd_got_request( hc ) )
1634: {
1635: case GR_NO_REQUEST:
1636: return;
1637: case GR_BAD_REQUEST:
1638: httpd_send_err( hc, 400, httpd_err400title, "", httpd_err400form, "" );
1639: finish_connection( c, tvP );
1640: return;
1641: }
1642:
1643: /* Yes. Try parsing and resolving it. */
1644: if ( httpd_parse_request( hc ) < 0 )
1645: {
1646: finish_connection( c, tvP );
1647: return;
1648: }
1649:
1650: /* Check the throttle table */
1651: if ( ! check_throttles( c ) )
1652: {
1653: httpd_send_err(
1654: hc, 503, httpd_err503title, "", httpd_err503form, hc->encodedurl );
1655: finish_connection( c, tvP );
1656: return;
1657: }
1658:
1659: /* Start the connection going. */
1660: if ( httpd_start_request( hc, tvP ) < 0 )
1661: {
1662: /* Something went wrong. Close down the connection. */
1663: finish_connection( c, tvP );
1664: return;
1665: }
1666:
1667: /* Fill in end_byte_index. */
1668: if ( hc->got_range )
1669: {
1670: c->next_byte_index = hc->first_byte_index;
1671: c->end_byte_index = hc->last_byte_index + 1;
1672: }
1673: else if ( hc->bytes_to_send < 0 )
1674: c->end_byte_index = 0;
1675: else
1676: c->end_byte_index = hc->bytes_to_send;
1677:
1678: /* Check if it's already handled. */
1679: if ( hc->file_address == (char*) 0 )
1680: {
1681: /* No file address means someone else is handling it. */
1682: int tind;
1683: for ( tind = 0; tind < c->numtnums; ++tind )
1684: throttles[c->tnums[tind]].bytes_since_avg += hc->bytes_sent;
1685: c->next_byte_index = hc->bytes_sent;
1686: finish_connection( c, tvP );
1687: return;
1688: }
1689: if ( c->next_byte_index >= c->end_byte_index )
1690: {
1691: /* There's nothing to send. */
1692: finish_connection( c, tvP );
1693: return;
1694: }
1695:
1696: /* Cool, we have a valid connection and a file to send to it. */
1697: c->conn_state = CNST_SENDING;
1698: c->started_at = tvP->tv_sec;
1699: c->wouldblock_delay = 0;
1700: client_data.p = c;
1701:
1702: fdwatch_del_fd( hc->conn_fd );
1703: fdwatch_add_fd( hc->conn_fd, c, FDW_WRITE );
1704: }
1705:
1706:
1707: static void
1708: handle_send( connecttab* c, struct timeval* tvP )
1709: {
1710: size_t max_bytes;
1711: int sz, coast;
1712: ClientData client_data;
1713: time_t elapsed;
1714: httpd_conn* hc = c->hc;
1715: int tind;
1716:
1717: if ( c->max_limit == THROTTLE_NOLIMIT )
1718: max_bytes = 1000000000L;
1719: else
1720: max_bytes = c->max_limit / 4; /* send at most 1/4 seconds worth */
1721:
1722: /* Do we need to write the headers first? */
1723: if ( hc->responselen == 0 )
1724: {
1725: /* No, just write the file. */
1726: #ifdef USE_SENDFILE
1727: off_t sbytes;
1728:
1729: sz = sendfile(
1730: hc->file_fd, hc->conn_fd, c->next_byte_index,
1731: MIN( c->end_byte_index - c->next_byte_index, max_bytes ),
1732: NULL, &sbytes, 0 );
1733: if (sz == -1 && errno == EAGAIN)
1734: sz = sbytes > 0 ? sbytes : -1;
1735: else if (sz == 0)
1736: sz = sbytes;
1737: #else
1738: sz = write(
1739: hc->conn_fd, &(hc->file_address[c->next_byte_index]),
1740: MIN( c->end_byte_index - c->next_byte_index, max_bytes ) );
1741: #endif
1742: }
1743: else
1744: {
1745: #ifdef USE_SENDFILE
1746: struct sf_hdtr sf;
1747: struct iovec iv;
1748: off_t sbytes;
1749:
1750: iv.iov_base = hc->response;
1751: iv.iov_len = hc->responselen;
1752: sf.headers = &iv;
1753: sf.hdr_cnt = 1;
1754: sf.trailers = NULL;
1755: sf.trl_cnt = 0;
1756: sz = sendfile(
1757: hc->file_fd, hc->conn_fd, c->next_byte_index,
1758: MIN( c->end_byte_index - c->next_byte_index, max_bytes ),
1759: &sf, &sbytes, 0 );
1760: if (sz == -1 && errno == EAGAIN)
1761: sz = sbytes > 0 ? sbytes : -1;
1762: else if (sz == 0)
1763: sz = sbytes;
1764: #else
1765: /* Yes. We'll combine headers and file into a single writev(),
1766: ** hoping that this generates a single packet.
1767: */
1768: struct iovec iv[2];
1769:
1770: iv[0].iov_base = hc->response;
1771: iv[0].iov_len = hc->responselen;
1772: iv[1].iov_base = &(hc->file_address[c->next_byte_index]);
1773: iv[1].iov_len = MIN( c->end_byte_index - c->next_byte_index, max_bytes );
1774: sz = writev( hc->conn_fd, iv, 2 );
1775: #endif
1776: }
1777:
1778: if ( sz < 0 && errno == EINTR )
1779: return;
1780:
1781: if ( sz == 0 ||
1782: ( sz < 0 && ( errno == EWOULDBLOCK || errno == EAGAIN ) ) )
1783: {
1784: /* This shouldn't happen, but some kernels, e.g.
1785: ** SunOS 4.1.x, are broken and select() says that
1786: ** O_NDELAY sockets are always writable even when
1787: ** they're actually not.
1788: **
1789: ** Current workaround is to block sending on this
1790: ** socket for a brief adaptively-tuned period.
1791: ** Fortunately we already have all the necessary
1792: ** blocking code, for use with throttling.
1793: */
1794: c->wouldblock_delay += MIN_WOULDBLOCK_DELAY;
1795: c->conn_state = CNST_PAUSING;
1796: fdwatch_del_fd( hc->conn_fd );
1797: client_data.p = c;
1798: if ( c->wakeup_timer != (Timer*) 0 )
1799: syslog( LOG_ERR, "replacing non-null wakeup_timer!" );
1800: c->wakeup_timer = tmr_create(
1801: tvP, wakeup_connection, client_data, c->wouldblock_delay, 0 );
1802: if ( c->wakeup_timer == (Timer*) 0 )
1803: {
1804: syslog( LOG_CRIT, "tmr_create(wakeup_connection) failed" );
1805: exit( 1 );
1806: }
1807: return;
1808: }
1809:
1810: if ( sz < 0 )
1811: {
1812: /* Something went wrong, close this connection.
1813: **
1814: ** If it's just an EPIPE, don't bother logging, that
1815: ** just means the client hung up on us.
1816: **
1817: ** On some systems, write() occasionally gives an EINVAL.
1818: ** Dunno why, something to do with the socket going
1819: ** bad. Anyway, we don't log those either.
1820: **
1821: ** And ECONNRESET isn't interesting either.
1822: */
1823: if ( errno != EPIPE && errno != EINVAL && errno != ECONNRESET
1824: #ifdef USE_SENDFILE
1825: && errno != ENOTCONN
1826: #endif
1827: )
1828: syslog( LOG_ERR, "write - %m sending %.80s", hc->encodedurl );
1829: clear_connection( c, tvP );
1830: return;
1831: }
1832:
1833: /* Ok, we wrote something. */
1834: c->active_at = tvP->tv_sec;
1835: /* Was this a headers + file writev()? */
1836: if ( hc->responselen > 0 )
1837: {
1838: /* Yes; did we write only part of the headers? */
1839: if ( sz < hc->responselen )
1840: {
1841: /* Yes; move the unwritten part to the front of the buffer. */
1842: int newlen = hc->responselen - sz;
1843: (void) memmove( hc->response, &(hc->response[sz]), newlen );
1844: hc->responselen = newlen;
1845: sz = 0;
1846: }
1847: else
1848: {
1849: /* Nope, we wrote the full headers, so adjust accordingly. */
1850: sz -= hc->responselen;
1851: hc->responselen = 0;
1852: }
1853: }
1854: /* And update how much of the file we wrote. */
1855: c->next_byte_index += sz;
1856: c->hc->bytes_sent += sz;
1857: for ( tind = 0; tind < c->numtnums; ++tind )
1858: throttles[c->tnums[tind]].bytes_since_avg += sz;
1859:
1860: /* Are we done? */
1861: if ( c->next_byte_index >= c->end_byte_index )
1862: {
1863: /* This connection is finished! */
1864: finish_connection( c, tvP );
1865: return;
1866: }
1867:
1868: /* Tune the (blockheaded) wouldblock delay. */
1869: if ( c->wouldblock_delay > MIN_WOULDBLOCK_DELAY )
1870: c->wouldblock_delay -= MIN_WOULDBLOCK_DELAY;
1871:
1872: /* If we're throttling, check if we're sending too fast. */
1873: if ( c->max_limit != THROTTLE_NOLIMIT )
1874: {
1875: elapsed = tvP->tv_sec - c->started_at;
1876: if ( elapsed == 0 )
1877: elapsed = 1; /* count at least one second */
1878: if ( c->hc->bytes_sent / elapsed > c->max_limit )
1879: {
1880: c->conn_state = CNST_PAUSING;
1881: fdwatch_del_fd( hc->conn_fd );
1882: /* How long should we wait to get back on schedule? If less
1883: ** than a second (integer math rounding), use 1/2 second.
1884: */
1885: coast = c->hc->bytes_sent / c->max_limit - elapsed;
1886: client_data.p = c;
1887: if ( c->wakeup_timer != (Timer*) 0 )
1888: syslog( LOG_ERR, "replacing non-null wakeup_timer!" );
1889: c->wakeup_timer = tmr_create(
1890: tvP, wakeup_connection, client_data,
1891: coast > 0 ? ( coast * 1000L ) : 500L, 0 );
1892: if ( c->wakeup_timer == (Timer*) 0 )
1893: {
1894: syslog( LOG_CRIT, "tmr_create(wakeup_connection) failed" );
1895: exit( 1 );
1896: }
1897: }
1898: }
1899: /* (No check on min_limit here, that only controls connection startups.) */
1900: }
1901:
1902:
1903: static void
1904: handle_linger( connecttab* c, struct timeval* tvP )
1905: {
1906: char buf[4096];
1907: int r;
1908:
1909: /* In lingering-close mode we just read and ignore bytes. An error
1910: ** or EOF ends things, otherwise we go until a timeout.
1911: */
1912: r = read( c->hc->conn_fd, buf, sizeof(buf) );
1913: if ( r < 0 && ( errno == EINTR || errno == EAGAIN ) )
1914: return;
1915: if ( r <= 0 )
1916: really_clear_connection( c, tvP );
1917: }
1918:
1919:
1920: static int
1921: check_throttles( connecttab* c )
1922: {
1923: int tnum;
1924: long l;
1925:
1926: c->numtnums = 0;
1927: c->max_limit = c->min_limit = THROTTLE_NOLIMIT;
1928: for ( tnum = 0; tnum < numthrottles && c->numtnums < MAXTHROTTLENUMS;
1929: ++tnum )
1930: if ( match( throttles[tnum].pattern, c->hc->expnfilename ) )
1931: {
1932: /* If we're way over the limit, don't even start. */
1933: if ( throttles[tnum].rate > throttles[tnum].max_limit * 2 )
1934: return 0;
1935: /* Also don't start if we're under the minimum. */
1936: if ( throttles[tnum].rate < throttles[tnum].min_limit )
1937: return 0;
1938: if ( throttles[tnum].num_sending < 0 )
1939: {
1940: syslog( LOG_ERR, "throttle sending count was negative - shouldn't happen!" );
1941: throttles[tnum].num_sending = 0;
1942: }
1943: c->tnums[c->numtnums++] = tnum;
1944: ++throttles[tnum].num_sending;
1945: l = throttles[tnum].max_limit / throttles[tnum].num_sending;
1946: if ( c->max_limit == THROTTLE_NOLIMIT )
1947: c->max_limit = l;
1948: else
1949: c->max_limit = MIN( c->max_limit, l );
1950: l = throttles[tnum].min_limit;
1951: if ( c->min_limit == THROTTLE_NOLIMIT )
1952: c->min_limit = l;
1953: else
1954: c->min_limit = MAX( c->min_limit, l );
1955: }
1956: return 1;
1957: }
1958:
1959:
1960: static void
1961: clear_throttles( connecttab* c, struct timeval* tvP )
1962: {
1963: int tind;
1964:
1965: for ( tind = 0; tind < c->numtnums; ++tind )
1966: --throttles[c->tnums[tind]].num_sending;
1967: }
1968:
1969:
1970: static void
1971: update_throttles( ClientData client_data, struct timeval* nowP )
1972: {
1973: int tnum, tind;
1974: int cnum;
1975: connecttab* c;
1976: long l;
1977:
1978: /* Update the average sending rate for each throttle. This is only used
1979: ** when new connections start up.
1980: */
1981: for ( tnum = 0; tnum < numthrottles; ++tnum )
1982: {
1983: throttles[tnum].rate = ( 2 * throttles[tnum].rate + throttles[tnum].bytes_since_avg / THROTTLE_TIME ) / 3;
1984: throttles[tnum].bytes_since_avg = 0;
1985: /* Log a warning message if necessary. */
1986: if ( throttles[tnum].rate > throttles[tnum].max_limit && throttles[tnum].num_sending != 0 )
1987: {
1988: if ( throttles[tnum].rate > throttles[tnum].max_limit * 2 )
1989: syslog( LOG_NOTICE, "throttle #%d '%.80s' rate %ld greatly exceeding limit %ld; %d sending", tnum, throttles[tnum].pattern, throttles[tnum].rate, throttles[tnum].max_limit, throttles[tnum].num_sending );
1990: else
1991: syslog( LOG_INFO, "throttle #%d '%.80s' rate %ld exceeding limit %ld; %d sending", tnum, throttles[tnum].pattern, throttles[tnum].rate, throttles[tnum].max_limit, throttles[tnum].num_sending );
1992: }
1993: if ( throttles[tnum].rate < throttles[tnum].min_limit && throttles[tnum].num_sending != 0 )
1994: {
1995: syslog( LOG_NOTICE, "throttle #%d '%.80s' rate %ld lower than minimum %ld; %d sending", tnum, throttles[tnum].pattern, throttles[tnum].rate, throttles[tnum].min_limit, throttles[tnum].num_sending );
1996: }
1997: }
1998:
1999: /* Now update the sending rate on all the currently-sending connections,
2000: ** redistributing it evenly.
2001: */
2002: for ( cnum = 0; cnum < max_connects; ++cnum )
2003: {
2004: c = &connects[cnum];
2005: if ( c->conn_state == CNST_SENDING || c->conn_state == CNST_PAUSING )
2006: {
2007: c->max_limit = THROTTLE_NOLIMIT;
2008: for ( tind = 0; tind < c->numtnums; ++tind )
2009: {
2010: tnum = c->tnums[tind];
2011: l = throttles[tnum].max_limit / throttles[tnum].num_sending;
2012: if ( c->max_limit == THROTTLE_NOLIMIT )
2013: c->max_limit = l;
2014: else
2015: c->max_limit = MIN( c->max_limit, l );
2016: }
2017: }
2018: }
2019: }
2020:
2021:
2022: static void
2023: finish_connection( connecttab* c, struct timeval* tvP )
2024: {
2025: /* If we haven't actually sent the buffered response yet, do so now. */
2026: httpd_write_response( c->hc );
2027:
2028: /* And clear. */
2029: clear_connection( c, tvP );
2030: }
2031:
2032:
2033: static void
2034: clear_connection( connecttab* c, struct timeval* tvP )
2035: {
2036: ClientData client_data;
2037:
2038: if ( c->wakeup_timer != (Timer*) 0 )
2039: {
2040: tmr_cancel( c->wakeup_timer );
2041: c->wakeup_timer = 0;
2042: }
2043:
2044: /* This is our version of Apache's lingering_close() routine, which is
2045: ** their version of the often-broken SO_LINGER socket option. For why
2046: ** this is necessary, see http://www.apache.org/docs/misc/fin_wait_2.html
2047: ** What we do is delay the actual closing for a few seconds, while reading
2048: ** any bytes that come over the connection. However, we don't want to do
2049: ** this unless it's necessary, because it ties up a connection slot and
2050: ** file descriptor which means our maximum connection-handling rate
2051: ** is lower. So, elsewhere we set a flag when we detect the few
2052: ** circumstances that make a lingering close necessary. If the flag
2053: ** isn't set we do the real close now.
2054: */
2055: if ( c->conn_state == CNST_LINGERING )
2056: {
2057: /* If we were already lingering, shut down for real. */
2058: tmr_cancel( c->linger_timer );
2059: c->linger_timer = (Timer*) 0;
2060: c->hc->should_linger = 0;
2061: }
2062: if ( c->hc->should_linger )
2063: {
2064: if ( c->conn_state != CNST_PAUSING )
2065: fdwatch_del_fd( c->hc->conn_fd );
2066: c->conn_state = CNST_LINGERING;
2067: shutdown( c->hc->conn_fd, SHUT_WR );
2068: fdwatch_add_fd( c->hc->conn_fd, c, FDW_READ );
2069: client_data.p = c;
2070: if ( c->linger_timer != (Timer*) 0 )
2071: syslog( LOG_ERR, "replacing non-null linger_timer!" );
2072: c->linger_timer = tmr_create(
2073: tvP, linger_clear_connection, client_data, LINGER_TIME, 0 );
2074: if ( c->linger_timer == (Timer*) 0 )
2075: {
2076: syslog( LOG_CRIT, "tmr_create(linger_clear_connection) failed" );
2077: exit( 1 );
2078: }
2079: }
2080: else
2081: really_clear_connection( c, tvP );
2082: }
2083:
2084:
2085: static void
2086: really_clear_connection( connecttab* c, struct timeval* tvP )
2087: {
2088: stats_bytes += c->hc->bytes_sent;
2089: if ( c->conn_state != CNST_PAUSING )
2090: fdwatch_del_fd( c->hc->conn_fd );
2091: httpd_close_conn( c->hc, tvP );
2092: clear_throttles( c, tvP );
2093: if ( c->linger_timer != (Timer*) 0 )
2094: {
2095: tmr_cancel( c->linger_timer );
2096: c->linger_timer = 0;
2097: }
2098: c->conn_state = CNST_FREE;
2099: c->next_free_connect = first_free_connect;
2100: first_free_connect = c - connects; /* division by sizeof is implied */
2101: --num_connects;
2102: }
2103:
2104:
2105: static void
2106: idle( ClientData client_data, struct timeval* nowP )
2107: {
2108: int cnum;
2109: connecttab* c;
2110:
2111: for ( cnum = 0; cnum < max_connects; ++cnum )
2112: {
2113: c = &connects[cnum];
2114: switch ( c->conn_state )
2115: {
2116: case CNST_READING:
2117: if ( nowP->tv_sec - c->active_at >= IDLE_READ_TIMELIMIT )
2118: {
2119: syslog( LOG_INFO,
2120: "%.80s connection timed out reading",
2121: httpd_ntoa( &c->hc->client_addr ) );
2122: httpd_send_err(
2123: c->hc, 408, httpd_err408title, "", httpd_err408form, "" );
2124: finish_connection( c, nowP );
2125: }
2126: break;
2127: case CNST_SENDING:
2128: case CNST_PAUSING:
2129: if ( nowP->tv_sec - c->active_at >= IDLE_SEND_TIMELIMIT )
2130: {
2131: syslog( LOG_INFO,
2132: "%.80s connection timed out sending",
2133: httpd_ntoa( &c->hc->client_addr ) );
2134: clear_connection( c, nowP );
2135: }
2136: break;
2137: }
2138: }
2139: }
2140:
2141:
2142: static void
2143: wakeup_connection( ClientData client_data, struct timeval* nowP )
2144: {
2145: connecttab* c;
2146:
2147: c = (connecttab*) client_data.p;
2148: c->wakeup_timer = (Timer*) 0;
2149: if ( c->conn_state == CNST_PAUSING )
2150: {
2151: c->conn_state = CNST_SENDING;
2152: fdwatch_add_fd( c->hc->conn_fd, c, FDW_WRITE );
2153: }
2154: }
2155:
2156: static void
2157: linger_clear_connection( ClientData client_data, struct timeval* nowP )
2158: {
2159: connecttab* c;
2160:
2161: c = (connecttab*) client_data.p;
2162: c->linger_timer = (Timer*) 0;
2163: really_clear_connection( c, nowP );
2164: }
2165:
2166:
2167: static void
2168: occasional( ClientData client_data, struct timeval* nowP )
2169: {
2170: mmc_cleanup( nowP );
2171: tmr_cleanup();
2172: watchdog_flag = 1; /* let the watchdog know that we are alive */
2173: }
2174:
2175:
2176: #ifdef STATS_TIME
2177: static void
2178: show_stats( ClientData client_data, struct timeval* nowP )
2179: {
2180: logstats( nowP );
2181: }
2182: #endif /* STATS_TIME */
2183:
2184:
2185: /* Generate debugging statistics syslog messages for all packages. */
2186: static void
2187: logstats( struct timeval* nowP )
2188: {
2189: struct timeval tv;
2190: time_t now;
2191: long up_secs, stats_secs;
2192:
2193: if ( nowP == (struct timeval*) 0 )
2194: {
2195: (void) gettimeofday( &tv, (struct timezone*) 0 );
2196: nowP = &tv;
2197: }
2198: now = nowP->tv_sec;
2199: up_secs = now - start_time;
2200: stats_secs = now - stats_time;
2201: if ( stats_secs == 0 )
2202: stats_secs = 1; /* fudge */
2203: stats_time = now;
2204: syslog( LOG_INFO,
2205: "up %ld seconds, stats for %ld seconds:", up_secs, stats_secs );
2206:
2207: thttpd_logstats( stats_secs );
2208: httpd_logstats( stats_secs );
2209: mmc_logstats( stats_secs );
2210: fdwatch_logstats( stats_secs );
2211: tmr_logstats( stats_secs );
2212: }
2213:
2214:
2215: /* Generate debugging statistics syslog message. */
2216: static void
2217: thttpd_logstats( long secs )
2218: {
2219: if ( secs > 0 )
2220: syslog( LOG_INFO,
2221: " thttpd - %ld connections (%g/sec), %d max simultaneous, %lld bytes (%g/sec), %d httpd_conns allocated",
2222: stats_connections, (float) stats_connections / secs,
2223: stats_simultaneous, (int64_t) stats_bytes,
2224: (float) stats_bytes / secs, httpd_conn_count );
2225: stats_connections = 0;
2226: stats_bytes = 0;
2227: stats_simultaneous = 0;
2228: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to thttpd.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / thttpd