65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht#define CORE_PRIVATE

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#define INCL_DOS

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#define INCL_DOSERRORS

c1d06b3018b34ede2b3fb6c7fe2ad28cd5ce5b68Christian Maeder

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include "ap_config.h"

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include "httpd.h"

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include "mpm_default.h"

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include "http_main.h"

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include "http_log.h"

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include "http_config.h"

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include "http_core.h" /* for get_remote_host */

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include "http_connection.h"

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include "scoreboard.h"

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder#include "ap_mpm.h"

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include "ap_listen.h"

d8623e217fff016f9e1759b5603fc06b29fda62cChristian Maeder#include "apr_portable.h"

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include "mpm_common.h"

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder#include "apr_strings.h"

d8623e217fff016f9e1759b5603fc06b29fda62cChristian Maeder

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include <os2.h>

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder#include <stdlib.h>

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include <sys/signal.h>

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include <process.h>

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include <time.h>

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht#include <io.h>

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbrichtstatic int ap_max_requests_per_child=0;

255f0ed47809d8fea6e177112139735ed8778359Till Mossakowskistatic char *ap_pid_fname=NULL;

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maederstatic int ap_daemons_to_start=0;

432ac7c08e2592af0660e026051ffb052e88a100Simon Ulbrichtstatic int ap_daemons_min_free=0;

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbrichtstatic int ap_daemons_max_free=0;

c1d06b3018b34ede2b3fb6c7fe2ad28cd5ce5b68Christian Maederstatic int ap_daemons_limit=0;

432ac7c08e2592af0660e026051ffb052e88a100Simon Ulbrichtstatic time_t ap_restart_time=0;

432ac7c08e2592af0660e026051ffb052e88a100Simon Ulbrichtstatic int ap_extended_status = 0;

432ac7c08e2592af0660e026051ffb052e88a100Simon Ulbricht

c1d06b3018b34ede2b3fb6c7fe2ad28cd5ce5b68Christian Maederstatic int max_daemons_limit = -1;

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maederchar ap_coredump_dir[MAX_STRING_LEN];

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbricht

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbrichtserver_rec *ap_server_conf;

e9a1a4d5820d527a6800d524ebaf29fbad6196c6Simon Ulbricht

6a26171b5bc5b6ec3e1b02ae30dcfb6f03d7ffefSimon Ulbricht

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbrichtstatic int one_process = 0;

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbricht

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbrichtstatic apr_pool_t *pconf; /* Pool for config stuff */

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbrichtstatic scoreboard *ap_scoreboard_image = NULL;

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbricht

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbrichtstruct thread_globals {

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbricht int child_num;

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbricht apr_pool_t *pchild; /* Pool for httpd child stuff */

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbricht int usr1_just_die;

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbricht};

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbricht

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbrichtstatic struct thread_globals **ppthread_globals = NULL;

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbricht

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbricht#define THREAD_GLOBAL(gvar) ((*ppthread_globals)->gvar)

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbricht

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbricht

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbrichtvoid reinit_scoreboard(apr_pool_t *p)

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbricht{

abea93ed557b22ea833e1524ee5ca11afc12208aSimon Ulbricht if (ap_scoreboard_image == NULL) {

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder ap_scoreboard_image = (scoreboard *) malloc(SCOREBOARD_SIZE);

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder if (ap_scoreboard_image == NULL) {

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder ap_log_error(APLOG_MARK, APLOG_STARTUP | APLOG_NOERRNO, 0, NULL,

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbricht "Ouch! Out of memory reiniting scoreboard!");

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbricht }

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht }

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht memset(ap_scoreboard_image, 0, SCOREBOARD_SIZE);

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht}

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbrichtvoid cleanup_scoreboard(void)

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbricht{

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht ap_assert(ap_scoreboard_image);

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht free(ap_scoreboard_image);

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht ap_scoreboard_image = NULL;

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht}

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbrichtstatic void clean_child_exit(int code)

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht{

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht if (THREAD_GLOBAL(pchild)) {

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht apr_destroy_pool(THREAD_GLOBAL(pchild));

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht }

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

22a42cbea5bdf4b39b99794550b1403b3820b5e5Christian Maeder ap_scoreboard_image->servers[THREAD_GLOBAL(child_num)].thread_retval = code;

22a42cbea5bdf4b39b99794550b1403b3820b5e5Christian Maeder _endthread();

ea9768c548fe6ae05d275380869c2923c3392244Simon Ulbricht}

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbrichtstatic apr_lock_t *accept_mutex = NULL;

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbrichtstatic apr_status_t accept_mutex_child_cleanup(void *foo)

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht{

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht return apr_unlock(accept_mutex);

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht}

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbrichtstatic void accept_mutex_child_init(apr_pool_t *p)

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht{

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht apr_register_cleanup(p, NULL, accept_mutex_child_cleanup, apr_null_cleanup);

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht}

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbrichtstatic void accept_mutex_init(apr_pool_t *p)

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbricht{

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht apr_status_t rc = apr_create_lock(&accept_mutex, APR_MUTEX, APR_INTRAPROCESS, NULL, p);

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht if (rc != APR_SUCCESS) {

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht ap_log_error(APLOG_MARK, APLOG_EMERG, rc, ap_server_conf,

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht "Error creating accept lock. Exiting!");

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht clean_child_exit(APEXIT_CHILDFATAL);

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht }

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht}

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbrichtstatic void accept_mutex_on(void)

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht{

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht apr_status_t rc = apr_lock(accept_mutex);

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht if (rc != APR_SUCCESS) {

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbricht ap_log_error(APLOG_MARK, APLOG_EMERG, rc, ap_server_conf,

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht "Error getting accept lock. Exiting!");

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht clean_child_exit(APEXIT_CHILDFATAL);

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht }

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht}

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbrichtstatic void accept_mutex_off(void)

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht{

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht apr_status_t rc = apr_unlock(accept_mutex);

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht if (rc != APR_SUCCESS) {

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbricht ap_log_error(APLOG_MARK, APLOG_EMERG, rc, ap_server_conf,

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht "Error freeing accept lock. Exiting!");

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht clean_child_exit(APEXIT_CHILDFATAL);

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht }

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht}

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht#ifdef SINGLE_LISTEN_UNSERIALIZED_ACCEPT

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht#define SAFE_ACCEPT(stmt) do {if (ap_listeners->next) {stmt;}} while(0)

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht#else

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht#define SAFE_ACCEPT(stmt) do {stmt;} while(0)

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht#endif

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon UlbrichtAP_DECLARE(int) ap_exists_scoreboard_image(void)

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht{

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbricht return (ap_scoreboard_image ? 1 : 0);

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht}

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon UlbrichtAP_DECLARE(int) ap_get_max_daemons(void)

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht{

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht return max_daemons_limit;

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht}

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbrichtint ap_update_child_status(int child_num, int status, request_rec *r)

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbricht{

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht int old_status;

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht short_score *ss;

ea9768c548fe6ae05d275380869c2923c3392244Simon Ulbricht

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht if (child_num < 0)

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht return -1;

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder ss = &ap_scoreboard_image->servers[child_num];

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder old_status = ss->status;

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder ss->status = status;

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder

987c9ee1092c7fd8b53242abefe4f3cf8e9a1011Simon Ulbricht if (ap_extended_status) {

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht if (status == SERVER_READY || status == SERVER_DEAD) {

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht /*

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht if (status == SERVER_DEAD) {

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht ss->my_access_count = 0L;

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht ss->my_bytes_served = 0L;

ea9768c548fe6ae05d275380869c2923c3392244Simon Ulbricht }

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht ss->conn_count = (unsigned short) 0;

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbricht ss->conn_bytes = (unsigned long) 0;

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht }

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht if (r) {

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht conn_rec *c = r->connection;

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht apr_cpystrn(ss->client, ap_get_remote_host(c, r->per_dir_config,

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht REMOTE_NOLOOKUP), sizeof(ss->client));

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder if (r->the_request == NULL) {

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder apr_cpystrn(ss->request, "NULL", sizeof(ss->request));

65660c22133e6de16f9ece7b36ac6423014b20aaChristian Maeder } else if (r->parsed_uri.password == NULL) {

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbricht apr_cpystrn(ss->request, r->the_request, sizeof(ss->request));

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbricht } else {

53d3b5d18cae658f0e54872ade90ab5259b52b95Simon Ulbricht /* Don't reveal the password in the server-status view */

53d3b5d18cae658f0e54872ade90ab5259b52b95Simon Ulbricht apr_cpystrn(ss->request, apr_pstrcat(r->pool, r->method, " ",

53d3b5d18cae658f0e54872ade90ab5259b52b95Simon Ulbricht ap_unparse_uri_components(r->pool, &r->parsed_uri, UNP_OMITPASSWORD),

c1d06b3018b34ede2b3fb6c7fe2ad28cd5ce5b68Christian Maeder r->assbackwards ? NULL : " ", r->protocol, NULL),

3ac14720aa7f1e0715311bd1598e7d78c37dd3c6Simon Ulbricht sizeof(ss->request));

53d3b5d18cae658f0e54872ade90ab5259b52b95Simon Ulbricht }

53d3b5d18cae658f0e54872ade90ab5259b52b95Simon Ulbricht ss->vhostrec = r->server;

53d3b5d18cae658f0e54872ade90ab5259b52b95Simon Ulbricht }

7c84f8fd92ed59eb2b9a674e6b1ea93c0f945006Simon Ulbricht }

53d3b5d18cae658f0e54872ade90ab5259b52b95Simon Ulbricht

53d3b5d18cae658f0e54872ade90ab5259b52b95Simon Ulbricht if (status == SERVER_STARTING && r == NULL) {

53d3b5d18cae658f0e54872ade90ab5259b52b95Simon Ulbricht /* clean up the slot's vhostrec pointer (maybe re-used)

53d3b5d18cae658f0e54872ade90ab5259b52b95Simon Ulbricht ss->vhostrec = NULL;

53d3b5d18cae658f0e54872ade90ab5259b52b95Simon Ulbricht ap_scoreboard_image->parent[child_num].generation = ap_scoreboard_image->global.running_generation;

c1d06b3018b34ede2b3fb6c7fe2ad28cd5ce5b68Christian Maeder }

53d3b5d18cae658f0e54872ade90ab5259b52b95Simon Ulbricht

a210c2e5add831cd438183c8602ed8e610922beaSimon Ulbricht return old_status;

1651c7f5055453e18a8c34f96c333e2aa702a34eSimon Ulbricht}

369771f5d48a40eda134026b1f45f63b2c00bdb8Simon Ulbricht

void ap_time_process_request(int child_num, int status)

{

short_score *ss;

if (child_num < 0)

return;

ss = &ap_scoreboard_image->servers[child_num];

if (status == START_PREQUEST) {

ss->start_time = apr_now();

}

else if (status == STOP_PREQUEST) {

ss->stop_time = apr_now();

}

}

static void increment_counts(int child_num, request_rec *r)

{

short_score *ss;

ss = &ap_scoreboard_image->servers[child_num];

#ifdef HAVE_TIMES

times(&ss->times);

#endif

ss->access_count++;

ss->my_access_count++;

ss->conn_count++;

ss->bytes_served += r->bytes_sent;

ss->my_bytes_served += r->bytes_sent;

ss->conn_bytes += r->bytes_sent;

}

static int find_child_by_tid(int tid)

{

int i;

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

if (ap_scoreboard_image->parent[i].tid == tid)

return i;

return -1;

}

#ifndef INTERVAL_OF_WRITABLE_PROBES

#define INTERVAL_OF_WRITABLE_PROBES 10

#endif

static int wait_or_timeout_counter;

static int wait_or_timeout(apr_wait_t *status)

{

int ret;

ULONG tid;

++wait_or_timeout_counter;

if (wait_or_timeout_counter == INTERVAL_OF_WRITABLE_PROBES) {

wait_or_timeout_counter = 0;

#if APR_HAS_OTHER_CHILD

apr_probe_writable_fds();

#endif

}

tid = 0;

ret = DosWaitThread(&tid, DCWW_NOWAIT);

if (ret == 0) {

int child_num = find_child_by_tid(tid);

ap_assert( child_num > 0 );

*status = ap_scoreboard_image->servers[child_num].thread_retval;

return tid;

}

DosSleep(SCOREBOARD_MAINTENANCE_INTERVAL / 1000);

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 void usr1_handler(int sig)

{

if (THREAD_GLOBAL(usr1_just_die)) {

just_die(sig);

}

ap_scoreboard_image->parent[THREAD_GLOBAL(child_num)].deferred_die = 1;

}

static int volatile shutdown_pending;

static int volatile restart_pending;

static int volatile is_graceful;

static void sig_term(int sig)

{

if (shutdown_pending == 1) {

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

return;

}

shutdown_pending = 1;

}

static void restart(int sig)

{

if (restart_pending == 1) {

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

return;

}

restart_pending = 1;

is_graceful = sig == SIGUSR1;

}

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, errno, ap_server_conf, "sigaction(SIGSEGV)");

#ifdef SIGBUS

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

ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGBUS)");

#endif

#ifdef SIGABORT

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

ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGABORT)");

#endif

#ifdef SIGABRT

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

ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGABRT)");

#endif

#ifdef SIGILL

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

ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_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, errno, ap_server_conf, "sigaction(SIGTERM)");

#ifdef SIGINT

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

ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_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, errno, ap_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, errno, ap_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, errno, ap_server_conf, "sigaction(SIGPIPE)");

#endif

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

sigaddset(&sa.sa_mask, SIGHUP);

sigaddset(&sa.sa_mask, SIGUSR1);

sa.sa_handler = restart;

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

ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGHUP)");

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

ap_log_error(APLOG_MARK, APLOG_WARNING, errno, ap_server_conf, "sigaction(SIGUSR1)");

#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 SIGUSR1

signal(SIGUSR1, restart);

#endif /* SIGUSR1 */

#ifdef SIGPIPE

signal(SIGPIPE, SIG_IGN);

#endif /* SIGPIPE */

#endif

}

AP_DECLARE(void) ap_child_terminate(request_rec *r)

{

r->connection->keepalive = 0;

ap_scoreboard_image->parent[THREAD_GLOBAL(child_num)].deferred_die = 1;

}

int ap_graceful_stop_signalled(void)

{

if (ap_scoreboard_image->parent[THREAD_GLOBAL(child_num)].deferred_die ||

ap_scoreboard_image->global.running_generation != ap_scoreboard_image->parent[THREAD_GLOBAL(child_num)].generation) {

return 1;

}

return 0;

}

int ap_stop_signalled(void)

{

if (shutdown_pending || restart_pending ||

ap_scoreboard_image->parent[THREAD_GLOBAL(child_num)].deferred_die ||

ap_scoreboard_image->global.running_generation != ap_scoreboard_image->parent[THREAD_GLOBAL(child_num)].generation) {

return 1;

}

return 0;

}

static int setup_listen_poll(apr_pool_t *pchild, apr_pollfd_t **listen_poll)

{

ap_listen_rec *lr;

int numfds = 0;

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

numfds++;

}

apr_setup_poll(listen_poll, numfds, pchild);

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

apr_add_poll_socket(*listen_poll, lr->sd, APR_POLLIN);

}

return 0;

}

static void child_main(void *child_num_arg)

{

ap_listen_rec *lr = NULL;

ap_listen_rec *first_lr = NULL;

apr_pool_t *ptrans;

conn_rec *current_conn;

apr_pool_t *pchild;

parent_score *sc_parent_rec;

int requests_this_child = 0;

apr_pollfd_t *listen_poll;

apr_socket_t *csd = NULL;

int nsds, rv;

/* Disable the restart signal handlers and enable the just_die stuff.

set_signals(); /* signals aren't inherrited by child threads */

signal(SIGHUP, just_die);

signal(SIGUSR1, just_die);

signal(SIGTERM, just_die);

/* Get a sub pool for global allocations in this child, so that

apr_create_pool(&pchild, pconf);

*ppthread_globals = (struct thread_globals *)apr_palloc(pchild, sizeof(struct thread_globals));

THREAD_GLOBAL(child_num) = (int)child_num_arg;

sc_parent_rec = ap_scoreboard_image->parent + THREAD_GLOBAL(child_num);

THREAD_GLOBAL(pchild) = pchild;

apr_create_pool(&ptrans, pchild);

if (setup_listen_poll(pchild, &listen_poll)) {

clean_child_exit(1);

}

/* needs to be done before we switch UIDs so we have permissions */

SAFE_ACCEPT(accept_mutex_child_init(pchild));

ap_child_init_hook(pchild, ap_server_conf);

(void) ap_update_child_status(THREAD_GLOBAL(child_num), SERVER_READY, (request_rec *) NULL);

signal(SIGHUP, just_die);

signal(SIGTERM, just_die);

while (!ap_stop_signalled()) {

int srv;

apr_socket_t *sd;

/* Prepare to receive a SIGUSR1 due to graceful restart so that

THREAD_GLOBAL(usr1_just_die) = 1;

signal(SIGUSR1, usr1_handler);

/*

current_conn = NULL;

apr_clear_pool(ptrans);

if ((ap_max_requests_per_child > 0

&& requests_this_child++ >= ap_max_requests_per_child)) {

clean_child_exit(0);

}

(void) ap_update_child_status(THREAD_GLOBAL(child_num), SERVER_READY, (request_rec *) NULL);

/*

/* Lock around "accept", if necessary */

SAFE_ACCEPT(accept_mutex_on());

if (ap_stop_signalled()) {

clean_child_exit(0);

}

for (;;) {

if (ap_listeners->next) {

/* more than one socket */

srv = apr_poll(listen_poll, &nsds, -1);

if (srv != APR_SUCCESS) {

/* Single Unix documents select as returning errnos

ap_log_error(APLOG_MARK, APLOG_ERR, errno, ap_server_conf, "select: (listen)");

clean_child_exit(1);

}

/* we remember the last_lr we searched last time around so that

if (first_lr == NULL) {

first_lr = ap_listeners;

}

lr = first_lr;

do {

apr_int16_t event;

if (!lr) {

lr = ap_listeners;

}

apr_get_revents(&event, lr->sd, listen_poll);

if (event == APR_POLLIN) {

first_lr = lr->next;

break;

}

lr = lr->next;

} while (lr != first_lr);

if (lr == first_lr) {

continue;

}

sd = lr->sd;

}

else {

/* only one socket, just pretend we did the other stuff */

sd = ap_listeners->sd;

}

/* if we accept() something we don't want to die, so we have to

THREAD_GLOBAL(usr1_just_die) = 0;

rv = apr_accept(&csd, sd, ptrans);

if (APR_STATUS_IS_SUCCESS(rv)) {

break; /* We have a socket ready for reading */

}

else if (APR_STATUS_IS_ECONNABORTED(rv)

|| APR_STATUS_IS_ECONNRESET(rv)

|| APR_STATUS_IS_ETIMEDOUT(rv)

|| APR_STATUS_IS_EHOSTUNREACH(rv)

|| APR_STATUS_IS_ENETUNREACH(rv)) {

/* Our old behaviour here was to continue after accept()

/* Linux generates most of these, other tcp

break;

}

else if (APR_STATUS_IS_EINTR(rv)) {

/* We only get hit by an EINTR if the parent is

clean_child_exit(0);

}

else {

ap_log_error(APLOG_MARK, APLOG_ERR, rv, ap_server_conf,

"accept: (client socket)");

clean_child_exit(1);

}

if (ap_stop_signalled()) {

clean_child_exit(0);

}

THREAD_GLOBAL(usr1_just_die) = 1;

}

SAFE_ACCEPT(accept_mutex_off()); /* unlock after "accept" */

/* We've got a socket, let's at least process one request off the

signal(SIGUSR1, SIG_IGN);

/*

ap_sock_disable_nagle(csd);

(void) ap_update_child_status(THREAD_GLOBAL(child_num), SERVER_BUSY_READ,

(request_rec *) NULL);

current_conn = ap_new_connection(ptrans, ap_server_conf, csd,

THREAD_GLOBAL(child_num));

ap_process_connection(current_conn);

ap_lingering_close(current_conn);

}

clean_child_exit(0);

}

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

{

TID tid;

if (slot + 1 > max_daemons_limit) {

max_daemons_limit = slot + 1;

}

if (one_process) {

struct thread_globals *parent_globals = *ppthread_globals;

signal(SIGHUP, just_die);

signal(SIGINT, just_die);

#ifdef SIGQUIT

signal(SIGQUIT, SIG_DFL);

#endif

signal(SIGTERM, just_die);

child_main((void *)slot);

*ppthread_globals = parent_globals;

}

ap_update_child_status(slot, SERVER_STARTING, (request_rec *) NULL);

if ((tid = _beginthread(child_main, NULL, 256*1024, (void *)slot)) == -1) {

ap_log_error(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, s, "_beginthread: Unable to create new thread");

/* _beginthread didn't succeed. Fix the scoreboard or else

(void) ap_update_child_status(slot, SERVER_DEAD, (request_rec *) NULL);

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

sleep(10);

return -1;

}

ap_scoreboard_image->parent[slot].tid = tid;

return 0;

}

static void startup_children(int number_to_start)

{

int i;

time_t now = time(0);

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

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

continue;

}

if (make_child(ap_server_conf, i, now) < 0) {

break;

}

--number_to_start;

}

}

static int idle_spawn_rate = 1;

#ifndef MAX_SPAWN_RATE

#define MAX_SPAWN_RATE (32)

#endif

static int hold_off_on_exponential_spawning;

static void perform_idle_server_maintenance(void)

{

int i;

int to_kill;

int idle_count;

short_score *ss;

time_t now = time(0);

int free_length;

int free_slots[MAX_SPAWN_RATE];

int last_non_dead;

int total_non_dead;

/* initialize the free_list */

free_length = 0;

to_kill = -1;

idle_count = 0;

last_non_dead = -1;

total_non_dead = 0;

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

int status;

if (i >= max_daemons_limit && free_length == idle_spawn_rate)

break;

ss = &ap_scoreboard_image->servers[i];

status = ss->status;

if (status == SERVER_DEAD) {

/* try to keep children numbers as low as possible */

if (free_length < idle_spawn_rate) {

free_slots[free_length] = i;

++free_length;

}

}

else {

/* We consider a starting server as idle because we started it

if (status <= SERVER_READY) {

++ idle_count;

/* always kill the highest numbered child if we have to...

to_kill = i;

}

++total_non_dead;

last_non_dead = i;

}

}

max_daemons_limit = last_non_dead + 1;

if (idle_count > ap_daemons_max_free) {

/* kill off one child... we use SIGUSR1 because that'll cause it to

ap_scoreboard_image->parent[to_kill].deferred_die = 1;

idle_spawn_rate = 1;

}

else if (idle_count < ap_daemons_min_free) {

/* terminate the free list */

if (free_length == 0) {

/* only report this condition once */

static int reported = 0;

if (!reported) {

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, 0, ap_server_conf,

"server reached MaxClients setting, consider"

" raising the MaxClients setting");

reported = 1;

}

idle_spawn_rate = 1;

}

else {

if (idle_spawn_rate >= 8) {

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_INFO, 0, ap_server_conf,

"server seems busy, (you may need "

"to increase StartServers, or Min/MaxSpareServers), "

"spawning %d children, there are %d idle, and "

"%d total children", idle_spawn_rate,

idle_count, total_non_dead);

}

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

make_child(ap_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 (idle_spawn_rate < MAX_SPAWN_RATE) {

idle_spawn_rate *= 2;

}

}

}

else {

idle_spawn_rate = 1;

}

}

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

{

int remaining_children_to_start;

int i;

apr_status_t status;

pconf = _pconf;

ap_server_conf = s;

ap_log_pid(pconf, ap_pid_fname);

if ((status = ap_listen_open(s->process, s->port)) != APR_SUCCESS) {

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ALERT, status, s,

"no listening sockets available, shutting down");

return -1;

}

SAFE_ACCEPT(accept_mutex_init(pconf));

if (!is_graceful) {

reinit_scoreboard(pconf);

}

set_signals();

if (ppthread_globals == NULL) {

if (DosAllocThreadLocalMemory(1, (PULONG *)&ppthread_globals)) {

ap_log_error(APLOG_MARK, APLOG_ALERT|APLOG_NOERRNO, 0, ap_server_conf,

"Error allocating thread local storage"

"Apache is exiting!");

} else {

*ppthread_globals = (struct thread_globals *)apr_palloc(pconf, sizeof(struct thread_globals));

}

}

if (ap_daemons_max_free < ap_daemons_min_free + 1) /* Don't thrash... */

ap_daemons_max_free = ap_daemons_min_free + 1;

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

remaining_children_to_start = ap_daemons_to_start;

if (remaining_children_to_start > ap_daemons_limit) {

remaining_children_to_start = ap_daemons_limit;

}

if (!is_graceful) {

startup_children(remaining_children_to_start);

remaining_children_to_start = 0;

}

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, 0, ap_server_conf,

"%s configured -- resuming normal operations",

ap_get_server_version());

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_INFO, 0, ap_server_conf,

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

restart_pending = shutdown_pending = 0;

while (!restart_pending && !shutdown_pending) {

int child_slot;

apr_wait_t status;

int tid = wait_or_timeout(&status);

/* XXX: if it takes longer than 1 second for all our children

if (tid >= 0) {

apr_proc_t dummyproc;

dummyproc.pid = tid;

ap_process_child_status(&dummyproc, status);

/* non-fatal death... note that it's gone in the scoreboard. */

child_slot = find_child_by_tid(tid);

if (child_slot >= 0) {

(void) ap_update_child_status(child_slot, SERVER_DEAD,

(request_rec *) NULL);

if (remaining_children_to_start

&& child_slot < ap_daemons_limit) {

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

make_child(ap_server_conf, child_slot, time(0));

--remaining_children_to_start;

}

#if APR_HAS_OTHER_CHILD

#endif

}

else if (is_graceful) {

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

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, ap_server_conf,

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

}

/* 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

startup_children(remaining_children_to_start);

remaining_children_to_start = 0;

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

continue;

}

perform_idle_server_maintenance();

}

if (shutdown_pending) {

/* Time to gracefully shut down */

const char *pidfile = NULL;

int slot;

TID tid;

ULONG rc;

ap_listen_rec *lr;

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

apr_close_socket(lr->sd);

DosSleep(0);

}

/* Kill off running threads */

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

if (ap_scoreboard_image->servers[slot].status != SERVER_DEAD) {

tid = ap_scoreboard_image->parent[slot].tid;

rc = DosKillThread(tid);

if (rc != ERROR_INVALID_THREADID) { // Already dead, ignore

if (rc == 0) {

rc = DosWaitThread(&tid, DCWW_WAIT);

if (rc) {

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, ap_server_conf,

"error %lu waiting for thread to terminate", rc);

}

} else {

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, ap_server_conf,

"error %lu killing thread", rc);

}

}

}

}

/* cleanup pid file on normal shutdown */

pidfile = ap_server_root_relative (pconf, ap_pid_fname);

if ( pidfile != NULL && unlink(pidfile) == 0)

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_INFO, 0,

ap_server_conf,

"removed PID file %s (pid=%ld)",

pidfile, (long)getpid());

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE, 0, ap_server_conf,

"caught SIGTERM, shutting down");

return 1;

}

/* we've been told to restart */

signal(SIGHUP, SIG_IGN);

signal(SIGUSR1, SIG_IGN);

if (one_process) {

/* not worth thinking about */

return 1;

}

/* advance to the next generation */

/* XXX: we really need to make sure this new generation number isn't in

++ap_scoreboard_image->global.running_generation;

if (is_graceful) {

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE, 0, ap_server_conf,

"SIGUSR1 received. Doing graceful restart");

/* kill off the idle ones */

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

ap_scoreboard_image->parent[i].deferred_die = 1;

}

/* This is mostly for debugging... so that we know what is still

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

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

ap_scoreboard_image->servers[i].status = SERVER_GRACEFUL;

}

}

}

else {

/* Kill 'em off */

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

DosKillThread(ap_scoreboard_image->parent[i].tid);

}

ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE, 0, ap_server_conf,

"SIGHUP received. Attempting to restart");

}

if (!is_graceful) {

ap_restart_time = time(NULL);

}

return 0;

}

static void spmt_os2_pre_config(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp)

{

one_process = !!ap_exists_config_define("ONE_PROCESS");

is_graceful = 0;

ap_listen_pre_config();

ap_daemons_to_start = DEFAULT_START_DAEMON;

ap_daemons_min_free = DEFAULT_MIN_FREE_DAEMON;

ap_daemons_max_free = DEFAULT_MAX_FREE_DAEMON;

ap_daemons_limit = HARD_SERVER_LIMIT;

ap_pid_fname = DEFAULT_PIDLOG;

ap_max_requests_per_child = DEFAULT_MAX_REQUESTS_PER_CHILD;

ap_extended_status = 0;

apr_cpystrn(ap_coredump_dir, ap_server_root, sizeof(ap_coredump_dir));

}

static void spmt_os2_hooks(apr_pool_t *p)

{

INIT_SIGLIST();

/* TODO: set one_process properly */ one_process = 0;