diff options
| -rw-r--r-- | CMakeLists.txt | 8 | ||||
| -rw-r--r-- | main.c | 68 | ||||
| -rw-r--r-- | ucode.c | 435 | ||||
| -rw-r--r-- | uhttpd.h | 15 |
4 files changed, 525 insertions, 1 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 7ae8ba4..564842d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -10,6 +10,7 @@ ADD_DEFINITIONS(-D_FILE_OFFSET_BITS=64 -Os -Wall -Werror -Wmissing-declarations OPTION(TLS_SUPPORT "TLS support" ON) OPTION(LUA_SUPPORT "Lua support" ON) OPTION(UBUS_SUPPORT "ubus support" ON) +OPTION(UCODE_SUPPORT "ucode support" ON) IF(APPLE) INCLUDE_DIRECTORIES(/opt/local/include) @@ -69,6 +70,13 @@ IF(LUA_SUPPORT) TARGET_LINK_LIBRARIES(uhttpd_lua ${LUA_LIBS} m dl) ENDIF() +IF(UCODE_SUPPORT) + SET(PLUGINS ${PLUGINS} uhttpd_ucode) + ADD_DEFINITIONS(-DHAVE_UCODE) + ADD_LIBRARY(uhttpd_ucode MODULE ucode.c) + TARGET_LINK_LIBRARIES(uhttpd_ucode ucode ${libjson}) +ENDIF() + IF(UBUS_SUPPORT) SET(PLUGINS ${PLUGINS} uhttpd_ubus) ADD_DEFINITIONS(-DHAVE_UBUS) @@ -188,6 +188,9 @@ static void init_defaults_pre(void) conf.cgi_path = "/sbin:/usr/sbin:/bin:/usr/bin"; INIT_LIST_HEAD(&conf.cgi_alias); INIT_LIST_HEAD(&conf.lua_prefix); +#if HAVE_UCODE + INIT_LIST_HEAD(&conf.ucode_prefix); +#endif } static void init_defaults_post(void) @@ -241,6 +244,25 @@ static void add_lua_prefix(const char *prefix, const char *handler) { } #endif +#ifdef HAVE_UCODE +static void add_ucode_prefix(const char *prefix, const char *handler) { + struct ucode_prefix *p; + char *pprefix, *phandler; + + p = calloc_a(sizeof(*p), + &pprefix, strlen(prefix) + 1, + &phandler, strlen(handler) + 1); + + if (!p) + return; + + p->prefix = strcpy(pprefix, prefix); + p->handler = strcpy(phandler, handler); + + list_add_tail(&p->list, &conf.ucode_prefix); +} +#endif + int main(int argc, char **argv) { struct alias *alias; @@ -256,6 +278,9 @@ int main(int argc, char **argv) #ifdef HAVE_LUA const char *lua_prefix = NULL, *lua_handler = NULL; #endif +#ifdef HAVE_UCODE + const char *ucode_prefix = NULL, *ucode_handler = NULL; +#endif BUILD_BUG_ON(sizeof(uh_buf) < PATH_MAX); @@ -263,7 +288,7 @@ int main(int argc, char **argv) init_defaults_pre(); signal(SIGPIPE, SIG_IGN); - while ((ch = getopt(argc, argv, "A:aC:c:Dd:E:e:fh:H:I:i:K:k:L:l:m:N:n:P:p:qRr:Ss:T:t:U:u:Xx:y:")) != -1) { + while ((ch = getopt(argc, argv, "A:aC:c:Dd:E:e:fh:H:I:i:K:k:L:l:m:N:n:O:o:P:p:qRr:Ss:T:t:U:u:Xx:y:")) != -1) { switch(ch) { #ifdef HAVE_TLS case 'C': @@ -475,6 +500,38 @@ int main(int argc, char **argv) "ignoring -%c\n", ch); break; #endif +#ifdef HAVE_UCODE + case 'o': + case 'O': + if (ch == 'o') { + if (ucode_prefix) + fprintf(stderr, "uhttpd: Ignoring previous -%c %s\n", + ch, ucode_prefix); + + ucode_prefix = optarg; + } + else { + if (ucode_handler) + fprintf(stderr, "uhttpd: Ignoring previous -%c %s\n", + ch, ucode_handler); + + ucode_handler = optarg; + } + + if (ucode_prefix && ucode_handler) { + add_ucode_prefix(ucode_prefix, ucode_handler); + ucode_prefix = NULL; + ucode_handler = NULL; + } + + break; +#else + case 'o': + case 'O': + fprintf(stderr, "uhttpd: ucode support not compiled, " + "ignoring -%c\n", ch); + break; +#endif #ifdef HAVE_UBUS case 'a': conf.ubus_noauth = 1; @@ -549,6 +606,15 @@ int main(int argc, char **argv) if (!list_empty(&conf.lua_prefix) && uh_plugin_init("uhttpd_lua.so")) return 1; #endif +#ifdef HAVE_UCODE + if (ucode_handler || ucode_prefix) { + fprintf(stderr, "Need handler and prefix to enable ucode support\n"); + return 1; + } + + if (!list_empty(&conf.ucode_prefix) && uh_plugin_init("uhttpd_ucode.so")) + return 1; +#endif #ifdef HAVE_UBUS if (conf.ubus_prefix && uh_plugin_init("uhttpd_ubus.so")) return 1; @@ -0,0 +1,435 @@ +/* + * uhttpd - Tiny single-threaded httpd + * + * Copyright (C) 2010-2013 Jo-Philipp Wich <xm@subsignal.org> + * Copyright (C) 2013 Felix Fietkau <nbd@openwrt.org> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <libubox/blobmsg.h> +#include <ucode/compiler.h> +#include <ucode/lib.h> +#include <ucode/vm.h> +#include <stdio.h> +#include <poll.h> + +#include "uhttpd.h" +#include "plugin.h" + +#define UH_UCODE_CB "handle_request" + +static const struct uhttpd_ops *ops; +static struct config *_conf; +#define conf (*_conf) + +static struct ucode_prefix *current_prefix; + +static uc_value_t * +uh_ucode_recv(uc_vm_t *vm, size_t nargs) +{ + static struct pollfd pfd = { .fd = STDIN_FILENO, .events = POLLIN }; + int data_len = 0, len = BUFSIZ, rlen, r; + uc_value_t *v = uc_fn_arg(0); + uc_stringbuf_t *buf; + + if (ucv_type(v) == UC_INTEGER) { + len = ucv_int64_get(v); + } + else if (v != NULL) { + uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Argument not an integer"); + + return NULL; + } + + buf = ucv_stringbuf_new(); + + while (len > 0) { + rlen = (len < BUFSIZ) ? len : BUFSIZ; + + if (printbuf_memset(buf, -1, 0, rlen)) { + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Out of memory"); + printbuf_free(buf); + + return NULL; + } + + buf->bpos -= rlen; + r = read(STDIN_FILENO, buf->buf + buf->bpos, rlen); + + if (r < 0) { + if (errno == EWOULDBLOCK || errno == EAGAIN) { + pfd.revents = 0; + poll(&pfd, 1, 1000); + + if (pfd.revents & POLLIN) + continue; + } + + if (errno == EINTR) + continue; + + if (!data_len) + data_len = -1; + + break; + } + + buf->bpos += r; + data_len += r; + len -= r; + + if (r != rlen) + break; + } + + if (data_len > 0) { + /* add final guard \0 but do not count it */ + if (printbuf_memset(buf, -1, 0, 1)) { + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Out of memory"); + printbuf_free(buf); + + return NULL; + } + + buf->bpos--; + + return ucv_stringbuf_finish(buf); + } + + printbuf_free(buf); + + return NULL; +} + +static uc_value_t * +uh_ucode_send(uc_vm_t *vm, size_t nargs) +{ + uc_value_t *val = uc_fn_arg(0); + ssize_t len; + char *p; + + if (ucv_type(val) == UC_STRING) { + len = write(STDOUT_FILENO, ucv_string_get(val), ucv_string_length(val)); + } + else if (val != NULL) { + p = ucv_to_string(vm, val); + len = p ? write(STDOUT_FILENO, p, strlen(p)) : 0; + free(p); + } + else { + len = 0; + } + + return ucv_int64_new(len); +} + +static uc_value_t * +uh_ucode_strconvert(uc_vm_t *vm, size_t nargs, int (*convert)(char *, int, const char *, int)) +{ + uc_value_t *val = uc_fn_arg(0); + static char out_buf[4096]; + int out_len; + char *p; + + if (ucv_type(val) == UC_STRING) { + out_len = convert(out_buf, sizeof(out_buf), + ucv_string_get(val), ucv_string_length(val)); + } + else if (val != NULL) { + p = ucv_to_string(vm, val); + out_len = p ? convert(out_buf, sizeof(out_buf), p, strlen(p)) : 0; + free(p); + } + else { + out_len = 0; + } + + if (out_len < 0) { + const char *error; + + if (out_len == -1) + error = "buffer overflow"; + else + error = "malformed string"; + + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, + "%s on URL conversion\n", error); + + return NULL; + } + + return ucv_string_new_length(out_buf, out_len); +} + +static uc_value_t * +uh_ucode_urldecode(uc_vm_t *vm, size_t nargs) +{ + return uh_ucode_strconvert(vm, nargs, ops->urldecode); +} + +static uc_value_t * +uh_ucode_urlencode(uc_vm_t *vm, size_t nargs) +{ + return uh_ucode_strconvert(vm, nargs, ops->urlencode); +} + +static uc_parse_config_t config = { + .strict_declarations = false, + .lstrip_blocks = true, + .trim_blocks = true +}; + +static void +uh_ucode_exception(uc_vm_t *vm, uc_exception_t *ex) +{ + uc_value_t *ctx; + + printf("Status: 500 Internal Server Error\r\n\r\n" + "Exception while executing ucode program %s:\n", + current_prefix->handler); + + switch (ex->type) { + case EXCEPTION_SYNTAX: printf("Syntax error"); break; + case EXCEPTION_RUNTIME: printf("Runtime error"); break; + case EXCEPTION_TYPE: printf("Type error"); break; + case EXCEPTION_REFERENCE: printf("Reference error"); break; + default: printf("Error"); + } + + printf(": %s\n", ex->message); + + ctx = ucv_object_get(ucv_array_get(ex->stacktrace, 0), "context", NULL); + + if (ctx) + printf("%s\n", ucv_string_get(ctx)); +} + +static void +uh_ucode_state_init(struct ucode_prefix *ucode) +{ + char *syntax_error = NULL; + uc_vm_t *vm = &ucode->ctx; + uc_function_t *handler; + uc_vm_status_t status; + uc_source_t *src; + uc_value_t *v; + int exitcode; + + uc_vm_init(vm, &config); + uc_stdlib_load(uc_vm_scope_get(vm)); + + /* build uhttpd api table */ + v = ucv_object_new(vm); + + ucv_object_add(v, "send", ucv_cfunction_new("send", uh_ucode_send)); + ucv_object_add(v, "sendc", ucv_get(ucv_object_get(v, "send", NULL))); + ucv_object_add(v, "recv", ucv_cfunction_new("recv", uh_ucode_recv)); + ucv_object_add(v, "urldecode", ucv_cfunction_new("urldecode", uh_ucode_urldecode)); + ucv_object_add(v, "urlencode", ucv_cfunction_new("urlencode", uh_ucode_urlencode)); + ucv_object_add(v, "docroot", ucv_string_new(conf.docroot)); + + ucv_object_add(uc_vm_scope_get(vm), "uhttpd", v); + + src = uc_source_new_file(ucode->handler); + + if (!src) { + fprintf(stderr, "Error: Unable to open ucode handler: %s\n", + strerror(errno)); + + exit(1); + } + + handler = uc_compile(&config, src, &syntax_error); + + uc_source_put(src); + + if (!handler) { + fprintf(stderr, "Error: Unable to compile ucode handler: %s\n", + syntax_error); + + exit(1); + } + + free(syntax_error); + + vm->output = fopen("/dev/null", "w"); + + if (!vm->output) { + fprintf(stderr, "Error: Unable to open /dev/null for writing: %s\n", + strerror(errno)); + + exit(1); + } + + status = uc_vm_execute(vm, handler, &v); + exitcode = (int)ucv_int64_get(v); + + ucv_put(v); + + switch (status) { + case STATUS_OK: + break; + + case STATUS_EXIT: + fprintf(stderr, "Error: The ucode handler invoked exit(%d)\n", exitcode); + exit(exitcode ? exitcode : 1); + + case ERROR_COMPILE: + fprintf(stderr, "Error: Compilation error while executing ucode handler\n"); + exit(1); + + case ERROR_RUNTIME: + fprintf(stderr, "Error: Runtime error while executing ucode handler\n"); + exit(2); + } + + v = ucv_object_get(uc_vm_scope_get(vm), UH_UCODE_CB, NULL); + + if (!ucv_is_callable(v)) { + fprintf(stderr, "Error: The ucode handler declares no " UH_UCODE_CB "() callback.\n"); + exit(1); + } + + uc_vm_exception_handler_set(vm, uh_ucode_exception); + + ucv_gc(vm); + + fclose(vm->output); + + vm->output = stdout; +} + +static void +ucode_main(struct client *cl, struct path_info *pi, char *url) +{ + uc_vm_t *vm = ¤t_prefix->ctx; + uc_value_t *req, *hdr, *res; + int path_len, prefix_len; + struct blob_attr *cur; + struct env_var *var; + char *str; + int rem; + + /* new env table for this request */ + req = ucv_object_new(vm); + + prefix_len = strlen(pi->name); + path_len = strlen(url); + str = strchr(url, '?'); + + if (str) { + if (*(str + 1)) + pi->query = str + 1; + + path_len = str - url; + } + + if (prefix_len > 0 && pi->name[prefix_len - 1] == '/') + prefix_len--; + + if (path_len > prefix_len) { + ucv_object_add(req, "PATH_INFO", + ucv_string_new_length(url + prefix_len, path_len - prefix_len)); + } + + for (var = ops->get_process_vars(cl, pi); var->name; var++) { + if (!var->value) + continue; + + ucv_object_add(req, var->name, ucv_string_new(var->value)); + } + + ucv_object_add(req, "HTTP_VERSION", + ucv_double_new(0.9 + (cl->request.version / 10.0))); + + hdr = ucv_object_new(vm); + + blob_for_each_attr(cur, cl->hdr.head, rem) + ucv_object_add(hdr, blobmsg_name(cur), ucv_string_new(blobmsg_data(cur))); + + ucv_object_add(req, "headers", hdr); + + res = uc_vm_invoke(vm, UH_UCODE_CB, 1, req); + + ucv_put(req); + ucv_put(res); + + exit(0); +} + +static void +ucode_handle_request(struct client *cl, char *url, struct path_info *pi) +{ + struct ucode_prefix *p; + static struct path_info _pi; + + list_for_each_entry(p, &conf.ucode_prefix, list) { + if (!ops->path_match(p->prefix, url)) + continue; + + pi = &_pi; + pi->name = p->prefix; + pi->phys = p->handler; + + current_prefix = p; + + if (!ops->create_process(cl, pi, url, ucode_main)) { + ops->client_error(cl, 500, "Internal Server Error", + "Failed to create CGI process: %s", + strerror(errno)); + } + + return; + } + + ops->client_error(cl, 500, "Internal Server Error", + "Failed to lookup matching handler"); +} + +static bool +check_ucode_url(const char *url) +{ + struct ucode_prefix *p; + + list_for_each_entry(p, &conf.ucode_prefix, list) + if (ops->path_match(p->prefix, url)) + return true; + + return false; +} + +static struct dispatch_handler ucode_dispatch = { + .script = true, + .check_url = check_ucode_url, + .handle_request = ucode_handle_request, +}; + +static int +ucode_plugin_init(const struct uhttpd_ops *o, struct config *c) +{ + struct ucode_prefix *p; + + ops = o; + _conf = c; + + list_for_each_entry(p, &conf.ucode_prefix, list) + uh_ucode_state_init(p); + + ops->dispatch_add(&ucode_dispatch); + return 0; +} + +struct uhttpd_plugin uhttpd_plugin = { + .init = ucode_plugin_init, +}; @@ -33,6 +33,9 @@ #include <libubus.h> #include <json-c/json.h> #endif +#ifdef HAVE_UCODE +#include <ucode/vm.h> +#endif #ifdef HAVE_TLS #include <libubox/ustream-ssl.h> #endif @@ -59,6 +62,15 @@ struct lua_prefix { void *ctx; }; +#ifdef HAVE_UCODE +struct ucode_prefix { + struct list_head list; + const char *handler; + const char *prefix; + uc_vm_t ctx; +}; +#endif + struct config { const char *docroot; const char *realm; @@ -85,6 +97,9 @@ struct config { int events_retry; struct list_head cgi_alias; struct list_head lua_prefix; +#ifdef HAVE_UCODE + struct list_head ucode_prefix; +#endif }; struct auth_realm { |