/*
 * 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 "apr_strings.h"
#include "apr_portable.h"
#include "apr_pools.h"
#include "fcgid_global.h"
#include "fcgid_protocol.h"

static size_t init_environment(char *buf, char **envp)
{
	char *spliter;
	int namelen, valuelen;
	char *cur_buf = buf;
	size_t buffer_size = 0;

	for (; *envp != NULL; envp++) {
		spliter = strchr(*envp, '=');
		if (spliter == NULL)
			continue;

		namelen = spliter - *envp;
		valuelen = strlen(spliter + 1);

		/* Put name length to buffer */
		if (namelen < 0x80) {
			if (!buf)
				buffer_size++;
			else
				*cur_buf++ = (unsigned char) namelen;
		} else {
			if (!buf)
				buffer_size += 4;
			else {
				*cur_buf++ = (unsigned char) ((namelen >> 24) | 0x80);
				*cur_buf++ = (unsigned char) (namelen >> 16);
				*cur_buf++ = (unsigned char) (namelen >> 8);
				*cur_buf++ = (unsigned char) namelen;
			}
		}

		/* Put value length to buffer */
		if (valuelen < 0x80) {
			if (!buf)
				buffer_size++;
			else
				*cur_buf++ = (unsigned char) valuelen;
		} else {
			if (!buf)
				buffer_size += 4;
			else {
				*cur_buf++ = (unsigned char) ((valuelen >> 24) | 0x80);
				*cur_buf++ = (unsigned char) (valuelen >> 16);
				*cur_buf++ = (unsigned char) (valuelen >> 8);
				*cur_buf++ = (unsigned char) valuelen;
			}
		}

		/* Now the name and body buffer */
		if (!buf) {
			buffer_size += namelen;
			buffer_size += valuelen;
		} else {
			memcpy(cur_buf, *envp, namelen);
			cur_buf += namelen;
			memcpy(cur_buf, spliter + 1, valuelen);
			cur_buf += valuelen;
		}
	}
	return buffer_size;
}

static void
init_begin_request_body(int role,
						FCGI_BeginRequestBody * begin_request_body)
{
	begin_request_body->roleB1 = (unsigned char) (((role >> 8) & 0xff));
	begin_request_body->roleB0 = (unsigned char) (role & 0xff);
	begin_request_body->flags = 0;
	memset(begin_request_body->reserved, 0,
		   sizeof(begin_request_body->reserved));
}

int
init_header(int type, int requestId, apr_size_t contentLength,
			apr_size_t paddingLength, FCGI_Header * header)
{
	if (contentLength > 65535 || paddingLength > 255)
		return 0;
	header->version = FCGI_VERSION_1;
	header->type = (unsigned char) type;
	header->requestIdB1 = (unsigned char) ((requestId >> 8) & 0xff);
	header->requestIdB0 = (unsigned char) (requestId & 0xff);
	header->contentLengthB1 =
		(unsigned char) ((contentLength >> 8) & 0xff);
	header->contentLengthB0 = (unsigned char) ((contentLength) & 0xff);
	header->paddingLength = (unsigned char) paddingLength;
	header->reserved = 0;
	return 1;
}

int
build_begin_block(int role, server_rec * main_server,
				  apr_bucket_alloc_t * alloc,
				  apr_bucket_brigade * request_brigade)
{
	/* Alloc memory for begin request header & body */
	FCGI_Header *begin_request_header =
		apr_bucket_alloc(sizeof(FCGI_Header), alloc);
	FCGI_BeginRequestBody *begin_request_body =
		apr_bucket_alloc(sizeof(FCGI_BeginRequestBody), alloc);
	apr_bucket *bucket_header =
		apr_bucket_heap_create((const char *) begin_request_header,
							   sizeof(*begin_request_header),
							   apr_bucket_free,
							   alloc);
	apr_bucket *bucket_body =
		apr_bucket_heap_create((const char *) begin_request_body,
							   sizeof(*begin_request_body),
							   apr_bucket_free,
							   alloc);

	/* Sanity check */
	if (!begin_request_header || !begin_request_body
		|| !bucket_header || !bucket_body) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
					 main_server,
					 "mod_fcgid: can't alloc memeory for begin request");
		return 0;
	}

	/* Initialize begin request header and body */
	if (!init_header(FCGI_BEGIN_REQUEST, 1, sizeof(FCGI_BeginRequestBody),
					 0, begin_request_header)) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
					 main_server,
					 "mod_fcgid: can't init begin request header");
		return 0;
	}
	init_begin_request_body(role, begin_request_body);

	/* Append the header and body to request brigade */
	APR_BRIGADE_INSERT_TAIL(request_brigade, bucket_header);
	APR_BRIGADE_INSERT_TAIL(request_brigade, bucket_body);

	return 1;
}

int
build_env_block(server_rec * main_server, char **envp,
				apr_bucket_alloc_t * alloc,
				apr_bucket_brigade * request_brigade)
{
	/* Get the size of the destination buffer */
	apr_size_t bufsize = init_environment(NULL, envp);

	/* Alloc memory for environment header and body */
	FCGI_Header *env_request_header =
		apr_bucket_alloc(sizeof(FCGI_Header), alloc);
	FCGI_Header *env_empty_header =
		apr_bucket_alloc(sizeof(FCGI_Header), alloc);
	char *buf = apr_bucket_alloc(bufsize, alloc);
	apr_bucket *bucket_header = apr_bucket_heap_create((const char *)
													   env_request_header,
													   sizeof
													   (*env_request_header),
													   apr_bucket_free,
													   alloc);
	apr_bucket *bucket_body = apr_bucket_heap_create(buf, bufsize,
													 apr_bucket_free,
													 alloc);
	apr_bucket *bucket_empty_header = apr_bucket_heap_create((const char *)
															 env_empty_header,
															 sizeof
															 (*env_empty_header),
															 apr_bucket_free,
															 alloc);

	if (!env_request_header || !buf || !env_empty_header || !bucket_header
		|| !bucket_body || !bucket_empty_header) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
					 main_server,
					 "mod_fcgid: can't alloc memory for envion");
		return 0;
	}

	/* Initialize header and body */
	if (!init_header(FCGI_PARAMS, 1, bufsize, 0, env_request_header)
		|| !init_header(FCGI_PARAMS, 1, 0, 0, env_empty_header)) {
		ap_log_error(APLOG_MARK, APLOG_WARNING, apr_get_os_error(),
					 main_server,
					 "mod_fcgid: can't init env request header");
		return 0;
	}
	init_environment(buf, envp);

	/* Append the header and body to request brigade */
	APR_BRIGADE_INSERT_TAIL(request_brigade, bucket_header);
	APR_BRIGADE_INSERT_TAIL(request_brigade, bucket_body);
	APR_BRIGADE_INSERT_TAIL(request_brigade, bucket_empty_header);

	return 1;
}