Refactoring and cleaning up

1 files changed, 979 insertions, 0 deletions

diff --git a/lua/sandborb/src/sandbird.c b/lua/sandborb/src/sandbird.c
new file mode 100644
index 0000000..e08c287
--- /dev/null
+++ b/lua/sandborb/src/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;
+}
+
+