e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#define CORE_PRIVATE

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#include "httpd.h"

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#include "http_main.h"

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#include "http_log.h"

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#include "http_config.h" /* for read_config */

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#include "http_core.h" /* for get_remote_host */

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#include "http_connection.h"

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#include "ap_mpm.h"

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#include "unixd.h"

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#include "iol_socket.h"

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#include "ap_listen.h"

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#include "scoreboard.h"

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#include "acceptlock.h"

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova

ccaa75089b23c0f043cdbd4001cba4e076ca4fd3Kristina Sojakova#include <poll.h>

ccaa75089b23c0f043cdbd4001cba4e076ca4fd3Kristina Sojakova#include <netinet/tcp.h>

ccaa75089b23c0f043cdbd4001cba4e076ca4fd3Kristina Sojakova#include <pthread.h>

ccaa75089b23c0f043cdbd4001cba4e076ca4fd3Kristina Sojakova

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova

ccaa75089b23c0f043cdbd4001cba4e076ca4fd3Kristina Sojakovastatic int threads_to_start = 0; /* Worker threads per child */

ccaa75089b23c0f043cdbd4001cba4e076ca4fd3Kristina Sojakovastatic int min_spare_threads = 0;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovastatic int max_spare_threads = 0;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovastatic int max_threads = 0;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovastatic int max_requests_per_child = 0;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovastatic char *ap_pid_fname=NULL;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovastatic int num_daemons=0;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovastatic int workers_may_exit = 0;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovastatic int requests_this_child;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovastatic int num_listenfds = 0;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovastatic struct pollfd *listenfds;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#if 0

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#define SAFE_ACCEPT(stmt) do {if (ap_listeners->next != NULL) {stmt;}} while (0)

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#else

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#define SAFE_ACCEPT(stmt) do {stmt;} while (0)

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#endif

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovaint max_daemons_limit = -1;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova

ccaa75089b23c0f043cdbd4001cba4e076ca4fd3Kristina Sojakovastatic char ap_coredump_dir[MAX_STRING_LEN];

ccaa75089b23c0f043cdbd4001cba4e076ca4fd3Kristina Sojakova

ccaa75089b23c0f043cdbd4001cba4e076ca4fd3Kristina Sojakovastatic int pipe_of_death[2];

ccaa75089b23c0f043cdbd4001cba4e076ca4fd3Kristina Sojakovastatic pthread_mutex_t pipe_of_death_mutex;

ccaa75089b23c0f043cdbd4001cba4e076ca4fd3Kristina Sojakova

ccaa75089b23c0f043cdbd4001cba4e076ca4fd3Kristina Sojakova

ccaa75089b23c0f043cdbd4001cba4e076ca4fd3Kristina Sojakovastatic server_rec *server_conf;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovastatic int one_process = 0;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#ifdef DEBUG_SIGSTOP

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovaint raise_sigstop_flags;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#endif

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova#ifdef HAS_OTHER_CHILD

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovatypedef struct other_child_rec other_child_rec;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovastruct other_child_rec {

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova other_child_rec *next;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova int pid;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova void (*maintenance) (int, void *, ap_wait_t);

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova void *data;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova int write_fd;

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakova};

e8dd447a2aa5fbac10668749dfe4142c05ec3d7dKristina Sojakovastatic other_child_rec *other_children;

#endif

static pool *pconf; /* Pool for config stuff */

static pool *pchild; /* Pool for httpd child stuff */

typedef struct {

pool *pool;

pthread_mutex_t mutex;

pthread_attr_t attr;

} worker_thread_info;

static int my_pid; /* Linux getpid() doesn't work except in main thread. Use

static int worker_thread_count;

static pthread_mutex_t worker_thread_count_mutex;

static int idle_thread_count;

static pthread_mutex_t idle_thread_count_mutex;

enum server_token_type ap_server_tokens = SrvTk_FULL;

API_EXPORT(const server_rec *) ap_get_server_conf(void)

{

return (server_conf);

}

void clean_child_exit(int code)

{

if (pchild) {

ap_destroy_pool(pchild);

}

exit(code);

}

#ifdef HAS_OTHER_CHILD

API_EXPORT(void) ap_register_other_child(int pid,

void (*maintenance) (int reason, void *, ap_wait_t status),

void *data, int write_fd)

{

other_child_rec *ocr;

ocr = ap_palloc(pconf, sizeof(*ocr));

ocr->pid = pid;

ocr->maintenance = maintenance;

ocr->data = data;

ocr->write_fd = write_fd;

ocr->next = other_children;

other_children = ocr;

}

API_EXPORT(void) ap_unregister_other_child(void *data)

{

other_child_rec **pocr, *nocr;

for (pocr = &other_children; *pocr; pocr = &(*pocr)->next) {

if ((*pocr)->data == data) {

nocr = (*pocr)->next;

(*(*pocr)->maintenance) (OC_REASON_UNREGISTER, (*pocr)->data, -1);

*pocr = nocr;

/* XXX: um, well we've just wasted some space in pconf ? */

return;

}

}

}

static void probe_writable_fds(void)

{

return;

#if 0

fd_set writable_fds;

int fd_max;

other_child_rec *ocr, *nocr;

struct timeval tv;

int rc;

if (other_children == NULL)

return;

fd_max = 0;

FD_ZERO(&writable_fds);

do {

for (ocr = other_children; ocr; ocr = ocr->next) {

if (ocr->write_fd == -1)

continue;

FD_SET(ocr->write_fd, &writable_fds);

if (ocr->write_fd > fd_max) {

fd_max = ocr->write_fd;

}

}

if (fd_max == 0)

return;

tv.tv_sec = 0;

tv.tv_usec = 0;

rc = ap_select(fd_max + 1, NULL, &writable_fds, NULL, &tv);

} while (rc == -1 && errno == EINTR);

if (rc == -1) {

/* XXX: uhh this could be really bad, we could have a bad file

ap_log_unixerr("probe_writable_fds", "select",

"could not probe writable fds", server_conf);

return;

}

if (rc == 0)

return;

for (ocr = other_children; ocr; ocr = nocr) {

nocr = ocr->next;

if (ocr->write_fd == -1)

continue;

if (FD_ISSET(ocr->write_fd, &writable_fds))

continue;

(*ocr->maintenance) (OC_REASON_UNWRITABLE, ocr->data, -1);

}

#endif

}

static int reap_other_child(int pid, ap_wait_t status)

{

other_child_rec *ocr, *nocr;

for (ocr = other_children; ocr; ocr = nocr) {

nocr = ocr->next;

if (ocr->pid != pid)

continue;

ocr->pid = -1;

(*ocr->maintenance) (OC_REASON_DEATH, ocr->data, status);

return 0;

}

return -1;

}

#endif

static void reclaim_child_processes(int terminate)

{

int i, status;

long int waittime = 1024 * 16; /* in usecs */

struct timeval tv;

int waitret, tries;

int not_dead_yet;

#ifdef HAS_OTHER_CHILD

other_child_rec *ocr, *nocr;

#endif

for (tries = terminate ? 4 : 1; tries <= 9; ++tries) {

/* don't want to hold up progress any more than

tv.tv_sec = waittime / 1000000;

tv.tv_usec = waittime % 1000000;

waittime = waittime * 4;

ap_select(0, NULL, NULL, NULL, &tv);

/* now see who is done */

not_dead_yet = 0;

for (i = 0; i < max_daemons_limit; ++i) {

int pid = ap_scoreboard_image[i].pid;

if (pid == my_pid || pid == 0)

continue;

waitret = waitpid(pid, &status, WNOHANG);

if (waitret == pid || waitret == -1) {

ap_scoreboard_image[i].pid = 0;

continue;

}

++not_dead_yet;

switch (tries) {

case 1: /* 16ms */

case 2: /* 82ms */

break;

case 3: /* 344ms */

case 4: /* 16ms */

case 5: /* 82ms */

case 6: /* 344ms */

case 7: /* 1.4sec */

/* ok, now it's being annoying */

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING,

server_conf,

"child process %d still did not exit, sending a SIGTERM",

pid);

kill(pid, SIGTERM);

break;

case 8: /* 6 sec */

/* die child scum */

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, server_conf,

"child process %d still did not exit, sending a SIGKILL",

pid);

kill(pid, SIGKILL);

break;

case 9: /* 14 sec */

/* gave it our best shot, but alas... If this really

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, server_conf,

"could not make child process %d exit, "

"attempting to continue anyway", pid);

break;

}

}

#ifdef HAS_OTHER_CHILD

for (ocr = other_children; ocr; ocr = nocr) {

nocr = ocr->next;

if (ocr->pid == -1)

continue;

waitret = waitpid(ocr->pid, &status, WNOHANG);

if (waitret == ocr->pid) {

ocr->pid = -1;

(*ocr->maintenance) (OC_REASON_DEATH, ocr->data, status);

}

else if (waitret == 0) {

(*ocr->maintenance) (OC_REASON_RESTART, ocr->data, -1);

++not_dead_yet;

}

else if (waitret == -1) {

/* uh what the heck? they didn't call unregister? */

ocr->pid = -1;

(*ocr->maintenance) (OC_REASON_LOST, ocr->data, -1);

}

}

#endif

if (!not_dead_yet) {

/* nothing left to wait for */

break;

}

}

}

#ifndef INTERVAL_OF_WRITABLE_PROBES

#define INTERVAL_OF_WRITABLE_PROBES 10

#endif

static int wait_or_timeout_counter;

static int wait_or_timeout(ap_wait_t *status)

{

struct timeval tv;

int ret;

++wait_or_timeout_counter;

if (wait_or_timeout_counter == INTERVAL_OF_WRITABLE_PROBES) {

wait_or_timeout_counter = 0;

#ifdef HAS_OTHER_CHILD

probe_writable_fds();

#endif

}

ret = waitpid(-1, status, WNOHANG);

if (ret == -1 && errno == EINTR) {

return -1;

}

if (ret > 0) {

return ret;

}

tv.tv_sec = SCOREBOARD_MAINTENANCE_INTERVAL / 1000000;

tv.tv_usec = SCOREBOARD_MAINTENANCE_INTERVAL % 1000000;

ap_select(0, NULL, NULL, NULL, &tv);

return -1;

}

#if defined(NSIG)

#define NumSIG NSIG

#elif defined(_NSIG)

#define NumSIG _NSIG

#elif defined(__NSIG)

#define NumSIG __NSIG

#else

#define NumSIG 32 /* for 1998's unixes, this is still a good assumption */

#endif

#ifdef SYS_SIGLIST /* platform has sys_siglist[] */

#define INIT_SIGLIST() /*nothing*/

#else /* platform has no sys_siglist[], define our own */

#define SYS_SIGLIST ap_sys_siglist

#define INIT_SIGLIST() siglist_init();

const char *ap_sys_siglist[NumSIG];

static void siglist_init(void)

{

int sig;

ap_sys_siglist[0] = "Signal 0";

#ifdef SIGHUP

ap_sys_siglist[SIGHUP] = "Hangup";

#endif

#ifdef SIGINT

ap_sys_siglist[SIGINT] = "Interrupt";

#endif

#ifdef SIGQUIT

ap_sys_siglist[SIGQUIT] = "Quit";

#endif

#ifdef SIGILL

ap_sys_siglist[SIGILL] = "Illegal instruction";

#endif

#ifdef SIGTRAP

ap_sys_siglist[SIGTRAP] = "Trace/BPT trap";

#endif

#ifdef SIGIOT

ap_sys_siglist[SIGIOT] = "IOT instruction";

#endif

#ifdef SIGABRT

ap_sys_siglist[SIGABRT] = "Abort";

#endif

#ifdef SIGEMT

ap_sys_siglist[SIGEMT] = "Emulator trap";

#endif

#ifdef SIGFPE

ap_sys_siglist[SIGFPE] = "Arithmetic exception";

#endif

#ifdef SIGKILL

ap_sys_siglist[SIGKILL] = "Killed";

#endif

#ifdef SIGBUS

ap_sys_siglist[SIGBUS] = "Bus error";

#endif

#ifdef SIGSEGV

ap_sys_siglist[SIGSEGV] = "Segmentation fault";

#endif

#ifdef SIGSYS

ap_sys_siglist[SIGSYS] = "Bad system call";

#endif

#ifdef SIGPIPE

ap_sys_siglist[SIGPIPE] = "Broken pipe";

#endif

#ifdef SIGALRM

ap_sys_siglist[SIGALRM] = "Alarm clock";

#endif

#ifdef SIGTERM

ap_sys_siglist[SIGTERM] = "Terminated";

#endif

#ifdef SIGUSR1

ap_sys_siglist[SIGUSR1] = "User defined signal 1";

#endif

#ifdef SIGUSR2

ap_sys_siglist[SIGUSR2] = "User defined signal 2";

#endif

#ifdef SIGCLD

ap_sys_siglist[SIGCLD] = "Child status change";

#endif

#ifdef SIGCHLD

ap_sys_siglist[SIGCHLD] = "Child status change";

#endif

#ifdef SIGPWR

ap_sys_siglist[SIGPWR] = "Power-fail restart";

#endif

#ifdef SIGWINCH

ap_sys_siglist[SIGWINCH] = "Window changed";

#endif

#ifdef SIGURG

ap_sys_siglist[SIGURG] = "urgent socket condition";

#endif

#ifdef SIGPOLL

ap_sys_siglist[SIGPOLL] = "Pollable event occurred";

#endif

#ifdef SIGIO

ap_sys_siglist[SIGIO] = "socket I/O possible";

#endif

#ifdef SIGSTOP

ap_sys_siglist[SIGSTOP] = "Stopped (signal)";

#endif

#ifdef SIGTSTP

ap_sys_siglist[SIGTSTP] = "Stopped";

#endif

#ifdef SIGCONT

ap_sys_siglist[SIGCONT] = "Continued";

#endif

#ifdef SIGTTIN

ap_sys_siglist[SIGTTIN] = "Stopped (tty input)";

#endif

#ifdef SIGTTOU

ap_sys_siglist[SIGTTOU] = "Stopped (tty output)";

#endif

#ifdef SIGVTALRM

ap_sys_siglist[SIGVTALRM] = "virtual timer expired";

#endif

#ifdef SIGPROF

ap_sys_siglist[SIGPROF] = "profiling timer expired";

#endif

#ifdef SIGXCPU

ap_sys_siglist[SIGXCPU] = "exceeded cpu limit";

#endif

#ifdef SIGXFSZ

ap_sys_siglist[SIGXFSZ] = "exceeded file size limit";

#endif

for (sig=0; sig < sizeof(ap_sys_siglist)/sizeof(ap_sys_siglist[0]); ++sig)

if (ap_sys_siglist[sig] == NULL)

ap_sys_siglist[sig] = "";

}

#endif /* platform has sys_siglist[] */

static void sig_coredump(int sig)

{

chdir(ap_coredump_dir);

signal(sig, SIG_DFL);

kill(getpid(), sig);

/* At this point we've got sig blocked, because we're still inside

}

static void just_die(int sig)

{

clean_child_exit(0);

}

static int volatile shutdown_pending;

static int volatile restart_pending;

static int volatile is_graceful;

void ap_start_shutdown(void)

{

if (shutdown_pending == 1) {

/* Um, is this _probably_ not an error, if the user has

return;

}

shutdown_pending = 1;

}

void ap_start_restart(int graceful)

{

if (restart_pending == 1) {

/* Probably not an error - don't bother reporting it */

return;

}

restart_pending = 1;

is_graceful = graceful;

}

static void sig_term(int sig)

{

ap_start_shutdown();

}

static void restart(int sig)

{

#ifndef WIN32

ap_start_restart(sig == SIGWINCH);

#else

ap_start_restart(1);

#endif

}

static void set_signals(void)

{

#ifndef NO_USE_SIGACTION

struct sigaction sa;

sigemptyset(&sa.sa_mask);

sa.sa_flags = 0;

if (!one_process) {

sa.sa_handler = sig_coredump;

#if defined(SA_ONESHOT)

sa.sa_flags = SA_ONESHOT;

#elif defined(SA_RESETHAND)

sa.sa_flags = SA_RESETHAND;

#endif

if (sigaction(SIGSEGV, &sa, NULL) < 0)

ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGSEGV)");

#ifdef SIGBUS

if (sigaction(SIGBUS, &sa, NULL) < 0)

ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGBUS)");

#endif

#ifdef SIGABORT

if (sigaction(SIGABORT, &sa, NULL) < 0)

ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGABORT)");

#endif

#ifdef SIGABRT

if (sigaction(SIGABRT, &sa, NULL) < 0)

ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGABRT)");

#endif

#ifdef SIGILL

if (sigaction(SIGILL, &sa, NULL) < 0)

ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGILL)");

#endif

sa.sa_flags = 0;

}

sa.sa_handler = sig_term;

if (sigaction(SIGTERM, &sa, NULL) < 0)

ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGTERM)");

#ifdef SIGINT

if (sigaction(SIGINT, &sa, NULL) < 0)

ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGINT)");

#endif

#ifdef SIGXCPU

sa.sa_handler = SIG_DFL;

if (sigaction(SIGXCPU, &sa, NULL) < 0)

ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGXCPU)");

#endif

#ifdef SIGXFSZ

sa.sa_handler = SIG_DFL;

if (sigaction(SIGXFSZ, &sa, NULL) < 0)

ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGXFSZ)");

#endif

#ifdef SIGPIPE

sa.sa_handler = SIG_IGN;

if (sigaction(SIGPIPE, &sa, NULL) < 0)

ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGPIPE)");

#endif

/* we want to ignore HUPs and WINCH while we're busy processing one */

sigaddset(&sa.sa_mask, SIGHUP);

sigaddset(&sa.sa_mask, SIGWINCH);

sa.sa_handler = restart;

if (sigaction(SIGHUP, &sa, NULL) < 0)

ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGHUP)");

if (sigaction(SIGWINCH, &sa, NULL) < 0)

ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGWINCH)");

#else

if (!one_process) {

signal(SIGSEGV, sig_coredump);

#ifdef SIGBUS

signal(SIGBUS, sig_coredump);

#endif /* SIGBUS */

#ifdef SIGABORT

signal(SIGABORT, sig_coredump);

#endif /* SIGABORT */

#ifdef SIGABRT

signal(SIGABRT, sig_coredump);

#endif /* SIGABRT */

#ifdef SIGILL

signal(SIGILL, sig_coredump);

#endif /* SIGILL */

#ifdef SIGXCPU

signal(SIGXCPU, SIG_DFL);

#endif /* SIGXCPU */

#ifdef SIGXFSZ

signal(SIGXFSZ, SIG_DFL);

#endif /* SIGXFSZ */

}

signal(SIGTERM, sig_term);

#ifdef SIGHUP

signal(SIGHUP, restart);

#endif /* SIGHUP */

#ifdef SIGWINCH

signal(SIGWINCH, restart);

#endif /* SIGWINCH */

#ifdef SIGPIPE

signal(SIGPIPE, SIG_IGN);

#endif /* SIGPIPE */

#endif

}

static int setup_listeners(pool *pconf, server_rec *s)

{

ap_listen_rec *lr;

int num_listeners = 0;

if (ap_listen_open(pconf, s->port)) {

return 0;

}

for (lr = ap_listeners; lr; lr = lr->next) {

num_listeners++;

}

return num_listeners;

}

#if defined(TCP_NODELAY) && !defined(MPE) && !defined(TPF)

static void sock_disable_nagle(int s) /* ZZZ abstract */

{

/* The Nagle algorithm says that we should delay sending partial

int just_say_no = 1;

if (setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char *) &just_say_no,

sizeof(int)) < 0) {

ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf,

"setsockopt: (TCP_NODELAY)");

}

}

#else

#define sock_disable_nagle(s) /* NOOP */

#endif

int ap_graceful_stop_signalled(void)

{

/* XXX - Does this really work? - Manoj */

return is_graceful;

}

static void process_socket(pool *p, struct sockaddr *sa_client, int csd)

{

struct sockaddr sa_server; /* ZZZZ */

size_t len = sizeof(struct sockaddr);

BUFF *conn_io;

conn_rec *current_conn;

ap_iol *iol;

if (getsockname(csd, &sa_server, &len) < 0) {

ap_log_error(APLOG_MARK, APLOG_ERR, server_conf, "getsockname");

close(csd);

return;

}

sock_disable_nagle(csd);

iol = unix_attach_socket(csd);

if (iol == NULL) {

if (errno == EBADF) {

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, NULL,

"filedescriptor (%u) larger than FD_SETSIZE (%u) "

"found, you probably need to rebuild Apache with a "

"larger FD_SETSIZE", csd, FD_SETSIZE);

}

else {

ap_log_error(APLOG_MARK, APLOG_WARNING, NULL,

"error attaching to socket");

}

close(csd);

return;

}

conn_io = ap_bcreate(p, B_RDWR);

ap_bpush_iol(conn_io, iol);

current_conn = ap_new_connection(p, server_conf, conn_io,

(const struct sockaddr_in *) sa_client,

(const struct sockaddr_in *) &sa_server,

0, 0);

ap_process_connection(current_conn);

}

static void *worker_thread(void *);

static int start_thread(worker_thread_info *thread_info)

{

pthread_t thread;

pthread_mutex_lock(&worker_thread_count_mutex);

if (worker_thread_count < max_threads) {

worker_thread_count++;

if (pthread_create(&thread, &(thread_info->attr), worker_thread, thread_info)) {

ap_log_error(APLOG_MARK, APLOG_ALERT, server_conf,

"pthread_create: unable to create worker thread");

/* In case system resources are maxxed out, we don't want

sleep(10);

worker_thread_count--;

workers_may_exit = 1;

pthread_mutex_unlock(&worker_thread_count_mutex);

return 0;

}

}

else {

static int reported = 0;

if (!reported) {

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, server_conf,

"server reached MaxThreadsPerChild setting, consider raising the"

" MaxThreadsPerChild or NumServers settings");

reported = 1;

}

pthread_mutex_unlock(&worker_thread_count_mutex);

return 0;

}

pthread_mutex_unlock(&worker_thread_count_mutex);

return 1;

}

static void *worker_thread(void *arg)

{

struct sockaddr sa_client;

int csd = -1;

pool *tpool; /* Pool for this thread */

pool *ptrans; /* Pool for per-transaction stuff */

int sd = -1;

int srv;

int ret;

char pipe_read_char;

int curr_pollfd, last_pollfd = 0;

size_t len = sizeof(struct sockaddr);

worker_thread_info *thread_info = arg;

int thread_just_started = 1;

pthread_mutex_lock(&thread_info->mutex);

tpool = ap_make_sub_pool(thread_info->pool);

pthread_mutex_unlock(&thread_info->mutex);

ptrans = ap_make_sub_pool(tpool);

/* TODO: Switch to a system where threads reuse the results from earlier

while (!workers_may_exit) {

workers_may_exit |= (max_requests_per_child != 0) && (requests_this_child <= 0);

if (workers_may_exit) break;

if (!thread_just_started) {

pthread_mutex_lock(&idle_thread_count_mutex);

if (idle_thread_count < max_spare_threads) {

idle_thread_count++;

pthread_mutex_unlock(&idle_thread_count_mutex);

}

else {

pthread_mutex_unlock(&idle_thread_count_mutex);

break;

}

}

else {

thread_just_started = 0;

}

SAFE_ACCEPT(intra_mutex_on(0));

if (workers_may_exit) {

SAFE_ACCEPT(intra_mutex_off(0));

break;

}

SAFE_ACCEPT(accept_mutex_on(0));

while (!workers_may_exit) {

srv = poll(listenfds, num_listenfds + 1, -1);

if (srv < 0) {

if (errno == EINTR) {

continue;

}

/* poll() will only return errors in catastrophic

ap_log_error(APLOG_MARK, APLOG_ERR, (const server_rec *)

ap_get_server_conf(), "poll: (listen)");

workers_may_exit = 1;

}

if (workers_may_exit) break;

if (listenfds[0].revents & POLLIN) {

/* A process got a signal on the shutdown pipe. Check if we're

pthread_mutex_lock(&pipe_of_death_mutex);

if (!workers_may_exit) {

ret = read(listenfds[0].fd, &pipe_read_char, 1);

if (ret == -1 && errno == EAGAIN) {

/* It lost the lottery. It must continue to suffer

pthread_mutex_unlock(&pipe_of_death_mutex);

continue;

}

else {

/* It won the lottery (or something else is very

workers_may_exit = 1;

pthread_mutex_unlock(&pipe_of_death_mutex);

break;

}

}

pthread_mutex_unlock(&pipe_of_death_mutex);

}

if (num_listenfds == 1) {

sd = ap_listeners->fd;

goto got_fd;

}

else {

/* find a listener */

curr_pollfd = last_pollfd;

do {

curr_pollfd++;

if (curr_pollfd > num_listenfds) {

curr_pollfd = 1;

}

/* XXX: Should we check for POLLERR? */

if (listenfds[curr_pollfd].revents & POLLIN) {

last_pollfd = curr_pollfd;

sd = listenfds[curr_pollfd].fd;

goto got_fd;

}

} while (curr_pollfd != last_pollfd);

}

}

got_fd:

if (!workers_may_exit) {

csd = ap_accept(sd, &sa_client, &len);

SAFE_ACCEPT(accept_mutex_off(0));

SAFE_ACCEPT(intra_mutex_off(0));

pthread_mutex_lock(&idle_thread_count_mutex);

if (idle_thread_count > min_spare_threads) {

idle_thread_count--;

}

else {

if (!start_thread(thread_info)) {

idle_thread_count--;

}

}

pthread_mutex_unlock(&idle_thread_count_mutex);

} else {

SAFE_ACCEPT(accept_mutex_off(0));

SAFE_ACCEPT(intra_mutex_off(0));

pthread_mutex_lock(&idle_thread_count_mutex);

idle_thread_count--;

pthread_mutex_unlock(&idle_thread_count_mutex);

break;

}

process_socket(ptrans, &sa_client, csd);

ap_clear_pool(ptrans);

requests_this_child--;

}

ap_destroy_pool(tpool);

pthread_mutex_lock(&worker_thread_count_mutex);

worker_thread_count--;

if (worker_thread_count == 0) {

/* All the threads have exited, now finish the shutdown process

kill(my_pid, SIGTERM);

}

pthread_mutex_unlock(&worker_thread_count_mutex);

return NULL;

}

static void child_main(void)

{

sigset_t sig_mask;

int signal_received;

int i;

worker_thread_info thread_info;

ap_listen_rec *lr;

my_pid = getpid();

pchild = ap_make_sub_pool(pconf);

/*stuff to do before we switch id's, so we have permissions.*/

SAFE_ACCEPT(intra_mutex_init(pchild, 1));

SAFE_ACCEPT(accept_mutex_child_init(pchild));

if (unixd_setup_child()) {

clean_child_exit(APEXIT_CHILDFATAL);

}

ap_child_init_hook(pchild, server_conf);

/*done with init critical section */

/* All threads should mask signals out, accoring to sigwait(2) man page */

sigemptyset(&sig_mask);

if (pthread_sigmask(SIG_SETMASK, &sig_mask, NULL) != 0) {

ap_log_error(APLOG_MARK, APLOG_ALERT, server_conf, "pthread_sigmask");

}

requests_this_child = max_requests_per_child;

/* Set up the pollfd array */

listenfds = ap_palloc(pchild, sizeof(struct pollfd) * (num_listenfds + 1));

listenfds[0].fd = pipe_of_death[0];

listenfds[0].events = POLLIN;

listenfds[0].revents = 0;

for (lr = ap_listeners, i = 1; i <= num_listenfds; lr = lr->next, ++i) {

listenfds[i].fd = lr->fd;

listenfds[i].events = POLLIN; /* should we add POLLPRI ?*/

listenfds[i].revents = 0;

}

/* Setup worker threads */

if (threads_to_start > max_threads) {

threads_to_start = max_threads;

}

idle_thread_count = threads_to_start;

worker_thread_count = 0;

thread_info.pool = ap_make_sub_pool(pconf);

pthread_mutex_init(&thread_info.mutex, NULL);

pthread_mutex_init(&idle_thread_count_mutex, NULL);

pthread_mutex_init(&worker_thread_count_mutex, NULL);

pthread_mutex_init(&pipe_of_death_mutex, NULL);

pthread_attr_init(&thread_info.attr);

pthread_attr_setdetachstate(&thread_info.attr, PTHREAD_CREATE_DETACHED);

/* We are creating worker threads right now */

for (i=0; i < threads_to_start; i++) {

/* start_thread shouldn't fail here */

if (!start_thread(&thread_info)) {

break;

}

}

/* This thread will be the one responsible for handling signals */

sigemptyset(&sig_mask);

sigaddset(&sig_mask, SIGTERM);

sigaddset(&sig_mask, SIGINT);

sigwait(&sig_mask, &signal_received);

switch (signal_received) {

case SIGTERM:

case SIGINT:

just_die(signal_received);

break;

default:

ap_log_error(APLOG_MARK, APLOG_ALERT, server_conf,

"received impossible signal: %d", signal_received);

just_die(SIGTERM);

}

}

static int make_child(server_rec *s, int slot, time_t now) /* ZZZ */

{

int pid;

(void) ap_update_child_status(slot, SERVER_ALIVE);

if (slot + 1 > max_daemons_limit) {

max_daemons_limit = slot + 1;

}

if (one_process) {

set_signals();

ap_scoreboard_image[slot].pid = getpid();

child_main();

}

if ((pid = fork()) == -1) {

ap_log_error(APLOG_MARK, APLOG_ERR, s, "fork: Unable to fork new process");

/* In case system resources are maxxed out, we don't want

sleep(10);

return -1;

}

if (!pid) {

#ifdef AIX_BIND_PROCESSOR

/* By default, AIX binds to a single processor. This bit unbinds

#include <sys/processor.h>

int status = bindprocessor(BINDPROCESS, (int)getpid(),

PROCESSOR_CLASS_ANY);

if (status != OK)

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, server_conf,

"processor unbind failed %d", status);

#endif

RAISE_SIGSTOP(MAKE_CHILD);

/* XXX - For an unthreaded server, a signal handler will be necessary

child_main();

return 0;

}

/* else */

ap_scoreboard_image[slot].pid = pid;

return 0;

}

static int startup_children(int number_to_start)

{

int i;

for (i = 0; number_to_start && i < num_daemons; ++i) {

if (ap_scoreboard_image[i].status != SERVER_DEAD) {

continue;

}

if (make_child(server_conf, i, 0) < 0) {

break;

}

--number_to_start;

}

return number_to_start;

}

static int spawn_rate = 1;

#ifndef MAX_SPAWN_RATE

#define MAX_SPAWN_RATE (32)

#endif

static int hold_off_on_exponential_spawning;

static void perform_child_maintenance(void)

{

int i;

time_t now = 0;

int free_length;

int free_slots[MAX_SPAWN_RATE];

int last_non_dead = -1;

/* initialize the free_list */

free_length = 0;

ap_check_signals();

for (i = 0; i < num_daemons; ++i) {

unsigned char status = ap_scoreboard_image[i].status;

if (status == SERVER_DEAD) {

free_slots[free_length] = i;

++free_length;

} else {

last_non_dead = i;

}

if (free_length >= spawn_rate) {

break;

}

}

max_daemons_limit = last_non_dead + 1;

if (free_length > 0) {

for (i = 0; i < free_length; ++i) {

make_child(server_conf, free_slots[i], now);

}

/* the next time around we want to spawn twice as many if this

if (hold_off_on_exponential_spawning) {

--hold_off_on_exponential_spawning;

}

else if (spawn_rate < MAX_SPAWN_RATE) {

spawn_rate *= 2;

}

}

else {

spawn_rate = 1;

}

}

static void server_main_loop(int remaining_children_to_start)

{

int child_slot;

ap_wait_t status;

int pid;

while (!restart_pending && !shutdown_pending) {

pid = wait_or_timeout(&status);

if (pid >= 0) {

child_slot = find_child_by_pid(pid);

if (child_slot >= 0) {

ap_update_child_status(child_slot, SERVER_DEAD);

if (remaining_children_to_start

&& child_slot < num_daemons) {

/* we're still doing a 1-for-1 replacement of dead

/* ZZZ abstract out for AP funcs. */

make_child(server_conf, child_slot, time(NULL));

--remaining_children_to_start;

}

#ifdef HAS_OTHER_CHILD

}

else if (reap_other_child(pid, status) == 0) {

/* handled */

#endif

}

else if (is_graceful) {

/* Great, we've probably just lost a slot in the

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, server_conf,

"long lost child came home! (pid %d)", pid);

}

/* Don't perform idle maintenance when a child dies,

continue;

}

else if (remaining_children_to_start) {

/* we hit a 1 second timeout in which none of the previous

remaining_children_to_start = \

startup_children(remaining_children_to_start);

/* In any event we really shouldn't do the code below because

continue;

}

perform_child_maintenance();

}

}

int ap_mpm_run(pool *_pconf, pool *plog, server_rec *s)

{

int remaining_children_to_start;

pconf = _pconf;

server_conf = s;

if (pipe(pipe_of_death) == -1) {

ap_log_error(APLOG_MARK, APLOG_ERR,

(const server_rec*) server_conf,

"pipe: (pipe_of_death)");

exit(1);

}

ap_note_cleanups_for_fd(pconf, pipe_of_death[0]);

ap_note_cleanups_for_fd(pconf, pipe_of_death[1]);

if (fcntl(pipe_of_death[0], F_SETFD, O_NONBLOCK) == -1) {

ap_log_error(APLOG_MARK, APLOG_ERR,

(const server_rec*) server_conf,

"fcntl: O_NONBLOCKing (pipe_of_death)");

exit(1);

}

server_conf = s;

if ((num_listenfds = setup_listeners(pconf, server_conf)) < 1) {

/* XXX: hey, what's the right way for the mpm to indicate a fatal error? */

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ALERT, s,

"no listening sockets available, shutting down");

return 1;

}

ap_clear_pool(plog);

ap_open_logs(server_conf, plog);

ap_log_pid(pconf, ap_pid_fname);

SAFE_ACCEPT(accept_mutex_init(pconf, 1));

if (!is_graceful) {

reinit_scoreboard(pconf);

}

set_signals();

/* If we're doing a graceful_restart then we're going to see a lot

remaining_children_to_start = num_daemons;

if (!is_graceful) {

remaining_children_to_start = \

startup_children(remaining_children_to_start);

}

else {

/* give the system some time to recover before kicking into

hold_off_on_exponential_spawning = 10;

}

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE, server_conf,

"%s configured -- resuming normal operations",

ap_get_server_version());

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_INFO, server_conf,

"Server built: %s", ap_get_server_built());