lighttpd
/
lighttpd1.4
2
0
Fork 0
Code Issues Releases Wiki Activity
lighttpd 1.4.x https://www.lighttpd.net/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3317 Commits
8 Branches
78 Tags
45 MiB
 
 
 
 
 
 
Tree: f47ffb438c
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'f47ffb438c'
${ noResults }
lighttpd1.4/src/mod_magnet.c

1065 lines
33 KiB
Raw Blame History

#include "first.h"
#include "base.h"
#include "log.h"
#include "buffer.h"
#include "http_chunk.h"
#include "http_header.h"
#include "plugin.h"
#include "mod_magnet_cache.h"
#include "sock_addr.h"
#include "stat_cache.h"
#include "status_counter.h"
#include "etag.h"
#include <stdlib.h>
#include <string.h>
#include <setjmp.h>
#include <lua.h>
#include <lauxlib.h>
#define LUA_RIDX_LIGHTTPD_REQUEST "lighty.request"
#define MAGNET_RESTART_REQUEST 99
/* plugin config for all request/connections */
static jmp_buf exceptionjmp;
typedef struct {
const array *url_raw;
const array *physical_path;
} plugin_config;
typedef struct {
PLUGIN_DATA;
plugin_config defaults;
plugin_config conf;
script_cache cache;
} plugin_data;
INIT_FUNC(mod_magnet_init) {
return calloc(1, sizeof(plugin_data));
}
FREE_FUNC(mod_magnet_free) {
plugin_data *p = p_d;
script_cache_free_data(&p->cache);
}
static void mod_magnet_merge_config_cpv(plugin_config * const pconf, const config_plugin_value_t * const cpv) {
switch (cpv->k_id) { /* index into static config_plugin_keys_t cpk[] */
case 0: /* magnet.attract-raw-url-to */
pconf->url_raw = cpv->v.a;
break;
case 1: /* magnet.attract-physical-path-to */
pconf->physical_path = cpv->v.a;
break;
default:/* should not happen */
return;
}
}
static void mod_magnet_merge_config(plugin_config * const pconf, const config_plugin_value_t *cpv) {
do {
mod_magnet_merge_config_cpv(pconf, cpv);
} while ((++cpv)->k_id != -1);
}
static void mod_magnet_patch_config(request_st * const r, plugin_data * const p) {
p->conf = p->defaults; /* copy small struct instead of memcpy() */
/*memcpy(&p->conf, &p->defaults, sizeof(plugin_config));*/
for (int i = 1, used = p->nconfig; i < used; ++i) {
if (config_check_cond(r, (uint32_t)p->cvlist[i].k_id))
mod_magnet_merge_config(&p->conf, p->cvlist + p->cvlist[i].v.u2[0]);
}
}
SETDEFAULTS_FUNC(mod_magnet_set_defaults) {
static const config_plugin_keys_t cpk[] = {
{ CONST_STR_LEN("magnet.attract-raw-url-to"),
T_CONFIG_ARRAY_VLIST,
T_CONFIG_SCOPE_CONNECTION }
,{ CONST_STR_LEN("magnet.attract-physical-path-to"),
T_CONFIG_ARRAY_VLIST,
T_CONFIG_SCOPE_CONNECTION }
,{ NULL, 0,
T_CONFIG_UNSET,
T_CONFIG_SCOPE_UNSET }
};
plugin_data * const p = p_d;
if (!config_plugin_values_init(srv, p, cpk, "mod_magnet"))
return HANDLER_ERROR;
/* process and validate config directives
* (init i to 0 if global context; to 1 to skip empty global context) */
for (int i = !p->cvlist[0].v.u2[1]; i < p->nconfig; ++i) {
const config_plugin_value_t *cpv = p->cvlist + p->cvlist[i].v.u2[0];
for (; -1 != cpv->k_id; ++cpv) {
switch (cpv->k_id) {
case 0: /* magnet.attract-raw-url-to */
case 1: /* magnet.attract-physical-path-to */
for (uint32_t j = 0; j < cpv->v.a->used; ++j) {
data_string *ds = (data_string *)cpv->v.a->data[j];
if (buffer_string_is_empty(&ds->value)) {
log_error(srv->errh, __FILE__, __LINE__,
"unexpected (blank) value for %s; "
"expected list of \"scriptpath\"", cpk[cpv->k_id].k);
return HANDLER_ERROR;
}
}
break;
default:/* should not happen */
break;
}
}
}
/* initialize p->defaults from global config context */
if (p->nconfig > 0 && p->cvlist->v.u2[1]) {
const config_plugin_value_t *cpv = p->cvlist + p->cvlist->v.u2[0];
if (-1 != cpv->k_id)
mod_magnet_merge_config(&p->defaults, cpv);
}
return HANDLER_GO_ON;
}
#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
/* lua5.1 backward compat definition */
static void lua_pushglobaltable(lua_State *L) { /* (-0, +1, -) */
lua_pushvalue(L, LUA_GLOBALSINDEX);
}
#endif
static void magnet_setfenv_mainfn(lua_State *L, int funcIndex) { /* (-1, 0, -) */
#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 502
/* set "_ENV" upvalue, which should be the first upvalue of a "main" lua
* function if it uses any global names
*/
const char* first_upvalue_name = lua_getupvalue(L, funcIndex, 1);
if (NULL == first_upvalue_name) return; /* doesn't have any upvalues */
lua_pop(L, 1); /* only need the name of the upvalue, not the value */
if (0 != strcmp(first_upvalue_name, "_ENV")) return;
if (NULL == lua_setupvalue(L, funcIndex, 1)) {
/* pop value if lua_setupvalue didn't set the (not existing) upvalue */
lua_pop(L, 1);
}
#else
lua_setfenv(L, funcIndex);
#endif
}
#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
/* lua 5.2 already supports __pairs */
/* See http://lua-users.org/wiki/GeneralizedPairsAndIpairs for implementation details.
* Override the default pairs() function to allow us to use a __pairs metakey
*/
static int magnet_pairs(lua_State *L) {
luaL_checkany(L, 1); /* "self" */
if (luaL_getmetafield(L, 1, "__pairs")) {
/* call __pairs(self) */
lua_pushvalue(L, 1);
lua_call(L, 1, 3);
} else {
/* call <original-pairs-method>(self) */
lua_pushvalue(L, lua_upvalueindex(1));
lua_pushvalue(L, 1);
lua_call(L, 1, 3);
}
return 3;
}
#endif
static void magnet_push_buffer(lua_State *L, const buffer *b) {
if (!buffer_is_empty(b))
lua_pushlstring(L, CONST_BUF_LEN(b));
else
lua_pushnil(L);
}
#if 0
static int magnet_array_get_element(lua_State *L, const array *a) {
/* __index: param 1 is the (empty) table the value was not found in */
size_t klen;
const char * const k = luaL_checklstring(L, 2, &klen);
const data_string * const ds = (const data_string *)
array_get_element_klen(a, k, klen);
magnet_push_buffer(L, NULL != ds ? &ds->value : NULL);
return 1;
}
#endif
/* Define a function that will iterate over an array* (in upval 1) using current position (upval 2) */
static int magnet_array_next(lua_State *L) {
data_unset *du;
data_string *ds;
data_integer *di;
size_t pos = lua_tointeger(L, lua_upvalueindex(1));
array *a = lua_touserdata(L, lua_upvalueindex(2));
lua_settop(L, 0);
if (pos >= a->used) return 0;
if (NULL != (du = a->data[pos])) {
lua_pushlstring(L, CONST_BUF_LEN(&du->key));
switch (du->type) {
case TYPE_STRING:
ds = (data_string *)du;
magnet_push_buffer(L, &ds->value);
break;
case TYPE_INTEGER:
di = (data_integer *)du;
lua_pushinteger(L, di->value);
break;
default:
lua_pushnil(L);
break;
}
/* Update our positional upval to reflect our new current position */
pos++;
lua_pushinteger(L, pos);
lua_replace(L, lua_upvalueindex(1));
/* Returning 2 items on the stack (key, value) */
return 2;
}
return 0;
}
/* Create the closure necessary to iterate over the array *a with the above function */
static int magnet_array_pairs(lua_State *L, array *a) {
lua_pushinteger(L, 0); /* Push our current pos (the start) into upval 1 */
lua_pushlightuserdata(L, a); /* Push our array *a into upval 2 */
lua_pushcclosure(L, magnet_array_next, 2); /* Push our new closure with 2 upvals */
return 1;
}
static request_st * magnet_get_request(lua_State *L) {
lua_getfield(L, LUA_REGISTRYINDEX, LUA_RIDX_LIGHTTPD_REQUEST);
request_st * const r = lua_touserdata(L, -1);
lua_pop(L, 1);
return r;
}
typedef struct {
const char *ptr;
size_t len;
} const_buffer;
static const_buffer magnet_checkconstbuffer(lua_State *L, int idx) {
const_buffer cb;
cb.ptr = luaL_checklstring(L, idx, &cb.len);
return cb;
}
static buffer* magnet_checkbuffer(lua_State *L, int idx) {
const_buffer cb = magnet_checkconstbuffer(L, idx);
buffer *b = buffer_init();
buffer_copy_string_len(b, cb.ptr, cb.len);
return b;
}
static int magnet_print(lua_State *L) {
const_buffer cb = magnet_checkconstbuffer(L, 1);
request_st * const r = magnet_get_request(L);
log_error(r->conf.errh, __FILE__, __LINE__, "(lua-print) %s", cb.ptr);
return 0;
}
static int magnet_stat(lua_State *L) {
buffer * const sb = magnet_checkbuffer(L, 1);
stat_cache_entry * const sce = stat_cache_get_entry(sb);
buffer_free(sb);
if (NULL == sce) {
lua_pushnil(L);
return 1;
}
lua_newtable(L); // return value
lua_pushboolean(L, S_ISREG(sce->st.st_mode));
lua_setfield(L, -2, "is_file");
lua_pushboolean(L, S_ISDIR(sce->st.st_mode));
lua_setfield(L, -2, "is_dir");
lua_pushboolean(L, S_ISCHR(sce->st.st_mode));
lua_setfield(L, -2, "is_char");
lua_pushboolean(L, S_ISBLK(sce->st.st_mode));
lua_setfield(L, -2, "is_block");
lua_pushboolean(L, S_ISSOCK(sce->st.st_mode));
lua_setfield(L, -2, "is_socket");
lua_pushboolean(L, S_ISLNK(sce->st.st_mode));
lua_setfield(L, -2, "is_link");
lua_pushboolean(L, S_ISFIFO(sce->st.st_mode));
lua_setfield(L, -2, "is_fifo");
lua_pushinteger(L, sce->st.st_mtime);
lua_setfield(L, -2, "st_mtime");
lua_pushinteger(L, sce->st.st_ctime);
lua_setfield(L, -2, "st_ctime");
lua_pushinteger(L, sce->st.st_atime);
lua_setfield(L, -2, "st_atime");
lua_pushinteger(L, sce->st.st_uid);
lua_setfield(L, -2, "st_uid");
lua_pushinteger(L, sce->st.st_gid);
lua_setfield(L, -2, "st_gid");
lua_pushinteger(L, sce->st.st_size);
lua_setfield(L, -2, "st_size");
lua_pushinteger(L, sce->st.st_ino);
lua_setfield(L, -2, "st_ino");
request_st * const r = magnet_get_request(L);
const buffer *etag = stat_cache_etag_get(sce, r->conf.etag_flags);
if (!buffer_string_is_empty(etag)) {
/* we have to mutate the etag */
buffer * const tb = r->tmp_buf;
etag_mutate(tb, etag);
lua_pushlstring(L, CONST_BUF_LEN(tb));
} else {
lua_pushnil(L);
}
lua_setfield(L, -2, "etag");
const buffer *content_type = stat_cache_content_type_get(sce, r);
if (!buffer_string_is_empty(content_type)) {
lua_pushlstring(L, CONST_BUF_LEN(content_type));
} else {
lua_pushnil(L);
}
lua_setfield(L, -2, "content-type");
return 1;
}
static int magnet_atpanic(lua_State *L) {
const_buffer cb = magnet_checkconstbuffer(L, 1);
request_st * const r = magnet_get_request(L);
log_error(r->conf.errh, __FILE__, __LINE__, "(lua-atpanic) %s", cb.ptr);
longjmp(exceptionjmp, 1);
}
static int magnet_reqhdr_get(lua_State *L) {
/* __index: param 1 is the (empty) table the value was not found in */
size_t klen;
const char * const k = luaL_checklstring(L, 2, &klen);
request_st * const r = magnet_get_request(L);
const buffer * const vb =
http_header_request_get(r, HTTP_HEADER_UNSPECIFIED, k, klen);
magnet_push_buffer(L, NULL != vb ? vb : NULL);
return 1;
}
static int magnet_reqhdr_pairs(lua_State *L) {
request_st * const r = magnet_get_request(L);
return magnet_array_pairs(L, &r->rqst_headers);
}
static int magnet_status_get(lua_State *L) {
/* __index: param 1 is the (empty) table the value was not found in */
const_buffer key = magnet_checkconstbuffer(L, 2);
int *i = status_counter_get_counter(key.ptr, key.len);
lua_pushinteger(L, (lua_Integer)*i);
return 1;
}
static int magnet_status_set(lua_State *L) {
/* __newindex: param 1 is the (empty) table the value is supposed to be set in */
const_buffer key = magnet_checkconstbuffer(L, 2);
int counter = (int) luaL_checkinteger(L, 3);
status_counter_set(key.ptr, key.len, counter);
return 0;
}
static int magnet_status_pairs(lua_State *L) {
return magnet_array_pairs(L, &plugin_stats);
}
typedef struct {
const char *name;
enum {
MAGNET_ENV_UNSET,
MAGNET_ENV_PHYSICAL_PATH,
MAGNET_ENV_PHYSICAL_REL_PATH,
MAGNET_ENV_PHYSICAL_DOC_ROOT,
MAGNET_ENV_PHYSICAL_BASEDIR,
MAGNET_ENV_URI_PATH,
MAGNET_ENV_URI_PATH_RAW,
MAGNET_ENV_URI_SCHEME,
MAGNET_ENV_URI_AUTHORITY,
MAGNET_ENV_URI_QUERY,
MAGNET_ENV_REQUEST_METHOD,
MAGNET_ENV_REQUEST_URI,
MAGNET_ENV_REQUEST_ORIG_URI,
MAGNET_ENV_REQUEST_PATH_INFO,
MAGNET_ENV_REQUEST_REMOTE_IP,
MAGNET_ENV_REQUEST_SERVER_ADDR,
MAGNET_ENV_REQUEST_PROTOCOL
} type;
} magnet_env_t;
static const magnet_env_t magnet_env[] = {
{ "physical.path", MAGNET_ENV_PHYSICAL_PATH },
{ "physical.rel-path", MAGNET_ENV_PHYSICAL_REL_PATH },
{ "physical.doc-root", MAGNET_ENV_PHYSICAL_DOC_ROOT },
{ "physical.basedir", MAGNET_ENV_PHYSICAL_BASEDIR },
{ "uri.path", MAGNET_ENV_URI_PATH },
{ "uri.path-raw", MAGNET_ENV_URI_PATH_RAW },
{ "uri.scheme", MAGNET_ENV_URI_SCHEME },
{ "uri.authority", MAGNET_ENV_URI_AUTHORITY },
{ "uri.query", MAGNET_ENV_URI_QUERY },
{ "request.method", MAGNET_ENV_REQUEST_METHOD },
{ "request.uri", MAGNET_ENV_REQUEST_URI },
{ "request.orig-uri", MAGNET_ENV_REQUEST_ORIG_URI },
{ "request.path-info", MAGNET_ENV_REQUEST_PATH_INFO },
{ "request.remote-ip", MAGNET_ENV_REQUEST_REMOTE_IP },
{ "request.remote-addr", MAGNET_ENV_REQUEST_REMOTE_IP },
{ "request.server-addr", MAGNET_ENV_REQUEST_SERVER_ADDR },
{ "request.protocol", MAGNET_ENV_REQUEST_PROTOCOL },
{ NULL, MAGNET_ENV_UNSET }
};
static buffer *magnet_env_get_buffer_by_id(request_st * const r, int id) {
buffer *dest = NULL;
/**
* map all internal variables to lua
*
*/
switch (id) {
case MAGNET_ENV_PHYSICAL_PATH: dest = &r->physical.path; break;
case MAGNET_ENV_PHYSICAL_REL_PATH: dest = &r->physical.rel_path; break;
case MAGNET_ENV_PHYSICAL_DOC_ROOT: dest = &r->physical.doc_root; break;
case MAGNET_ENV_PHYSICAL_BASEDIR: dest = &r->physical.basedir; break;
case MAGNET_ENV_URI_PATH: dest = &r->uri.path; break;
case MAGNET_ENV_URI_PATH_RAW:
{
dest = r->tmp_buf;
buffer_clear(dest);
uint32_t len = buffer_string_length(&r->target);
char *qmark = memchr(r->target.ptr, '?', len);
buffer_copy_string_len(dest, r->target.ptr, qmark ? (uint32_t)(qmark - r->target.ptr) : len);
break;
}
case MAGNET_ENV_URI_SCHEME: dest = &r->uri.scheme; break;
case MAGNET_ENV_URI_AUTHORITY: dest = &r->uri.authority; break;
case MAGNET_ENV_URI_QUERY: dest = &r->uri.query; break;
case MAGNET_ENV_REQUEST_METHOD:
dest = r->tmp_buf;
buffer_clear(dest);
http_method_append(dest, r->http_method);
break;
case MAGNET_ENV_REQUEST_URI: dest = &r->target; break;
case MAGNET_ENV_REQUEST_ORIG_URI: dest = &r->target_orig; break;
case MAGNET_ENV_REQUEST_PATH_INFO: dest = &r->pathinfo; break;
case MAGNET_ENV_REQUEST_REMOTE_IP: dest = r->con->dst_addr_buf; break;
case MAGNET_ENV_REQUEST_SERVER_ADDR:
{
const server_socket * const srv_socket = r->con->srv_socket;
dest = r->tmp_buf;
buffer_clear(dest);
switch (srv_socket->addr.plain.sa_family) {
case AF_INET:
case AF_INET6:
if (sock_addr_is_addr_wildcard(&srv_socket->addr)) {
sock_addr addrbuf;
socklen_t addrlen = sizeof(addrbuf);
const int fd = r->con->fd;
if (0 == getsockname(fd,(struct sockaddr *)&addrbuf,&addrlen)) {
char buf[INET6_ADDRSTRLEN + 1];
const char *s = sock_addr_inet_ntop(&addrbuf, buf, sizeof(buf)-1);
if (NULL != s)
buffer_copy_string_len(dest, s, strlen(s));
}
}
else {
buffer_copy_buffer(dest, srv_socket->srv_token);
if (dest->ptr[0] != '[' || dest->ptr[buffer_string_length(dest)-1] != ']') {
char *s = strrchr(dest->ptr, ':');
if (s != NULL) /* local IP without port */
buffer_string_set_length(dest, s - dest->ptr);
}
}
break;
default:
break;
}
break;
}
case MAGNET_ENV_REQUEST_PROTOCOL:
dest = r->tmp_buf;
buffer_copy_string(dest, get_http_version_name(r->http_version));
break;
case MAGNET_ENV_UNSET: break;
}
return dest;
}
static int magnet_env_get_id(const char * const key) {
for (int i = 0; magnet_env[i].name; ++i) {
if (0 == strcmp(key, magnet_env[i].name))
return magnet_env[i].type;
}
return MAGNET_ENV_UNSET;
}
static buffer *magnet_env_get_buffer(request_st * const r, const char * const key) {
return magnet_env_get_buffer_by_id(r, magnet_env_get_id(key));
}
static int magnet_env_get(lua_State *L) {
/* __index: param 1 is the (empty) table the value was not found in */
const char *key = luaL_checkstring(L, 2);
request_st * const r = magnet_get_request(L);
magnet_push_buffer(L, magnet_env_get_buffer(r, key));
return 1;
}
static int magnet_env_set(lua_State *L) {
/* __newindex: param 1 is the (empty) table the value is supposed to be set in */
const char * const key = luaL_checkstring(L, 2);
luaL_checkany(L, 3); /* nil or a string */
request_st * const r = magnet_get_request(L);
const int env_id = magnet_env_get_id(key);
if (env_id == MAGNET_ENV_URI_PATH_RAW) {
/* modify uri-path of r->target; preserve query-part, if present */
/* XXX: should we require that resulting path begin with '/' or %2F ? */
const uint32_t len = buffer_string_length(&r->target);
const char * const qmark = memchr(r->target.ptr, '?', len);
const_buffer val = { NULL, 0 };
if (!lua_isnil(L, 3))
val = magnet_checkconstbuffer(L, 3);
if (NULL != qmark)
buffer_copy_string_len(r->tmp_buf, qmark,
len - (uint32_t)(qmark - r->target.ptr));
buffer_copy_string_len(&r->target, val.ptr, val.len);
if (NULL != qmark)
buffer_append_string_buffer(&r->target, r->tmp_buf);
return 0;
}
buffer * const dest = magnet_env_get_buffer_by_id(r, env_id);
if (NULL == dest)
return luaL_error(L, "couldn't store '%s' in lighty.env[]", key);
if (lua_isnil(L, 3)) {
if (env_id==MAGNET_ENV_URI_QUERY || env_id==MAGNET_ENV_PHYSICAL_PATH)
buffer_clear(dest);
else
buffer_string_set_length(dest, 0);
}
else {
const_buffer val = magnet_checkconstbuffer(L, 3);
buffer_copy_string_len(dest, val.ptr, val.len);
/* NB: setting r->uri.query does not modify query-part in r->target
* (r->uri.query is uri-decoded; r->target is not) */
}
switch (env_id) {
case MAGNET_ENV_URI_SCHEME:
case MAGNET_ENV_URI_AUTHORITY:
buffer_to_lower(dest);
if (env_id == MAGNET_ENV_URI_AUTHORITY)
r->server_name = dest;
break;
default:
break;
}
return 0;
}
static int magnet_env_next(lua_State *L) {
const int pos = lua_tointeger(L, lua_upvalueindex(1));
/* ignore previous key: use upvalue for current pos */
lua_settop(L, 0);
if (NULL == magnet_env[pos].name) return 0; /* end of list */
/* Update our positional upval to reflect our new current position */
lua_pushinteger(L, pos + 1);
lua_replace(L, lua_upvalueindex(1));
/* key to return */
lua_pushstring(L, magnet_env[pos].name);
/* get value */
request_st * const r = magnet_get_request(L);
magnet_push_buffer(L, magnet_env_get_buffer_by_id(r, magnet_env[pos].type));
/* return 2 items on the stack (key, value) */
return 2;
}
static int magnet_env_pairs(lua_State *L) {
lua_pushinteger(L, 0); /* Push our current pos (the start) into upval 1 */
lua_pushcclosure(L, magnet_env_next, 1); /* Push our new closure with 1 upvals */
return 1;
}
static int magnet_cgi_get(lua_State *L) {
/* __index: param 1 is the (empty) table the value was not found in */
size_t klen;
const char * const k = luaL_checklstring(L, 2, &klen);
request_st * const r = magnet_get_request(L);
const buffer * const vb = http_header_env_get(r, k, klen);
magnet_push_buffer(L, NULL != vb ? vb : NULL);
return 1;
}
static int magnet_cgi_set(lua_State *L) {
/* __newindex: param 1 is the (empty) table the value is supposed to be set in */
const_buffer key = magnet_checkconstbuffer(L, 2);
const_buffer val = magnet_checkconstbuffer(L, 3);
request_st * const r = magnet_get_request(L);
http_header_env_set(r, key.ptr, key.len, val.ptr, val.len);
return 0;
}
static int magnet_cgi_pairs(lua_State *L) {
request_st * const r = magnet_get_request(L);
return magnet_array_pairs(L, &r->env);
}
static int magnet_copy_response_header(request_st * const r, lua_State * const L, int lighty_table_ndx) {
force_assert(lua_istable(L, lighty_table_ndx));
lua_getfield(L, lighty_table_ndx, "header"); /* lighty.header */
if (lua_istable(L, -1)) {
/* header is found, and is a table */
lua_pushnil(L);
while (lua_next(L, -2) != 0) {
if (lua_isstring(L, -1) && lua_isstring(L, -2)) {
const_buffer key = magnet_checkconstbuffer(L, -2);
const_buffer val = magnet_checkconstbuffer(L, -1);
enum http_header_e id = http_header_hkey_get(key.ptr, key.len);
val.len
? http_header_response_set(r, id, key.ptr, key.len, val.ptr, val.len)
: http_header_response_unset(r, id, key.ptr, key.len);
}
lua_pop(L, 1);
}
}
lua_pop(L, 1); /* pop lighty.header */
return 0;
}
/**
* walk through the content array
*
* content = { "<pre>", { file = "/content" } , "</pre>" }
*
* header["Content-Type"] = "text/html"
*
* return 200
*/
static int magnet_attach_content(request_st * const r, lua_State * const L, int lighty_table_ndx) {
force_assert(lua_istable(L, lighty_table_ndx));
lua_getfield(L, lighty_table_ndx, "content"); /* lighty.content */
if (lua_istable(L, -1)) {
int i;
/* content is found, and is a table */
for (i = 1; ; i++) {
lua_rawgeti(L, -1, i);
/* -1 is the value and should be the value ... aka a table */
if (lua_isstring(L, -1)) {
const_buffer data = magnet_checkconstbuffer(L, -1);
chunkqueue_append_mem(r->write_queue, data.ptr, data.len);
} else if (lua_istable(L, -1)) {
lua_getfield(L, -1, "filename");
lua_getfield(L, -2, "length"); /* (0-based) end of range (not actually "length") */
lua_getfield(L, -3, "offset"); /* (0-based) start of range */
if (lua_isstring(L, -3)) { /* filename has to be a string */
off_t off = (off_t) luaL_optinteger(L, -1, 0);
off_t len = (off_t) luaL_optinteger(L, -2, -1); /*(-1 to http_chunk_append_file_range() uses file size minus offset)*/
if (off < 0) {
return luaL_error(L, "offset for '%s' is negative", lua_tostring(L, -3));
}
if (len >= off) {
len -= off;
} else if (-1 != len) {
return luaL_error(L, "offset > length for '%s'", lua_tostring(L, -3));
}
if (0 != len) {
buffer *fn = magnet_checkbuffer(L, -3);
int rc = http_chunk_append_file_range(r, fn, off, len);
buffer_free(fn);
if (0 != rc) {
return luaL_error(L, "error opening file content '%s' at offset %lld", lua_tostring(L, -3), (long long)off);
}
}
} else {
return luaL_error(L, "content[%d] is a table and requires the field \"filename\"", i);
}
lua_pop(L, 3);
} else if (lua_isnil(L, -1)) {
/* end of list */
lua_pop(L, 1);
break;
} else {
return luaL_error(L, "content[%d] is neither a string nor a table: ", i);
}
lua_pop(L, 1); /* pop the content[...] entry value */
}
} else {
return luaL_error(L, "lighty.content has to be a table");
}
lua_pop(L, 1); /* pop lighty.content */
return 0;
}
static int traceback(lua_State *L) {
if (!lua_isstring(L, 1)) /* 'message' not a string? */
return 1; /* keep it intact */
lua_getglobal(L, "debug");
if (!lua_istable(L, -1)) {
lua_pop(L, 1);
return 1;
}
lua_getfield(L, -1, "traceback");
if (!lua_isfunction(L, -1)) {
lua_pop(L, 2);
return 1;
}
lua_pushvalue(L, 1); /* pass error message */
lua_pushinteger(L, 2); /* skip this function and traceback */
lua_call(L, 2, 1); /* call debug.traceback */
return 1;
}
/* push traceback function before calling lua_pcall after narg arguments
* have been pushed (inserts it before the arguments). returns index for
* traceback function ("msgh" in lua_pcall)
*/
static int push_traceback(lua_State *L, int narg) {
int base = lua_gettop(L) - narg; /* function index */
lua_pushcfunction(L, traceback);
lua_insert(L, base);
return base;
}
static handler_t magnet_attract(request_st * const r, plugin_data * const p, buffer * const name) {
lua_State *L;
int lua_return_value;
const int func_ndx = 1;
const int lighty_table_ndx = 2;
/* get the script-context */
L = script_cache_get_script(&p->cache, name, r->conf.etag_flags);
if (lua_isstring(L, -1)) {
log_error(r->conf.errh, __FILE__, __LINE__,
"loading script %s failed: %s", name->ptr, lua_tostring(L, -1));
lua_pop(L, 1);
force_assert(lua_gettop(L) == 0); /* only the error should have been on the stack */
r->http_status = 500;
r->handler_module = NULL;
return HANDLER_FINISHED;
}
force_assert(lua_gettop(L) == 1);
force_assert(lua_isfunction(L, func_ndx));
lua_pushlightuserdata(L, r);
lua_setfield(L, LUA_REGISTRYINDEX, LUA_RIDX_LIGHTTPD_REQUEST);
lua_atpanic(L, magnet_atpanic);
/**
* we want to create empty environment for our script
*
* setmetatable({}, {__index = _G})
*
* if a function symbol is not defined in our env, __index will lookup
* in the global env.
*
* all variables created in the script-env will be thrown
* away at the end of the script run.
*/
lua_newtable(L); /* my empty environment aka {} (sp += 1) */
/* we have to overwrite the print function */
lua_pushcfunction(L, magnet_print); /* (sp += 1) */
lua_setfield(L, -2, "print"); /* -1 is the env we want to set(sp -= 1) */
/**
* lighty.request[] (ro) has the HTTP-request headers
* lighty.env[] (rw) has various url/physical file paths and
* request meta data; might contain nil values
* lighty.req_env[] (ro) has the cgi environment
* lighty.status[] (ro) has the status counters
* lighty.content[] (rw) is a table of string/file
* lighty.header[] (rw) is a array to set response headers
*/
lua_newtable(L); /* lighty.* (sp += 1) */
lua_newtable(L); /* {} (sp += 1) */
lua_newtable(L); /* the meta-table for the request-table (sp += 1) */
lua_pushcfunction(L, magnet_reqhdr_get); /* (sp += 1) */
lua_setfield(L, -2, "__index"); /* (sp -= 1) */
lua_pushcfunction(L, magnet_reqhdr_pairs); /* (sp += 1) */
lua_setfield(L, -2, "__pairs"); /* (sp -= 1) */
lua_setmetatable(L, -2); /* tie the metatable to request (sp -= 1) */
lua_setfield(L, -2, "request"); /* content = {} (sp -= 1) */
lua_newtable(L); /* {} (sp += 1) */
lua_newtable(L); /* the meta-table for the env-table (sp += 1) */
lua_pushcfunction(L, magnet_env_get); /* (sp += 1) */
lua_setfield(L, -2, "__index"); /* (sp -= 1) */
lua_pushcfunction(L, magnet_env_set); /* (sp += 1) */
lua_setfield(L, -2, "__newindex"); /* (sp -= 1) */
lua_pushcfunction(L, magnet_env_pairs); /* (sp += 1) */
lua_setfield(L, -2, "__pairs"); /* (sp -= 1) */
lua_setmetatable(L, -2); /* tie the metatable to env (sp -= 1) */
lua_setfield(L, -2, "env"); /* content = {} (sp -= 1) */
lua_newtable(L); /* {} (sp += 1) */
lua_newtable(L); /* the meta-table for the req_env-table (sp += 1) */
lua_pushcfunction(L, magnet_cgi_get); /* (sp += 1) */
lua_setfield(L, -2, "__index"); /* (sp -= 1) */
lua_pushcfunction(L, magnet_cgi_set); /* (sp += 1) */
lua_setfield(L, -2, "__newindex"); /* (sp -= 1) */
lua_pushcfunction(L, magnet_cgi_pairs); /* (sp += 1) */
lua_setfield(L, -2, "__pairs"); /* (sp -= 1) */
lua_setmetatable(L, -2); /* tie the metatable to req_env (sp -= 1) */
lua_setfield(L, -2, "req_env"); /* content = {} (sp -= 1) */
lua_newtable(L); /* {} (sp += 1) */
lua_newtable(L); /* the meta-table for the status-table (sp += 1) */
lua_pushcfunction(L, magnet_status_get); /* (sp += 1) */
lua_setfield(L, -2, "__index"); /* (sp -= 1) */
lua_pushcfunction(L, magnet_status_set); /* (sp += 1) */
lua_setfield(L, -2, "__newindex"); /* (sp -= 1) */
lua_pushcfunction(L, magnet_status_pairs); /* (sp += 1) */
lua_setfield(L, -2, "__pairs"); /* (sp -= 1) */
lua_setmetatable(L, -2); /* tie the metatable to statzs (sp -= 1) */
lua_setfield(L, -2, "status"); /* content = {} (sp -= 1) */
/* add empty 'content' and 'header' tables */
lua_newtable(L); /* {} (sp += 1) */
lua_setfield(L, -2, "content"); /* content = {} (sp -= 1) */
lua_newtable(L); /* {} (sp += 1) */
lua_setfield(L, -2, "header"); /* header = {} (sp -= 1) */
lua_pushinteger(L, MAGNET_RESTART_REQUEST);
lua_setfield(L, -2, "RESTART_REQUEST");
lua_pushcfunction(L, magnet_stat); /* (sp += 1) */
lua_setfield(L, -2, "stat"); /* -1 is the env we want to set (sp -= 1) */
/* insert lighty table at index 2 */
lua_pushvalue(L, -1);
lua_insert(L, lighty_table_ndx);
lua_setfield(L, -2, "lighty"); /* lighty.* (sp -= 1) */
#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
/* override the default pairs() function to our __pairs capable version;
* not needed for lua 5.2+
*/
lua_getglobal(L, "pairs"); /* push original pairs() (sp += 1) */
lua_pushcclosure(L, magnet_pairs, 1);
lua_setfield(L, -2, "pairs"); /* (sp -= 1) */
#endif
lua_newtable(L); /* the meta-table for the new env (sp += 1) */
lua_pushglobaltable(L); /* (sp += 1) */
lua_setfield(L, -2, "__index"); /* { __index = _G } (sp -= 1) */
lua_setmetatable(L, -2); /* setmetatable({}, {__index = _G}) (sp -= 1) */
magnet_setfenv_mainfn(L, 1); /* (sp -= 1) */
/* pcall will destroy the func value, duplicate it */ /* (sp += 1) */
lua_pushvalue(L, func_ndx);
{
int errfunc = push_traceback(L, 0);
int ret = lua_pcall(L, 0, 1, errfunc);
lua_remove(L, errfunc);
/* reset environment */
lua_pushglobaltable(L); /* (sp += 1) */
magnet_setfenv_mainfn(L, 1); /* (sp -= 1) */
if (0 != ret) {
log_error(r->conf.errh, __FILE__, __LINE__,
"lua_pcall(): %s", lua_tostring(L, -1));
lua_pop(L, 2); /* remove the error-msg and the lighty table at index 2 */
force_assert(lua_gettop(L) == 1); /* only the function should be on the stack */
r->http_status = 500;
r->handler_module = NULL;
return HANDLER_FINISHED;
}
}
/* we should have the function, the lighty table and the return value on the stack */
force_assert(lua_gettop(L) == 3);
switch (lua_type(L, -1)) {
case LUA_TNUMBER:
case LUA_TNIL:
lua_return_value = (int) luaL_optinteger(L, -1, -1);
break;
default:
log_error(r->conf.errh, __FILE__, __LINE__,
"lua_pcall(): unexpected return type: %s", luaL_typename(L, -1));
lua_return_value = -1;
break;
}
lua_pop(L, 1); /* pop return value */
magnet_copy_response_header(r, L, lighty_table_ndx);
{
handler_t result = HANDLER_GO_ON;
if (lua_return_value > 99) {
r->http_status = lua_return_value;
r->resp_body_finished = 1;
/* try { ...*/
if (0 == setjmp(exceptionjmp)) {
magnet_attach_content(r, L, lighty_table_ndx);
if (!chunkqueue_is_empty(r->write_queue)) {
r->handler_module = p->self;
}
} else {
lua_settop(L, 2); /* remove all but function and lighty table */
/* } catch () { */
r->http_status = 500;
r->handler_module = NULL;
}
result = HANDLER_FINISHED;
} else if (MAGNET_RESTART_REQUEST == lua_return_value) {
result = HANDLER_COMEBACK;
}
lua_pop(L, 1); /* pop the lighty table */
force_assert(lua_gettop(L) == 1); /* only the function should remain on the stack */
return result;
}
}
static handler_t magnet_attract_array(request_st * const r, plugin_data * const p, int is_uri) {
mod_magnet_patch_config(r, p);
const array * const files = (is_uri)
? p->conf.url_raw
: p->conf.physical_path;
/* no filename set */
if (NULL == files || files->used == 0) return HANDLER_GO_ON;
r->con->srv->request_env(r);
/**
* execute all files and jump out on the first !HANDLER_GO_ON
*/
handler_t ret = HANDLER_GO_ON;
for (uint32_t i = 0; i < files->used && ret == HANDLER_GO_ON; ++i) {
data_string *ds = (data_string *)files->data[i];
ret = magnet_attract(r, p, &ds->value);
}
if (r->error_handler_saved_status) {
/* retrieve (possibly modified) REDIRECT_STATUS and store as number */
int x;
const buffer * const vb = http_header_env_get(r, CONST_STR_LEN("REDIRECT_STATUS"));
if (vb && (x = http_header_str_to_code(vb->ptr)) != -1)
r->error_handler_saved_status =
r->error_handler_saved_status > 0 ? (int)x : -(int)x;
}
return ret;
}
URIHANDLER_FUNC(mod_magnet_uri_handler) {
return magnet_attract_array(r, p_d, 1);
}
URIHANDLER_FUNC(mod_magnet_physical) {
return magnet_attract_array(r, p_d, 0);
}
int mod_magnet_plugin_init(plugin *p);
int mod_magnet_plugin_init(plugin *p) {
p->version = LIGHTTPD_VERSION_ID;
p->name = "magnet";
p->init = mod_magnet_init;
p->handle_uri_clean = mod_magnet_uri_handler;
p->handle_physical = mod_magnet_physical;
p->set_defaults = mod_magnet_set_defaults;
p->cleanup = mod_magnet_free;
return 0;
}