void status_to_name(lua_State *L, apr_status_t status) { /* Use a switch statement for fast number to string mapping: */ switch (status) { # ifdef APR_ANONYMOUS case APR_ANONYMOUS: lua_pushliteral(L, "ANONYMOUS"); return; # endif # ifdef APR_BADARG case APR_BADARG: lua_pushliteral(L, "BADARG"); return; # endif # ifdef APR_BADCH case APR_BADCH: lua_pushliteral(L, "BADCH"); return; # endif # ifdef APR_DETACH case APR_DETACH: lua_pushliteral(L, "DETACH"); return; # endif # ifdef APR_EABOVEROOT case APR_EABOVEROOT: lua_pushliteral(L, "EABOVEROOT"); return; # endif # ifdef APR_EABSOLUTE case APR_EABSOLUTE: lua_pushliteral(L, "EABSOLUTE"); return; # endif # ifdef APR_EACCES case APR_EACCES: lua_pushliteral(L, "EACCES"); return; # endif # ifdef APR_EAFNOSUPPORT case APR_EAFNOSUPPORT: lua_pushliteral(L, "EAFNOSUPPORT"); return; # endif # ifdef APR_EAGAIN case APR_EAGAIN: lua_pushliteral(L, "EAGAIN"); return; # endif # ifdef APR_EBADDATE case APR_EBADDATE: lua_pushliteral(L, "EBADDATE"); return; # endif # ifdef APR_EBADF case APR_EBADF: lua_pushliteral(L, "EBADF"); return; # endif # ifdef APR_EBADIP case APR_EBADIP: lua_pushliteral(L, "EBADIP"); return; # endif # ifdef APR_EBADMASK case APR_EBADMASK: lua_pushliteral(L, "EBADMASK"); return; # endif # ifdef APR_EBADPATH case APR_EBADPATH: lua_pushliteral(L, "EBADPATH"); return; # endif # ifdef APR_EBUSY case APR_EBUSY: lua_pushliteral(L, "EBUSY"); return; # endif # ifdef APR_ECONNABORTED case APR_ECONNABORTED: lua_pushliteral(L, "ECONNABORTED"); return; # endif # ifdef APR_ECONNREFUSED case APR_ECONNREFUSED: lua_pushliteral(L, "ECONNREFUSED"); return; # endif # ifdef APR_ECONNRESET case APR_ECONNRESET: lua_pushliteral(L, "ECONNRESET"); return; # endif # ifdef APR_EDSOOPEN case APR_EDSOOPEN: lua_pushliteral(L, "EDSOOPEN"); return; # endif # ifdef APR_EEXIST case APR_EEXIST: lua_pushliteral(L, "EEXIST"); return; # endif # ifdef APR_EFTYPE case APR_EFTYPE: lua_pushliteral(L, "EFTYPE"); return; # endif # ifdef APR_EGENERAL case APR_EGENERAL: lua_pushliteral(L, "EGENERAL"); return; # endif # ifdef APR_EHOSTUNREACH case APR_EHOSTUNREACH: lua_pushliteral(L, "EHOSTUNREACH"); return; # endif # ifdef APR_EINCOMPLETE case APR_EINCOMPLETE: lua_pushliteral(L, "EINCOMPLETE"); return; # endif # ifdef APR_EINIT case APR_EINIT: lua_pushliteral(L, "EINIT"); return; # endif # ifdef APR_EINPROGRESS case APR_EINPROGRESS: lua_pushliteral(L, "EINPROGRESS"); return; # endif # ifdef APR_EINTR case APR_EINTR: lua_pushliteral(L, "EINTR"); return; # endif # ifdef APR_EINVAL case APR_EINVAL: lua_pushliteral(L, "EINVAL"); return; # endif # ifdef APR_EINVALSOCK case APR_EINVALSOCK: lua_pushliteral(L, "EINVALSOCK"); return; # endif # ifdef APR_EMFILE case APR_EMFILE: lua_pushliteral(L, "EMFILE"); return; # endif # ifdef APR_EMISMATCH case APR_EMISMATCH: lua_pushliteral(L, "EMISMATCH"); return; # endif # ifdef APR_ENAMETOOLONG case APR_ENAMETOOLONG: lua_pushliteral(L, "ENAMETOOLONG"); return; # endif # ifdef APR_ENETUNREACH case APR_ENETUNREACH: lua_pushliteral(L, "ENETUNREACH"); return; # endif # ifdef APR_ENFILE case APR_ENFILE: lua_pushliteral(L, "ENFILE"); return; # endif # ifdef APR_ENODIR case APR_ENODIR: lua_pushliteral(L, "ENODIR"); return; # endif # ifdef APR_ENOENT case APR_ENOENT: lua_pushliteral(L, "ENOENT"); return; # endif # ifdef APR_ENOLOCK case APR_ENOLOCK: lua_pushliteral(L, "ENOLOCK"); return; # endif # ifdef APR_ENOMEM case APR_ENOMEM: lua_pushliteral(L, "ENOMEM"); return; # endif # ifdef APR_ENOPOLL case APR_ENOPOLL: lua_pushliteral(L, "ENOPOLL"); return; # endif # ifdef APR_ENOPOOL case APR_ENOPOOL: lua_pushliteral(L, "ENOPOOL"); return; # endif # ifdef APR_ENOPROC case APR_ENOPROC: lua_pushliteral(L, "ENOPROC"); return; # endif # ifdef APR_ENOSHMAVAIL case APR_ENOSHMAVAIL: lua_pushliteral(L, "ENOSHMAVAIL"); return; # endif # ifdef APR_ENOSOCKET case APR_ENOSOCKET: lua_pushliteral(L, "ENOSOCKET"); return; # endif # ifdef APR_ENOSPC case APR_ENOSPC: lua_pushliteral(L, "ENOSPC"); return; # endif # ifdef APR_ENOSTAT case APR_ENOSTAT: lua_pushliteral(L, "ENOSTAT"); return; # endif # ifdef APR_ENOTDIR case APR_ENOTDIR: lua_pushliteral(L, "ENOTDIR"); return; # endif # ifdef APR_ENOTEMPTY case APR_ENOTEMPTY: lua_pushliteral(L, "ENOTEMPTY"); return; # endif # ifdef APR_ENOTENOUGHENTROPY case APR_ENOTENOUGHENTROPY: lua_pushliteral(L, "ENOTENOUGHENTROPY"); return; # endif # ifdef APR_ENOTHDKEY case APR_ENOTHDKEY: lua_pushliteral(L, "ENOTHDKEY"); return; # endif # ifdef APR_ENOTHREAD case APR_ENOTHREAD: lua_pushliteral(L, "ENOTHREAD"); return; # endif # ifdef APR_ENOTIME case APR_ENOTIME: lua_pushliteral(L, "ENOTIME"); return; # endif # ifdef APR_ENOTIMPL case APR_ENOTIMPL: lua_pushliteral(L, "ENOTIMPL"); return; # endif # ifdef APR_ENOTSOCK case APR_ENOTSOCK: lua_pushliteral(L, "ENOTSOCK"); return; # endif # ifdef APR_EOF case APR_EOF: lua_pushliteral(L, "EOF"); return; # endif # ifdef APR_EPATHWILD case APR_EPATHWILD: lua_pushliteral(L, "EPATHWILD"); return; # endif # ifdef APR_EPIPE case APR_EPIPE: lua_pushliteral(L, "EPIPE"); return; # endif # ifdef APR_EPROC_UNKNOWN case APR_EPROC_UNKNOWN: lua_pushliteral(L, "EPROC_UNKNOWN"); return; # endif # ifdef APR_ERELATIVE case APR_ERELATIVE: lua_pushliteral(L, "ERELATIVE"); return; # endif # ifdef APR_ESPIPE case APR_ESPIPE: lua_pushliteral(L, "ESPIPE"); return; # endif # ifdef APR_ESYMNOTFOUND case APR_ESYMNOTFOUND: lua_pushliteral(L, "ESYMNOTFOUND"); return; # endif # ifdef APR_ETIMEDOUT case APR_ETIMEDOUT: lua_pushliteral(L, "ETIMEDOUT"); return; # endif # ifdef APR_EXDEV case APR_EXDEV: lua_pushliteral(L, "EXDEV"); return; # endif # ifdef APR_FILEBASED case APR_FILEBASED: lua_pushliteral(L, "FILEBASED"); return; # endif # ifdef APR_INCHILD case APR_INCHILD: lua_pushliteral(L, "INCHILD"); return; # endif # ifdef APR_INCOMPLETE case APR_INCOMPLETE: lua_pushliteral(L, "INCOMPLETE"); return; # endif # ifdef APR_INPARENT case APR_INPARENT: lua_pushliteral(L, "INPARENT"); return; # endif # ifdef APR_KEYBASED case APR_KEYBASED: lua_pushliteral(L, "KEYBASED"); return; # endif # ifdef APR_NOTDETACH case APR_NOTDETACH: lua_pushliteral(L, "NOTDETACH"); return; # endif # ifdef APR_NOTFOUND case APR_NOTFOUND: lua_pushliteral(L, "NOTFOUND"); return; # endif # ifdef APR_SUCCESS case APR_SUCCESS: lua_pushliteral(L, "SUCCESS"); return; # endif # ifdef APR_TIMEUP case APR_TIMEUP: lua_pushliteral(L, "TIMEUP"); return; # endif } /* If the switch statement fails we fall back to the following monstrosity :-) */ if (0) ; # ifdef APR_STATUS_IS_ANONYMOUS else if (APR_STATUS_IS_ANONYMOUS(status)) { lua_pushliteral(L, "ANONYMOUS"); return; } # endif # ifdef APR_STATUS_IS_BADARG else if (APR_STATUS_IS_BADARG(status)) { lua_pushliteral(L, "BADARG"); return; } # endif # ifdef APR_STATUS_IS_BADCH else if (APR_STATUS_IS_BADCH(status)) { lua_pushliteral(L, "BADCH"); return; } # endif # ifdef APR_STATUS_IS_DETACH else if (APR_STATUS_IS_DETACH(status)) { lua_pushliteral(L, "DETACH"); return; } # endif # ifdef APR_STATUS_IS_EABOVEROOT else if (APR_STATUS_IS_EABOVEROOT(status)) { lua_pushliteral(L, "EABOVEROOT"); return; } # endif # ifdef APR_STATUS_IS_EABSOLUTE else if (APR_STATUS_IS_EABSOLUTE(status)) { lua_pushliteral(L, "EABSOLUTE"); return; } # endif # ifdef APR_STATUS_IS_EACCES else if (APR_STATUS_IS_EACCES(status)) { lua_pushliteral(L, "EACCES"); return; } # endif # ifdef APR_STATUS_IS_EAFNOSUPPORT else if (APR_STATUS_IS_EAFNOSUPPORT(status)) { lua_pushliteral(L, "EAFNOSUPPORT"); return; } # endif # ifdef APR_STATUS_IS_EAGAIN else if (APR_STATUS_IS_EAGAIN(status)) { lua_pushliteral(L, "EAGAIN"); return; } # endif # ifdef APR_STATUS_IS_EBADDATE else if (APR_STATUS_IS_EBADDATE(status)) { lua_pushliteral(L, "EBADDATE"); return; } # endif # ifdef APR_STATUS_IS_EBADF else if (APR_STATUS_IS_EBADF(status)) { lua_pushliteral(L, "EBADF"); return; } # endif # ifdef APR_STATUS_IS_EBADIP else if (APR_STATUS_IS_EBADIP(status)) { lua_pushliteral(L, "EBADIP"); return; } # endif # ifdef APR_STATUS_IS_EBADMASK else if (APR_STATUS_IS_EBADMASK(status)) { lua_pushliteral(L, "EBADMASK"); return; } # endif # ifdef APR_STATUS_IS_EBADPATH else if (APR_STATUS_IS_EBADPATH(status)) { lua_pushliteral(L, "EBADPATH"); return; } # endif # ifdef APR_STATUS_IS_EBUSY else if (APR_STATUS_IS_EBUSY(status)) { lua_pushliteral(L, "EBUSY"); return; } # endif # ifdef APR_STATUS_IS_ECONNABORTED else if (APR_STATUS_IS_ECONNABORTED(status)) { lua_pushliteral(L, "ECONNABORTED"); return; } # endif # ifdef APR_STATUS_IS_ECONNREFUSED else if (APR_STATUS_IS_ECONNREFUSED(status)) { lua_pushliteral(L, "ECONNREFUSED"); return; } # endif # ifdef APR_STATUS_IS_ECONNRESET else if (APR_STATUS_IS_ECONNRESET(status)) { lua_pushliteral(L, "ECONNRESET"); return; } # endif # ifdef APR_STATUS_IS_EDSOOPEN else if (APR_STATUS_IS_EDSOOPEN(status)) { lua_pushliteral(L, "EDSOOPEN"); return; } # endif # ifdef APR_STATUS_IS_EEXIST else if (APR_STATUS_IS_EEXIST(status)) { lua_pushliteral(L, "EEXIST"); return; } # endif # ifdef APR_STATUS_IS_EFTYPE else if (APR_STATUS_IS_EFTYPE(status)) { lua_pushliteral(L, "EFTYPE"); return; } # endif # ifdef APR_STATUS_IS_EGENERAL else if (APR_STATUS_IS_EGENERAL(status)) { lua_pushliteral(L, "EGENERAL"); return; } # endif # ifdef APR_STATUS_IS_EHOSTUNREACH else if (APR_STATUS_IS_EHOSTUNREACH(status)) { lua_pushliteral(L, "EHOSTUNREACH"); return; } # endif # ifdef APR_STATUS_IS_EINCOMPLETE else if (APR_STATUS_IS_EINCOMPLETE(status)) { lua_pushliteral(L, "EINCOMPLETE"); return; } # endif # ifdef APR_STATUS_IS_EINIT else if (APR_STATUS_IS_EINIT(status)) { lua_pushliteral(L, "EINIT"); return; } # endif # ifdef APR_STATUS_IS_EINPROGRESS else if (APR_STATUS_IS_EINPROGRESS(status)) { lua_pushliteral(L, "EINPROGRESS"); return; } # endif # ifdef APR_STATUS_IS_EINTR else if (APR_STATUS_IS_EINTR(status)) { lua_pushliteral(L, "EINTR"); return; } # endif # ifdef APR_STATUS_IS_EINVAL else if (APR_STATUS_IS_EINVAL(status)) { lua_pushliteral(L, "EINVAL"); return; } # endif # ifdef APR_STATUS_IS_EINVALSOCK else if (APR_STATUS_IS_EINVALSOCK(status)) { lua_pushliteral(L, "EINVALSOCK"); return; } # endif # ifdef APR_STATUS_IS_EMFILE else if (APR_STATUS_IS_EMFILE(status)) { lua_pushliteral(L, "EMFILE"); return; } # endif # ifdef APR_STATUS_IS_EMISMATCH else if (APR_STATUS_IS_EMISMATCH(status)) { lua_pushliteral(L, "EMISMATCH"); return; } # endif # ifdef APR_STATUS_IS_ENAMETOOLONG else if (APR_STATUS_IS_ENAMETOOLONG(status)) { lua_pushliteral(L, "ENAMETOOLONG"); return; } # endif # ifdef APR_STATUS_IS_ENETUNREACH else if (APR_STATUS_IS_ENETUNREACH(status)) { lua_pushliteral(L, "ENETUNREACH"); return; } # endif # ifdef APR_STATUS_IS_ENFILE else if (APR_STATUS_IS_ENFILE(status)) { lua_pushliteral(L, "ENFILE"); return; } # endif # ifdef APR_STATUS_IS_ENODIR else if (APR_STATUS_IS_ENODIR(status)) { lua_pushliteral(L, "ENODIR"); return; } # endif # ifdef APR_STATUS_IS_ENOENT else if (APR_STATUS_IS_ENOENT(status)) { lua_pushliteral(L, "ENOENT"); return; } # endif # ifdef APR_STATUS_IS_ENOLOCK else if (APR_STATUS_IS_ENOLOCK(status)) { lua_pushliteral(L, "ENOLOCK"); return; } # endif # ifdef APR_STATUS_IS_ENOMEM else if (APR_STATUS_IS_ENOMEM(status)) { lua_pushliteral(L, "ENOMEM"); return; } # endif # ifdef APR_STATUS_IS_ENOPOLL else if (APR_STATUS_IS_ENOPOLL(status)) { lua_pushliteral(L, "ENOPOLL"); return; } # endif # ifdef APR_STATUS_IS_ENOPOOL else if (APR_STATUS_IS_ENOPOOL(status)) { lua_pushliteral(L, "ENOPOOL"); return; } # endif # ifdef APR_STATUS_IS_ENOPROC else if (APR_STATUS_IS_ENOPROC(status)) { lua_pushliteral(L, "ENOPROC"); return; } # endif # ifdef APR_STATUS_IS_ENOSHMAVAIL else if (APR_STATUS_IS_ENOSHMAVAIL(status)) { lua_pushliteral(L, "ENOSHMAVAIL"); return; } # endif # ifdef APR_STATUS_IS_ENOSOCKET else if (APR_STATUS_IS_ENOSOCKET(status)) { lua_pushliteral(L, "ENOSOCKET"); return; } # endif # ifdef APR_STATUS_IS_ENOSPC else if (APR_STATUS_IS_ENOSPC(status)) { lua_pushliteral(L, "ENOSPC"); return; } # endif # ifdef APR_STATUS_IS_ENOSTAT else if (APR_STATUS_IS_ENOSTAT(status)) { lua_pushliteral(L, "ENOSTAT"); return; } # endif # ifdef APR_STATUS_IS_ENOTDIR else if (APR_STATUS_IS_ENOTDIR(status)) { lua_pushliteral(L, "ENOTDIR"); return; } # endif # ifdef APR_STATUS_IS_ENOTEMPTY else if (APR_STATUS_IS_ENOTEMPTY(status)) { lua_pushliteral(L, "ENOTEMPTY"); return; } # endif # ifdef APR_STATUS_IS_ENOTENOUGHENTROPY else if (APR_STATUS_IS_ENOTENOUGHENTROPY(status)) { lua_pushliteral(L, "ENOTENOUGHENTROPY"); return; } # endif # ifdef APR_STATUS_IS_ENOTHDKEY else if (APR_STATUS_IS_ENOTHDKEY(status)) { lua_pushliteral(L, "ENOTHDKEY"); return; } # endif # ifdef APR_STATUS_IS_ENOTHREAD else if (APR_STATUS_IS_ENOTHREAD(status)) { lua_pushliteral(L, "ENOTHREAD"); return; } # endif # ifdef APR_STATUS_IS_ENOTIME else if (APR_STATUS_IS_ENOTIME(status)) { lua_pushliteral(L, "ENOTIME"); return; } # endif # ifdef APR_STATUS_IS_ENOTIMPL else if (APR_STATUS_IS_ENOTIMPL(status)) { lua_pushliteral(L, "ENOTIMPL"); return; } # endif # ifdef APR_STATUS_IS_ENOTSOCK else if (APR_STATUS_IS_ENOTSOCK(status)) { lua_pushliteral(L, "ENOTSOCK"); return; } # endif # ifdef APR_STATUS_IS_EOF else if (APR_STATUS_IS_EOF(status)) { lua_pushliteral(L, "EOF"); return; } # endif # ifdef APR_STATUS_IS_EPATHWILD else if (APR_STATUS_IS_EPATHWILD(status)) { lua_pushliteral(L, "EPATHWILD"); return; } # endif # ifdef APR_STATUS_IS_EPIPE else if (APR_STATUS_IS_EPIPE(status)) { lua_pushliteral(L, "EPIPE"); return; } # endif # ifdef APR_STATUS_IS_EPROC_UNKNOWN else if (APR_STATUS_IS_EPROC_UNKNOWN(status)) { lua_pushliteral(L, "EPROC_UNKNOWN"); return; } # endif # ifdef APR_STATUS_IS_ERELATIVE else if (APR_STATUS_IS_ERELATIVE(status)) { lua_pushliteral(L, "ERELATIVE"); return; } # endif # ifdef APR_STATUS_IS_ESPIPE else if (APR_STATUS_IS_ESPIPE(status)) { lua_pushliteral(L, "ESPIPE"); return; } # endif # ifdef APR_STATUS_IS_ESYMNOTFOUND else if (APR_STATUS_IS_ESYMNOTFOUND(status)) { lua_pushliteral(L, "ESYMNOTFOUND"); return; } # endif # ifdef APR_STATUS_IS_ETIMEDOUT else if (APR_STATUS_IS_ETIMEDOUT(status)) { lua_pushliteral(L, "ETIMEDOUT"); return; } # endif # ifdef APR_STATUS_IS_EXDEV else if (APR_STATUS_IS_EXDEV(status)) { lua_pushliteral(L, "EXDEV"); return; } # endif # ifdef APR_STATUS_IS_FILEBASED else if (APR_STATUS_IS_FILEBASED(status)) { lua_pushliteral(L, "FILEBASED"); return; } # endif # ifdef APR_STATUS_IS_INCHILD else if (APR_STATUS_IS_INCHILD(status)) { lua_pushliteral(L, "INCHILD"); return; } # endif # ifdef APR_STATUS_IS_INCOMPLETE else if (APR_STATUS_IS_INCOMPLETE(status)) { lua_pushliteral(L, "INCOMPLETE"); return; } # endif # ifdef APR_STATUS_IS_INPARENT else if (APR_STATUS_IS_INPARENT(status)) { lua_pushliteral(L, "INPARENT"); return; } # endif # ifdef APR_STATUS_IS_KEYBASED else if (APR_STATUS_IS_KEYBASED(status)) { lua_pushliteral(L, "KEYBASED"); return; } # endif # ifdef APR_STATUS_IS_NOTDETACH else if (APR_STATUS_IS_NOTDETACH(status)) { lua_pushliteral(L, "NOTDETACH"); return; } # endif # ifdef APR_STATUS_IS_NOTFOUND else if (APR_STATUS_IS_NOTFOUND(status)) { lua_pushliteral(L, "NOTFOUND"); return; } # endif # ifdef APR_STATUS_IS_TIMEUP else if (APR_STATUS_IS_TIMEUP(status)) { lua_pushliteral(L, "TIMEUP"); return; } # endif lua_pushinteger(L, status); }
/*static */ void worker_main(void *arg) { ap_listen_rec *lr, *first_lr, *last_lr = NULL; apr_pool_t *ptrans; apr_allocator_t *allocator; apr_bucket_alloc_t *bucket_alloc; conn_rec *current_conn; apr_status_t stat = APR_EINIT; ap_sb_handle_t *sbh; apr_thread_t *thd = NULL; apr_os_thread_t osthd; int my_worker_num = (int)arg; apr_socket_t *csd = NULL; int requests_this_child = 0; apr_socket_t *sd = NULL; fd_set main_fds; int sockdes; int srv; struct timeval tv; int wouldblock_retry; osthd = apr_os_thread_current(); apr_os_thread_put(&thd, &osthd, pmain); tv.tv_sec = 1; tv.tv_usec = 0; apr_allocator_create(&allocator); apr_allocator_max_free_set(allocator, ap_max_mem_free); apr_pool_create_ex(&ptrans, pmain, NULL, allocator); apr_allocator_owner_set(allocator, ptrans); apr_pool_tag(ptrans, "transaction"); bucket_alloc = apr_bucket_alloc_create_ex(allocator); atomic_inc (&worker_thread_count); while (!die_now) { /* * (Re)initialize this child to a pre-connection state. */ current_conn = NULL; apr_pool_clear(ptrans); if ((ap_max_requests_per_child > 0 && requests_this_child++ >= ap_max_requests_per_child)) { DBPRINT1 ("\n**Thread slot %d is shutting down", my_worker_num); clean_child_exit(0, my_worker_num, ptrans, bucket_alloc); } ap_update_child_status_from_indexes(0, my_worker_num, WORKER_READY, (request_rec *) NULL); /* * Wait for an acceptable connection to arrive. */ for (;;) { if (shutdown_pending || restart_pending || (ap_scoreboard_image->servers[0][my_worker_num].status == WORKER_IDLE_KILL)) { DBPRINT1 ("\nThread slot %d is shutting down\n", my_worker_num); clean_child_exit(0, my_worker_num, ptrans, bucket_alloc); } /* Check the listen queue on all sockets for requests */ memcpy(&main_fds, &listenfds, sizeof(fd_set)); srv = select(listenmaxfd + 1, &main_fds, NULL, NULL, &tv); if (srv <= 0) { if (srv < 0) { ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf, APLOGNO(00217) "select() failed on listen socket"); apr_thread_yield(); } continue; } /* remember the last_lr we searched last time around so that we don't end up starving any particular listening socket */ if (last_lr == NULL) { lr = ap_listeners; } else { lr = last_lr->next; if (!lr) lr = ap_listeners; } first_lr = lr; do { apr_os_sock_get(&sockdes, lr->sd); if (FD_ISSET(sockdes, &main_fds)) goto got_listener; lr = lr->next; if (!lr) lr = ap_listeners; } while (lr != first_lr); /* if we get here, something unexpected happened. Go back into the select state and try again. */ continue; got_listener: last_lr = lr; sd = lr->sd; wouldblock_retry = MAX_WB_RETRIES; while (wouldblock_retry) { if ((stat = apr_socket_accept(&csd, sd, ptrans)) == APR_SUCCESS) { break; } else { /* if the error is a wouldblock then maybe we were too quick try to pull the next request from the listen queue. Try a few more times then return to our idle listen state. */ if (!APR_STATUS_IS_EAGAIN(stat)) { break; } if (wouldblock_retry--) { apr_thread_yield(); } } } /* If we got a new socket, set it to non-blocking mode and process it. Otherwise handle the error. */ if (stat == APR_SUCCESS) { apr_socket_opt_set(csd, APR_SO_NONBLOCK, 0); #ifdef DBINFO_ON if (wouldblock_retry < MAX_WB_RETRIES) { retry_success++; avg_retries += (MAX_WB_RETRIES-wouldblock_retry); } #endif break; /* We have a socket ready for reading */ } else { #ifdef DBINFO_ON if (APR_STATUS_IS_EAGAIN(stat)) { would_block++; retry_fail++; } else if ( #else if (APR_STATUS_IS_EAGAIN(stat) || #endif APR_STATUS_IS_ECONNRESET(stat) || APR_STATUS_IS_ETIMEDOUT(stat) || APR_STATUS_IS_EHOSTUNREACH(stat) || APR_STATUS_IS_ENETUNREACH(stat)) { ; } #ifdef USE_WINSOCK else if (APR_STATUS_IS_ENETDOWN(stat)) { /* * When the network layer has been shut down, there * is not much use in simply exiting: the parent * would simply re-create us (and we'd fail again). * Use the CHILDFATAL code to tear the server down. * @@@ Martin's idea for possible improvement: * A different approach would be to define * a new APEXIT_NETDOWN exit code, the reception * of which would make the parent shutdown all * children, then idle-loop until it detected that * the network is up again, and restart the children. * Ben Hyde noted that temporary ENETDOWN situations * occur in mobile IP. */ ap_log_error(APLOG_MARK, APLOG_EMERG, stat, ap_server_conf, APLOGNO(00218) "apr_socket_accept: giving up."); clean_child_exit(APEXIT_CHILDFATAL, my_worker_num, ptrans, bucket_alloc); } #endif else { ap_log_error(APLOG_MARK, APLOG_ERR, stat, ap_server_conf, APLOGNO(00219) "apr_socket_accept: (client socket)"); clean_child_exit(1, my_worker_num, ptrans, bucket_alloc); } } } ap_create_sb_handle(&sbh, ptrans, 0, my_worker_num); /* * We now have a connection, so set it up with the appropriate * socket options, file descriptors, and read/write buffers. */ current_conn = ap_run_create_connection(ptrans, ap_server_conf, csd, my_worker_num, sbh, bucket_alloc); if (current_conn) { current_conn->current_thread = thd; ap_process_connection(current_conn, csd); ap_lingering_close(current_conn); } request_count++; } clean_child_exit(0, my_worker_num, ptrans, bucket_alloc); }
static void im_tcp_read(nx_module_t *module, nx_event_t *event) { nx_im_tcp_conf_t *imconf; nx_logdata_t *logdata; boolean volatile got_eof = FALSE; apr_socket_t *sock; nx_module_input_t *input; apr_sockaddr_t *sa; char *ipstr; apr_status_t rv; nx_exception_t e; ASSERT(event != NULL); ASSERT(module != NULL); log_debug("im_tcp_read"); if ( nx_module_get_status(module) != NX_MODULE_STATUS_RUNNING ) { log_debug("module %s not running, not reading any more data", module->name); return; } imconf = (nx_im_tcp_conf_t *) module->config; sock = (apr_socket_t *) event->data; ASSERT(imconf->listensock != NULL); if ( sock == imconf->listensock ) { im_tcp_accept(module); return; } //else we have data from a client connection CHECKERR_MSG(apr_socket_data_get((void **) &input, "input", sock), "couldn't get input data from socket"); ASSERT(input != NULL); // if this is null there is a race/double free in event handling if ( (rv = nx_module_input_fill_buffer_from_socket(input)) != APR_SUCCESS ) { if ( APR_STATUS_IS_ECONNREFUSED(rv) || APR_STATUS_IS_ECONNABORTED(rv) || APR_STATUS_IS_ECONNRESET(rv) || APR_STATUS_IS_ETIMEDOUT(rv) || APR_STATUS_IS_TIMEUP(rv) || APR_STATUS_IS_EHOSTUNREACH(rv) || APR_STATUS_IS_ENETUNREACH(rv) || APR_STATUS_IS_EOF(rv) ) { got_eof = TRUE; } else if ( APR_STATUS_IS_EAGAIN(rv) ) { nx_module_add_poll_event(module); } else { im_tcp_free_input(input); throw(rv, "Module %s couldn't read from socket", input->module->name); } } try { while ( (logdata = input->inputfunc->func(input, input->inputfunc->data)) != NULL ) { //log_debug("read %d bytes: [%s]", (int) logdata->datalen, logdata->data); ipstr = nx_module_input_data_get(input, "recv_from_str"); nx_logdata_set_string(logdata, "MessageSourceAddress", ipstr); nx_module_add_logdata_input(module, input, logdata); } } catch(e) { im_tcp_free_input(input); rethrow_msg(e, "Module %s couldn't read the input", input->module->name); } if ( got_eof == TRUE ) { CHECKERR_MSG(apr_socket_addr_get(&sa, APR_REMOTE, input->desc.s), "couldn't get info on accepted socket"); CHECKERR_MSG(apr_sockaddr_ip_get(&ipstr, sa), "couldn't get IP of accepted socket"); log_aprwarn(rv, "TCP connection closed from %s:%u", ipstr, sa->port); im_tcp_free_input(input); } }