11 #include "http_chunk.h"
13 #include "connections.h"
14 #include "stat_cache.h"
17 #include "network_backends.h"
20 #include <sys/types.h>
40 #ifdef HAVE_VALGRIND_VALGRIND_H
41 # include <valgrind/valgrind.h>
44 #ifdef HAVE_SYS_WAIT_H
45 # include <sys/wait.h>
53 #ifdef HAVE_SYS_RESOURCE_H
54 # include <sys/resource.h>
57 #ifdef HAVE_SYS_PRCTL_H
58 # include <sys/prctl.h>
62 # include <openssl/err.h>
66 /* IRIX doesn't like the alarm based time() optimization */
67 /* #define USE_ALARM */
71 # ifndef HAVE_ISSETUGID
73 static int l_issetugid(void) {
74 return (geteuid() != getuid() || getegid() != getgid());
77 # define issetugid l_issetugid
81 static int oneshot_fd
= 0;
82 static volatile sig_atomic_t srv_shutdown
= 0;
83 static volatile sig_atomic_t graceful_shutdown
= 0;
84 static volatile sig_atomic_t handle_sig_alarm
= 1;
85 static volatile sig_atomic_t handle_sig_hup
= 0;
86 static volatile sig_atomic_t forwarded_sig_hup
= 0;
88 #if defined(HAVE_SIGACTION) && defined(SA_SIGINFO)
89 static volatile siginfo_t last_sigterm_info
;
90 static volatile siginfo_t last_sighup_info
;
92 static void sigaction_handler(int sig
, siginfo_t
*si
, void *context
) {
93 static siginfo_t empty_siginfo
;
96 if (!si
) si
= &empty_siginfo
;
101 last_sigterm_info
= *si
;
104 if (graceful_shutdown
) {
107 graceful_shutdown
= 1;
109 last_sigterm_info
= *si
;
113 handle_sig_alarm
= 1;
117 * we send the SIGHUP to all procs in the process-group
118 * this includes ourself
120 * make sure we only send it once and don't create a
123 if (!forwarded_sig_hup
) {
125 last_sighup_info
= *si
;
127 forwarded_sig_hup
= 0;
134 #elif defined(HAVE_SIGNAL) || defined(HAVE_SIGACTION)
135 static void signal_handler(int sig
) {
137 case SIGTERM
: srv_shutdown
= 1; break;
139 if (graceful_shutdown
) srv_shutdown
= 1;
140 else graceful_shutdown
= 1;
143 case SIGALRM
: handle_sig_alarm
= 1; break;
144 case SIGHUP
: handle_sig_hup
= 1; break;
151 static int daemonize(void) {
155 signal(SIGTTOU
, SIG_IGN
);
158 signal(SIGTTIN
, SIG_IGN
);
161 signal(SIGTSTP
, SIG_IGN
);
164 if (pipe(pipefd
) < 0) exit(-1);
166 if (0 > (pid
= fork())) exit(-1);
173 /* parent waits for grandchild to be ready */
175 bytes
= read(pipefd
[0], &buf
, sizeof(buf
));
176 } while (bytes
< 0 && EINTR
== errno
);
180 /* closed fd (without writing) == failure in grandchild */
181 fputs("daemonized server failed to start; check error log for details\n", stderr
);
190 if (-1 == setsid()) exit(0);
192 signal(SIGHUP
, SIG_IGN
);
194 if (0 != fork()) exit(0);
196 if (0 != chdir("/")) exit(0);
198 fd_close_on_exec(pipefd
[1]);
203 static server
*server_init(void) {
205 FILE *frandom
= NULL
;
207 server
*srv
= calloc(1, sizeof(*srv
));
210 srv->x = buffer_init();
212 CLEAN(response_header
);
213 CLEAN(parse_full_path
);
217 CLEAN(response_range
);
219 srv
->empty_string
= buffer_init_string("");
220 CLEAN(cond_check_buf
);
222 CLEAN(srvconf
.errorlog_file
);
223 CLEAN(srvconf
.breakagelog_file
);
224 CLEAN(srvconf
.groupname
);
225 CLEAN(srvconf
.username
);
226 CLEAN(srvconf
.changeroot
);
227 CLEAN(srvconf
.bindhost
);
228 CLEAN(srvconf
.event_handler
);
229 CLEAN(srvconf
.pid_file
);
231 CLEAN(tmp_chunk_len
);
235 srv->x = array_init();
237 CLEAN(config_context
);
238 CLEAN(config_touched
);
242 for (i
= 0; i
< FILE_CACHE_MAX
; i
++) {
243 srv
->mtime_cache
[i
].mtime
= (time_t)-1;
244 srv
->mtime_cache
[i
].str
= buffer_init();
247 if ((NULL
!= (frandom
= fopen("/dev/urandom", "rb")) || NULL
!= (frandom
= fopen("/dev/random", "rb")))
248 && 1 == fread(srv
->entropy
, sizeof(srv
->entropy
), 1, frandom
)) {
250 memcpy(&e
, srv
->entropy
, sizeof(e
) < sizeof(srv
->entropy
) ? sizeof(e
) : sizeof(srv
->entropy
));
252 srv
->is_real_entropy
= 1;
255 srand(time(NULL
) ^ getpid());
256 srv
->is_real_entropy
= 0;
257 for (j
= 0; j
< sizeof(srv
->entropy
); j
++)
258 srv
->entropy
[j
] = rand();
260 if (frandom
) fclose(frandom
);
262 srv
->cur_ts
= time(NULL
);
263 srv
->startup_ts
= srv
->cur_ts
;
265 srv
->conns
= calloc(1, sizeof(*srv
->conns
));
266 force_assert(srv
->conns
);
268 srv
->joblist
= calloc(1, sizeof(*srv
->joblist
));
269 force_assert(srv
->joblist
);
271 srv
->fdwaitqueue
= calloc(1, sizeof(*srv
->fdwaitqueue
));
272 force_assert(srv
->fdwaitqueue
);
274 srv
->srvconf
.modules
= array_init();
275 srv
->srvconf
.modules_dir
= buffer_init_string(LIBRARY_DIR
);
276 srv
->srvconf
.network_backend
= buffer_init();
277 srv
->srvconf
.upload_tempdirs
= array_init();
278 srv
->srvconf
.reject_expect_100_with_417
= 1;
279 srv
->srvconf
.xattr_name
= buffer_init_string("Content-Type");
280 srv
->srvconf
.http_header_strict
= 1;
281 srv
->srvconf
.http_host_strict
= 1; /*(implies http_host_normalize)*/
282 srv
->srvconf
.http_host_normalize
= 0;
283 srv
->srvconf
.high_precision_timestamps
= 0;
286 srv
->errorlog_fd
= STDERR_FILENO
;
287 srv
->errorlog_mode
= ERRORLOG_FD
;
289 srv
->split_vals
= array_init();
294 static void server_free(server
*srv
) {
297 for (i
= 0; i
< FILE_CACHE_MAX
; i
++) {
298 buffer_free(srv
->mtime_cache
[i
].str
);
301 if (oneshot_fd
> 0) {
308 CLEAN(response_header
);
309 CLEAN(parse_full_path
);
313 CLEAN(response_range
);
316 CLEAN(cond_check_buf
);
318 CLEAN(srvconf
.errorlog_file
);
319 CLEAN(srvconf
.breakagelog_file
);
320 CLEAN(srvconf
.groupname
);
321 CLEAN(srvconf
.username
);
322 CLEAN(srvconf
.changeroot
);
323 CLEAN(srvconf
.bindhost
);
324 CLEAN(srvconf
.event_handler
);
325 CLEAN(srvconf
.pid_file
);
326 CLEAN(srvconf
.modules_dir
);
327 CLEAN(srvconf
.network_backend
);
328 CLEAN(srvconf
.xattr_name
);
330 CLEAN(tmp_chunk_len
);
334 fdevent_unregister(srv
->ev
, srv
->fd
);
336 fdevent_free(srv
->ev
);
340 if (srv
->config_storage
) {
341 for (i
= 0; i
< srv
->config_context
->used
; i
++) {
342 specific_config
*s
= srv
->config_storage
[i
];
346 buffer_free(s
->document_root
);
347 buffer_free(s
->server_name
);
348 buffer_free(s
->server_tag
);
349 buffer_free(s
->ssl_pemfile
);
350 buffer_free(s
->ssl_ca_file
);
351 buffer_free(s
->ssl_cipher_list
);
352 buffer_free(s
->ssl_dh_file
);
353 buffer_free(s
->ssl_ec_curve
);
354 buffer_free(s
->error_handler
);
355 buffer_free(s
->error_handler_404
);
356 buffer_free(s
->errorfile_prefix
);
357 array_free(s
->mimetypes
);
358 buffer_free(s
->ssl_verifyclient_username
);
360 SSL_CTX_free(s
->ssl_ctx
);
361 EVP_PKEY_free(s
->ssl_pemfile_pkey
);
362 X509_free(s
->ssl_pemfile_x509
);
363 if (NULL
!= s
->ssl_ca_file_cert_names
) sk_X509_NAME_pop_free(s
->ssl_ca_file_cert_names
, X509_NAME_free
);
367 free(srv
->config_storage
);
368 srv
->config_storage
= NULL
;
374 CLEAN(config_context
);
375 CLEAN(config_touched
);
377 CLEAN(srvconf
.upload_tempdirs
);
380 joblist_free(srv
, srv
->joblist
);
381 fdwaitqueue_free(srv
, srv
->fdwaitqueue
);
383 if (srv
->stat_cache
) {
384 stat_cache_free(srv
->stat_cache
);
387 array_free(srv
->srvconf
.modules
);
388 array_free(srv
->split_vals
);
391 if (srv
->ssl_is_init
) {
392 CRYPTO_cleanup_all_ex_data();
394 #if OPENSSL_VERSION_NUMBER >= 0x10100000L \
395 && !defined(LIBRESSL_VERSION_NUMBER)
396 /*(OpenSSL libraries handle thread init and deinit)
397 * https://github.com/openssl/openssl/pull/1048 */
398 #elif OPENSSL_VERSION_NUMBER >= 0x10000000L
399 ERR_remove_thread_state(NULL
);
410 static void remove_pid_file(server
*srv
, int *pid_fd
) {
411 if (!buffer_string_is_empty(srv
->srvconf
.pid_file
) && 0 <= *pid_fd
) {
412 if (0 != ftruncate(*pid_fd
, 0)) {
413 log_error_write(srv
, __FILE__
, __LINE__
, "sbds",
414 "ftruncate failed for:",
415 srv
->srvconf
.pid_file
,
424 if (!buffer_string_is_empty(srv
->srvconf
.pid_file
) &&
425 buffer_string_is_empty(srv
->srvconf
.changeroot
)) {
426 if (0 != unlink(srv
->srvconf
.pid_file
->ptr
)) {
427 if (errno
!= EACCES
&& errno
!= EPERM
) {
428 log_error_write(srv
, __FILE__
, __LINE__
, "sbds",
429 "unlink failed for:",
430 srv
->srvconf
.pid_file
,
439 static server_socket
* server_oneshot_getsock(server
*srv
, sock_addr
*cnt_addr
) {
440 server_socket
*srv_socket
, *srv_socket_wild
= NULL
;
442 for (i
= 0; i
< srv
->srv_sockets
.used
; ++i
) {
443 srv_socket
= srv
->srv_sockets
.ptr
[i
];
444 if (cnt_addr
->plain
.sa_family
!= srv_socket
->addr
.plain
.sa_family
) continue;
445 switch (cnt_addr
->plain
.sa_family
) {
447 if (srv_socket
->addr
.ipv4
.sin_port
!= cnt_addr
->ipv4
.sin_port
) continue;
448 if (srv_socket
->addr
.ipv4
.sin_addr
.s_addr
== cnt_addr
->ipv4
.sin_addr
.s_addr
) {
451 if (srv_socket
->addr
.ipv4
.sin_addr
.s_addr
== htonl(INADDR_ANY
)) {
452 srv_socket_wild
= srv_socket
;
457 if (srv_socket
->addr
.ipv6
.sin6_port
!= cnt_addr
->ipv6
.sin6_port
) continue;
458 if (0 == memcmp(&srv_socket
->addr
.ipv6
.sin6_addr
, &cnt_addr
->ipv6
.sin6_addr
, sizeof(struct in6_addr
))) {
461 if (0 == memcmp(&srv_socket
->addr
.ipv6
.sin6_addr
, &in6addr_any
, sizeof(struct in6_addr
))) {
462 srv_socket_wild
= srv_socket
;
468 if (0 == strcmp(srv_socket
->addr
.un
.sun_path
, cnt_addr
->un
.sun_path
)) {
477 if (NULL
!= srv_socket_wild
) {
478 return srv_socket_wild
;
479 } else if (srv
->srv_sockets
.used
) {
480 return srv
->srv_sockets
.ptr
[0];
482 log_error_write(srv
, __FILE__
, __LINE__
, "s", "no sockets configured");
488 static int server_oneshot_init(server
*srv
, int fd
) {
489 /* Note: does not work with netcat due to requirement that fd be socket.
490 * STDOUT_FILENO was not saved earlier in startup, and that is to where
491 * netcat expects output to be sent. Since lighttpd expects connections
492 * to be sockets, con->fd is where output is sent; separate fds are not
493 * stored for input and output, but netcat has different fds for stdin
494 * and * stdout. To support netcat, would additionally need to avoid
495 * S_ISSOCK(), getsockname(), and getpeername() below, reconstructing
496 * addresses from environment variables:
497 * NCAT_LOCAL_ADDR NCAT_LOCAL_PORT
498 * NCAT_REMOTE_ADDR NCAT_REMOTE_PORT
502 server_socket
*srv_socket
;
507 if (0 != fstat(fd
, &st
)) {
508 log_error_write(srv
, __FILE__
, __LINE__
, "ss", "fstat:", strerror(errno
));
512 if (!S_ISSOCK(st
.st_mode
)) {
513 /* require that fd is a socket
514 * (modules might expect STDIN_FILENO and STDOUT_FILENO opened to /dev/null) */
515 log_error_write(srv
, __FILE__
, __LINE__
, "s", "lighttpd -1 stdin is not a socket");
519 cnt_len
= sizeof(cnt_addr
);
520 if (0 != getsockname(fd
, (struct sockaddr
*)&cnt_addr
, &cnt_len
)) {
521 log_error_write(srv
, __FILE__
, __LINE__
, "ss", "getsockname:", strerror(errno
));
525 srv_socket
= server_oneshot_getsock(srv
, &cnt_addr
);
526 if (NULL
== srv_socket
) return 0;
528 cnt_len
= sizeof(cnt_addr
);
529 if (0 != getpeername(fd
, (struct sockaddr
*)&cnt_addr
, &cnt_len
)) {
530 log_error_write(srv
, __FILE__
, __LINE__
, "ss", "getpeername:", strerror(errno
));
534 if (cnt_addr
.plain
.sa_family
!= AF_UNIX
) {
535 network_accept_tcp_nagle_disable(fd
);
538 con
= connection_accepted(srv
, srv_socket
, &cnt_addr
, fd
);
539 if (NULL
== con
) return 0;
541 connection_state_machine(srv
, con
);
546 static void show_version (void) {
548 # define TEXT_SSL " (ssl)"
552 char *b
= PACKAGE_DESC TEXT_SSL \
553 " - a light and fast webserver\n" \
554 "Build-Date: " __DATE__
" " __TIME__
"\n";
557 write_all(STDOUT_FILENO
, b
, strlen(b
));
560 static void show_features (void) {
561 const char features
[] = ""
563 "\t+ select (generic)\n"
565 "\t- select (generic)\n"
572 #ifdef USE_LINUX_SIGIO
573 "\t+ rt-signals (Linux 2.4+)\n"
575 "\t- rt-signals (Linux 2.4+)\n"
577 #ifdef USE_LINUX_EPOLL
578 "\t+ epoll (Linux 2.6)\n"
580 "\t- epoll (Linux 2.6)\n"
582 #ifdef USE_SOLARIS_DEVPOLL
583 "\t+ /dev/poll (Solaris)\n"
585 "\t- /dev/poll (Solaris)\n"
587 #ifdef USE_SOLARIS_PORT
588 "\t+ eventports (Solaris)\n"
590 "\t- eventports (Solaris)\n"
592 #ifdef USE_FREEBSD_KQUEUE
593 "\t+ kqueue (FreeBSD)\n"
595 "\t- kqueue (FreeBSD)\n"
598 "\t+ libev (generic)\n"
600 "\t- libev (generic)\n"
602 "\nNetwork handler:\n\n"
603 #if defined USE_LINUX_SENDFILE
604 "\t+ linux-sendfile\n"
606 "\t- linux-sendfile\n"
608 #if defined USE_FREEBSD_SENDFILE
609 "\t+ freebsd-sendfile\n"
611 "\t- freebsd-sendfile\n"
613 #if defined USE_DARWIN_SENDFILE
614 "\t+ darwin-sendfile\n"
616 "\t- darwin-sendfile\n"
618 #if defined USE_SOLARIS_SENDFILEV
619 "\t+ solaris-sendfilev\n"
621 "\t- solaris-sendfilev\n"
623 #if defined USE_WRITEV
640 #if defined HAVE_ZLIB_H && defined HAVE_LIBZ
645 #if defined HAVE_BZLIB_H && defined HAVE_LIBBZ2
646 "\t+ bzip2 support\n"
648 "\t- bzip2 support\n"
650 #if defined(HAVE_CRYPT) || defined(HAVE_CRYPT_R) || defined(HAVE_LIBCRYPT)
651 "\t+ crypt support\n"
653 "\t- crypt support\n"
666 "\t+ mySQL support\n"
668 "\t- mySQL support\n"
670 #if defined(HAVE_LDAP_H) && defined(HAVE_LBER_H) && defined(HAVE_LIBLDAP) && defined(HAVE_LIBLBER)
676 "\t+ memcached support\n"
678 "\t- memcached support\n"
695 #ifdef HAVE_SQLITE3_H
696 "\t+ SQLite support\n"
698 "\t- SQLite support\n"
707 printf("\nEvent Handlers:\n\n%s", features
);
710 static void show_help (void) {
712 # define TEXT_SSL " (ssl)"
716 char *b
= PACKAGE_DESC TEXT_SSL
" ("__DATE__
" " __TIME__
")" \
717 " - a light and fast webserver\n" \
719 " -f <name> filename of the config-file\n" \
720 " -m <name> module directory (default: "LIBRARY_DIR
")\n" \
721 " -i <secs> graceful shutdown after <secs> of inactivity\n" \
722 " -1 process single (one) request on stdin socket, then exit\n" \
723 " -p print the parsed config-file in internal form, and exit\n" \
724 " -t test config-file syntax, then exit\n" \
725 " -tt test config-file syntax, load and init modules, then exit\n" \
726 " -D don't go to background (default: go to background)\n" \
727 " -v show version\n" \
728 " -V show compile-time features\n" \
729 " -h show this help\n" \
734 write_all(STDOUT_FILENO
, b
, strlen(b
));
737 int main (int argc
, char **argv
) {
739 int print_config
= 0;
746 time_t idle_limit
= 0, last_active_ts
= time(NULL
);
747 #ifdef HAVE_SIGACTION
748 struct sigaction act
;
750 #ifdef HAVE_GETRLIMIT
755 int parent_pipe_fd
= -1;
759 struct itimerval interval
;
761 interval
.it_interval
.tv_sec
= 1;
762 interval
.it_interval
.tv_usec
= 0;
763 interval
.it_value
.tv_sec
= 1;
764 interval
.it_value
.tv_usec
= 0;
767 /* for nice %b handling in strfime() */
768 setlocale(LC_TIME
, "C");
770 if (NULL
== (srv
= server_init())) {
771 fprintf(stderr
, "did this really happen?\n");
775 /* init structs done */
777 srv
->srvconf
.port
= 0;
779 i_am_root
= (getuid() == 0);
783 srv
->srvconf
.dont_daemonize
= 0;
784 srv
->srvconf
.preflight_check
= 0;
786 while(-1 != (o
= getopt(argc
, argv
, "f:m:i:hvVD1pt"))) {
789 if (srv
->config_storage
) {
790 log_error_write(srv
, __FILE__
, __LINE__
, "s",
791 "Can only read one config file. Use the include command to use multiple config files.");
796 if (config_read(srv
, optarg
)) {
802 buffer_copy_string(srv
->srvconf
.modules_dir
, optarg
);
806 long timeout
= strtol(optarg
, &endptr
, 0);
807 if (!*optarg
|| *endptr
|| timeout
< 0) {
808 log_error_write(srv
, __FILE__
, __LINE__
, "ss",
809 "Invalid idle timeout value:", optarg
);
813 idle_limit
= (time_t)timeout
;
816 case 'p': print_config
= 1; break;
817 case 't': ++test_config
; break;
818 case '1': oneshot_fd
= dup(STDIN_FILENO
); break;
819 case 'D': srv
->srvconf
.dont_daemonize
= 1; break;
820 case 'v': show_version(); server_free(srv
); return 0;
821 case 'V': show_features(); server_free(srv
); return 0;
822 case 'h': show_help(); server_free(srv
); return 0;
830 if (!srv
->config_storage
) {
831 log_error_write(srv
, __FILE__
, __LINE__
, "s",
832 "No configuration available. Try using -f option.");
839 data_unset
*dc
= srv
->config_context
->data
[0];
842 fprintf(stdout
, "\n");
844 /* shouldn't happend */
845 fprintf(stderr
, "global config not found\n");
850 if (1 == test_config
) {
851 printf("Syntax OK\n");
852 } else { /*(test_config > 1)*/
854 srv
->srvconf
.preflight_check
= 1;
855 srv
->srvconf
.dont_daemonize
= 1;
856 buffer_reset(srv
->srvconf
.pid_file
);
860 if (test_config
|| print_config
) {
866 if (oneshot_fd
<= STDERR_FILENO
) {
867 log_error_write(srv
, __FILE__
, __LINE__
, "s",
868 "Invalid fds at startup with lighttpd -1");
872 graceful_shutdown
= 1;
873 srv
->sockets_disabled
= 1;
874 srv
->srvconf
.dont_daemonize
= 1;
875 buffer_reset(srv
->srvconf
.pid_file
);
876 if (srv
->srvconf
.max_worker
) {
877 srv
->srvconf
.max_worker
= 0;
878 log_error_write(srv
, __FILE__
, __LINE__
, "s",
879 "server one-shot command line option disables server.max-worker config file option.");
883 /* close stdin and stdout, as they are not needed */
884 openDevNull(STDIN_FILENO
);
885 openDevNull(STDOUT_FILENO
);
887 if (0 != config_set_defaults(srv
)) {
888 log_error_write(srv
, __FILE__
, __LINE__
, "s",
889 "setting default values failed");
896 if (!i_am_root
&& issetugid()) {
897 /* we are setuid-root */
899 log_error_write(srv
, __FILE__
, __LINE__
, "s",
900 "Are you nuts ? Don't apply a SUID bit to this binary");
907 /* check document-root */
908 if (buffer_string_is_empty(srv
->config_storage
[0]->document_root
)) {
909 log_error_write(srv
, __FILE__
, __LINE__
, "s",
910 "document-root is not set\n");
917 if (plugins_load(srv
)) {
918 log_error_write(srv
, __FILE__
, __LINE__
, "s",
919 "loading plugins finally failed");
927 /* open pid file BEFORE chroot */
928 if (!buffer_string_is_empty(srv
->srvconf
.pid_file
)) {
929 if (-1 == (pid_fd
= open(srv
->srvconf
.pid_file
->ptr
, O_WRONLY
| O_CREAT
| O_EXCL
| O_TRUNC
, S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IROTH
))) {
931 if (errno
!= EEXIST
) {
932 log_error_write(srv
, __FILE__
, __LINE__
, "sbs",
933 "opening pid-file failed:", srv
->srvconf
.pid_file
, strerror(errno
));
937 if (0 != stat(srv
->srvconf
.pid_file
->ptr
, &st
)) {
938 log_error_write(srv
, __FILE__
, __LINE__
, "sbs",
939 "stating existing pid-file failed:", srv
->srvconf
.pid_file
, strerror(errno
));
942 if (!S_ISREG(st
.st_mode
)) {
943 log_error_write(srv
, __FILE__
, __LINE__
, "sb",
944 "pid-file exists and isn't regular file:", srv
->srvconf
.pid_file
);
948 if (-1 == (pid_fd
= open(srv
->srvconf
.pid_file
->ptr
, O_WRONLY
| O_CREAT
| O_TRUNC
, S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IROTH
))) {
949 log_error_write(srv
, __FILE__
, __LINE__
, "sbs",
950 "opening pid-file failed:", srv
->srvconf
.pid_file
, strerror(errno
));
954 fd_close_on_exec(pid_fd
);
957 if (srv
->event_handler
== FDEVENT_HANDLER_SELECT
) {
958 /* select limits itself
960 * as it is a hard limit and will lead to a segfault we add some safety
962 srv
->max_fds
= FD_SETSIZE
- 200;
968 struct group
*grp
= NULL
;
969 struct passwd
*pwd
= NULL
;
972 #ifdef HAVE_VALGRIND_VALGRIND_H
973 if (RUNNING_ON_VALGRIND
) use_rlimit
= 0;
976 #ifdef HAVE_GETRLIMIT
977 if (0 != getrlimit(RLIMIT_NOFILE
, &rlim
)) {
978 log_error_write(srv
, __FILE__
, __LINE__
,
979 "ss", "couldn't get 'max filedescriptors'",
984 if (use_rlimit
&& srv
->srvconf
.max_fds
) {
987 rlim
.rlim_cur
= srv
->srvconf
.max_fds
;
988 rlim
.rlim_max
= srv
->srvconf
.max_fds
;
990 if (0 != setrlimit(RLIMIT_NOFILE
, &rlim
)) {
991 log_error_write(srv
, __FILE__
, __LINE__
,
992 "ss", "couldn't set 'max filedescriptors'",
998 if (srv
->event_handler
== FDEVENT_HANDLER_SELECT
) {
999 srv
->max_fds
= rlim
.rlim_cur
< (rlim_t
)FD_SETSIZE
- 200 ? (int)rlim
.rlim_cur
: (int)FD_SETSIZE
- 200;
1001 srv
->max_fds
= rlim
.rlim_cur
;
1004 /* set core file rlimit, if enable_cores is set */
1005 if (use_rlimit
&& srv
->srvconf
.enable_cores
&& getrlimit(RLIMIT_CORE
, &rlim
) == 0) {
1006 rlim
.rlim_cur
= rlim
.rlim_max
;
1007 setrlimit(RLIMIT_CORE
, &rlim
);
1010 if (srv
->event_handler
== FDEVENT_HANDLER_SELECT
) {
1011 /* don't raise the limit above FD_SET_SIZE */
1012 if (srv
->max_fds
> ((int)FD_SETSIZE
) - 200) {
1013 log_error_write(srv
, __FILE__
, __LINE__
, "sd",
1014 "can't raise max filedescriptors above", FD_SETSIZE
- 200,
1015 "if event-handler is 'select'. Use 'poll' or something else or reduce server.max-fds.");
1022 /* set user and group */
1023 if (!buffer_string_is_empty(srv
->srvconf
.username
)) {
1024 if (NULL
== (pwd
= getpwnam(srv
->srvconf
.username
->ptr
))) {
1025 log_error_write(srv
, __FILE__
, __LINE__
, "sb",
1026 "can't find username", srv
->srvconf
.username
);
1030 if (pwd
->pw_uid
== 0) {
1031 log_error_write(srv
, __FILE__
, __LINE__
, "s",
1032 "I will not set uid to 0\n");
1037 if (!buffer_string_is_empty(srv
->srvconf
.groupname
)) {
1038 if (NULL
== (grp
= getgrnam(srv
->srvconf
.groupname
->ptr
))) {
1039 log_error_write(srv
, __FILE__
, __LINE__
, "sb",
1040 "can't find groupname", srv
->srvconf
.groupname
);
1043 if (grp
->gr_gid
== 0) {
1044 log_error_write(srv
, __FILE__
, __LINE__
, "s",
1045 "I will not set gid to 0\n");
1050 /* we need root-perms for port < 1024 */
1051 if (0 != network_init(srv
)) {
1059 * Change group before chroot, when we have access
1063 if (-1 == setgid(grp
->gr_gid
)) {
1064 log_error_write(srv
, __FILE__
, __LINE__
, "ss", "setgid failed: ", strerror(errno
));
1067 if (-1 == setgroups(0, NULL
)) {
1068 log_error_write(srv
, __FILE__
, __LINE__
, "ss", "setgroups failed: ", strerror(errno
));
1071 if (!buffer_string_is_empty(srv
->srvconf
.username
)) {
1072 initgroups(srv
->srvconf
.username
->ptr
, grp
->gr_gid
);
1077 if (!buffer_string_is_empty(srv
->srvconf
.changeroot
)) {
1080 if (-1 == chroot(srv
->srvconf
.changeroot
->ptr
)) {
1081 log_error_write(srv
, __FILE__
, __LINE__
, "ss", "chroot failed: ", strerror(errno
));
1084 if (-1 == chdir("/")) {
1085 log_error_write(srv
, __FILE__
, __LINE__
, "ss", "chdir failed: ", strerror(errno
));
1091 /* drop root privs */
1093 if (-1 == setuid(pwd
->pw_uid
)) {
1094 log_error_write(srv
, __FILE__
, __LINE__
, "ss", "setuid failed: ", strerror(errno
));
1099 #if defined(HAVE_SYS_PRCTL_H) && defined(PR_SET_DUMPABLE)
1101 * on IRIX 6.5.30 they have prctl() but no DUMPABLE
1103 if (srv
->srvconf
.enable_cores
) {
1104 prctl(PR_SET_DUMPABLE
, 1, 0, 0, 0);
1109 #ifdef HAVE_GETRLIMIT
1110 if (0 != getrlimit(RLIMIT_NOFILE
, &rlim
)) {
1111 log_error_write(srv
, __FILE__
, __LINE__
,
1112 "ss", "couldn't get 'max filedescriptors'",
1118 * we are not root can can't increase the fd-limit above rlim_max, but we can reduce it
1120 if (srv
->srvconf
.max_fds
&& srv
->srvconf
.max_fds
<= rlim
.rlim_max
) {
1123 rlim
.rlim_cur
= srv
->srvconf
.max_fds
;
1125 if (0 != setrlimit(RLIMIT_NOFILE
, &rlim
)) {
1126 log_error_write(srv
, __FILE__
, __LINE__
,
1127 "ss", "couldn't set 'max filedescriptors'",
1133 if (srv
->event_handler
== FDEVENT_HANDLER_SELECT
) {
1134 srv
->max_fds
= rlim
.rlim_cur
< (rlim_t
)FD_SETSIZE
- 200 ? (int)rlim
.rlim_cur
: (int)FD_SETSIZE
- 200;
1136 srv
->max_fds
= rlim
.rlim_cur
;
1139 /* set core file rlimit, if enable_cores is set */
1140 if (srv
->srvconf
.enable_cores
&& getrlimit(RLIMIT_CORE
, &rlim
) == 0) {
1141 rlim
.rlim_cur
= rlim
.rlim_max
;
1142 setrlimit(RLIMIT_CORE
, &rlim
);
1146 if (srv
->event_handler
== FDEVENT_HANDLER_SELECT
) {
1147 /* don't raise the limit above FD_SET_SIZE */
1148 if (srv
->max_fds
> ((int)FD_SETSIZE
) - 200) {
1149 log_error_write(srv
, __FILE__
, __LINE__
, "sd",
1150 "can't raise max filedescriptors above", FD_SETSIZE
- 200,
1151 "if event-handler is 'select'. Use 'poll' or something else or reduce server.max-fds.");
1156 if (0 != network_init(srv
)) {
1165 if (srv
->srvconf
.max_conns
> srv
->max_fds
/2) {
1166 /* we can't have more connections than max-fds/2 */
1167 log_error_write(srv
, __FILE__
, __LINE__
, "sdd", "can't have more connections than fds/2: ", srv
->srvconf
.max_conns
, srv
->max_fds
);
1168 srv
->max_conns
= srv
->max_fds
/2;
1169 } else if (srv
->srvconf
.max_conns
) {
1170 /* otherwise respect the wishes of the user */
1171 srv
->max_conns
= srv
->srvconf
.max_conns
;
1173 /* or use the default: we really don't want to hit max-fds */
1174 srv
->max_conns
= srv
->max_fds
/3;
1177 if (HANDLER_GO_ON
!= plugins_call_init(srv
)) {
1178 log_error_write(srv
, __FILE__
, __LINE__
, "s", "Initialization of plugins failed. Going down.");
1188 /* network is up, let's deamonize ourself */
1189 if (srv
->srvconf
.dont_daemonize
== 0) {
1190 parent_pipe_fd
= daemonize();
1195 #ifdef HAVE_SIGACTION
1196 memset(&act
, 0, sizeof(act
));
1197 act
.sa_handler
= SIG_IGN
;
1198 sigaction(SIGPIPE
, &act
, NULL
);
1199 sigaction(SIGUSR1
, &act
, NULL
);
1200 # if defined(SA_SIGINFO)
1201 act
.sa_sigaction
= sigaction_handler
;
1202 sigemptyset(&act
.sa_mask
);
1203 act
.sa_flags
= SA_SIGINFO
;
1205 act
.sa_handler
= signal_handler
;
1206 sigemptyset(&act
.sa_mask
);
1209 sigaction(SIGINT
, &act
, NULL
);
1210 sigaction(SIGTERM
, &act
, NULL
);
1211 sigaction(SIGHUP
, &act
, NULL
);
1212 sigaction(SIGALRM
, &act
, NULL
);
1214 /* it should be safe to restart syscalls after SIGCHLD */
1215 act
.sa_flags
|= SA_RESTART
| SA_NOCLDSTOP
;
1216 sigaction(SIGCHLD
, &act
, NULL
);
1218 #elif defined(HAVE_SIGNAL)
1219 /* ignore the SIGPIPE from sendfile() */
1220 signal(SIGPIPE
, SIG_IGN
);
1221 signal(SIGUSR1
, SIG_IGN
);
1222 signal(SIGALRM
, signal_handler
);
1223 signal(SIGTERM
, signal_handler
);
1224 signal(SIGHUP
, signal_handler
);
1225 signal(SIGCHLD
, signal_handler
);
1226 signal(SIGINT
, signal_handler
);
1230 signal(SIGALRM
, signal_handler
);
1232 /* setup periodic timer (1 second) */
1233 if (setitimer(ITIMER_REAL
, &interval
, NULL
)) {
1234 log_error_write(srv
, __FILE__
, __LINE__
, "s", "setting timer failed");
1238 getitimer(ITIMER_REAL
, &interval
);
1242 srv
->gid
= getgid();
1243 srv
->uid
= getuid();
1245 /* write pid file */
1247 buffer_copy_int(srv
->tmp_buf
, getpid());
1248 buffer_append_string_len(srv
->tmp_buf
, CONST_STR_LEN("\n"));
1249 if (-1 == write_all(pid_fd
, CONST_BUF_LEN(srv
->tmp_buf
))) {
1250 log_error_write(srv
, __FILE__
, __LINE__
, "ss", "Couldn't write pid file:", strerror(errno
));
1256 /* Close stderr ASAP in the child process to make sure that nothing
1257 * is being written to that fd which may not be valid anymore. */
1258 if (!srv
->srvconf
.preflight_check
&& -1 == log_error_open(srv
)) {
1259 log_error_write(srv
, __FILE__
, __LINE__
, "s", "Opening errorlog failed. Going down.");
1267 if (HANDLER_GO_ON
!= plugins_call_set_defaults(srv
)) {
1268 log_error_write(srv
, __FILE__
, __LINE__
, "s", "Configuration of plugins failed. Going down.");
1277 /* settings might be enabled during module config set defaults */
1278 srv
->config_storage
[0]->high_precision_timestamps
= srv
->srvconf
.high_precision_timestamps
;
1280 /* dump unused config-keys */
1281 for (i
= 0; i
< srv
->config_context
->used
; i
++) {
1282 array
*config
= ((data_config
*)srv
->config_context
->data
[i
])->value
;
1285 for (j
= 0; config
&& j
< config
->used
; j
++) {
1286 data_unset
*du
= config
->data
[j
];
1288 /* all var.* is known as user defined variable */
1289 if (strncmp(du
->key
->ptr
, "var.", sizeof("var.") - 1) == 0) {
1293 if (NULL
== array_get_element(srv
->config_touched
, du
->key
->ptr
)) {
1294 log_error_write(srv
, __FILE__
, __LINE__
, "sbs",
1295 "WARNING: unknown config-key:",
1302 if (srv
->config_unsupported
) {
1303 log_error_write(srv
, __FILE__
, __LINE__
, "s",
1304 "Configuration contains unsupported keys. Going down.");
1307 if (srv
->config_deprecated
) {
1308 log_error_write(srv
, __FILE__
, __LINE__
, "s",
1309 "Configuration contains deprecated keys. Going down.");
1312 if (srv
->config_unsupported
|| srv
->config_deprecated
) {
1320 if (srv
->srvconf
.preflight_check
) {
1321 /*printf("Preflight OK");*//*(stdout reopened to /dev/null)*/
1332 * notify daemonize-grandparent of successful startup
1333 * do this before any further forking is done (workers)
1335 if (srv
->srvconf
.dont_daemonize
== 0) {
1336 if (0 > write(parent_pipe_fd
, "", 1)) return -1;
1337 close(parent_pipe_fd
);
1340 if (idle_limit
&& srv
->srvconf
.max_worker
) {
1341 srv
->srvconf
.max_worker
= 0;
1342 log_error_write(srv
, __FILE__
, __LINE__
, "s",
1343 "server idle time limit command line option disables server.max-worker config file option.");
1346 /* start watcher and workers */
1347 num_childs
= srv
->srvconf
.max_worker
;
1348 if (num_childs
> 0) {
1350 while (!child
&& !srv_shutdown
&& !graceful_shutdown
) {
1351 if (num_childs
> 0) {
1365 if (-1 != wait(&status
)) {
1367 * one of our workers went away
1374 * if we receive a SIGHUP we have to close our logs ourself as we don't
1375 * have the mainloop who can help us here
1377 if (handle_sig_hup
) {
1380 log_error_cycle(srv
);
1383 * forward to all procs in the process-group
1385 * we also send it ourself
1387 if (!forwarded_sig_hup
&& 0 != srv
->srvconf
.max_worker
) {
1388 forwarded_sig_hup
= 1;
1401 * for the parent this is the exit-point
1405 * kill all children too
1407 if (graceful_shutdown
) {
1409 } else if (srv_shutdown
) {
1413 remove_pid_file(srv
, &pid_fd
);
1414 log_error_close(srv
);
1416 connections_free(srv
);
1423 * make sure workers do not muck with pid-file
1429 buffer_reset(srv
->srvconf
.pid_file
);
1433 if (NULL
== (srv
->ev
= fdevent_init(srv
, srv
->max_fds
+ 1, srv
->event_handler
))) {
1434 log_error_write(srv
, __FILE__
, __LINE__
,
1435 "s", "fdevent_init failed");
1439 /* libev backend overwrites our SIGCHLD handler and calls waitpid on SIGCHLD; we want our own SIGCHLD handling. */
1440 #ifdef HAVE_SIGACTION
1441 sigaction(SIGCHLD
, &act
, NULL
);
1442 #elif defined(HAVE_SIGNAL)
1443 signal(SIGCHLD
, signal_handler
);
1447 * kqueue() is called here, select resets its internals,
1448 * all server sockets get their handlers
1451 if (0 != network_register_fdevents(srv
)) {
1459 /* might fail if user is using fam (not gamin) and famd isn't running */
1460 if (NULL
== (srv
->stat_cache
= stat_cache_init())) {
1461 log_error_write(srv
, __FILE__
, __LINE__
, "s",
1462 "stat-cache could not be setup, dieing.");
1468 if (srv
->srvconf
.stat_cache_engine
== STAT_CACHE_ENGINE_FAM
) {
1469 if (0 != FAMOpen2(&srv
->stat_cache
->fam
, "lighttpd")) {
1470 log_error_write(srv
, __FILE__
, __LINE__
, "s",
1471 "could not open a fam connection, dieing.");
1474 #ifdef HAVE_FAMNOEXISTS
1475 FAMNoExists(&srv
->stat_cache
->fam
);
1478 fdevent_register(srv
->ev
, FAMCONNECTION_GETFD(&srv
->stat_cache
->fam
), stat_cache_handle_fdevent
, NULL
);
1479 fdevent_event_set(srv
->ev
, &(srv
->stat_cache
->fam_fcce_ndx
), FAMCONNECTION_GETFD(&srv
->stat_cache
->fam
), FDEVENT_IN
);
1484 /* get the current number of FDs */
1485 srv
->cur_fds
= open("/dev/null", O_RDONLY
);
1486 close(srv
->cur_fds
);
1488 for (i
= 0; i
< srv
->srv_sockets
.used
; i
++) {
1489 server_socket
*srv_socket
= srv
->srv_sockets
.ptr
[i
];
1490 if (srv
->sockets_disabled
) continue; /* lighttpd -1 (one-shot mode) */
1491 if (-1 == fdevent_fcntl_set(srv
->ev
, srv_socket
->fd
)) {
1492 log_error_write(srv
, __FILE__
, __LINE__
, "ss", "fcntl failed:", strerror(errno
));
1497 if (oneshot_fd
&& server_oneshot_init(srv
, oneshot_fd
)) {
1502 while (!srv_shutdown
) {
1507 if (handle_sig_hup
) {
1510 /* reset notification */
1514 /* cycle logfiles */
1516 switch(r
= plugins_call_handle_sighup(srv
)) {
1520 log_error_write(srv
, __FILE__
, __LINE__
, "sd", "sighup-handler return with an error", r
);
1524 if (-1 == log_error_cycle(srv
)) {
1525 log_error_write(srv
, __FILE__
, __LINE__
, "s", "cycling errorlog failed, dying");
1529 #ifdef HAVE_SIGACTION
1530 log_error_write(srv
, __FILE__
, __LINE__
, "sdsd",
1531 "logfiles cycled UID =",
1532 last_sighup_info
.si_uid
,
1534 last_sighup_info
.si_pid
);
1536 log_error_write(srv
, __FILE__
, __LINE__
, "s",
1542 if (handle_sig_alarm
) {
1546 /* reset notification */
1547 handle_sig_alarm
= 0;
1550 /* get current time */
1551 min_ts
= time(NULL
);
1553 if (min_ts
!= srv
->cur_ts
) {
1554 #ifdef DEBUG_CONNECTION_STATES
1557 connections
*conns
= srv
->conns
;
1560 switch(r
= plugins_call_handle_trigger(srv
)) {
1564 log_error_write(srv
, __FILE__
, __LINE__
, "s", "one of the triggers failed");
1567 log_error_write(srv
, __FILE__
, __LINE__
, "d", r
);
1571 /* trigger waitpid */
1572 srv
->cur_ts
= min_ts
;
1574 /* check idle time limit, if enabled */
1575 if (idle_limit
&& idle_limit
< min_ts
- last_active_ts
&& !graceful_shutdown
) {
1576 log_error_write(srv
, __FILE__
, __LINE__
, "sDs", "[note] idle timeout", (int)idle_limit
,
1577 "s exceeded, initiating graceful shutdown");
1578 graceful_shutdown
= 2; /* value 2 indicates idle timeout */
1581 /* cleanup stat-cache */
1582 stat_cache_trigger_cleanup(srv
);
1584 * check all connections for timeouts
1587 for (ndx
= 0; ndx
< conns
->used
; ndx
++) {
1588 connection
* const con
= conns
->ptr
[ndx
];
1589 const int waitevents
= fdevent_event_get_interest(srv
->ev
, con
->fd
);
1593 if (waitevents
& FDEVENT_IN
) {
1594 if (con
->request_count
== 1 || con
->state
!= CON_STATE_READ
) { /* e.g. CON_STATE_READ_POST || CON_STATE_WRITE */
1595 if (srv
->cur_ts
- con
->read_idle_ts
> con
->conf
.max_read_idle
) {
1597 if (con
->conf
.log_request_handling
) {
1598 log_error_write(srv
, __FILE__
, __LINE__
, "sd",
1599 "connection closed - read timeout:", con
->fd
);
1602 connection_set_state(srv
, con
, CON_STATE_ERROR
);
1606 if (srv
->cur_ts
- con
->read_idle_ts
> con
->keep_alive_idle
) {
1608 if (con
->conf
.log_request_handling
) {
1609 log_error_write(srv
, __FILE__
, __LINE__
, "sd",
1610 "connection closed - keep-alive timeout:", con
->fd
);
1613 connection_set_state(srv
, con
, CON_STATE_ERROR
);
1619 /* max_write_idle timeout currently functions as backend timeout,
1620 * too, after response has been started.
1621 * future: have separate backend timeout, and then change this
1622 * to check for write interest before checking for timeout */
1623 /*if (waitevents & FDEVENT_OUT)*/
1624 if ((con
->state
== CON_STATE_WRITE
) &&
1625 (con
->write_request_ts
!= 0)) {
1627 if (srv
->cur_ts
- con
->write_request_ts
> 60) {
1628 log_error_write(srv
, __FILE__
, __LINE__
, "sdd",
1629 "connection closed - pre-write-request-timeout:", con
->fd
, srv
->cur_ts
- con
->write_request_ts
);
1633 if (srv
->cur_ts
- con
->write_request_ts
> con
->conf
.max_write_idle
) {
1635 if (con
->conf
.log_timeouts
) {
1636 log_error_write(srv
, __FILE__
, __LINE__
, "sbsbsosds",
1637 "NOTE: a request from",
1641 "timed out after writing",
1644 (int)con
->conf
.max_write_idle
,
1645 "seconds. If this a problem increase server.max-write-idle");
1647 connection_set_state(srv
, con
, CON_STATE_ERROR
);
1652 if (con
->state
== CON_STATE_CLOSE
&& (srv
->cur_ts
- con
->close_timeout_ts
> HTTP_LINGER_TIMEOUT
)) {
1656 /* we don't like div by zero */
1657 if (0 == (t_diff
= srv
->cur_ts
- con
->connection_start
)) t_diff
= 1;
1659 if (con
->traffic_limit_reached
&&
1660 (con
->conf
.kbytes_per_second
== 0 ||
1661 ((con
->bytes_written
/ t_diff
) < con
->conf
.kbytes_per_second
* 1024))) {
1662 /* enable connection again */
1663 con
->traffic_limit_reached
= 0;
1669 connection_state_machine(srv
, con
);
1671 con
->bytes_written_cur_second
= 0;
1672 *(con
->conf
.global_bytes_per_second_cnt_ptr
) = 0;
1674 #if DEBUG_CONNECTION_STATES
1676 fprintf(stderr
, "connection-state: ");
1680 fprintf(stderr
, "c[%d,%d]: %s ",
1683 connection_get_state(con
->state
));
1687 #ifdef DEBUG_CONNECTION_STATES
1688 if (cs
== 1) fprintf(stderr
, "\n");
1693 if (srv
->sockets_disabled
) {
1694 /* our server sockets are disabled, why ? */
1696 if ((srv
->cur_fds
+ srv
->want_fds
< srv
->max_fds
* 8 / 10) && /* we have enough unused fds */
1697 (srv
->conns
->used
<= srv
->max_conns
* 9 / 10) &&
1698 (0 == graceful_shutdown
)) {
1699 for (i
= 0; i
< srv
->srv_sockets
.used
; i
++) {
1700 server_socket
*srv_socket
= srv
->srv_sockets
.ptr
[i
];
1701 fdevent_event_set(srv
->ev
, &(srv_socket
->fde_ndx
), srv_socket
->fd
, FDEVENT_IN
);
1704 log_error_write(srv
, __FILE__
, __LINE__
, "s", "[note] sockets enabled again");
1706 srv
->sockets_disabled
= 0;
1709 if ((srv
->cur_fds
+ srv
->want_fds
> srv
->max_fds
* 9 / 10) || /* out of fds */
1710 (srv
->conns
->used
>= srv
->max_conns
) || /* out of connections */
1711 (graceful_shutdown
)) { /* graceful_shutdown */
1713 /* disable server-fds */
1715 for (i
= 0; i
< srv
->srv_sockets
.used
; i
++) {
1716 server_socket
*srv_socket
= srv
->srv_sockets
.ptr
[i
];
1718 if (graceful_shutdown
) {
1719 /* we don't want this socket anymore,
1721 * closing it right away will make it possible for
1722 * the next lighttpd to take over (graceful restart)
1725 fdevent_event_del(srv
->ev
, &(srv_socket
->fde_ndx
), srv_socket
->fd
);
1726 fdevent_unregister(srv
->ev
, srv_socket
->fd
);
1727 close(srv_socket
->fd
);
1728 srv_socket
->fd
= -1;
1730 /* network_close() will cleanup after us */
1732 fdevent_event_set(srv
->ev
, &(srv_socket
->fde_ndx
), srv_socket
->fd
, 0);
1736 if (graceful_shutdown
) {
1737 remove_pid_file(srv
, &pid_fd
);
1738 log_error_write(srv
, __FILE__
, __LINE__
, "s", "[note] graceful shutdown started");
1739 } else if (srv
->conns
->used
>= srv
->max_conns
) {
1740 log_error_write(srv
, __FILE__
, __LINE__
, "s", "[note] sockets disabled, connection limit reached");
1742 log_error_write(srv
, __FILE__
, __LINE__
, "s", "[note] sockets disabled, out-of-fds");
1745 srv
->sockets_disabled
= 1;
1749 if (graceful_shutdown
&& srv
->conns
->used
== 0) {
1750 /* we are in graceful shutdown phase and all connections are closed
1751 * we are ready to terminate without harming anyone */
1756 /* we still have some fds to share */
1757 if (srv
->want_fds
) {
1758 /* check the fdwaitqueue for waiting fds */
1759 int free_fds
= srv
->max_fds
- srv
->cur_fds
- 16;
1762 for (; free_fds
> 0 && NULL
!= (con
= fdwaitqueue_unshift(srv
, srv
->fdwaitqueue
)); free_fds
--) {
1763 connection_state_machine(srv
, con
);
1769 if ((n
= fdevent_poll(srv
->ev
, 1000)) > 0) {
1770 /* n is the number of events */
1775 log_error_write(srv
, __FILE__
, __LINE__
, "sd",
1779 last_active_ts
= srv
->cur_ts
;
1782 fdevent_handler handler
;
1786 fd_ndx
= fdevent_event_next_fdndx (srv
->ev
, fd_ndx
);
1787 if (-1 == fd_ndx
) break; /* not all fdevent handlers know how many fds got an event */
1789 revents
= fdevent_event_get_revent (srv
->ev
, fd_ndx
);
1790 fd
= fdevent_event_get_fd (srv
->ev
, fd_ndx
);
1791 handler
= fdevent_get_handler(srv
->ev
, fd
);
1792 context
= fdevent_get_context(srv
->ev
, fd
);
1795 log_error_write(srv
, __FILE__
, __LINE__
, "sdd",
1796 "event for", fd
, revents
);
1798 switch (r
= (*handler
)(srv
, context
, revents
)) {
1799 case HANDLER_FINISHED
:
1801 case HANDLER_WAIT_FOR_EVENT
:
1802 case HANDLER_WAIT_FOR_FD
:
1805 /* should never happen */
1809 log_error_write(srv
, __FILE__
, __LINE__
, "d", r
);
1813 } else if (n
< 0 && errno
!= EINTR
) {
1814 log_error_write(srv
, __FILE__
, __LINE__
, "ss",
1815 "fdevent_poll failed:",
1819 for (ndx
= 0; ndx
< srv
->joblist
->used
; ndx
++) {
1820 connection
*con
= srv
->joblist
->ptr
[ndx
];
1821 connection_state_machine(srv
, con
);
1822 con
->in_joblist
= 0;
1825 srv
->joblist
->used
= 0;
1828 if (0 == graceful_shutdown
) {
1829 remove_pid_file(srv
, &pid_fd
);
1832 if (2 == graceful_shutdown
) { /* value 2 indicates idle timeout */
1833 log_error_write(srv
, __FILE__
, __LINE__
, "s",
1834 "server stopped after idle timeout");
1836 #ifdef HAVE_SIGACTION
1837 log_error_write(srv
, __FILE__
, __LINE__
, "sdsd",
1838 "server stopped by UID =",
1839 last_sigterm_info
.si_uid
,
1841 last_sigterm_info
.si_pid
);
1843 log_error_write(srv
, __FILE__
, __LINE__
, "s",
1849 log_error_close(srv
);
1851 connections_free(srv
);