path: root/src/gnutls_lua.c

/**
 *  Copyright 2004-2005 Paul Querna
 *
 *  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 "mod_gnutls.h"

#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"

#include <ctype.h>

static char *MGS_LUA_RRKEY = "request_rec";

static request_rec *mgs_lua_getrr(lua_State * lvm)
{
	request_rec *r;

	/* Push the request_rec off the registry, onto the stack. */
	lua_pushlightuserdata(lvm, MGS_LUA_RRKEY);
	lua_gettable(lvm, LUA_REGISTRYINDEX);
	r = lua_touserdata(lvm, -1);
	lua_pop(lvm, 1);
	return r;
}

static int get_request_table(lua_State * lvm, long offset)
{
	const char *key;
	request_rec *r;
	const char *value;
	apr_table_t *t;
	key = luaL_checkstring(lvm, 1);

	r = mgs_lua_getrr(lvm);

	t = *(apr_table_t **) ((char *) r + offset);

	value = apr_table_get(t, key);

	if (value) {
		lua_pushstring(lvm, value);
		return 1;
	} else {
		return 0;
	}
}

static int mgs_lua_getenv(lua_State * lvm)
{
	return get_request_table(lvm,
				 APR_OFFSETOF(request_rec,
					      subprocess_env));
}

static int mgs_lua_getheader(lua_State * lvm)
{
	return get_request_table(lvm,
				 APR_OFFSETOF(request_rec, headers_in));
}

static const luaL_reg mgs_lua_reg[] = {
	{"getenv", mgs_lua_getenv},
	{"header", mgs_lua_getheader},
	{NULL, NULL}
};

lua_State *get_luastate()
{
	lua_State *lvm = lua_open();
	luaopen_base(lvm);
	luaopen_io(lvm);
	luaopen_table(lvm);
	luaopen_string(lvm);
	luaopen_math(lvm);
	luaopen_loadlib(lvm);
	luaL_openlib(lvm, "ap", mgs_lua_reg, 0);

	return lvm;
}

int mgs_authz_lua(request_rec * r)
{
	int rv;
	lua_State *lvm;
	mgs_dirconf_rec *dc = ap_get_module_config(r->per_dir_config,
						   &gnutls_module);

	if (dc->lua_bytecode_len <= 0) {
		return 0;
	}

	lvm = get_luastate();
	lua_pushlightuserdata(lvm, MGS_LUA_RRKEY);
	lua_pushlightuserdata(lvm, r);
	lua_settable(lvm, LUA_REGISTRYINDEX);

	/* Push Bytecode onto the stack */
	rv = luaL_loadbuffer(lvm, dc->lua_bytecode, dc->lua_bytecode_len,
			     "gnutls-lua");

	if (rv != 0) {
		/* Get the Error message */
		const char *error = lua_tostring(lvm, -1);
		ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
			      "GnuTLS: Error Loading Lua Bytecode: %s",
			      error);
		lua_pop(lvm, 1);
		return -1;
	}

	rv = lua_pcall(lvm, 0, 1, 0);
	if (rv != 0) {
		/* Get the Error message */
		const char *error = lua_tostring(lvm, -1);
		ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
			      "GnuTLS: Error Running Lua: %s", error);
		lua_pop(lvm, 1);
		return -1;
	}

	rv = (int) lua_tonumber(lvm, -1);
	ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
		      "GnuTLS: (%d) Lua Return: %d",
		      dc->lua_bytecode_len, rv);
	lua_pop(lvm, 1);
	lua_close(lvm);
	return rv;
}

static apr_size_t config_getstr(ap_configfile_t * cfg, char *buf,
				size_t bufsiz)
{
	apr_size_t i = 0;

	if (cfg->getstr) {
		const char *res = (cfg->getstr) (buf, bufsiz, cfg->param);
		if (res) {
			i = strlen(buf);
			if (i && buf[i - 1] == '\n')
				++cfg->line_number;
		} else {
			buf[0] = '\0';
			i = 0;
		}
	} else {
		while (i < bufsiz) {
			int ch = (cfg->getch) (cfg->param);
			if (ch == EOF)
				break;
			buf[i++] = ch;
			if (ch == '\n') {
				++cfg->line_number;
				break;
			}
		}
	}
	return i;
}

struct cr_ctx {
	ap_configfile_t *cfp;
	size_t startline;
	char buf[HUGE_STRING_LEN];
};

static const char *LUACMD = "gnutlsrequire";
static const char *lf =
    "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n";
#define N_LF 32

static const char *direct_chunkreader(lua_State * lvm, void *udata,
				      size_t * plen)
{
	const char *p;
	struct cr_ctx *ctx = udata;

	if (ctx->startline) {
		*plen = ctx->startline > N_LF ? N_LF : ctx->startline;
		ctx->startline -= *plen;
		return lf;
	}
	*plen = config_getstr(ctx->cfp, ctx->buf, HUGE_STRING_LEN);

	for (p = ctx->buf; isspace(*p); ++p);
	if (p[0] == '<' && p[1] == '/') {
		int i = 0;
		while (i < strlen(LUACMD)) {
			if (tolower(p[i + 2]) != LUACMD[i])
				return ctx->buf;
			++i;
		}
		*plen = 0;
		return NULL;
	}
	return ctx->buf;
}

static int ldump_writer(lua_State * L, const void *b, size_t size, void *B)
{
	(void) L;
	luaL_addlstring((luaL_Buffer *) B, (const char *) b, size);
	return 1;
}

/* a bytecode buffer*/
typedef struct bcbuf_ctx {
	apr_size_t buflen;
	char *buf;
} bcbuf_ctx;

const char *mgs_set_require_section(cmd_parms * cmd, void *mconfig,
				    const char *arg)
{
	apr_size_t bytecode_len;
	const char *bytecode;
	bcbuf_ctx *bcbuf;
	luaL_Buffer b;
	ap_directive_t **current = mconfig;
	struct cr_ctx ctx[1];
	int result;
	const char *filename =
	    apr_psprintf(cmd->pool, "@%s", cmd->config_file->name);
	// get a word argument
	const char *word;
	apr_size_t wordlen;
	lua_State *lvm = get_luastate();

	word = ap_getword_conf(cmd->pool, &arg);
	wordlen = strlen(word);
	do {
		if (wordlen) {
			if (word[wordlen - 1] == '>') {
				--wordlen;
				break;
			}
			if (*arg == '>')
				break;
		}
		return apr_pstrcat(cmd->pool, "<", LUACMD,
				   "> takes exactly one argument", NULL);
	} while (0);

	ctx->cfp = cmd->config_file;
	ctx->startline = cmd->config_file->line_number;
	lua_settop(lvm, 0);
	result = lua_load(lvm, direct_chunkreader, ctx, filename);

	if (result != 0) {
		word =
		    apr_pstrcat(cmd->pool, "Lua Error:",
				lua_tostring(lvm, -1), NULL);
		lua_close(lvm);
		return word;
	} else {
		luaL_buffinit(lvm, &b);
		lua_dump(lvm, ldump_writer, &b);
		luaL_pushresult(&b);
		bytecode = lua_tostring(lvm, -1);
		bytecode_len = lua_strlen(lvm, -1);
	}

	/* Here, we have to replace our current config node for the next pass */
	if (!*current) {
		*current = apr_pcalloc(cmd->pool, sizeof(**current));
	}

	(*current)->filename = cmd->config_file->name;
	(*current)->line_num = ctx->startline;
	(*current)->directive =
	    apr_pstrdup(cmd->pool, "GnuTLSRequireByteCode");
	(*current)->args = NULL;

	bcbuf = apr_pcalloc(cmd->pool, sizeof(bcbuf));
	bcbuf->buflen = bytecode_len;
	bcbuf->buf = apr_pstrmemdup(cmd->pool, bytecode, bytecode_len);

	(*current)->data = bcbuf;
	lua_close(lvm);
	return NULL;
}

const char *mgs_set_require_bytecode(cmd_parms * cmd, void *mconfig,
				     const char *arg)
{
	bcbuf_ctx *bcbuf;
	ap_directive_t *directive = cmd->directive;
	mgs_dirconf_rec *dc = mconfig;

	bcbuf = directive->data;
	dc->lua_bytecode_len = bcbuf->buflen;
	dc->lua_bytecode =
	    apr_pstrmemdup(cmd->pool, bcbuf->buf, bcbuf->buflen);

	return NULL;
}