static void check_sockets(const apr_pollfd_t *pollarray,
apr_socket_t **sockarray, int which, int pollin,
abts_case *tc)
{
apr_status_t rv;
apr_int16_t event;
char *str;
rv = apr_poll_revents_get(&event, sockarray[which],
(apr_pollfd_t *)pollarray);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
if (pollin) {
str = apr_psprintf(p, "Socket %d not signalled when it should be",
which);
ABTS_ASSERT(tc, str, event & APR_POLLIN);
} else {
str = apr_psprintf(p, "Socket %d signalled when it should not be",
which);
ABTS_ASSERT(tc, str, !(event & APR_POLLIN));
}
}
void ap_mpm_child_main(apr_pool_t *pconf)
{
ap_listen_rec *lr = NULL;
ap_listen_rec *first_lr = NULL;
int requests_this_child = 0;
apr_socket_t *sd = ap_listeners->sd;
int nsds, rv = 0;
unsigned long ulTimes;
int my_pid = getpid();
ULONG rc, c;
HQUEUE workq;
apr_pollfd_t *pollset;
int num_listeners;
TID server_maint_tid;
void *sb_mem;
/* Stop Ctrl-C/Ctrl-Break signals going to child processes */
DosSetSignalExceptionFocus(0, &ulTimes);
set_signals();
/* Create pool for child */
apr_pool_create(&pchild, pconf);
ap_run_child_init(pchild, ap_server_conf);
/* Create an event semaphore used to trigger other threads to shutdown */
rc = DosCreateEventSem(NULL, &shutdown_event, 0, FALSE);
if (rc) {
ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf,
"unable to create shutdown semaphore, exiting");
clean_child_exit(APEXIT_CHILDFATAL);
}
/* Gain access to the scoreboard. */
rc = DosGetNamedSharedMem(&sb_mem, ap_scoreboard_fname,
PAG_READ|PAG_WRITE);
if (rc) {
ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf,
"scoreboard not readable in child, exiting");
clean_child_exit(APEXIT_CHILDFATAL);
}
ap_calc_scoreboard_size();
ap_init_scoreboard(sb_mem);
/* Gain access to the accpet mutex */
rc = DosOpenMutexSem(NULL, &ap_mpm_accept_mutex);
if (rc) {
ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf,
"accept mutex couldn't be accessed in child, exiting");
clean_child_exit(APEXIT_CHILDFATAL);
}
/* Find our pid in the scoreboard so we know what slot our parent allocated us */
for (child_slot = 0; ap_scoreboard_image->parent[child_slot].pid != my_pid && child_slot < HARD_SERVER_LIMIT; child_slot++);
if (child_slot == HARD_SERVER_LIMIT) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, ap_server_conf,
"child pid not found in scoreboard, exiting");
clean_child_exit(APEXIT_CHILDFATAL);
}
ap_my_generation = ap_scoreboard_image->parent[child_slot].generation;
memset(ap_scoreboard_image->servers[child_slot], 0, sizeof(worker_score) * HARD_THREAD_LIMIT);
/* Set up an OS/2 queue for passing connections & termination requests
* to worker threads
*/
rc = DosCreateQueue(&workq, QUE_FIFO, apr_psprintf(pchild, "/queues/httpd/work.%d", my_pid));
if (rc) {
ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf,
"unable to create work queue, exiting");
clean_child_exit(APEXIT_CHILDFATAL);
}
/* Create initial pool of worker threads */
for (c = 0; c < ap_min_spare_threads; c++) {
// ap_scoreboard_image->servers[child_slot][c].tid = _beginthread(worker_main, NULL, 128*1024, (void *)c);
}
/* Start maintenance thread */
server_maint_tid = _beginthread(server_maintenance, NULL, 32768, NULL);
/* Set up poll */
for (num_listeners = 0, lr = ap_listeners; lr; lr = lr->next) {
num_listeners++;
}
apr_poll_setup(&pollset, num_listeners, pchild);
for (lr = ap_listeners; lr; lr = lr->next) {
apr_poll_socket_add(pollset, lr->sd, APR_POLLIN);
}
/* Main connection accept loop */
do {
apr_pool_t *pconn;
worker_args_t *worker_args;
apr_pool_create(&pconn, pchild);
worker_args = apr_palloc(pconn, sizeof(worker_args_t));
worker_args->pconn = pconn;
if (num_listeners == 1) {
rv = apr_accept(&worker_args->conn_sd, ap_listeners->sd, pconn);
} else {
rc = DosRequestMutexSem(ap_mpm_accept_mutex, SEM_INDEFINITE_WAIT);
if (shutdown_pending) {
DosReleaseMutexSem(ap_mpm_accept_mutex);
break;
}
rv = APR_FROM_OS_ERROR(rc);
if (rv == APR_SUCCESS) {
rv = apr_poll(pollset, num_listeners, &nsds, -1);
DosReleaseMutexSem(ap_mpm_accept_mutex);
}
if (rv == APR_SUCCESS) {
if (first_lr == NULL) {
first_lr = ap_listeners;
}
lr = first_lr;
do {
apr_int16_t event;
apr_poll_revents_get(&event, lr->sd, pollset);
if (event == APR_POLLIN) {
apr_sockaddr_t *sa;
apr_port_t port;
apr_socket_addr_get(&sa, APR_LOCAL, lr->sd);
apr_sockaddr_port_get(&port, sa);
first_lr = lr->next;
break;
}
lr = lr->next;
if (!lr) {
lr = ap_listeners;
}
} while (lr != first_lr);
if (lr == first_lr) {
continue;
}
sd = lr->sd;
rv = apr_accept(&worker_args->conn_sd, sd, pconn);
}
}
if (rv != APR_SUCCESS) {
if (!APR_STATUS_IS_EINTR(rv)) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, ap_server_conf,
"apr_accept");
clean_child_exit(APEXIT_CHILDFATAL);
}
} else {
DosWriteQueue(workq, WORKTYPE_CONN, sizeof(worker_args_t), worker_args, 0);
requests_this_child++;
}
if (ap_max_requests_per_child != 0 && requests_this_child >= ap_max_requests_per_child)
break;
} while (!shutdown_pending && ap_my_generation == ap_scoreboard_image->global->running_generation);
ap_scoreboard_image->parent[child_slot].quiescing = 1;
DosPostEventSem(shutdown_event);
DosWaitThread(&server_maint_tid, DCWW_WAIT);
if (is_graceful) {
char someleft;
/* tell our worker threads to exit */
for (c=0; c<HARD_THREAD_LIMIT; c++) {
if (ap_scoreboard_image->servers[child_slot][c].status != SERVER_DEAD) {
DosWriteQueue(workq, WORKTYPE_EXIT, 0, NULL, 0);
}
}
do {
someleft = 0;
for (c=0; c<HARD_THREAD_LIMIT; c++) {
if (ap_scoreboard_image->servers[child_slot][c].status != SERVER_DEAD) {
someleft = 1;
DosSleep(1000);
break;
}
}
} while (someleft);
} else {
DosPurgeQueue(workq);
for (c=0; c<HARD_THREAD_LIMIT; c++) {
if (ap_scoreboard_image->servers[child_slot][c].status != SERVER_DEAD) {
DosKillThread(ap_scoreboard_image->servers[child_slot][c].tid);
}
}
}
apr_pool_destroy(pchild);
}
static int32 worker_thread(void * dummy)
{
proc_info * ti = dummy;
int child_slot = ti->slot;
apr_pool_t *tpool = ti->tpool;
apr_allocator_t *allocator;
apr_socket_t *csd = NULL;
apr_pool_t *ptrans; /* Pool for per-transaction stuff */
apr_bucket_alloc_t *bucket_alloc;
apr_socket_t *sd = NULL;
apr_status_t rv = APR_EINIT;
int srv , n;
int curr_pollfd = 0, last_pollfd = 0;
sigset_t sig_mask;
int requests_this_child = ap_max_requests_per_thread;
apr_pollfd_t *pollset;
/* each worker thread is in control of its own destiny...*/
int this_worker_should_exit = 0;
free(ti);
mpm_state = AP_MPMQ_STARTING;
on_exit_thread(check_restart, (void*)child_slot);
/* block the signals for this thread */
sigfillset(&sig_mask);
sigprocmask(SIG_BLOCK, &sig_mask, NULL);
apr_allocator_create(&allocator);
apr_allocator_max_free_set(allocator, ap_max_mem_free);
apr_pool_create_ex(&ptrans, tpool, NULL, allocator);
apr_allocator_owner_set(allocator, ptrans);
apr_pool_tag(ptrans, "transaction");
bucket_alloc = apr_bucket_alloc_create_ex(allocator);
apr_thread_mutex_lock(worker_thread_count_mutex);
worker_thread_count++;
apr_thread_mutex_unlock(worker_thread_count_mutex);
(void) ap_update_child_status_from_indexes(0, child_slot, SERVER_STARTING,
(request_rec*)NULL);
apr_poll_setup(&pollset, num_listening_sockets + 1, tpool);
for(n=0 ; n <= num_listening_sockets ; n++)
apr_poll_socket_add(pollset, listening_sockets[n], APR_POLLIN);
mpm_state = AP_MPMQ_RUNNING;
while (1) {
/* If we're here, then chances are (unless we're the first thread created)
* we're going to be held up in the accept mutex, so doing this here
* shouldn't hurt performance.
*/
this_worker_should_exit |= (ap_max_requests_per_thread != 0) && (requests_this_child <= 0);
if (this_worker_should_exit) break;
(void) ap_update_child_status_from_indexes(0, child_slot, SERVER_READY,
(request_rec*)NULL);
apr_thread_mutex_lock(accept_mutex);
while (!this_worker_should_exit) {
apr_int16_t event;
apr_status_t ret;
ret = apr_poll(pollset, num_listening_sockets + 1, &srv, -1);
if (ret != APR_SUCCESS) {
if (APR_STATUS_IS_EINTR(ret)) {
continue;
}
/* poll() will only return errors in catastrophic
* circumstances. Let's try exiting gracefully, for now. */
ap_log_error(APLOG_MARK, APLOG_ERR, ret, (const server_rec *)
ap_server_conf, "apr_poll: (listen)");
this_worker_should_exit = 1;
} else {
/* if we've bailed in apr_poll what's the point of trying to use the data? */
apr_poll_revents_get(&event, listening_sockets[0], pollset);
if (event & APR_POLLIN){
apr_sockaddr_t *rec_sa;
apr_size_t len = 5;
char *tmpbuf = apr_palloc(ptrans, sizeof(char) * 5);
apr_sockaddr_info_get(&rec_sa, "127.0.0.1", APR_UNSPEC, 7772, 0, ptrans);
if ((ret = apr_recvfrom(rec_sa, listening_sockets[0], 0, tmpbuf, &len))
!= APR_SUCCESS){
ap_log_error(APLOG_MARK, APLOG_ERR, ret, NULL,
"error getting data from UDP!!");
}else {
/* add checking??? */
}
this_worker_should_exit = 1;
}
}
if (this_worker_should_exit) break;
if (num_listening_sockets == 1) {
sd = ap_listeners->sd;
goto got_fd;
}
else {
/* find a listener */
curr_pollfd = last_pollfd;
do {
curr_pollfd++;
if (curr_pollfd > num_listening_sockets)
curr_pollfd = 1;
/* Get the revent... */
apr_poll_revents_get(&event, listening_sockets[curr_pollfd], pollset);
if (event & APR_POLLIN) {
last_pollfd = curr_pollfd;
sd = listening_sockets[curr_pollfd];
goto got_fd;
}
} while (curr_pollfd != last_pollfd);
}
}
got_fd:
if (!this_worker_should_exit) {
rv = apr_accept(&csd, sd, ptrans);
apr_thread_mutex_unlock(accept_mutex);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, ap_server_conf,
"apr_accept");
} else {
process_socket(ptrans, csd, child_slot, bucket_alloc);
requests_this_child--;
}
}
else {
apr_thread_mutex_unlock(accept_mutex);
break;
}
apr_pool_clear(ptrans);
}
ap_update_child_status_from_indexes(0, child_slot, SERVER_DEAD, (request_rec*)NULL);
apr_bucket_alloc_destroy(bucket_alloc);
ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, NULL,
"worker_thread %ld exiting", find_thread(NULL));
apr_thread_mutex_lock(worker_thread_count_mutex);
worker_thread_count--;
apr_thread_mutex_unlock(worker_thread_count_mutex);
return (0);
}