diff options
Diffstat (limited to 'lua')
| -rw-r--r-- | lua/sandborb/.gitignore | 3 | ||||
| -rw-r--r-- | lua/sandborb/app.c | 95 | ||||
| -rwxr-xr-x | lua/sandborb/build.sh | 13 | ||||
| -rw-r--r-- | lua/sandborb/json.lua | 388 | ||||
| -rw-r--r-- | lua/sandborb/route_handler.lua | 37 | ||||
| -rw-r--r-- | lua/sandborb/sandbird.c | 979 | ||||
| -rw-r--r-- | lua/sandborb/sandbird.h | 91 |
7 files changed, 1606 insertions, 0 deletions
diff --git a/lua/sandborb/.gitignore b/lua/sandborb/.gitignore new file mode 100644 index 0000000..92e5c23 --- /dev/null +++ b/lua/sandborb/.gitignore @@ -0,0 +1,3 @@ +/a.out +/.vscode +*.gch \ No newline at end of file diff --git a/lua/sandborb/app.c b/lua/sandborb/app.c new file mode 100644 index 0000000..1cfa6d0 --- /dev/null +++ b/lua/sandborb/app.c @@ -0,0 +1,95 @@ +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <lua.h> +#include <lualib.h> +#include <lauxlib.h> + +#include "sandbird.h" + +/* Functions to be called from Lua */ +static int l_sb_send_header(lua_State *L) { + sb_Event *e = lua_touserdata(L, 1); + const char *key = lua_tostring(L, 2); + const char *value = lua_tostring(L, 3); + sb_send_header(e->stream, key, value); + return 0; /* Number of return values */ +} + +static int l_sb_send_status(lua_State *L) { + sb_Event *e = lua_touserdata(L, 1); + int status = lua_tointeger(L, 2); + const char *message = lua_tostring(L, 3); + sb_send_status(e->stream, status, message); + return 0; /* Number of return values */ +} + +static int event_handler(sb_Event *e) { + if (e->type == SB_EV_REQUEST) { + printf("%s - %s %s\n", e->address, e->method, e->path); + + lua_State *L = luaL_newstate(); /* create a new Lua state */ + luaL_openlibs(L); /* load Lua libraries */ + + /* Expose our functions to Lua */ + lua_pushcfunction(L, l_sb_send_header); + lua_setglobal(L, "sb_send_header"); + lua_pushcfunction(L, l_sb_send_status); + lua_setglobal(L, "sb_send_status"); + + /* load and run the Lua script */ + if (luaL_dofile(L, "route_handler.lua") != LUA_OK) { + fprintf(stderr, "Failed to load Lua script: %s\n", lua_tostring(L, -1)); + lua_close(L); + return SB_RES_OK; + } + + /* call the Lua function */ + lua_getglobal(L, "HANDLE_ROUTE"); /* all caps because it is a global function */ + lua_pushlightuserdata(L, e); /* Pass the event as userdata to Lua */ + lua_pushstring(L, e->path); + if (lua_pcall(L, 2, 1, 0) != LUA_OK) { + fprintf(stderr, "Failed to call Lua function: %s\n", lua_tostring(L, -1)); + lua_close(L); + return SB_RES_OK; + } + + /* get the result from the Lua function */ + const char *response = lua_tostring(L, -1); + lua_pop(L, 1); + + sb_writef(e->stream, response); + + lua_close(L); /* close the Lua state */ + } + return SB_RES_OK; +} + + +int main(void) { + sb_Options opt; + sb_Server *server; + + memset(&opt, 0, sizeof(opt)); + opt.port = "8000"; + opt.handler = event_handler; + + server = sb_new_server(&opt); + + if (!server) { + fprintf(stderr, "failed to initialize server\n"); + exit(EXIT_FAILURE); + } + + printf("Server running at http://localhost:%s\n", opt.port); + + for (;;) { + sb_poll_server(server, 1000); + } + + sb_close_server(server); + return EXIT_SUCCESS; +} + + + diff --git a/lua/sandborb/build.sh b/lua/sandborb/build.sh new file mode 100755 index 0000000..28f1724 --- /dev/null +++ b/lua/sandborb/build.sh @@ -0,0 +1,13 @@ +#!/usr/bin/env sh + +if [ -f a.out ]; then + rm a.out +fi + +cc app.c sandbird.c -I /opt/homebrew/include/lua5.4 sandbird.h -std=c99 -pedantic -Wall -Wextra -llua + +if [ -f a.out ]; then + ./a.out +else + echo "Build failed" +fi \ No newline at end of file diff --git a/lua/sandborb/json.lua b/lua/sandborb/json.lua new file mode 100644 index 0000000..711ef78 --- /dev/null +++ b/lua/sandborb/json.lua @@ -0,0 +1,388 @@ +-- +-- json.lua +-- +-- Copyright (c) 2020 rxi +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +-- of the Software, and to permit persons to whom the Software is furnished to do +-- so, subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all +-- copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +-- SOFTWARE. +-- + +local json = { _version = "0.1.2" } + +------------------------------------------------------------------------------- +-- Encode +------------------------------------------------------------------------------- + +local encode + +local escape_char_map = { + [ "\\" ] = "\\", + [ "\"" ] = "\"", + [ "\b" ] = "b", + [ "\f" ] = "f", + [ "\n" ] = "n", + [ "\r" ] = "r", + [ "\t" ] = "t", +} + +local escape_char_map_inv = { [ "/" ] = "/" } +for k, v in pairs(escape_char_map) do + escape_char_map_inv[v] = k +end + + +local function escape_char(c) + return "\\" .. (escape_char_map[c] or string.format("u%04x", c:byte())) +end + + +local function encode_nil(val) + return "null" +end + + +local function encode_table(val, stack) + local res = {} + stack = stack or {} + + -- Circular reference? + if stack[val] then error("circular reference") end + + stack[val] = true + + if rawget(val, 1) ~= nil or next(val) == nil then + -- Treat as array -- check keys are valid and it is not sparse + local n = 0 + for k in pairs(val) do + if type(k) ~= "number" then + error("invalid table: mixed or invalid key types") + end + n = n + 1 + end + if n ~= #val then + error("invalid table: sparse array") + end + -- Encode + for i, v in ipairs(val) do + table.insert(res, encode(v, stack)) + end + stack[val] = nil + return "[" .. table.concat(res, ",") .. "]" + + else + -- Treat as an object + for k, v in pairs(val) do + if type(k) ~= "string" then + error("invalid table: mixed or invalid key types") + end + table.insert(res, encode(k, stack) .. ":" .. encode(v, stack)) + end + stack[val] = nil + return "{" .. table.concat(res, ",") .. "}" + end +end + + +local function encode_string(val) + return '"' .. val:gsub('[%z\1-\31\\"]', escape_char) .. '"' +end + + +local function encode_number(val) + -- Check for NaN, -inf and inf + if val ~= val or val <= -math.huge or val >= math.huge then + error("unexpected number value '" .. tostring(val) .. "'") + end + return string.format("%.14g", val) +end + + +local type_func_map = { + [ "nil" ] = encode_nil, + [ "table" ] = encode_table, + [ "string" ] = encode_string, + [ "number" ] = encode_number, + [ "boolean" ] = tostring, +} + + +encode = function(val, stack) + local t = type(val) + local f = type_func_map[t] + if f then + return f(val, stack) + end + error("unexpected type '" .. t .. "'") +end + + +function json.encode(val) + return ( encode(val) ) +end + + +------------------------------------------------------------------------------- +-- Decode +------------------------------------------------------------------------------- + +local parse + +local function create_set(...) + local res = {} + for i = 1, select("#", ...) do + res[ select(i, ...) ] = true + end + return res +end + +local space_chars = create_set(" ", "\t", "\r", "\n") +local delim_chars = create_set(" ", "\t", "\r", "\n", "]", "}", ",") +local escape_chars = create_set("\\", "/", '"', "b", "f", "n", "r", "t", "u") +local literals = create_set("true", "false", "null") + +local literal_map = { + [ "true" ] = true, + [ "false" ] = false, + [ "null" ] = nil, +} + + +local function next_char(str, idx, set, negate) + for i = idx, #str do + if set[str:sub(i, i)] ~= negate then + return i + end + end + return #str + 1 +end + + +local function decode_error(str, idx, msg) + local line_count = 1 + local col_count = 1 + for i = 1, idx - 1 do + col_count = col_count + 1 + if str:sub(i, i) == "\n" then + line_count = line_count + 1 + col_count = 1 + end + end + error( string.format("%s at line %d col %d", msg, line_count, col_count) ) +end + + +local function codepoint_to_utf8(n) + -- http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=iws-appendixa + local f = math.floor + if n <= 0x7f then + return string.char(n) + elseif n <= 0x7ff then + return string.char(f(n / 64) + 192, n % 64 + 128) + elseif n <= 0xffff then + return string.char(f(n / 4096) + 224, f(n % 4096 / 64) + 128, n % 64 + 128) + elseif n <= 0x10ffff then + return string.char(f(n / 262144) + 240, f(n % 262144 / 4096) + 128, + f(n % 4096 / 64) + 128, n % 64 + 128) + end + error( string.format("invalid unicode codepoint '%x'", n) ) +end + + +local function parse_unicode_escape(s) + local n1 = tonumber( s:sub(1, 4), 16 ) + local n2 = tonumber( s:sub(7, 10), 16 ) + -- Surrogate pair? + if n2 then + return codepoint_to_utf8((n1 - 0xd800) * 0x400 + (n2 - 0xdc00) + 0x10000) + else + return codepoint_to_utf8(n1) + end +end + + +local function parse_string(str, i) + local res = "" + local j = i + 1 + local k = j + + while j <= #str do + local x = str:byte(j) + + if x < 32 then + decode_error(str, j, "control character in string") + + elseif x == 92 then -- `\`: Escape + res = res .. str:sub(k, j - 1) + j = j + 1 + local c = str:sub(j, j) + if c == "u" then + local hex = str:match("^[dD][89aAbB]%x%x\\u%x%x%x%x", j + 1) + or str:match("^%x%x%x%x", j + 1) + or decode_error(str, j - 1, "invalid unicode escape in string") + res = res .. parse_unicode_escape(hex) + j = j + #hex + else + if not escape_chars[c] then + decode_error(str, j - 1, "invalid escape char '" .. c .. "' in string") + end + res = res .. escape_char_map_inv[c] + end + k = j + 1 + + elseif x == 34 then -- `"`: End of string + res = res .. str:sub(k, j - 1) + return res, j + 1 + end + + j = j + 1 + end + + decode_error(str, i, "expected closing quote for string") +end + + +local function parse_number(str, i) + local x = next_char(str, i, delim_chars) + local s = str:sub(i, x - 1) + local n = tonumber(s) + if not n then + decode_error(str, i, "invalid number '" .. s .. "'") + end + return n, x +end + + +local function parse_literal(str, i) + local x = next_char(str, i, delim_chars) + local word = str:sub(i, x - 1) + if not literals[word] then + decode_error(str, i, "invalid literal '" .. word .. "'") + end + return literal_map[word], x +end + + +local function parse_array(str, i) + local res = {} + local n = 1 + i = i + 1 + while 1 do + local x + i = next_char(str, i, space_chars, true) + -- Empty / end of array? + if str:sub(i, i) == "]" then + i = i + 1 + break + end + -- Read token + x, i = parse(str, i) + res[n] = x + n = n + 1 + -- Next token + i = next_char(str, i, space_chars, true) + local chr = str:sub(i, i) + i = i + 1 + if chr == "]" then break end + if chr ~= "," then decode_error(str, i, "expected ']' or ','") end + end + return res, i +end + + +local function parse_object(str, i) + local res = {} + i = i + 1 + while 1 do + local key, val + i = next_char(str, i, space_chars, true) + -- Empty / end of object? + if str:sub(i, i) == "}" then + i = i + 1 + break + end + -- Read key + if str:sub(i, i) ~= '"' then + decode_error(str, i, "expected string for key") + end + key, i = parse(str, i) + -- Read ':' delimiter + i = next_char(str, i, space_chars, true) + if str:sub(i, i) ~= ":" then + decode_error(str, i, "expected ':' after key") + end + i = next_char(str, i + 1, space_chars, true) + -- Read value + val, i = parse(str, i) + -- Set + res[key] = val + -- Next token + i = next_char(str, i, space_chars, true) + local chr = str:sub(i, i) + i = i + 1 + if chr == "}" then break end + if chr ~= "," then decode_error(str, i, "expected '}' or ','") end + end + return res, i +end + + +local char_func_map = { + [ '"' ] = parse_string, + [ "0" ] = parse_number, + [ "1" ] = parse_number, + [ "2" ] = parse_number, + [ "3" ] = parse_number, + [ "4" ] = parse_number, + [ "5" ] = parse_number, + [ "6" ] = parse_number, + [ "7" ] = parse_number, + [ "8" ] = parse_number, + [ "9" ] = parse_number, + [ "-" ] = parse_number, + [ "t" ] = parse_literal, + [ "f" ] = parse_literal, + [ "n" ] = parse_literal, + [ "[" ] = parse_array, + [ "{" ] = parse_object, +} + + +parse = function(str, idx) + local chr = str:sub(idx, idx) + local f = char_func_map[chr] + if f then + return f(str, idx) + end + decode_error(str, idx, "unexpected character '" .. chr .. "'") +end + + +function json.decode(str) + if type(str) ~= "string" then + error("expected argument of type string, got " .. type(str)) + end + local res, idx = parse(str, next_char(str, 1, space_chars, true)) + idx = next_char(str, idx, space_chars, true) + if idx <= #str then + decode_error(str, idx, "trailing garbage") + end + return res +end + + +return json diff --git a/lua/sandborb/route_handler.lua b/lua/sandborb/route_handler.lua new file mode 100644 index 0000000..98ece1d --- /dev/null +++ b/lua/sandborb/route_handler.lua @@ -0,0 +1,37 @@ +local json = require "json" + +local function brackets(e) + sb_send_status(e, 200, "OK") + sb_send_header(e, "Content-Type", "application/json") + return json.encode({ 1, 2, 3, { x = 10 } }) +end + +local function banana(e) + sb_send_status(e, 200, "OK") + sb_send_header(e, "Content-Type", "text/html, charset=utf-8") + return "<h1>Bananas are delicious!</h1>" +end + +local function error_404(e,p) + sb_send_status(e, 404, "Not Found") + sb_send_header(e, "Content-Type", "text/html, charset=utf-8") + return "<h1>404 - Page not found: " .. p .. "</h1>" +end + +function HANDLE_ROUTE(e, path) + if path == "/" then + sb_send_status(e, 200, "OK") + sb_send_header(e, "Content-Type", "text/html, charset=utf-8") + return "Hello, you are at the root!" + elseif path == "/about" then + sb_send_status(e, 200, "OK") + sb_send_header(e, "Content-Type", "text/text") + return "This is the about page!" + elseif path == "/banana" then + return banana(e) + elseif path == "/json" then + return brackets(e) + else + return error_404(e, path) + end +end \ No newline at end of file diff --git a/lua/sandborb/sandbird.c b/lua/sandborb/sandbird.c new file mode 100644 index 0000000..e08c287 --- /dev/null +++ b/lua/sandborb/sandbird.c @@ -0,0 +1,979 @@ +/** + * Copyright (c) 2016 rxi + * + * This library is free software; you can redistribute it and/or modify it + * under the terms of the MIT license. See LICENSE for details. + */ + + +#ifdef _WIN32 + #ifndef _WIN32_WINNT + #define _WIN32_WINNT 0x501 + #endif + #ifndef _CRT_SECURE_NO_WARNINGS + #define _CRT_SECURE_NO_WARNINGS + #endif + #ifndef FD_SETSIZE + #define FD_SETSIZE 2048 + #endif + #include <winsock2.h> + #include <ws2tcpip.h> + #include <windows.h> +#else + #ifndef _POSIX_C_SOURCE + #define _POSIX_C_SOURCE 200809L + #endif + #include <unistd.h> + #include <fcntl.h> + #include <netdb.h> + #include <sys/types.h> + #include <sys/socket.h> + #include <sys/select.h> + #include <arpa/inet.h> + #include <netinet/in.h> +#endif +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <ctype.h> +#include <time.h> +#include <signal.h> +#include <errno.h> + +#include "sandbird.h" + + +#ifdef _WIN32 + #define close(a) closesocket(a) + #define setsockopt(a, b, c, d, e) setsockopt(a, b, c, (char*)(d), e) + + #undef errno + #define errno WSAGetLastError() + + #undef EWOULDBLOCK + #define EWOULDBLOCK WSAEWOULDBLOCK + + const char *inet_ntop(int af, const void *src, char *dst, socklen_t size) { + union { struct sockaddr sa; struct sockaddr_in sai; + struct sockaddr_in6 sai6; } addr; + int res; + memset(&addr, 0, sizeof(addr)); + addr.sa.sa_family = af; + if (af == AF_INET6) { + memcpy(&addr.sai6.sin6_addr, src, sizeof(addr.sai6.sin6_addr)); + } else { + memcpy(&addr.sai.sin_addr, src, sizeof(addr.sai.sin_addr)); + } + res = WSAAddressToStringA(&addr.sa, sizeof(addr), 0, dst, (LPDWORD) &size); + if (res != 0) return NULL; + return dst; + } +#endif + +#ifdef _WIN32 + typedef SOCKET sb_Socket; +#else + typedef int sb_Socket; + #define INVALID_SOCKET -1 +#endif + +typedef struct sb_Buffer sb_Buffer; + +struct sb_Buffer { char *s; size_t len, cap; }; + +struct sb_Stream { + int state; /* Current state of the stream */ + sb_Server *server; /* The server object which owns this stream */ + char address[46]; /* Remote IP address */ + time_t init_time; /* Time the stream was created */ + time_t last_activity; /* Time of Last I/O activity on the stream */ + size_t expected_recv_len; /* Expected length of the stream's request */ + size_t data_idx; /* Index of data section in recv_buf */ + sb_Socket sockfd; /* Socket for this streams connection */ + sb_Buffer recv_buf; /* Data received from client */ + sb_Buffer send_buf; /* Data waiting to be sent to client */ + FILE *send_fp; /* File currently being sent to client */ + sb_Stream *next; /* Next stream in linked list */ +}; + +struct sb_Server { + sb_Stream *streams; /* Linked list of all streams */ + sb_Handler handler; /* Event handler callback function */ + sb_Socket sockfd; /* Listeneing server socket */ + void *udata; /* User data value passed to all events */ + time_t now; /* The current time */ + time_t timeout; /* Stream no-activity timeout */ + time_t max_lifetime; /* Maximum time a stream can exist */ + size_t max_request_size; /* Maximum request size in bytes */ +}; + +enum { + STATE_RECEIVING_HEADER, + STATE_RECEIVING_REQUEST, + STATE_SENDING_STATUS, + STATE_SENDING_HEADER, + STATE_SENDING_DATA, + STATE_SENDING_FILE, + STATE_CLOSING +}; + + +/*=========================================================================== + * Utility + *===========================================================================*/ + +static void set_socket_non_blocking(sb_Socket sockfd) { +#ifdef _WIN32 + u_long mode = 1; + ioctlsocket(sockfd, FIONBIO, &mode); +#else + int flags = fcntl(sockfd, F_GETFL); + fcntl(sockfd, F_SETFL, flags | O_NONBLOCK); +#endif +} + + +static int get_socket_address(sb_Socket sockfd, char *dst) { + int err; + union { struct sockaddr sa; struct sockaddr_storage sas; + struct sockaddr_in sai; struct sockaddr_in6 sai6; } addr; + socklen_t sz = sizeof(addr); + err = getpeername(sockfd, &addr.sa, &sz); + if (err == -1) { + *dst = '\0'; + return SB_EFAILURE; + } + if (addr.sas.ss_family == AF_INET6) { + inet_ntop(AF_INET6, &addr.sai6.sin6_addr, dst, INET6_ADDRSTRLEN); + } else { + inet_ntop(AF_INET, &addr.sai.sin_addr, dst, INET_ADDRSTRLEN); + } + return SB_ESUCCESS; +} + + +static unsigned str_to_uint(const char *str) { + unsigned n; + if (!str || sscanf(str, "%u", &n) != 1) return 0; + return n; +} + + +static int hex_to_int(int chr) { + return isdigit(chr) ? (chr - '0') : (tolower(chr) - 'a' + 10); +} + + +static int url_decode(char *dst, const char *src, size_t len) { + len--; + while (*src && !strchr("?& \t\r\n", *src) && len) { + if (src[0] == '%' && src[1] && src[2]) { + *dst = (hex_to_int(src[1]) << 4) | hex_to_int(src[2]); + src += 2; + } else if (*src == '+') { + *dst = ' '; + } else { + *dst = *src; + } + dst++, src++, len--; + } + *dst = '\0'; + return (len == 0) ? SB_ETRUNCATED : SB_ESUCCESS; +} + + +static int mem_equal(const void *a, const void *b, size_t len) { + const char *p = a, *q = b; + while (len) { + if (*p != *q) return 0; + p++, q++, len--; + } + return 1; +} + + +static int mem_case_equal(const void *a, const void *b, size_t len) { + const char *p = a, *q = b; + while (len) { + if (tolower(*p) != tolower(*q)) return 0; + p++, q++, len--; + } + return 1; +} + + +static const char *find_header_value(const char *str, const char *field) { + size_t len = strlen(field); + while (*str && !mem_equal(str, "\r\n", 2)) { + if (mem_case_equal(str, field, len) && str[len] == ':') { + str += len + 1; + return str + strspn(str, " \t"); + } + str += strcspn(str, "\r"); + str += mem_equal(str, "\r\n", 2) ? 2 : 0; + } + return NULL; +} + + +static const char *find_var_value(const char *str, const char *name) { + size_t len = strlen(name); + for (;;) { + if (mem_equal(str, name, len) && str[len] == '=') { + return str + len + 1; + } + str += strcspn(str, "& \t\r\n"); + if (*str != '&') break; + str++; + } + return NULL; +} + + +const char *sb_error_str(int code) { + switch (code) { + case SB_ESUCCESS : return "success"; + case SB_EFAILURE : return "failure"; + case SB_EOUTOFMEM : return "out of memory"; + case SB_ETRUNCATED : return "result truncated"; + case SB_EBADSTATE : return "bad stream state for this operation"; + case SB_EBADRESULT : return "bad result code from event handler"; + case SB_ECANTOPEN : return "cannot open file"; + case SB_ENOTFOUND : return "not found"; + case SB_EFDTOOBIG : return "got socket fd larger than FD_SETSIZE"; + default : return "unknown"; + } +} + + +/*=========================================================================== + * Buffer + *===========================================================================*/ + +static void sb_buffer_init(sb_Buffer *buf) { + memset(buf, 0, sizeof(*buf)); +} + + +static void sb_buffer_deinit(sb_Buffer *buf) { + free(buf->s); +} + + +static void sb_buffer_shift(sb_Buffer *buf, size_t n) { + buf->len -= n; + memmove(buf->s, buf->s + n, buf->len); +} + + +static int sb_buffer_reserve(sb_Buffer *buf, size_t n) { + void *p; + if (buf->cap >= n) return SB_ESUCCESS; + p = realloc(buf->s, n); + if (!p) return SB_EOUTOFMEM; + buf->s = p; + buf->cap = n; + return SB_ESUCCESS; +} + + +static int sb_buffer_push_char(sb_Buffer *buf, char chr) { + if (buf->len == buf->cap) { + int err = sb_buffer_reserve(buf, (buf->cap << 1) | (!buf->cap)); + if (err) return err; + } + buf->s[buf->len++] = chr; + return SB_ESUCCESS; +} + + +static int sb_buffer_push_str(sb_Buffer *buf, const char *p, size_t len) { + int err; + size_t orig_len = buf->len; + while (len) { + err = sb_buffer_push_char(buf, *p); + if (err) { + buf->len = orig_len; + return err; + } + p++, len--; + } + return SB_ESUCCESS; +} + + +static int sb_buffer_vwritef(sb_Buffer *buf, const char *fmt, va_list args) { + int err; + size_t orig_len = buf->len; + char fbuf[64]; + char lbuf[512]; + char *s; + + while (*fmt) { + if (*fmt == '%') { + switch (*++fmt) { + + case 's': + s = va_arg(args, char*); + if (s == NULL) s = "(null)"; + err = sb_buffer_push_str(buf, s, strlen(s)); + if (err) goto fail; + break; + + default: + fbuf[0] = '%'; + s = fbuf + 1; + while ( !isalpha(*fmt) && *fmt != '%' ) *s++ = *fmt++; + s[0] = *fmt, s[1] = '\0'; + switch (*fmt) { + case 'f': + case 'g': sprintf(lbuf, fbuf, va_arg(args, double)); break; + case 'c': + case 'd': + case 'i': sprintf(lbuf, fbuf, va_arg(args, int)); break; + case 'u': + case 'x': + case 'X': sprintf(lbuf, fbuf, va_arg(args, unsigned)); break; + case 'p': sprintf(lbuf, fbuf, va_arg(args, void*)); break; + default : lbuf[0] = *fmt, lbuf[1] = '\0'; + } + err = sb_buffer_push_str(buf, lbuf, strlen(lbuf)); + if (err) goto fail; + } + } else { + err = sb_buffer_push_char(buf, *fmt); + if (err) goto fail; + } + fmt++; + } + + return SB_ESUCCESS; + +fail: + buf->len = orig_len; + return err; +} + + +static int sb_buffer_writef(sb_Buffer *buf, const char *fmt, ...) { + int err; + va_list args; + va_start(args, fmt); + err = sb_buffer_vwritef(buf, fmt, args); + va_end(args); + return err; +} + + +static int sb_buffer_null_terminate(sb_Buffer *buf) { + int err = sb_buffer_push_char(buf, '\0'); + if (err) return err; + buf->len--; + return SB_ESUCCESS; +} + + +/*=========================================================================== + * Stream + *===========================================================================*/ + +static sb_Stream *sb_stream_new(sb_Server *srv, sb_Socket sockfd) { + sb_Stream *st = malloc( sizeof(*st) ); + if (!st) return NULL; + memset(st, 0, sizeof(*st)); + sb_buffer_init(&st->recv_buf); + sb_buffer_init(&st->send_buf); + st->sockfd = sockfd; + st->server = srv; + st->init_time = srv->now; + st->last_activity = srv->now; + set_socket_non_blocking(sockfd); + get_socket_address(sockfd, st->address); + return st; +} + + +static void sb_stream_close(sb_Stream *st) { + st->state = STATE_CLOSING; +} + + +static int sb_stream_emit(sb_Stream *st, sb_Event *e) { + int res; + e->stream = st; + e->udata = st->server->udata; + e->server = st->server; + e->address = st->address; + res = e->server->handler(e); + if (res < 0) return res; + switch (res) { + case SB_RES_CLOSE : sb_stream_close(st); /* Fall through */ + case SB_RES_OK : return SB_ESUCCESS; + default : return SB_EBADRESULT; + } +} + + +static void sb_stream_destroy(sb_Stream *st) { + sb_Event e; + /* Emit close event */ + e.type = SB_EV_CLOSE; + sb_stream_emit(st, &e); + /* Clean up */ + close(st->sockfd); + if (st->send_fp) fclose(st->send_fp); + sb_buffer_deinit(&st->recv_buf); + sb_buffer_deinit(&st->send_buf); + free(st); +} + + +static int sb_stream_recv(sb_Stream *st) { + for (;;) { + char buf[4096]; + int err, i, sz; + + /* Receive data */ + sz = recv(st->sockfd, buf, sizeof(buf) - 1, 0); + if (sz <= 0) { + /* Disconnected? */ + if (sz == 0 || errno != EWOULDBLOCK) { + sb_stream_close(st); + } + return SB_ESUCCESS; + } + + /* Update last_activity */ + st->last_activity = st->server->now; + + /* Write to recv_buf */ + for (i = 0; i < sz; i++) { + err = sb_buffer_push_char(&st->recv_buf, buf[i]); + if (err) return err; + + /* Have we received the whole header? */ + if ( + st->state == STATE_RECEIVING_HEADER && + st->recv_buf.len >= 4 && + mem_equal(st->recv_buf.s + st->recv_buf.len - 4, "\r\n\r\n", 4) + ) { + const char *s; + /* Update stream's current state */ + st->state = STATE_RECEIVING_REQUEST; + /* Assure recv_buf is null-terminated */ + err = sb_buffer_null_terminate(&st->recv_buf); + if (err) return err; + /* If the header contains the Content-Length field we set the + * expected_recv_len and continue writing to the recv_buf, otherwise we + * assume the request is complete */ + s = find_header_value(st->recv_buf.s, "Content-Length"); + if (s) { + st->expected_recv_len = st->recv_buf.len + str_to_uint(s); + st->data_idx = st->recv_buf.len; + } else { + goto handle_request; + } + } + + /* Have we received all the data we're expecting? */ + if (st->expected_recv_len == st->recv_buf.len) { + /* Handle request */ + sb_Event e; + int n, path_idx; + char method[16], path[512], ver[16]; +handle_request: + st->state = STATE_SENDING_STATUS; + /* Assure recv_buf string is NULL-terminated */ + err = sb_buffer_null_terminate(&st->recv_buf); + if (err) return err; + /* Get method, path, version */ + n = sscanf(st->recv_buf.s, "%15s %n%*s %15s", method, &path_idx, ver); + /* Is request line invalid? */ + if (n != 2 || !mem_equal(ver, "HTTP", 4)) { + sb_stream_close(st); + return SB_ESUCCESS; + } + /* Build and emit `request` event */ + url_decode(path, st->recv_buf.s + path_idx, sizeof(path)); + e.type = SB_EV_REQUEST; + e.method = method; + e.path = path; + err = sb_stream_emit(st, &e); + if (err) return err; + /* No more data needs to be received (nor should it exist) */ + return SB_ESUCCESS; + } + } + } + + return SB_ESUCCESS; +} + + +static int sb_stream_send(sb_Stream *st) { + if (st->send_buf.len > 0) { + int sz; + + /* Send data */ +send_data: + sz = send(st->sockfd, st->send_buf.s, st->send_buf.len, 0); + if (sz <= 0) { + /* Disconnected? */ + if (errno != EWOULDBLOCK) { + sb_stream_close(st); + } + return SB_ESUCCESS; + } + + /* Remove sent bytes from buffer */ + sb_buffer_shift(&st->send_buf, sz); + + /* Update last_activity */ + st->last_activity = st->server->now; + + } else if (st->send_fp) { + /* Read chunk, write to stream and continue sending */ + int err = sb_buffer_reserve(&st->send_buf, 8192); + if (err) return err; + st->send_buf.len = fread(st->send_buf.s, 1, st->send_buf.cap, st->send_fp); + if (st->send_buf.len > 0) goto send_data; + + /* Reached end of file */ + fclose(st->send_fp); + st->send_fp = NULL; + + } else { + /* No more data left -- disconnect */ + sb_stream_close(st); + } + + return SB_ESUCCESS; +} + + +static int sb_stream_finalize_header(sb_Stream *st) { + int err; + if (st->state < STATE_SENDING_HEADER) { + err = sb_send_status(st, 200, "OK"); + if (err) return err; + } + err = sb_buffer_push_str(&st->send_buf, "\r\n", 2); + if (err) return err; + st->state = STATE_SENDING_DATA; + return SB_ESUCCESS; +} + + +int sb_send_status(sb_Stream *st, int code, const char *msg) { + int err; + if (st->state != STATE_SENDING_STATUS) { + return SB_EBADSTATE; + } + err = sb_buffer_writef(&st->send_buf, "HTTP/1.1 %d %s\r\n", code, msg); + if (err) return err; + st->state = STATE_SENDING_HEADER; + return SB_ESUCCESS; +} + + +int sb_send_header(sb_Stream *st, const char *field, const char *val) { + int err; + if (st->state > STATE_SENDING_HEADER) { + return SB_EBADSTATE; + } + if (st->state < STATE_SENDING_HEADER) { + err = sb_send_status(st, 200, "OK"); + if (err) return err; + } + err = sb_buffer_writef(&st->send_buf, "%s: %s\r\n", field, val); + if (err) return err; + return SB_ESUCCESS; +} + + +int sb_send_file(sb_Stream *st, const char *filename) { + int err; + char buf[32]; + size_t sz; + FILE *fp = NULL; + if (st->state > STATE_SENDING_HEADER) { + return SB_EBADSTATE; + } + /* Try to open file */ + fp = fopen(filename, "rb"); + if (!fp) return SB_ECANTOPEN; + + /* Get file size and write headers */ + fseek(fp, 0, SEEK_END); + sz = ftell(fp); + sprintf(buf, "%u", (unsigned) sz); + err = sb_send_header(st, "Content-Length", buf); + if (err) goto fail; + err = sb_stream_finalize_header(st); + if (err) goto fail; + + /* Rewind file, set stream's fp and state */ + fseek(fp, 0, SEEK_SET); + st->send_fp = fp; + st->state = STATE_SENDING_FILE; + return SB_ESUCCESS; + +fail: + if (fp) fclose(fp); + return err; +} + + +int sb_write(sb_Stream *st, const void *data, size_t len) { + if (st->state < STATE_SENDING_DATA) { + int err = sb_stream_finalize_header(st); + if (err) return err; + } + if (st->state != STATE_SENDING_DATA) return SB_EBADSTATE; + return sb_buffer_push_str(&st->send_buf, data, len); +} + + +int sb_vwritef(sb_Stream *st, const char *fmt, va_list args) { + if (st->state < STATE_SENDING_DATA) { + int err = sb_stream_finalize_header(st); + if (err) return err; + } + if (st->state != STATE_SENDING_DATA) return SB_EBADSTATE; + return sb_buffer_vwritef(&st->send_buf, fmt, args); +} + + +int sb_writef(sb_Stream *st, const char *fmt, ...) { + int err; + va_list args; + va_start(args, fmt); + err = sb_vwritef(st, fmt, args); + va_end(args); + return err; +} + + +int sb_get_header(sb_Stream *st, const char *field, char *dst, size_t len) { + size_t n; + int res = SB_ESUCCESS; + const char *s = find_header_value(st->recv_buf.s, field); + if (!s) { + *dst = '\0'; + return SB_ENOTFOUND; + } + n = strchr(s, '\r') - s; + while (n > 1 && strchr(" \t", s[n-1])) n--; /* trim whitespace from end */ + if (n > len - 1) { + n = len - 1; + res = SB_ETRUNCATED; + } + memcpy(dst, s, n); + dst[n] = '\0'; + return res; +} + + +int sb_get_var(sb_Stream *st, const char *name, char *dst, size_t len) { + const char *q, *s = NULL; + + /* Find beginning of query string */ + q = st->recv_buf.s + strcspn(st->recv_buf.s, "?\r"); + q = (*q == '?') ? (q + 1) : NULL; + + /* Try to get var from query string, then data string */ + if (q) s = find_var_value(q, name); + if (!s && st->data_idx) { + s = find_var_value(st->recv_buf.s + st->data_idx, name); + } + if (!s) { + *dst = '\0'; + return SB_ENOTFOUND; + } + return url_decode(dst, s, len); +} + + +int sb_get_cookie(sb_Stream *st, const char *name, char *dst, size_t len) { + size_t n; + const char *s = st->recv_buf.s; + int res = SB_ESUCCESS; + size_t name_len = strlen(name); + + /* Get cookie header */ + s = find_header_value(st->recv_buf.s, "Cookie"); + if (!s) goto fail; + + /* Find var */ + while (*s) { + s += strspn(s, " \t"); + /* Found var? find value, get len, copy value and return */ + if ( mem_case_equal(s, name, name_len) && strchr(" =", s[name_len]) ) { + s += name_len; + s += strspn(s, "= \t\r"); + n = strcspn(s, ";\r"); + if (n >= len - 1) { + n = len - 1; + res = SB_ETRUNCATED; + } + memcpy(dst, s, n); + dst[n] = '\0'; + return res; + } + s += strcspn(s, ";\r"); + if (*s != ';') goto fail; + s++; + } + +fail: + *dst = '\0'; + return SB_ENOTFOUND; +} + + +#define P_ATCHK(x) do { if (!(p = (x))) goto fail; } while (0) +#define P_AFTERL(x, l) do {\ + size_t len__ = (l);\ + for (;; p++) {\ + if (p == end - len__) goto fail;\ + if (mem_equal(p, x, len__)) break;\ + }\ + p += len__;\ + } while (0) +#define P_AFTER(s) P_AFTERL(s, strlen(s)) + +const void *sb_get_multipart(sb_Stream *st, const char *name, size_t *len) { + const char *boundary; + size_t boundary_len; + size_t name_len = strlen(name); + const char *p = st->recv_buf.s; + char *end = st->recv_buf.s + st->recv_buf.len; + + /* Get boundary string */ + P_ATCHK( find_header_value(p, "Content-Type") ); + P_AFTER( "boundary=" ); + boundary = p; + P_AFTER( "\r\n" ); + boundary_len = p - boundary - 2; + +next: + /* Move to after first boundary, then to start of name */ + P_AFTERL( boundary, boundary_len ); + P_AFTER( "\r\n" ); + P_ATCHK( find_header_value(p, "Content-Disposition") ); + P_AFTER( "name=\"" ); + + /* Does the name match what we were looking for? */ + if (mem_equal(p, name, name_len) && p[name_len] == '"') { + const char *res; + /* Move to start of data */ + P_AFTER( "\r\n\r\n" ); + res = p; + /* Find boundary, set length and return result */ + P_AFTERL( boundary, boundary_len ); + *len = p - res - boundary_len - 4; + return res; + } + + /* Try the next part */ + goto next; + +fail: + *len = 0; + return NULL; +} + + +/*=========================================================================== + * Server + *===========================================================================*/ + +sb_Server *sb_new_server(const sb_Options *opt) { + sb_Server *srv; + struct addrinfo hints, *ai = NULL; + int err, optval; + +#ifdef _WIN32 + { WSADATA dat; WSAStartup(MAKEWORD(2, 2), &dat); } +#else + /* Stops the SIGPIPE signal being raised when writing to a closed socket */ + signal(SIGPIPE, SIG_IGN); +#endif + + /* Create server object */ + srv = malloc( sizeof(*srv) ); + if (!srv) goto fail; + memset(srv, 0, sizeof(*srv)); + srv->sockfd = INVALID_SOCKET; + srv->handler = opt->handler; + srv->udata = opt->udata; + srv->timeout = opt->timeout ? str_to_uint(opt->timeout) : 30000; + srv->max_request_size = str_to_uint(opt->max_request_size); + srv->max_lifetime = str_to_uint(opt->max_lifetime); + + /* Get addrinfo */ + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_PASSIVE; + err = getaddrinfo(opt->host, opt->port, &hints, &ai); + if (err) goto fail; + + /* Init socket */ + srv->sockfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); + if (srv->sockfd == INVALID_SOCKET) goto fail; + set_socket_non_blocking(srv->sockfd); + + /* Set SO_REUSEADDR so that the socket can be immediately bound without + * having to wait for any closed socket on the same port to timeout */ + optval = 1; + setsockopt(srv->sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)); + + /* Bind and listen */ + err = bind(srv->sockfd, ai->ai_addr, ai->ai_addrlen); + if (err) goto fail; + err = listen(srv->sockfd, 1023); + if (err) goto fail; + + /* Clean up */ + freeaddrinfo(ai); + ai = NULL; + + return srv; + +fail: + if (ai) freeaddrinfo(ai); + if (srv) sb_close_server(srv); + return NULL; +} + + +void sb_close_server(sb_Server *srv) { + /* Destroy all streams */ + while (srv->streams) { + sb_Stream *st = srv->streams; + srv->streams = st->next; + sb_stream_destroy(st); + } + + /* Clean up */ + if (srv->sockfd != INVALID_SOCKET) { + close(srv->sockfd); + } + free(srv); +} + + +int sb_poll_server(sb_Server *srv, int timeout) { + sb_Stream *st, **st_next; + fd_set fds_read, fds_write; + sb_Socket max_fd = srv->sockfd; + struct timeval tv; + int err; + + /* Init fd_sets */ + FD_ZERO(&fds_read); + FD_ZERO(&fds_write); + + /* Add server sockfd to fd_set */ + FD_SET(srv->sockfd, &fds_read); + + /* Add streams to fd_sets */ + for (st = srv->streams; st; st = st->next) { + if (st->state >= STATE_SENDING_STATUS) { + FD_SET(st->sockfd, &fds_write); + } else { + FD_SET(st->sockfd, &fds_read); + } + if (st->sockfd > max_fd) max_fd = st->sockfd; + } + + /* Init timeout timeval */ + tv.tv_sec = timeout / 1000; + tv.tv_usec = (timeout % 1000) * 1000; + + /* Do select */ + select(max_fd + 1, &fds_read, &fds_write, NULL, &tv); + + /* Get and store current time */ + srv->now = time(NULL); + + /* Handle existing streams */ + st_next = &srv->streams; + while (*st_next) { + st = *st_next; + + /* Receive data */ + if (FD_ISSET(st->sockfd, &fds_read)) { + err = sb_stream_recv(st); + if (err) return err; + } + + /* Send data */ + if (FD_ISSET(st->sockfd, &fds_write)) { + err = sb_stream_send(st); + if (err) return err; + } + + /* Check stream against timeout, max request length and max lifetime */ + if ( + (srv->timeout && srv->now - st->last_activity > srv->timeout / 1000) || + (srv->max_lifetime && + srv->now - st->init_time > srv->max_lifetime / 1000) || + (srv->max_request_size && st->recv_buf.len >= srv->max_request_size) + ) { + sb_stream_close(st); + } + + /* Handle disconnect -- destroy stream */ + if (st->state == STATE_CLOSING) { + *st_next = st->next; + sb_stream_destroy(st); + continue; + } + + /* Next */ + st_next = &(*st_next)->next; + } + + /* Handle new streams */ + if (FD_ISSET(srv->sockfd, &fds_read)) { + sb_Event e; + sb_Socket sockfd; + + /* Accept connections */ + while ( (sockfd = accept(srv->sockfd, NULL, NULL)) != INVALID_SOCKET ) { + +#ifdef _WIN32 + /* As the fd_set on windows is an array rather than a bitset, an fd + * value can never be too large for it; thus this check is omitted */ +#else + /* Check FD size, error if it is larger than FD_SETSIZE */ + if (sockfd > FD_SETSIZE) { + close(sockfd); + return SB_EFDTOOBIG; + } +#endif + + /* Init new stream */ + st = sb_stream_new(srv, sockfd); + if (!st) { + close(sockfd); + return SB_EOUTOFMEM; + } + + /* Push stream to list */ + st->next = srv->streams; + srv->streams = st; + + /* Do `connect` event */ + e.type = SB_EV_CONNECT; + err = sb_stream_emit(st, &e); + if (err) return err; + } + } + + return SB_ESUCCESS; +} + + diff --git a/lua/sandborb/sandbird.h b/lua/sandborb/sandbird.h new file mode 100644 index 0000000..e1c0e7c --- /dev/null +++ b/lua/sandborb/sandbird.h @@ -0,0 +1,91 @@ +/** + * Copyright (c) 2016 rxi + * + * This library is free software; you can redistribute it and/or modify it + * under the terms of the MIT license. See LICENSE for details. + */ + + +#ifndef SANDBIRD_H +#define SANDBIRD_H + +#include <stddef.h> +#include <stdarg.h> + +#ifdef __cplusplus +extern "C" { +#endif + +#define SB_VERSION "0.1.3" + +typedef struct sb_Server sb_Server; +typedef struct sb_Stream sb_Stream; +typedef struct sb_Event sb_Event; +typedef struct sb_Options sb_Options; +typedef int (*sb_Handler)(sb_Event*); + +struct sb_Event { + int type; + void *udata; + sb_Server *server; + sb_Stream *stream; + const char *address; + const char *method; + const char *path; +}; + +struct sb_Options { + sb_Handler handler; + void *udata; + const char *host; + const char *port; + const char *timeout; + const char *max_lifetime; + const char *max_request_size; +}; + +enum { + SB_ESUCCESS = 0, + SB_EFAILURE = -1, + SB_EOUTOFMEM = -2, + SB_ETRUNCATED = -3, + SB_EBADSTATE = -4, + SB_EBADRESULT = -5, + SB_ECANTOPEN = -6, + SB_ENOTFOUND = -7, + SB_EFDTOOBIG = -8 +}; + +enum { + SB_EV_CONNECT, + SB_EV_CLOSE, + SB_EV_REQUEST +}; + +enum { + SB_RES_OK, + SB_RES_CLOSE +}; + +const char *sb_error_str(int code); +sb_Server *sb_new_server(const sb_Options *opt); +void sb_close_server(sb_Server *srv); +int sb_poll_server(sb_Server *srv, int timeout); +int sb_send_status(sb_Stream *st, int code, const char *msg); +int sb_send_header(sb_Stream *st, const char *field, const char *val); +int sb_send_file(sb_Stream *st, const char *filename); +int sb_write(sb_Stream *st, const void *data, size_t len); +int sb_vwritef(sb_Stream *st, const char *fmt, va_list args); +int sb_writef(sb_Stream *st, const char *fmt, ...); +int sb_get_header(sb_Stream *st, const char *field, char *dst, size_t len); +int sb_get_var(sb_Stream *st, const char *name, char *dst, size_t len); +int sb_get_cookie(sb_Stream *st, const char *name, char *dst, size_t len); +const void *sb_get_multipart(sb_Stream *st, const char *name, size_t *len); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif + + |