blob: c3560de5a89efa37319c0c7b78a8dadadac5c4a4 [file] [log] [blame]
#include "httpd.h"
#include "apr_thread_proc.h"
#include "apr_strings.h"
#include "apr_portable.h"
#include "apr_pools.h"
#include "util_script.h"
#include "mod_core.h"
#include "mod_cgi.h"
#include "apr_tables.h"
#include "fcgid_proc.h"
#include "fcgid_proctbl.h"
#include "fcgid_protocol.h"
#include "fcgid_conf.h"
#include "fcgid_pm.h"
#include "fcgid_spawn_ctl.h"
#define SHUTDOWN_EVENT_NAME "_FCGI_SHUTDOWN_EVENT_"
#define FINISH_EVENT_DATA_NAME "finish_event"
#ifndef SIGKILL
#define SIGKILL 9
#endif
/* It's tested on WinNT ONLY, if it work on the other MS platform, let me know */
#if WINVER < 0x0400
#error It is tested on WinNT only
#endif
typedef struct {
HANDLE handle_pipe;
OVERLAPPED overlap_read;
OVERLAPPED overlap_write;
} fcgid_namedpipe_handle;
static int g_process_counter = 0;
static apr_pool_t *g_inode_cginame_map = NULL;
static apr_status_t close_finish_event(void *finishevent)
{
HANDLE *finish_event = finishevent;
CloseHandle(*finish_event);
return APR_SUCCESS;
}
apr_status_t
proc_spawn_process(char *wrapperpath, fcgid_proc_info * procinfo,
fcgid_procnode * procnode)
{
HANDLE *finish_event, listen_handle;
int bufused = 0;
SECURITY_ATTRIBUTES SecurityAttributes;
apr_procattr_t *proc_attr;
apr_status_t rv;
apr_file_t *file;
char **proc_environ;
char key_name[_POSIX_PATH_MAX];
char sock_path[_POSIX_PATH_MAX];
char *dummy;
char *argv[2];
int argc;
char *wargv[APACHE_ARG_MAX], *word; /* For wrapper */
const char *tmp;
/* Build wrapper args */
argc = 0;
tmp = wrapperpath;
while (1) {
word = ap_getword_white(procnode->proc_pool, &tmp);
if (word == NULL || *word == '\0')
break;
if (argc >= APACHE_ARG_MAX)
break;
wargv[argc++] = word;
}
wargv[argc] = NULL;
memset(&SecurityAttributes, 0, sizeof(SecurityAttributes));
/* Create the pool if necessary */
if (!g_inode_cginame_map)
apr_pool_create(&g_inode_cginame_map,
procinfo->main_server->process->pconf);
if (!g_inode_cginame_map) {
ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
procinfo->main_server,
"mod_fcgid: can't cgi name map table");
return APR_ENOMEM;
}
/* Prepare finish event */
finish_event = apr_palloc(procnode->proc_pool, sizeof(HANDLE));
if (!finish_event) {
ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
procinfo->main_server,
"mod_fcgid: can't allocate finish event");
return APR_ENOMEM;
}
*finish_event = CreateEvent(NULL, TRUE, FALSE, NULL);
if (*finish_event == NULL
|| !SetHandleInformation(*finish_event, HANDLE_FLAG_INHERIT, TRUE))
{
ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
procinfo->main_server,
"mod_fcgid: can't create mutex for subprocess");
return APR_ENOLOCK;
}
apr_pool_cleanup_register(procnode->proc_pool, finish_event,
close_finish_event, apr_pool_cleanup_null);
/* For proc_kill_gracefully() */
apr_pool_userdata_set(finish_event, FINISH_EVENT_DATA_NAME,
NULL, procnode->proc_pool);
/* Pass the finish event id to subprocess */
apr_table_setn(procinfo->proc_environ, SHUTDOWN_EVENT_NAME,
apr_ltoa(procnode->proc_pool, (long) *finish_event));
/* Prepare the listen namedpipe file name */
apr_snprintf(sock_path, _POSIX_PATH_MAX - 1,
"\\\\.\\pipe\\fcgidpipe-%u.%lu",
GetCurrentProcessId(), g_process_counter++);
/* Prepare the listen namedpipe handle */
SecurityAttributes.bInheritHandle = TRUE;
SecurityAttributes.nLength = sizeof(SecurityAttributes);
SecurityAttributes.lpSecurityDescriptor = NULL;
listen_handle = CreateNamedPipe(sock_path,
PIPE_ACCESS_DUPLEX,
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
PIPE_WAIT, PIPE_UNLIMITED_INSTANCES,
8192, 8192, 0, &SecurityAttributes);
if (listen_handle == INVALID_HANDLE_VALUE) {
ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
procinfo->main_server,
"mod_fcgid: can't create namedpipe for subprocess");
return APR_ENOSOCKET;
}
strncpy(procnode->socket_path, sock_path, _POSIX_PATH_MAX - 1);
procnode->socket_path[_POSIX_PATH_MAX - 1] = '\0';
/* Build environment variables */
proc_environ = ap_create_environment(procnode->proc_pool,
procinfo->proc_environ);
if (!proc_environ) {
ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
procinfo->main_server,
"mod_fcgid: can't build environment variables");
return APR_ENOMEM;
}
/* Create process now */
if (!
(procnode->proc_id =
apr_pcalloc(procnode->proc_pool, sizeof(apr_proc_t)))
|| (rv =
apr_procattr_create(&proc_attr,
procnode->proc_pool)) != APR_SUCCESS
|| (rv =
apr_procattr_dir_set(proc_attr,
ap_make_dirstr_parent(procnode->proc_pool,
(wrapperpath != NULL
&& wrapperpath[0] !=
'\0') ? wargv[0] :
procinfo->cgipath))) !=
APR_SUCCESS
|| (rv =
apr_procattr_cmdtype_set(proc_attr, APR_PROGRAM)) != APR_SUCCESS
|| (rv = apr_procattr_detach_set(proc_attr, 1)) != APR_SUCCESS
|| (rv =
apr_os_file_put(&file, &listen_handle, 0,
procnode->proc_pool)) != APR_SUCCESS
|| (rv =
apr_procattr_child_in_set(proc_attr, file, NULL)) != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_WARNING, rv, procinfo->main_server,
"mod_fcgid: can't create fastcgi process attribute");
CloseHandle(listen_handle);
return APR_ENOPROC;
}
/* fork and exec now */
if (wrapperpath != NULL && wrapperpath[0] != '\0') {
ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, procinfo->main_server,
"mod_fcgid: call %s with wrapper %s",
procinfo->cgipath, wrapperpath);
if ((rv =
apr_proc_create(procnode->proc_id, wargv[0],
(const char *const *) wargv,
(const char *const *) proc_environ, proc_attr,
procnode->proc_pool)) != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, procinfo->main_server,
"mod_fcgid: can't create wrapper process for %s",
procinfo->cgipath);
CloseHandle(listen_handle);
return rv;
}
} else {
argv[0] = procinfo->cgipath;
argv[1] = NULL;
if ((rv =
apr_proc_create(procnode->proc_id, procinfo->cgipath,
(const char *const *) argv,
(const char *const *) proc_environ, proc_attr,
procnode->proc_pool)) != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, procinfo->main_server,
"mod_fcgid: can't create process");
CloseHandle(listen_handle);
return rv;
}
}
/* OK, I created the process, now put it back to idle list */
CloseHandle(listen_handle);
/* Set the (deviceid, inode, shareid) -> fastcgi path map for log */
apr_snprintf(key_name, _POSIX_PATH_MAX, "%lX%lX%lX",
procnode->inode, procnode->deviceid,
procnode->share_grp_id);
dummy = NULL;
apr_pool_userdata_get(&dummy, key_name, g_inode_cginame_map);
if (!dummy) {
/* Insert a new item if key not found */
char *put_key = apr_psprintf(g_inode_cginame_map, "%lX%lX%lX",
procnode->inode, procnode->deviceid,
procnode->share_grp_id);
char *fcgipath = apr_psprintf(g_inode_cginame_map, "%s",
procinfo->cgipath);
if (put_key && fcgipath)
apr_pool_userdata_set(fcgipath, put_key, NULL,
g_inode_cginame_map);
}
return APR_SUCCESS;
}
apr_status_t
proc_kill_gracefully(fcgid_procnode * procnode, server_rec * main_server)
{
HANDLE *finish_event = NULL;
apr_pool_userdata_get((void **) &finish_event,
FINISH_EVENT_DATA_NAME, procnode->proc_pool);
if (finish_event != NULL)
SetEvent(*finish_event);
return APR_SUCCESS;
}
apr_status_t proc_kill_force(fcgid_procnode * procnode,
server_rec * main_server)
{
return apr_proc_kill(procnode->proc_id, SIGKILL);
}
apr_status_t
proc_wait_process(server_rec * main_server, fcgid_procnode * procnode)
{
apr_status_t rv;
int exitcode;
apr_exit_why_e exitwhy;
if ((rv = apr_proc_wait(procnode->proc_id, &exitcode, &exitwhy,
APR_NOWAIT)) == APR_CHILD_DONE) {
/* Log why and how it die */
proc_print_exit_info(procnode, exitcode, exitwhy, main_server);
/* Register the death */
register_termination(main_server, procnode);
/* Destroy pool */
apr_pool_destroy(procnode->proc_pool);
procnode->proc_pool = NULL;
}
return rv;
}
static apr_status_t ipc_handle_cleanup(void *thehandle)
{
fcgid_namedpipe_handle *handle = thehandle;
/* Sanity check */
if (handle) {
if (handle->handle_pipe != INVALID_HANDLE_VALUE)
CloseHandle(handle->handle_pipe);
if (handle->overlap_read.hEvent != NULL)
CloseHandle(handle->overlap_read.hEvent);
if (handle->overlap_write.hEvent != NULL)
CloseHandle(handle->overlap_write.hEvent);
handle->handle_pipe = INVALID_HANDLE_VALUE;
handle->overlap_read.hEvent = NULL;
handle->overlap_write.hEvent = NULL;
}
return APR_SUCCESS;
}
apr_status_t
proc_connect_ipc(server_rec * main_server,
fcgid_procnode * procnode, fcgid_ipc * ipc_handle)
{
/* Prepare the ipc struct */
fcgid_namedpipe_handle *handle_info;
ipc_handle->ipc_handle_info =
(fcgid_namedpipe_handle *) apr_pcalloc(ipc_handle->request->pool,
sizeof
(fcgid_namedpipe_handle));
if (!ipc_handle->ipc_handle_info)
return APR_ENOMEM;
handle_info = (fcgid_namedpipe_handle *) ipc_handle->ipc_handle_info;
/* Prepare OVERLAPPED struct for non-block I/O */
handle_info->overlap_read.hEvent =
CreateEvent(NULL, FALSE, FALSE, NULL);
handle_info->overlap_write.hEvent =
CreateEvent(NULL, FALSE, FALSE, NULL);
handle_info->handle_pipe = INVALID_HANDLE_VALUE;
apr_pool_cleanup_register(ipc_handle->request->pool,
handle_info,
ipc_handle_cleanup, apr_pool_cleanup_null);
if (handle_info->overlap_read.hEvent == NULL
|| handle_info->overlap_write.hEvent == NULL)
return APR_ENOMEM;
/* Connect to name pipe */
handle_info->handle_pipe = CreateFile(procnode->socket_path, GENERIC_READ | GENERIC_WRITE, 0, /* no sharing */
NULL, /* no security attributes */
OPEN_EXISTING, /* opens existing pipe */
/*0 */ FILE_FLAG_OVERLAPPED,
NULL /* no template file */ );
if (handle_info->handle_pipe == INVALID_HANDLE_VALUE
&& ipc_handle->connect_timeout != 0
&& GetLastError() == ERROR_PIPE_BUSY) {
/* Wait a while and try again */
if (WaitNamedPipe
(procnode->socket_path, ipc_handle->connect_timeout)) {
handle_info->handle_pipe = CreateFile(procnode->socket_path, GENERIC_READ | GENERIC_WRITE, 0, /* no sharing */
NULL, /* no security attributes */
OPEN_EXISTING, /* opens existing pipe */
0, /* default attributes */
NULL /* no template file */
);
}
}
if (handle_info->handle_pipe == INVALID_HANDLE_VALUE) {
if (GetLastError() == ERROR_FILE_NOT_FOUND) /* The process has exited */
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, main_server,
"mod_fcgid: can't connect to named pipe, fastcgi server %d has been terminated",
procnode->proc_id->pid);
else
ap_log_error(APLOG_MARK, APLOG_DEBUG, apr_get_os_error(),
main_server,
"mod_fcgid: can't connect to named pipe, fastcgi server pid: %d",
procnode->proc_id->pid);
return APR_ESPIPE;
}
/* Now named pipe connected */
return APR_SUCCESS;
}
apr_status_t proc_close_ipc(server_rec * main_server,
fcgid_ipc * ipc_handle)
{
apr_status_t rv;
rv = apr_pool_cleanup_run(ipc_handle->request->pool,
ipc_handle->ipc_handle_info,
ipc_handle_cleanup);
ipc_handle->ipc_handle_info = NULL;
return rv;
}
apr_status_t proc_read_ipc(server_rec * main_server,
fcgid_ipc * ipc_handle, const char *buffer,
apr_size_t * size)
{
apr_status_t rv;
fcgid_namedpipe_handle *handle_info;
DWORD bytesread;
handle_info = (fcgid_namedpipe_handle *) ipc_handle->ipc_handle_info;
if (ReadFile(handle_info->handle_pipe, (LPVOID) buffer,
*size, &bytesread, &handle_info->overlap_read)) {
*size = bytesread;
return APR_SUCCESS;
} else if ((rv = GetLastError()) != ERROR_IO_PENDING) {
ap_log_error(APLOG_MARK, APLOG_WARNING, APR_FROM_OS_ERROR(rv),
main_server, "mod_fcgid: can't read from pipe");
return rv;
} else {
/* it's ERROR_IO_PENDING */
DWORD transferred;
DWORD dwWaitResult
= WaitForSingleObject(handle_info->overlap_read.hEvent,
ipc_handle->communation_timeout * 1000);
if (dwWaitResult == WAIT_OBJECT_0) {
if (!GetOverlappedResult(handle_info->handle_pipe,
&handle_info->overlap_read,
&transferred, FALSE /* don't wait */ )
|| transferred == 0) {
rv = apr_get_os_error();
ap_log_error(APLOG_MARK, APLOG_WARNING,
rv, main_server,
"mod_fcgid: get overlap result error");
return rv;
}
*size = transferred;
return APR_SUCCESS;
} else {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0,
main_server, "mod_fcgid: read timeout from pipe");
return APR_ETIMEDOUT;
}
}
}
apr_status_t proc_write_ipc(server_rec * main_server,
fcgid_ipc * ipc_handle,
apr_bucket_brigade * birgade_send)
{
fcgid_namedpipe_handle *handle_info;
apr_bucket *bucket_request;
apr_status_t rv;
DWORD transferred;
handle_info = (fcgid_namedpipe_handle *) ipc_handle->ipc_handle_info;
for (bucket_request = APR_BRIGADE_FIRST(birgade_send);
bucket_request != APR_BRIGADE_SENTINEL(birgade_send);
bucket_request = APR_BUCKET_NEXT(bucket_request)) {
char *write_buf;
apr_size_t write_buf_len;
apr_size_t has_write;
if (APR_BUCKET_IS_EOS(bucket_request))
break;
if (APR_BUCKET_IS_FLUSH(bucket_request))
continue;
if ((rv =
apr_bucket_read(bucket_request, &write_buf, &write_buf_len,
APR_BLOCK_READ)) != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_WARNING, rv, main_server,
"mod_fcgid: can't read request from bucket");
return rv;
}
/* Write the buffer to fastcgi server */
has_write = 0;
while (has_write < write_buf_len) {
DWORD byteswrite;
if (WriteFile(handle_info->handle_pipe,
write_buf + has_write,
write_buf_len - has_write,
&byteswrite, &handle_info->overlap_write)) {
has_write += byteswrite;
continue;
} else if ((rv = GetLastError()) != ERROR_IO_PENDING) {
ap_log_error(APLOG_MARK, APLOG_WARNING,
APR_FROM_OS_ERROR(rv), main_server,
"mod_fcgid: can't write to pipe");
return rv;
} else {
/*
it's ERROR_IO_PENDING on write
*/
DWORD dwWaitResult
=
WaitForSingleObject(handle_info->overlap_write.hEvent,
ipc_handle->communation_timeout *
1000);
if (dwWaitResult == WAIT_OBJECT_0) {
if (!GetOverlappedResult(handle_info->handle_pipe,
&handle_info->overlap_write,
&transferred,
FALSE /* don't wait */ )
|| transferred == 0) {
ap_log_error(APLOG_MARK, APLOG_WARNING,
apr_get_os_error(), main_server,
"mod_fcgid: get overlap result error");
return APR_ESPIPE;
}
has_write += transferred;
continue;
} else {
ap_log_error(APLOG_MARK, APLOG_WARNING, 0,
main_server,
"mod_fcgid: write timeout to pipe");
return APR_ESPIPE;
}
}
}
}
return APR_SUCCESS;
}
void
proc_print_exit_info(fcgid_procnode * procnode, int exitcode,
apr_exit_why_e exitwhy, server_rec * main_server)
{
char *cgipath = NULL;
char *diewhy = NULL;
char key_name[_POSIX_PATH_MAX];
/* Get the file name infomation base on inode and deviceid */
apr_snprintf(key_name, _POSIX_PATH_MAX, "%lX%lX%lX",
procnode->inode, procnode->deviceid,
procnode->share_grp_id);
apr_pool_userdata_get(&cgipath, key_name, g_inode_cginame_map);
/* Reasons to exit */
switch (procnode->diewhy) {
case FCGID_DIE_KILLSELF:
if (exitwhy == APR_PROC_EXIT)
diewhy = "normal exit";
else
diewhy = "access violation";
break;
case FCGID_DIE_IDLE_TIMEOUT:
diewhy = "idle timeout";
break;
case FCGID_DIE_LIFETIME_EXPIRED:
diewhy = "lifetime expired";
break;
case FCGID_DIE_BUSY_TIMEOUT:
diewhy = "busy timeout";
break;
case FCGID_DIE_CONNECT_ERROR:
diewhy = "connect error, server may has exited";
break;
case FCGID_DIE_COMM_ERROR:
diewhy = "communication error";
break;
case FCGID_DIE_SHUTDOWN:
diewhy = "shutting down";
break;
default:
diewhy = "unknow";
}
/* Print log now */
if (cgipath)
ap_log_error(APLOG_MARK, APLOG_INFO, 0, main_server,
"mod_fcgid: process %s(%d) exit(%s), return code %d",
cgipath, procnode->proc_id->pid, diewhy, exitcode);
else
ap_log_error(APLOG_MARK, APLOG_WARNING, 0, main_server,
"mod_fcgid: can't get cgi name while exiting, exitcode: %d",
exitcode);
}