/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "httpd.h"
#include "http_request.h"
#include "apr_strings.h"
#include "apr_portable.h"
#include "apr_pools.h"
#include "apr_file_io.h"
#include "util_script.h"
#include "fcgid_bridge.h"
#include "fcgid_pm.h"
#include "fcgid_proctbl.h"
#include "fcgid_proc.h"
#include "fcgid_conf.h"
#include "fcgid_spawn_ctl.h"
#include "fcgid_protocol.h"
#include "fcgid_bucket.h"
#define FCGID_APPLY_TRY_COUNT 2
#define FCGID_REQUEST_COUNT 32

static int g_variables_inited = 0;
static int g_busy_timeout;
static int g_connect_timeout;
static int g_comm_timeout;
static int g_max_requests_per_process;

static fcgid_procnode *apply_free_procnode(server_rec * main_server,
										   fcgid_command * command)
{
	/* Scan idle list, find a node match inode, deviceid and groupid
	   If there is no one there, return NULL */
	fcgid_procnode *previous_node, *current_node, *next_node;
	fcgid_procnode *busy_list_header, *proc_table;
	apr_ino_t inode = command->inode;
	apr_dev_t deviceid = command->deviceid;
	uid_t uid = command->uid;
	gid_t gid = command->gid;
	apr_size_t share_grp_id = command->share_grp_id;
	char *virtualhost = command->virtualhost;

	proc_table = proctable_get_table_array();
	previous_node = proctable_get_idle_list();
	busy_list_header = proctable_get_busy_list();

	safe_lock(main_server);
	current_node = &proc_table[previous_node->next_index];
	while (current_node != proc_table) {
		next_node = &proc_table[current_node->next_index];

		if (current_node->inode == inode
			&& current_node->deviceid == deviceid
			&& current_node->share_grp_id == share_grp_id
			&& current_node->virtualhost == virtualhost
			&& current_node->uid == uid && current_node->gid == gid) {
			/* Unlink from idle list */
			previous_node->next_index = current_node->next_index;

			/* Link to busy list */
			current_node->next_index = busy_list_header->next_index;
			busy_list_header->next_index = current_node - proc_table;

			safe_unlock(main_server);
			return current_node;
		} else
			previous_node = current_node;

		current_node = next_node;
	}
	safe_unlock(main_server);

	/* Found nothing */
	return NULL;
}

static void
return_procnode(server_rec * main_server,
				fcgid_procnode * procnode, int communicate_error)
{
	fcgid_procnode *previous_node, *current_node, *next_node;
	fcgid_procnode *proc_table = proctable_get_table_array();
	fcgid_procnode *error_list_header = proctable_get_error_list();
	fcgid_procnode *idle_list_header = proctable_get_idle_list();
	fcgid_procnode *busy_list_header = proctable_get_busy_list();

	safe_lock(main_server);

	/* Unlink the node from busy list first */
	previous_node = busy_list_header;
	current_node = &proc_table[previous_node->next_index];
	while (current_node != proc_table) {
		next_node = &proc_table[current_node->next_index];
		if (current_node == procnode) {
			/* Unlink from busy list */
			previous_node->next_index = current_node->next_index;
			break;
		} else
			previous_node = current_node;
		current_node = next_node;
	}

	/* Return to error list or idle list */
	if (communicate_error) {
		/* Link to error list */
		procnode->next_index = error_list_header->next_index;
		error_list_header->next_index = procnode - proc_table;
	} else {
		/* Link to idle list */
		procnode->next_index = idle_list_header->next_index;
		idle_list_header->next_index = procnode - proc_table;
	}

	safe_unlock(main_server);
}

static int
count_busy_processes(server_rec * main_server, fcgid_command * command)
{
	int result = 0;
	fcgid_procnode *previous_node, *current_node, *next_node;
	fcgid_procnode *proc_table = proctable_get_table_array();
	fcgid_procnode *busy_list_header = proctable_get_busy_list();

	safe_lock(main_server);

	previous_node = busy_list_header;
	current_node = &proc_table[previous_node->next_index];
	while (current_node != proc_table) {
		if (current_node->inode == command->inode
			&& current_node->deviceid == command->deviceid
			&& current_node->share_grp_id == command->share_grp_id
			&& current_node->virtualhost == command->virtualhost
			&& current_node->uid == command->uid
			&& current_node->gid == command->gid) {
			result++;
		}
		next_node = &proc_table[current_node->next_index];
		current_node = next_node;
	}

	safe_unlock(main_server);

	return result;
}

apr_status_t bucket_ctx_cleanup(void *thectx)
{
	/* Cleanup jobs:
	   1. Free bucket buffer
	   2. Return procnode
	   NOTE: ipc will be clean when request pool cleanup, so I don't need to close it here
	 */
	fcgid_bucket_ctx *ctx = (fcgid_bucket_ctx *) thectx;
	server_rec *main_server = ctx->ipc.request->server;

	/* Free bucket buffer */
	if (ctx->buffer) {
		apr_bucket_destroy(ctx->buffer);
		ctx->buffer = NULL;
	}

	proc_close_ipc(main_server, &ctx->ipc);

	if (ctx->procnode) {
		/* Return procnode
		   I will return this slot to idle(or error) list except:
		   I take too much time on this request( greater than get_busy_timeout() ),
		   so the process manager may have put this slot from busy list to error
		   list, and the contain of this slot may have been modified
		   In this case I will do nothing and return, let the process manager 
		   do the job   
		 */
		int dt =
			apr_time_sec(apr_time_now()) - apr_time_sec(ctx->active_time);
		if (dt > g_busy_timeout) {
			/* Do nothing but print log */
			ap_log_error(APLOG_MARK, APLOG_INFO, 0,
						 main_server,
						 "mod_fcgid: process busy timeout, take %d seconds for this request",
						 dt);
		} else if (ctx->has_error) {
			ctx->procnode->diewhy = FCGID_DIE_COMM_ERROR;
			return_procnode(main_server, ctx->procnode,
							1 /* communication error */ );
		} else if (g_max_requests_per_process != -1
				   && ++ctx->procnode->requests_handled >=
				   g_max_requests_per_process) {
			ctx->procnode->diewhy = FCGID_DIE_LIFETIME_EXPIRED;
			return_procnode(main_server, ctx->procnode,
							1 /* handled all requests */ );
		} else
			return_procnode(main_server, ctx->procnode,
							0 /* communication ok */ );

		ctx->procnode = NULL;
	}

	return APR_SUCCESS;
}

static int getsfunc_fcgid_BRIGADE(char *buf, int len, void *arg)
{
	apr_bucket_brigade *bb = (apr_bucket_brigade *) arg;
	const char *dst_end = buf + len - 1;	/* leave room for terminating null */
	char *dst = buf;
	apr_bucket *e = APR_BRIGADE_FIRST(bb);
	apr_status_t rv;
	int done = 0;
	int getLF = 0;
	int getColon = 0;

	while ((dst < dst_end) && !done && !APR_BUCKET_IS_EOS(e)) {
		const char *bucket_data;
		apr_size_t bucket_data_len;
		const char *src;
		const char *src_end;
		apr_bucket *next;

		rv = apr_bucket_read(e, &bucket_data, &bucket_data_len,
							 APR_BLOCK_READ);
		if (rv != APR_SUCCESS) {
			return 0;
		}

		/* Move on to next bucket if it's fastcgi header bucket */
		if (e->type == &ap_bucket_type_fcgid_header
			|| e->type == &apr_bucket_type_immortal) {
			next = APR_BUCKET_NEXT(e);
			apr_bucket_delete(e);
			e = next;
			if (getLF) {
				done = 1;
			}
			continue;
		}

		if (bucket_data_len == 0)
			return 0;

		/* Base on RFC2616 section 4.2 */
		src = bucket_data;
		src_end = bucket_data + bucket_data_len;
		while ((src < src_end) && (dst < dst_end) && !done) {
			if (*src == ':')
				getColon = 1;

			if (getLF && ((*src != ' ' && *src != '\t') || !getColon)) {
				done = 1;
				getColon = 0;
				break;
			} else if (getLF && (*src == ' ' || *src == '\t')) {
				*dst++ = '\r';
				*dst++ = '\n';
				getLF = 0;
			}

			if (*src == '\n') {
				getLF = 1;
			} else if (*src != '\r') {
				*dst++ = *src;
			}
			src++;
		}

		if (src < src_end) {
			apr_bucket_split(e, src - bucket_data);
		}
		next = APR_BUCKET_NEXT(e);
		apr_bucket_delete(e);
		e = next;
	}
	*dst = 0;
	return 1;
}

static int
handle_request(request_rec * r, int role, const char *argv0,
			   fcgid_wrapper_conf * wrapper_conf,
			   apr_bucket_brigade * output_brigade)
{
	apr_pool_t *request_pool = r->main ? r->main->pool : r->pool;
	server_rec *main_server = r->server;
	fcgid_command fcgi_request;
	fcgid_bucket_ctx *bucket_ctx;
	int i, j, cond_status;
	apr_status_t rv;
	apr_bucket_brigade *brigade_stdout;
	char sbuf[MAX_STRING_LEN];
	const char *location;

	if (!g_variables_inited) {
		g_connect_timeout = get_ipc_connect_timeout(r->server);
		g_comm_timeout = get_ipc_comm_timeout(r->server);
		g_busy_timeout = get_busy_timeout(r->server);
		g_max_requests_per_process =
			get_max_requests_per_process(r->server);
		if (g_comm_timeout == 0)
			g_comm_timeout = 1;
		g_variables_inited = 1;
	}

	bucket_ctx = apr_pcalloc(request_pool, sizeof(*bucket_ctx));
	if (!bucket_ctx) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
					 r->server,
					 "mod_fcgid: apr_calloc bucket_ctx failed in handle_request function");
		return HTTP_INTERNAL_SERVER_ERROR;
	}
	bucket_ctx->ipc.connect_timeout = g_connect_timeout;
	bucket_ctx->ipc.communation_timeout = g_comm_timeout;
	bucket_ctx->ipc.request = r;
	apr_pool_cleanup_register(request_pool, bucket_ctx,
							  bucket_ctx_cleanup, apr_pool_cleanup_null);

	/* Try to get a connected ipc handle */
	for (i = 0; i < FCGID_REQUEST_COUNT; i++) {
		/* Apply a free process slot, send a spawn request if I can't get one */
		for (j = 0; j < FCGID_APPLY_TRY_COUNT; j++) {
			apr_ino_t inode =
				wrapper_conf ? wrapper_conf->inode : r->finfo.inode;
			apr_dev_t deviceid =
				wrapper_conf ? wrapper_conf->deviceid : r->finfo.device;
			apr_size_t shareid =
				wrapper_conf ? wrapper_conf->share_group_id : 0;

			/* Init spawn request */
			procmgr_init_spawn_cmd(&fcgi_request, r, argv0, deviceid,
								   inode, shareid);

			/* Apply a process slot */
			bucket_ctx->procnode =
				apply_free_procnode(r->server, &fcgi_request);
			if (bucket_ctx->procnode)
				break;

			/* Avoid sleeping the very first time through if there are no
			   busy processes; the problem is just that we haven't spawned
			   anything yet, so waiting is pointless */
			if (i > 0 || j > 0
				|| count_busy_processes(r->server, &fcgi_request)) {
				apr_sleep(apr_time_from_sec(1));

				bucket_ctx->procnode =
					apply_free_procnode(r->server, &fcgi_request);
				if (bucket_ctx->procnode)
					break;
			}

			/* Send a spawn request if I can't get a process slot */
			procmgr_post_spawn_cmd(&fcgi_request, r);
		}

		/* Connect to the fastcgi server */
		if (bucket_ctx->procnode) {
			if (proc_connect_ipc
				(r->server, bucket_ctx->procnode,
				 &bucket_ctx->ipc) != APR_SUCCESS) {
				proc_close_ipc(r->server, &bucket_ctx->ipc);
				bucket_ctx->procnode->diewhy = FCGID_DIE_CONNECT_ERROR;
				return_procnode(r->server, bucket_ctx->procnode,
								1 /* has error */ );
				bucket_ctx->procnode = NULL;
			} else
				break;
		}
	}

	/* Now I get a connected ipc handle */
	if (!bucket_ctx->procnode) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, 0, r->server,
					 "mod_fcgid: can't apply process slot for %s", argv0);
		return HTTP_SERVICE_UNAVAILABLE;
	}
	bucket_ctx->active_time = bucket_ctx->procnode->last_active_time =
		apr_time_now();

	/* Write output_brigade to fastcgi server */
	if ((rv =
		 proc_write_ipc(main_server, &bucket_ctx->ipc,
						output_brigade)) != APR_SUCCESS) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, rv, r->server,
					 "mod_fcgid: write data to fastcgi server error");
		bucket_ctx->has_error = 1;
		return HTTP_INTERNAL_SERVER_ERROR;
	}

	/* Create brigade */
	brigade_stdout =
		apr_brigade_create(request_pool, r->connection->bucket_alloc);
	if (!brigade_stdout) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, rv, r->server,
					 "mod_fcgid: apr_brigade_create failed in handle_request function");
		return HTTP_INTERNAL_SERVER_ERROR;
	}
	APR_BRIGADE_INSERT_TAIL(brigade_stdout,
							ap_bucket_fcgid_header_create(r->connection->
														  bucket_alloc,
														  bucket_ctx));
	/*APR_BRIGADE_INSERT_TAIL(brigade_stdout, apr_bucket_flush_create(r->connection->bucket_alloc)); */

	/* Check the script header first. If got error, return immediately */
	if ((cond_status = ap_scan_script_header_err_core
		 (r, sbuf, getsfunc_fcgid_BRIGADE, brigade_stdout)) >= 400)
		return cond_status;

	/* Check redirect */
	location = apr_table_get(r->headers_out, "Location");

	if (location && location[0] == '/' && r->status == 200) {
		/* This redirect needs to be a GET no matter what the original 
		 * method was. 
		 */
		r->method = apr_pstrdup(r->pool, "GET");
		r->method_number = M_GET;

		/* We already read the message body (if any), so don't allow 
		 * the redirected request to think it has one. We can ignore 
		 * Transfer-Encoding, since we used REQUEST_CHUNKED_ERROR. 
		 */
		apr_table_unset(r->headers_in, "Content-Length");

		ap_internal_redirect_handler(location, r);
		return HTTP_OK;
	} else if (location && r->status == 200) {
		/* XX Note that if a script wants to produce its own Redirect 
		 * body, it now has to explicitly *say* "Status: 302" 
		 */
		return HTTP_MOVED_TEMPORARILY;
	}

	/* Now pass to output filter */
	if (role == FCGI_RESPONDER && (rv =
								   ap_pass_brigade(r->output_filters,
												   brigade_stdout)) !=
		APR_SUCCESS) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, rv, r->server,
					 "mod_fcgid: ap_pass_brigade failed in handle_request function");
		return HTTP_INTERNAL_SERVER_ERROR;
	}

	/* Retrun condition status */
	return cond_status;
}

int bridge_request(request_rec * r, int role, const char *argv0,
				   fcgid_wrapper_conf * wrapper_conf)
{
	apr_pool_t *request_pool = r->main ? r->main->pool : r->pool;
	server_rec *main_server = r->server;
	apr_status_t rv = APR_SUCCESS;
	int seen_eos;
	size_t request_size = 0;
	apr_file_t *fd = NULL;
	int need_truncate = 1;
	apr_off_t cur_pos = 0;
	FCGI_Header *stdin_request_header;
	apr_bucket_brigade *output_brigade;
	apr_bucket *bucket_input, *bucket_header, *bucket_eos;
	size_t max_request_len = get_max_request_len(main_server);
	size_t max_mem_request_len = get_max_mem_request_len(main_server);
	char **envp = ap_create_environment(request_pool,
										r->subprocess_env);

	/* Create brigade for the request to fastcgi server */
	output_brigade =
		apr_brigade_create(request_pool, r->connection->bucket_alloc);
	if (!output_brigade) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
					 main_server,
					 "mod_fcgid: can't alloc memory for output brigade");
		return HTTP_INTERNAL_SERVER_ERROR;
	}

	/* Build the begin request and environ request, append them to output_brigade */
	if (!build_begin_block
		(role, r->server, r->connection->bucket_alloc, output_brigade)
		|| !build_env_block(r->server, envp, r->connection->bucket_alloc,
							output_brigade)) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, 0,
					 main_server,
					 "mod_fcgid: can't build begin or env request");
		return HTTP_INTERNAL_SERVER_ERROR;
	}

	/* Stdin header and body */
	/* XXX HACK: I have to read all the request into memory before sending it 
	   to fastcgi application server, this prevents slow clients from 
	   keeping the server in processing too long. 
	   Buf sometimes it's not acceptable(think about uploading a larage attachment)
	   file_bucket is a better choice in this case...
	   To do, or not to do, that is the question ^_^
	 */
	seen_eos = 0;
	do {
		apr_bucket_brigade *input_brigade =
			apr_brigade_create(request_pool,
							   r->connection->bucket_alloc);

		if (!input_brigade
			|| (rv = ap_get_brigade(r->input_filters, input_brigade,
									AP_MODE_READBYTES,
									APR_BLOCK_READ,
									HUGE_STRING_LEN)) != APR_SUCCESS) {
			ap_log_error(APLOG_MARK, APLOG_WARNING, rv,
						 main_server,
						 "mod_fcgid: can't get data from http client");
			apr_brigade_destroy(output_brigade);
			if (input_brigade)
				apr_brigade_destroy(input_brigade);
			return HTTP_INTERNAL_SERVER_ERROR;
		}

		request_size = 0;
		for (bucket_input = APR_BRIGADE_FIRST(input_brigade);
			 bucket_input != APR_BRIGADE_SENTINEL(input_brigade);
			 bucket_input = APR_BUCKET_NEXT(bucket_input)) {
			const char *data;
			apr_size_t len;
			apr_bucket *bucket_stdin;

			if (APR_BUCKET_IS_EOS(bucket_input)) {
				seen_eos = 1;
				break;
			}

			if (APR_BUCKET_IS_METADATA(bucket_input))
				continue;

			if ((rv = apr_bucket_read(bucket_input, &data, &len,
									  APR_BLOCK_READ)) != APR_SUCCESS) {
				ap_log_error(APLOG_MARK, APLOG_WARNING, rv,
							 main_server,
							 "mod_fcgid: can't read request from HTTP client");
				apr_brigade_destroy(input_brigade);
				apr_brigade_destroy(output_brigade);
				return HTTP_INTERNAL_SERVER_ERROR;
			}

			/* Append a header, and the the bucket */
			stdin_request_header = apr_bucket_alloc(sizeof(FCGI_Header),
													r->connection->
													bucket_alloc);
			bucket_header =
				apr_bucket_heap_create((const char *) stdin_request_header,
									   sizeof(*stdin_request_header),
									   apr_bucket_free,
									   r->connection->bucket_alloc);

			request_size += len;
			if (request_size > max_request_len) {
				ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
							 main_server,
							 "mod_fcgid: http request length %d > %d",
							 request_size, max_request_len);
				return HTTP_INTERNAL_SERVER_ERROR;
			}

			if (request_size > max_mem_request_len) {
				apr_size_t wrote_len;
				static const char *fd_key = "fcgid_fd";

				if (fd == NULL)
					apr_pool_userdata_get((void **) &fd, fd_key,
										  r->connection->pool);

				if (fd == NULL) {
					const char *tempdir = NULL;
					char *template;

					rv = apr_temp_dir_get(&tempdir, r->pool);
					if (rv != APR_SUCCESS) {
						ap_log_error(APLOG_MARK, APLOG_WARNING,
									 apr_get_os_error(), main_server,
									 "mod_fcigd: can't get tmp dir");
						return HTTP_INTERNAL_SERVER_ERROR;
					}

					apr_filepath_merge(&template, tempdir,
									   "fcgid.tmp.XXXXXX",
									   APR_FILEPATH_NATIVE, r->pool);
					rv = apr_file_mktemp(&fd, template, 0,
										 r->connection->pool);
					if (rv != APR_SUCCESS) {
						ap_log_error(APLOG_MARK, APLOG_WARNING,
									 apr_get_os_error(), main_server,
									 "mod_fcgid: can't open tmp file fot stdin request");
						return HTTP_INTERNAL_SERVER_ERROR;
					}
					apr_pool_userdata_set((const void *) fd, fd_key,
										  apr_pool_cleanup_null,
										  r->connection->pool);
				} else if (need_truncate) {
					need_truncate = 0;
					apr_file_trunc(fd, 0);
					cur_pos = 0;
				}
				// Write request to tmp file
				if ((rv =
					 apr_file_write_full(fd, (const void *) data, len,
										 &wrote_len)) != APR_SUCCESS
					|| len != wrote_len) {
					ap_log_error(APLOG_MARK, APLOG_WARNING,
								 apr_get_os_error(), main_server,
								 "mod_fcgid: can't write tmp file for stdin request");
					return HTTP_INTERNAL_SERVER_ERROR;
				}
				// Create file bucket
				bucket_stdin =
					apr_bucket_file_create(fd, cur_pos, len, r->pool,
										   r->connection->bucket_alloc);
				cur_pos += len;
			} else {
				if (APR_BUCKET_IS_HEAP(bucket_input))
					apr_bucket_copy(bucket_input, &bucket_stdin);
				else {
					/* mod_ssl have a bug? */
					char *pcopydata =
						apr_bucket_alloc(len, r->connection->bucket_alloc);
					memcpy(pcopydata, data, len);
					bucket_stdin =
						apr_bucket_heap_create(pcopydata, len,
											   apr_bucket_free,
											   r->connection->
											   bucket_alloc);
				}
			}

			if (!stdin_request_header || !bucket_header || !bucket_stdin
				|| !init_header(FCGI_STDIN, 1, len, 0,
								stdin_request_header)) {
				ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
							 main_server,
							 "mod_fcgid: can't alloc memory for stdin request");
				apr_brigade_destroy(input_brigade);
				apr_brigade_destroy(output_brigade);
				return HTTP_INTERNAL_SERVER_ERROR;
			}
			APR_BRIGADE_INSERT_TAIL(output_brigade, bucket_header);
			APR_BRIGADE_INSERT_TAIL(output_brigade, bucket_stdin);
		}

		apr_brigade_destroy(input_brigade);
	}
	while (!seen_eos);

	/* Append an empty body stdin header */
	stdin_request_header = apr_bucket_alloc(sizeof(FCGI_Header),
											r->connection->bucket_alloc);
	bucket_header =
		apr_bucket_heap_create((const char *) stdin_request_header,
							   sizeof(*stdin_request_header),
							   apr_bucket_free,
							   r->connection->bucket_alloc);
	if (!stdin_request_header || !bucket_header
		|| !init_header(FCGI_STDIN, 1, 0, 0, stdin_request_header)) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
					 main_server,
					 "mod_fcgid: can't alloc memory for stdin request");
		return HTTP_INTERNAL_SERVER_ERROR;
	}
	APR_BRIGADE_INSERT_TAIL(output_brigade, bucket_header);

	/* The eos bucket now */
	bucket_eos = apr_bucket_eos_create(r->connection->bucket_alloc);
	if (!bucket_eos) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
					 main_server,
					 "mod_fcgid: can't alloc memory for eos bucket");
		return HTTP_INTERNAL_SERVER_ERROR;
	}
	APR_BRIGADE_INSERT_TAIL(output_brigade, bucket_eos);

	/* Bridge the request */
	return handle_request(r, role, argv0, wrapper_conf, output_brigade);
}