#include <unistd.h>
#include <sys/un.h>
#include <sys/types.h>
#include <netinet/tcp.h>		/* For TCP_NODELAY */
#include <sys/poll.h>
#define CORE_PRIVATE
#include "httpd.h"
#include "apr_thread_proc.h"
#include "apr_strings.h"
#include "apr_portable.h"
#include "apr_pools.h"
#include "apr_network_io.h"
#include "mpm_common.h"
#include "util_script.h"
#include "unixd.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 DEFAULT_FCGID_LISTENBACKLOG 5
typedef struct {
	int handle_socket;
} fcgid_namedpipe_handle;

static int g_process_counter = 0;
static apr_pool_t *g_inode_cginame_map = NULL;
static const char *g_socket_dir = NULL;

static apr_status_t ap_unix_create_privileged_process(apr_proc_t * newproc,
													  const char *progname,
													  const char *const
													  *args, const char *const
													  *env,
													  apr_procattr_t *
													  attr,
													  ap_unix_identity_t *
													  ugid, apr_pool_t * p)
{
	int i = 0;
	const char **newargs;
	char *newprogname;
	char *execuser, *execgroup;
	const char *argv0;

	if (!unixd_config.suexec_enabled) {
		return apr_proc_create(newproc, progname, args, env, attr, p);
	}

	argv0 = ap_strrchr_c(progname, '/');
	/* Allow suexec's "/" check to succeed */
	if (argv0 != NULL) {
		argv0++;
	} else {
		argv0 = progname;
	}


	if (ugid->userdir) {
		execuser = apr_psprintf(p, "~%ld", (long) ugid->uid);
	} else {
		execuser = apr_psprintf(p, "%ld", (long) ugid->uid);
	}
	execgroup = apr_psprintf(p, "%ld", (long) ugid->gid);

	if (!execuser || !execgroup) {
		return APR_ENOMEM;
	}

	i = 0;
	if (args) {
		while (args[i]) {
			i++;
		}
	}
	/* allocate space for 4 new args, the input args, and a null terminator */
	newargs = apr_palloc(p, sizeof(char *) * (i + 4));
	newprogname = SUEXEC_BIN;
	newargs[0] = SUEXEC_BIN;
	newargs[1] = execuser;
	newargs[2] = execgroup;
	newargs[3] = apr_pstrdup(p, argv0);

	/*
	 ** using a shell to execute suexec makes no sense thus
	 ** we force everything to be APR_PROGRAM, and never
	 ** APR_SHELLCMD
	 */
	if (apr_procattr_cmdtype_set(attr, APR_PROGRAM) != APR_SUCCESS) {
		return APR_EGENERAL;
	}

	i = 1;
	do {
		newargs[i + 3] = args[i];
	} while (args[i++]);

	return apr_proc_create(newproc, newprogname, newargs, env, attr, p);
}

static apr_status_t fcgid_create_privileged_process(apr_proc_t * newproc,
													const char *progname,
													const char *const
													*args,
													const char *const *env,
													apr_procattr_t * attr,
													fcgid_proc_info *
													procinfo,
													apr_pool_t * p)
{
	ap_unix_identity_t ugid;

	if (!unixd_config.suexec_enabled
		|| (procinfo->uid == (uid_t) - 1
			&& procinfo->gid == (gid_t) - 1)) {
		return apr_proc_create(newproc, progname, args, env, attr, p);
	}

	ugid.gid = procinfo->gid;
	ugid.uid = procinfo->uid;
	ugid.userdir = procinfo->userdir;
	return ap_unix_create_privileged_process(newproc, progname, args, env,
											 attr, &ugid, p);
}

static apr_status_t socket_file_cleanup(void *theprocnode)
{
	fcgid_procnode *procnode = (fcgid_procnode *) theprocnode;

	unlink(procnode->socket_path);
	return APR_SUCCESS;
}

static apr_status_t exec_setuid_cleanup(void *dummy)
{
	seteuid(0);
	setuid(unixd_config.user_id);
	return APR_SUCCESS;
}

apr_status_t
proc_spawn_process(char *lpszwapper, fcgid_proc_info * procinfo,
				   fcgid_procnode * procnode)
{
	server_rec *main_server = procinfo->main_server;
	apr_status_t rv = APR_SUCCESS;
	apr_file_t *file;
	int omask, retcode, unix_socket;
	char **proc_environ;
	struct sockaddr_un unix_addr;
	apr_procattr_t *procattr = NULL;
	char key_name[_POSIX_PATH_MAX];
	void *dummy;
	int argc;
	char *wargv[APACHE_ARG_MAX], *word;	/* For wrapper */
	const char *tmp;
	char *argv[2];

	/* Build wrapper args */
	argc = 0;
	tmp = lpszwapper;
	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;

	/* Initialize the variables */
	if (!g_inode_cginame_map) {
		apr_pool_create(&g_inode_cginame_map,
						procinfo->main_server->process->pconf);
	}

	if (!g_socket_dir)
		g_socket_dir = get_socketpath(procinfo->main_server);
	if (!g_inode_cginame_map || !g_socket_dir) {
		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;
	}

	/* 
	   Create UNIX domain socket before spawn 
	 */

	/* Generate a UNIX domain socket file path */
	/* XXX It's nothing I can do if strlen(g_socket_dir) too long... */
	memset(&unix_addr, 0, sizeof(unix_addr));
	unix_addr.sun_family = AF_UNIX;
	apr_snprintf(unix_addr.sun_path, sizeof(unix_addr.sun_path) - 1,
				 "%s/%d.%d", g_socket_dir, getpid(), g_process_counter++);
	strncpy(procnode->socket_path, unix_addr.sun_path,
			sizeof(procnode->socket_path) - 1);

	/* Unlink the file just in case */
	unlink(unix_addr.sun_path);

	/* Create the socket */
	if ((unix_socket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
		ap_log_error(APLOG_MARK, APLOG_ERR, errno, main_server,
					 "mod_fcgid: couldn't create unix domain socket");
		return errno;
	}

	/* Unlink it when process exit */
	if (unixd_config.suexec_enabled) {
		apr_pool_cleanup_register(procnode->proc_pool,
								  procnode, socket_file_cleanup,
								  exec_setuid_cleanup);
	} else {
		apr_pool_cleanup_register(procnode->proc_pool,
								  procnode, socket_file_cleanup,
								  apr_pool_cleanup_null);
	}

	/* Bind the socket */
	omask = umask(0077);
	retcode = bind(unix_socket, (struct sockaddr *) &unix_addr,
				   sizeof(unix_addr));
	umask(omask);
	if (retcode < 0) {
		ap_log_error(APLOG_MARK, APLOG_ERR, errno, main_server,
					 "mod_fcgid: couldn't bind unix domain socket %s",
					 unix_addr.sun_path);
		close(unix_socket);
		return errno;
	}

	/* Listen the socket */
	if (listen(unix_socket, DEFAULT_FCGID_LISTENBACKLOG) < 0) {
		ap_log_error(APLOG_MARK, APLOG_ERR, errno, main_server,
					 "mod_fcgid: couldn't listen on unix domain socket");
		close(unix_socket);
		return errno;
	}

	/* Correct the file owner */
	if (!geteuid()) {
		if (chown(unix_addr.sun_path, unixd_config.user_id, -1) < 0) {
			ap_log_error(APLOG_MARK, APLOG_ERR, errno, main_server,
						 "mod_fcgid: couldn't change owner of unix domain socket %s",
						 unix_addr.sun_path);
			close(unix_socket);
			return errno;
		}
	}

	{
		int oldflags = fcntl(unix_socket, F_GETFD, 0);

		if (oldflags < 0) {
			ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
						 procinfo->main_server,
						 "mod_fcgid: fcntl F_GETFD failed");
			close(unix_socket);
			return errno;
		}

		oldflags |= FD_CLOEXEC;
		if (fcntl(unix_socket, F_SETFD, oldflags) < 0) {
			ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
						 procinfo->main_server,
						 "mod_fcgid: fcntl F_SETFD failed");
			close(unix_socket);
			return errno;
		}
	}

	/* 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");
		close(unix_socket);
		return APR_ENOMEM;
	}

	/* Prepare the fork */
	if (!
		(procnode->proc_id =
		 apr_pcalloc(procnode->proc_pool, sizeof(apr_proc_t)))
|| (rv =
	apr_procattr_create(&procattr, procnode->proc_pool)) != APR_SUCCESS
|| (rv =
	apr_procattr_child_err_set(procattr,
							   procinfo->main_server->error_log,
							   NULL)) != APR_SUCCESS
|| (rv =
	apr_procattr_child_out_set(procattr,
							   procinfo->main_server->error_log,
							   NULL)) != APR_SUCCESS
|| (rv =
	apr_procattr_dir_set(procattr,
						 ap_make_dirstr_parent(procnode->proc_pool,
											   (lpszwapper != NULL
												&& lpszwapper[0] !=
												'\0') ? wargv[0] :
											   procinfo->cgipath))) !=
APR_SUCCESS
|| (rv = apr_procattr_cmdtype_set(procattr, APR_PROGRAM)) != APR_SUCCESS
|| (rv =
	apr_os_file_put(&file, &unix_socket, 0,
					procnode->proc_pool)) != APR_SUCCESS
|| (rv = apr_procattr_child_in_set(procattr, file, NULL)) != APR_SUCCESS) {
		ap_log_error(APLOG_MARK, APLOG_ERR, rv, procinfo->main_server,
					 "mod_fcgid: couldn't set child process attributes: %s",
					 unix_addr.sun_path);
		close(unix_socket);
		return rv;
	}

	/* fork and exec now */
	if (lpszwapper != NULL && lpszwapper[0] != '\0') {
		ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, procinfo->main_server,
					 "mod_fcgid: call %s with wrapper %s",
					 procinfo->cgipath, lpszwapper);
		if ((rv =
			 fcgid_create_privileged_process(procnode->proc_id,
											 wargv[0],
											 (const char *const *) wargv,
											 (const char *const *)
											 proc_environ, procattr,
											 procinfo,
											 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);
			close(unix_socket);
			return rv;
		}
	} else {
		argv[0] = procinfo->cgipath;
		argv[1] = NULL;
		if ((rv =
			 fcgid_create_privileged_process(procnode->proc_id,
											 procinfo->cgipath,
											 (const char *const *) argv,
											 (const char *const *)
											 proc_environ, procattr,
											 procinfo,
											 procnode->proc_pool)) !=
			APR_SUCCESS) {
			ap_log_error(APLOG_MARK, APLOG_ERR, rv, procinfo->main_server,
						 "mod_fcgid: can't create process");
			close(unix_socket);
			return rv;
		}
	}

	/* Set the (deviceid, inode) -> fastcgi path map for log */
	apr_snprintf(key_name, _POSIX_PATH_MAX, "%lX%lX",
				 procnode->inode, (unsigned long) procnode->deviceid);
	dummy = NULL;
	apr_pool_userdata_get((void **) &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",
									 procnode->inode,
									 (unsigned long) procnode->deviceid);
		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);
	}

	/* Close socket before try to connect to it */
	close(unix_socket);

	return APR_SUCCESS;
}

apr_status_t
proc_kill_gracefully(fcgid_procnode * procnode, server_rec * main_server)
{

	/* su as root before sending kill signal, for suEXEC */
	apr_status_t rv;

	if (unixd_config.suexec_enabled && seteuid(0) != 0) {

		/* It's fatal error */
		kill(getpid(), SIGTERM);
		return APR_EACCES;
	}
	rv = apr_proc_kill(procnode->proc_id, SIGTERM);
	if (unixd_config.suexec_enabled && seteuid(unixd_config.user_id) != 0) {
		kill(getpid(), SIGTERM);
		return APR_EACCES;
	}
	return rv;
}

apr_status_t proc_kill_force(fcgid_procnode * procnode,
							 server_rec * main_server)
{
	apr_status_t rv;

	if (unixd_config.suexec_enabled && seteuid(0) != 0) {

		/* It's fatal error */
		kill(getpid(), SIGTERM);
		return APR_EACCES;
	}
	rv = apr_proc_kill(procnode->proc_id, SIGKILL);
	if (unixd_config.suexec_enabled && seteuid(unixd_config.user_id) != 0) {
		kill(getpid(), SIGTERM);
		return APR_EACCES;
	}
	return rv;
}

apr_status_t
proc_wait_process(server_rec * main_server, fcgid_procnode * procnode)
{
	apr_status_t rv;
	int exitcode;
	apr_exit_why_e exitwhy;

	rv = apr_proc_wait(procnode->proc_id, &exitcode, &exitwhy, APR_NOWAIT);
	if (rv == APR_CHILD_DONE || rv == APR_EGENERAL) {
		/* 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 APR_CHILD_DONE;
	}

	return rv;
}

static apr_status_t ipc_handle_cleanup(void *thesocket)
{
	fcgid_namedpipe_handle *handle_info =
		(fcgid_namedpipe_handle *) thesocket;

	if (handle_info) {
		if (handle_info->handle_socket != -1) {
			close(handle_info->handle_socket);
			handle_info->handle_socket = -1;
		}
	}

	return APR_SUCCESS;
}

static apr_status_t set_socket_nonblock(int sd)
{
#ifndef BEOS
	int fd_flags;

	fd_flags = fcntl(sd, F_GETFL, 0);
#if defined(O_NONBLOCK)
	fd_flags |= O_NONBLOCK;
#elif defined(O_NDELAY)
	fd_flags |= O_NDELAY;
#elif defined(FNDELAY)
	fd_flags |= FNDELAY;
#else
#error Please teach APR how to make sockets non-blocking on your platform.
#endif
	if (fcntl(sd, F_SETFL, fd_flags) == -1) {
		return errno;
	}
#else
	int on = 1;
	if (setsockopt(sd, SOL_SOCKET, SO_NONBLOCK, &on, sizeof(int)) < 0)
		return errno;
#endif							/* BEOS */
	return APR_SUCCESS;
}

apr_status_t
proc_connect_ipc(server_rec * main_server,
				 fcgid_procnode * procnode, fcgid_ipc * ipc_handle)
{
	fcgid_namedpipe_handle *handle_info;
	struct sockaddr_un unix_addr;
	apr_status_t rv;
	apr_int32_t on = 1;

	/* Alloc memory for unix domain socket */
	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;
	handle_info->handle_socket = socket(AF_UNIX, SOCK_STREAM, 0);
	apr_pool_cleanup_register(ipc_handle->request->pool,
							  handle_info, ipc_handle_cleanup,
							  apr_pool_cleanup_null);

	/* Connect to fastcgi server */
	memset(&unix_addr, 0, sizeof(unix_addr));
	unix_addr.sun_family = AF_UNIX;
	strncpy(unix_addr.sun_path, procnode->socket_path,
			sizeof(unix_addr.sun_path) - 1);

	/* I am the only one who connecting the server
	   So I don't have to worry about ECONNREFUSED(listen queue overflow) problem,
	   and I will never retry on error */
	if (connect(handle_info->handle_socket, (struct sockaddr *) &unix_addr,
				sizeof(unix_addr)) < 0) {
		ap_log_error(APLOG_MARK, APLOG_DEBUG, apr_get_os_error(),
					 main_server,
					 "mod_fcgid: can't connect unix domain socket: %s",
					 procnode->socket_path);
		return APR_ECONNREFUSED;
	}

	/* Set no delay option */
	setsockopt(handle_info->handle_socket, IPPROTO_TCP, TCP_NODELAY,
			   (char *) &on, sizeof(on));

	/* Set nonblock option */
	if ((rv =
		 set_socket_nonblock(handle_info->handle_socket)) != APR_SUCCESS) {
		ap_log_error(APLOG_MARK, APLOG_DEBUG, rv, main_server,
					 "mod_fcgid: can't set nonblock unix domain socket");
		return rv;
	}

	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)
{
	int retcode, unix_socket;
	fcgid_namedpipe_handle *handle_info;
	struct pollfd pollfds[1];

	handle_info = (fcgid_namedpipe_handle *) ipc_handle->ipc_handle_info;
	unix_socket = handle_info->handle_socket;

	do {
		if ((retcode = read(unix_socket, (void *) buffer, *size)) > 0) {
			*size = retcode;
			return APR_SUCCESS;
		}
	} while (retcode == -1 && APR_STATUS_IS_EINTR(errno));
	if (retcode == -1 && !APR_STATUS_IS_EAGAIN(errno)) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, errno,
					 main_server,
					 "mod_fcgid: read data from fastcgi server error");
		return errno;
	}

	/* I have to wait a while */

	pollfds[0].fd = unix_socket;
	pollfds[0].events = POLLIN;
	do {
		retcode = poll(pollfds, 1, ipc_handle->communation_timeout * 1000);
	} while (retcode <= 0 && APR_STATUS_IS_EINTR(errno));
	if (retcode == -1) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, errno,
					 main_server,
					 "mod_fcgid: poll unix domain socket error");
		return errno;
	} else if (retcode == 0) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, 0,
					 main_server,
					 "mod_fcgid: read data timeout in %d seconds",
					 ipc_handle->communation_timeout);
		return APR_ETIMEDOUT;
	}

	do {
		if ((retcode = read(unix_socket, (void *) buffer, *size)) > 0) {
			*size = retcode;
			return APR_SUCCESS;
		}
	} while (retcode == -1 && APR_STATUS_IS_EINTR(errno));

	if (retcode == 0) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, 0,
					 main_server,
					 "mod_fcgid: Read data error, fastcgi server has close connection");
		return APR_EPIPE;
	}

	ap_log_error(APLOG_MARK, APLOG_WARNING, errno,
				 main_server,
				 "mod_fcgid: read data from fastcgi server error.");
	return errno;
}

static apr_status_t socket_writev(fcgid_ipc * ipc_handle,
								  struct iovec *vec, int nvec,
								  int *writecnt)
{
	int retcode, unix_socket;
	fcgid_namedpipe_handle *handle_info;
	struct pollfd pollfds[1];

	handle_info = (fcgid_namedpipe_handle *) ipc_handle->ipc_handle_info;
	unix_socket = handle_info->handle_socket;

	/* Try nonblock write */
	do {
		if ((retcode = writev(unix_socket, vec, nvec)) > 0) {
			*writecnt = retcode;
			return APR_SUCCESS;
		}
	} while (retcode == -1 && APR_STATUS_IS_EINTR(errno));
	if (!APR_STATUS_IS_EAGAIN(errno))
		return errno;

	/* poll() */
	pollfds[0].fd = unix_socket;
	pollfds[0].events = POLLOUT;
	do {
		retcode = poll(pollfds, 1, ipc_handle->communation_timeout * 1000);
	} while (retcode <= 0 && APR_STATUS_IS_EINTR(errno));
	if (retcode == -1)
		return errno;

	/* Write again */
	do {
		if ((retcode = writev(unix_socket, vec, nvec)) > 0) {
			*writecnt = retcode;
			return APR_SUCCESS;
		}
	} while (retcode == -1 && APR_STATUS_IS_EINTR(errno));

	if (retcode == 0) {
		ap_log_error(APLOG_MARK, APLOG_INFO, 0,
					 ipc_handle->request->server,
					 "mod_fcgid: Write data error, fastcgi server has close connection");
		return APR_EPIPE;
	}

	return errno;
}

static apr_status_t writev_it_all(fcgid_ipc * ipc_handle,
								  struct iovec *vec, int nvec)
{
	apr_size_t bytes_written = 0;
	apr_status_t rv;
	apr_size_t len = 0;
	int i = 0;
	int writecnt = 0;

	/* Calculate the total size */
	for (i = 0; i < nvec; i++) {
		len += vec[i].iov_len;
	}

	i = 0;
	while (bytes_written != len) {
		rv = socket_writev(ipc_handle, vec + i, nvec - i, &writecnt);
		if (rv != APR_SUCCESS)
			return rv;
		bytes_written += writecnt;

		if (bytes_written < len) {
			/* Skip over the vectors that have already been written */
			apr_size_t cnt = vec[i].iov_len;

			while (writecnt >= cnt && i + 1 < nvec) {
				i++;
				cnt += vec[i].iov_len;
			}

			if (writecnt < cnt) {
				/* Handle partial write of vec i */
				vec[i].iov_base = (char *) vec[i].iov_base +
					(vec[i].iov_len - (cnt - writecnt));
				vec[i].iov_len = cnt - writecnt;
			}
		}
	}

	return APR_SUCCESS;
}

#define FCGID_VEC_COUNT 8
apr_status_t proc_write_ipc(server_rec * main_server,
							fcgid_ipc * ipc_handle,
							apr_bucket_brigade * output_brigade)
{
	apr_status_t rv;
	struct iovec vec[FCGID_VEC_COUNT];
	int nvec = 0;
	apr_bucket *e;

	for (e = APR_BRIGADE_FIRST(output_brigade);
		 e != APR_BRIGADE_SENTINEL(output_brigade);
		 e = APR_BUCKET_NEXT(e)) {
		/* Read bucket */
		if ((rv = apr_bucket_read(e, (const char **) &vec[nvec].iov_base,
								  &vec[nvec].iov_len,
								  APR_BLOCK_READ)) != APR_SUCCESS)
			return rv;

		if (nvec == (FCGID_VEC_COUNT - 1)) {
			/* It's time to write now */
			if ((rv =
				 writev_it_all(ipc_handle, vec,
							   FCGID_VEC_COUNT)) != APR_SUCCESS)
				return rv;
			nvec = 0;
		} else
			nvec++;
	}

	/* There are something left */
	if (nvec != 0) {
		if ((rv = writev_it_all(ipc_handle, vec, nvec)) != APR_SUCCESS)
			return rv;
	}

	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 signal_info[HUGE_STRING_LEN];
	char key_name[_POSIX_PATH_MAX];
	int signum = exitcode;

	memset(signal_info, 0, HUGE_STRING_LEN);

	/* Get the file name infomation base on inode and deviceid */
	apr_snprintf(key_name, _POSIX_PATH_MAX, "%lX%lX",
				 procnode->inode, (unsigned long) procnode->deviceid);
	apr_pool_userdata_get((void **) &cgipath, key_name,
						  g_inode_cginame_map);

	/* Reasons to exit */
	switch (procnode->diewhy) {
	case FCGID_DIE_KILLSELF:
		diewhy = "normal exit";
		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";
		break;
	case FCGID_DIE_COMM_ERROR:
		diewhy = "communication error";
		break;
	case FCGID_DIE_SHUTDOWN:
		diewhy = "shutting down";
		break;
	default:
		diewhy = "unknow";
	}

	/* Get signal info */
	if (APR_PROC_CHECK_SIGNALED(exitwhy)) {
		switch (signum) {
		case SIGTERM:
		case SIGHUP:
		case AP_SIG_GRACEFUL:
		case SIGKILL:
			apr_snprintf(signal_info, HUGE_STRING_LEN - 1,
						 "get stop signal %d", signum);
			break;

		default:
			if (APR_PROC_CHECK_CORE_DUMP(exitwhy)) {
				apr_snprintf(signal_info, HUGE_STRING_LEN - 1,
							 "get signal %d, possible coredump generated",
							 signum);
			} else {
				apr_snprintf(signal_info, HUGE_STRING_LEN - 1,
							 "get unexpected signal %d", signum);
			}
		}
	} else if (APR_PROC_CHECK_EXIT(exitwhy)) {
		apr_snprintf(signal_info, HUGE_STRING_LEN - 1,
					 "terminated by calling exit(), return code: %d",
					 exitcode);
		if (procnode->diewhy == FCGID_DIE_CONNECT_ERROR)
			diewhy = "server exited";
	}

	/* Print log now */
	if (cgipath)
		ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, main_server,
					 "mod_fcgid: process %s(%d) exit(%s), %s",
					 cgipath, procnode->proc_id->pid, diewhy, signal_info);
	else
		ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, main_server,
					 "mod_fcgid: can't get cgi name while exiting, exitcode: %d",
					 exitcode);
}