/*
 * uhttpd - Tiny single-threaded httpd - Lua handler
 *
 *   Copyright (C) 2010 Jo-Philipp Wich <xm@subsignal.org>
 *
 *  Licensed 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 "uhttpd.h"
#include "uhttpd-utils.h"
#include "uhttpd-lua.h"


static int uh_lua_recv(lua_State *L)
{
	size_t length;
	char buffer[UH_LIMIT_MSGHEAD];
	ssize_t rlen = 0;
	fd_set reader;
	struct timeval timeout;

	length = luaL_checknumber(L, 1);

	if( (length > 0) && (length <= sizeof(buffer)) )
	{
		FD_ZERO(&reader);
		FD_SET(fileno(stdin), &reader);

		/* fail after 0.1s */
		timeout.tv_sec  = 0;
		timeout.tv_usec = 100000;

		/* check whether fd is readable */
		if( select(fileno(stdin) + 1, &reader, NULL, NULL, &timeout) > 0 )
		{
			/* receive data */
			rlen = read(fileno(stdin), buffer, length);
			lua_pushnumber(L, rlen);

			if( rlen > 0 )
			{
				lua_pushlstring(L, buffer, rlen);
				return 2;
			}

			return 1;
		}

		/* no, timeout and actually no data */
		lua_pushnumber(L, -2);
		return 1;
	}

	/* parameter error */
	lua_pushnumber(L, -3);
	return 1;
}

static int uh_lua_send_common(lua_State *L, int chunked)
{
	size_t length;
	const char *buffer;
	char chunk[16];
	ssize_t slen = 0;

	buffer = luaL_checklstring(L, 1, &length);

	if( chunked )
	{
		if( length > 0 )
		{
			snprintf(chunk, sizeof(chunk), "%X\r\n", length);
			slen =  write(fileno(stdout), chunk, strlen(chunk));
			slen += write(fileno(stdout), buffer, length);
			slen += write(fileno(stdout), "\r\n", 2);
		}
		else
		{
			slen = write(fileno(stdout), "0\r\n\r\n", 5);
		}
	}
	else
	{
		slen = write(fileno(stdout), buffer, length);
	}

	lua_pushnumber(L, slen);
	return 1;
}

static int uh_lua_send(lua_State *L)
{
	return uh_lua_send_common(L, 0);
}

static int uh_lua_sendc(lua_State *L)
{
	return uh_lua_send_common(L, 1);
}

static int uh_lua_urldecode(lua_State *L)
{
	size_t inlen, outlen;
	const char *inbuf;
	char outbuf[UH_LIMIT_MSGHEAD];

	inbuf = luaL_checklstring(L, 1, &inlen);
	outlen = uh_urldecode(outbuf, sizeof(outbuf), inbuf, inlen);

	lua_pushlstring(L, outbuf, outlen);
	return 1;
}


lua_State * uh_lua_init(const char *handler)
{
	lua_State *L = lua_open();
	const char *err_str = NULL;

	/* Load standard libaries */
	luaL_openlibs(L);

	/* build uhttpd api table */
	lua_newtable(L);

	/* register global send and receive functions */
	lua_pushcfunction(L, uh_lua_recv);
	lua_setfield(L, -2, "recv");

	lua_pushcfunction(L, uh_lua_send);
	lua_setfield(L, -2, "send");

	lua_pushcfunction(L, uh_lua_sendc);
	lua_setfield(L, -2, "sendc");

	lua_pushcfunction(L, uh_lua_urldecode);
	lua_setfield(L, -2, "urldecode");

	/* _G.uhttpd = { ... } */
	lua_setfield(L, LUA_GLOBALSINDEX, "uhttpd");


	/* load Lua handler */
	switch( luaL_loadfile(L, handler) )
	{
		case LUA_ERRSYNTAX:
			fprintf(stderr,
				"Lua handler contains syntax errors, unable to continue\n");
			exit(1);

		case LUA_ERRMEM:
			fprintf(stderr,
				"Lua handler ran out of memory, unable to continue\n");
			exit(1);

		case LUA_ERRFILE:
			fprintf(stderr,
				"Lua cannot open the handler script, unable to continue\n");
			exit(1);

		default:
			/* compile Lua handler */
			switch( lua_pcall(L, 0, 0, 0) )
			{
				case LUA_ERRRUN:
					err_str = luaL_checkstring(L, -1);
					fprintf(stderr,
						"Lua handler had runtime error, unable to continue\n"
						"Error: %s\n", err_str
					);
					exit(1);

				case LUA_ERRMEM:
					err_str = luaL_checkstring(L, -1);
					fprintf(stderr,
						"Lua handler ran out of memory, unable to continue\n"
						"Error: %s\n", err_str
					);
					exit(1);

				default:
					/* test handler function */
					lua_getglobal(L, UH_LUA_CALLBACK);

					if( ! lua_isfunction(L, -1) )
					{
						fprintf(stderr,
							"Lua handler provides no " UH_LUA_CALLBACK "(), unable to continue\n");
						exit(1);
					}

					lua_pop(L, 1);
					break;
			}

			break;
	}

	return L;
}

void uh_lua_request(struct client *cl, struct http_request *req, lua_State *L)
{
	pid_t pid;

	int i, data_sent;
	int content_length = 0;
	int buflen = 0;
	int fd_max = 0;
	char *query_string;
	const char *prefix = cl->server->conf->lua_prefix;
	const char *err_str = NULL;

	int rfd[2] = { 0, 0 };
	int wfd[2] = { 0, 0 };

	char buf[UH_LIMIT_MSGHEAD];

	fd_set reader;
	fd_set writer;

	struct timeval timeout;


	/* spawn pipes for me->child, child->me */
	if( (pipe(rfd) < 0) || (pipe(wfd) < 0) )
	{
		uh_http_sendhf(cl, 500, "Internal Server Error",
			"Failed to create pipe: %s", strerror(errno));

		if( rfd[0] > 0 ) close(rfd[0]);
		if( rfd[1] > 0 ) close(rfd[1]);
		if( wfd[0] > 0 ) close(wfd[0]);
		if( wfd[1] > 0 ) close(wfd[1]);

		return;
	}


	switch( (pid = fork()) )
	{
		case -1:
			uh_http_sendhf(cl, 500, "Internal Server Error",
				"Failed to fork child: %s", strerror(errno));
			break;

		case 0:
			/* child */
			close(rfd[0]);
			close(wfd[1]);

			/* patch stdout and stdin to pipes */
			dup2(rfd[1], 1);
			dup2(wfd[0], 0);

			/* put handler callback on stack */
			lua_getglobal(L, UH_LUA_CALLBACK);

			/* build env table */
			lua_newtable(L);

			/* request method */
			switch(req->method)
			{
				case UH_HTTP_MSG_GET:
					lua_pushstring(L, "GET");
					break;

				case UH_HTTP_MSG_HEAD:
					lua_pushstring(L, "HEAD");
					break;

				case UH_HTTP_MSG_POST:
					lua_pushstring(L, "POST");
					break;
			}

			lua_setfield(L, -2, "REQUEST_METHOD");

			/* request url */
			lua_pushstring(L, req->url);
			lua_setfield(L, -2, "REQUEST_URI");

			/* script name */
			lua_pushstring(L, cl->server->conf->lua_prefix);
			lua_setfield(L, -2, "SCRIPT_NAME");

			/* query string, path info */
			if( (query_string = strchr(req->url, '?')) != NULL )
			{
				lua_pushstring(L, query_string + 1);
				lua_setfield(L, -2, "QUERY_STRING");

				if( (int)(query_string - req->url) > strlen(prefix) )
				{
					lua_pushlstring(L,
						&req->url[strlen(prefix)],
						(int)(query_string - req->url) - strlen(prefix)
					);

					lua_setfield(L, -2, "PATH_INFO");
				}
			}
			else if( strlen(req->url) > strlen(prefix) )
			{
				lua_pushstring(L, &req->url[strlen(prefix)]);
				lua_setfield(L, -2, "PATH_INFO");
			}

			/* http protcol version */
			lua_pushnumber(L, floor(req->version * 10) / 10);
			lua_setfield(L, -2, "HTTP_VERSION");

			if( req->version > 1.0 )
				lua_pushstring(L, "HTTP/1.1");
			else
				lua_pushstring(L, "HTTP/1.0");

			lua_setfield(L, -2, "SERVER_PROTOCOL");


			/* address information */
			lua_pushstring(L, sa_straddr(&cl->peeraddr));
			lua_setfield(L, -2, "REMOTE_ADDR");

			lua_pushinteger(L, sa_port(&cl->peeraddr));
			lua_setfield(L, -2, "REMOTE_PORT");

			lua_pushstring(L, sa_straddr(&cl->servaddr));
			lua_setfield(L, -2, "SERVER_ADDR");

			lua_pushinteger(L, sa_port(&cl->servaddr));
			lua_setfield(L, -2, "SERVER_PORT");

			/* essential env vars */
			foreach_header(i, req->headers)
			{
				if( !strcasecmp(req->headers[i], "Content-Length") )
				{
					lua_pushnumber(L, atoi(req->headers[i+1]));
					lua_setfield(L, -2, "CONTENT_LENGTH");
				}
				else if( !strcasecmp(req->headers[i], "Content-Type") )
				{
					lua_pushstring(L, req->headers[i+1]);
					lua_setfield(L, -2, "CONTENT_TYPE");
				}
			}

			/* misc. headers */
			lua_newtable(L);

			foreach_header(i, req->headers)
			{
				if( strcasecmp(req->headers[i], "Content-Length") &&
					strcasecmp(req->headers[i], "Content-Type")
				) {
					lua_pushstring(L, req->headers[i+1]);
					lua_setfield(L, -2, req->headers[i]);
				}
			}

			lua_setfield(L, -2, "headers");


			/* call */
			switch( lua_pcall(L, 1, 0, 0) )
			{
				case LUA_ERRMEM:
				case LUA_ERRRUN:
					err_str = luaL_checkstring(L, -1);

					if( ! err_str )
						err_str = "Unknown error";

					printf(
						"HTTP/%.1f 500 Internal Server Error\r\n"
						"Connection: close\r\n"
						"Content-Type: text/plain\r\n"
						"Content-Length: %i\r\n\r\n"
						"Lua raised a runtime error:\n  %s\n",
							req->version, 31 + strlen(err_str), err_str
					);

					break;

				default:
					break;
			}

			close(wfd[0]);
			close(rfd[1]);
			exit(0);

			break;

		/* parent; handle I/O relaying */
		default:
			/* close unneeded pipe ends */
			close(rfd[1]);
			close(wfd[0]);

			/* max watch fd */
			fd_max = max(rfd[0], wfd[1]) + 1;

			/* find content length */
			if( req->method == UH_HTTP_MSG_POST )
			{
				foreach_header(i, req->headers)
				{
					if( ! strcasecmp(req->headers[i], "Content-Length") )
					{
						content_length = atoi(req->headers[i+1]);
						break;
					}
				}
			}


#define ensure(x) \
	do { if( x < 0 ) goto out; } while(0)

			data_sent = 0;

			/* I/O loop, watch our pipe ends and dispatch child reads/writes from/to socket */
			while( 1 )
			{
				FD_ZERO(&reader);
				FD_ZERO(&writer);

				FD_SET(rfd[0], &reader);
				FD_SET(wfd[1], &writer);

				timeout.tv_sec = 15;
				timeout.tv_usec = 0;

				/* wait until we can read or write or both */
				if( select(fd_max, &reader, (content_length > -1) ? &writer : NULL, NULL, &timeout) > 0 )
				{
					/* ready to write to Lua child */
					if( FD_ISSET(wfd[1], &writer) )
					{
						/* there is unread post data waiting */
						if( content_length > 0 )
						{
							/* read it from socket ... */
							if( (buflen = uh_tcp_recv(cl, buf, min(content_length, sizeof(buf)))) > 0 )
							{
								/* ... and write it to child's stdin */
								if( write(wfd[1], buf, buflen) < 0 )
									perror("write()");

								content_length -= buflen;
							}

							/* unexpected eof! */
							else
							{
								if( write(wfd[1], "", 0) < 0 )
									perror("write()");

								content_length = 0;
							}
						}

						/* there is no more post data, close pipe to child's stdin */
						else if( content_length > -1 )
						{
							close(wfd[1]);
							content_length = -1;
						}
					}

					/* ready to read from Lua child */
					if( FD_ISSET(rfd[0], &reader) )
					{
						/* read data from child ... */
						if( (buflen = read(rfd[0], buf, sizeof(buf))) > 0 )
						{
							/* pass through buffer to socket */
							ensure(uh_tcp_send(cl, buf, buflen));
							data_sent = 1;
						}

						/* looks like eof from child */
						else
						{
							/* error? */
							if( ! data_sent )
								uh_http_sendhf(cl, 500, "Internal Server Error",
									"The Lua child did not produce any response");

							break;
						}
					}
				}

				/* no activity for 15 seconds... looks dead */
				else
				{
					ensure(uh_http_sendhf(cl, 504, "Gateway Timeout",
						"The Lua handler took too long to produce a response"));

					break;
				}
			}

		out:
			close(rfd[0]);
			close(wfd[1]);

			break;
	}
}