nyara 0.0.1.pre

data/ext/http_parser.c

@@ -0,0 +1 @@
+#include "http-parser/http_parser.c"

data/ext/inc/epoll.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <sys/epoll.h>
+
+static struct epoll_event qevents[MAX_E];
+
+static void ADD_E(int fd, uint64_t etype) {
+  struct epoll_event e;
+  e.events = EPOLLIN;
+  e.data.u64 = (etype << 32) | (uint64_t)fd;
+
+  // todo timeout
+# ifdef NDEBUG
+  epoll_ctl(qfd, EPOLL_CTL_ADD, fd, &e);
+# else
+  if (epoll_ctl(qfd, EPOLL_CTL_ADD, fd, &e))
+    printf("%s: %s\n", __func__, strerror(errno));
+# endif
+}
+
+static void DEL_E(int fd) {
+  struct epoll_event e;
+  e.events = EPOLLIN;
+  e.data.ptr = NULL;
+
+# ifdef NDEBUG
+  epoll_ctl(qfd, EPOLL_CTL_DEL, fd, &e);
+# else
+  if (epoll_ctl(qfd, EPOLL_CTL_DEL, fd, &e))
+    printf("%s: %s\n", __func__, strerror(errno));
+# endif
+}
+
+static void INIT_E() {
+  qfd = epoll_create(10); // size not important
+  if (qfd == -1) {
+    printf("%s\n", strerror(errno));
+    exit(-1);
+  }
+}
+
+static void LOOP_E() {
+  while (1) {
+    // heart beat of 0.1 sec, allow ruby signal interrupts to be inserted
+    int sz = epoll_wait(qfd, qevents, MAX_E, 100);
+
+    for (int i = 0; i < sz; i++) {
+      switch (qevents[i].events) {
+        case EPOLLIN: {
+          int fd = (int)(qevents[i].data.u64 & 0xFFFFFFFF);
+          int etype = (int)(qevents[i].data.u64 >> 32);
+          loop_body(fd, etype);
+          break;
+        }
+      }
+    }
+    // execute other thread / interrupts
+    rb_thread_schedule();
+  }
+}

data/ext/inc/kqueue.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <sys/types.h>
+#include <sys/time.h>
+#ifdef HAVE_SYS_EVENT_H
+# include <sys/event.h>
+#else
+# include <sys/queue.h>
+#endif
+
+static void loop_body(int fd, int etype);
+
+#define MAX_E 1024
+static int qfd;
+static struct kevent qevents[MAX_E];
+
+static void ADD_E(int fd, uint64_t etype) {
+  struct kevent e;
+  EV_SET(&e, fd, EVFILT_READ, EV_ADD, 0, 0, (void*)etype);
+  // todo timeout
+# ifdef NDEBUG
+  kevent(qfd, &e, 1, NULL, 0, NULL);
+# else
+  if (kevent(qfd, &e, 1, NULL, 0, NULL))
+    printf("%s: %s\n", __func__, strerror(errno));
+# endif
+}
+
+static void DEL_E(int fd) {
+  struct kevent e;
+  EV_SET(&e, fd, EVFILT_READ, EV_DELETE, 0, 0, NULL);
+# ifdef NDEBUG
+  kevent(qfd, &e, 1, NULL, 0, NULL);
+# else
+  if (kevent(qfd, &e, 1, NULL, 0, NULL))
+    printf("%s: %s\n", __func__, strerror(errno));
+# endif
+}
+
+static void INIT_E() {
+  qfd = kqueue();
+  if (qfd == -1) {
+    printf("%s\n", strerror(errno));
+    exit(-1);
+  }
+}
+
+static void LOOP_E() {
+  // printf("%d,%d,%d,\n%d,%d,%d,\n%d,%d,%d,\n",
+  // EV_ADD, EV_ENABLE, EV_DISABLE,
+  // EV_DELETE, EV_RECEIPT, EV_ONESHOT,
+  // EV_CLEAR, EV_EOF, EV_ERROR);
+
+  struct timespec ts = {0, 1000 * 1000 * 100};
+  while (1) {
+    // heart beat of 0.1 sec, allow ruby signal interrupts to be inserted
+    int sz = kevent(qfd, NULL, 0, qevents, MAX_E, &ts);
+
+    for (int i = 0; i < sz; i++) {
+      switch (qevents[i].filter) {
+        case EVFILT_READ: {
+          int fd = (int)qevents[i].ident;
+          // EV_EOF is set if the read side of the socket is shutdown
+          // the event can keep flipping back to consume cpu if we don't remove it
+          if ((qevents[i].flags & EV_EOF)) {
+            DEL_E(fd);
+          } else {
+            loop_body(fd, (int)qevents[i].udata);
+          }
+          break;
+        }
+      }
+    }
+    // execute other thread / interrupts
+    rb_thread_schedule();
+  }
+}

data/ext/inc/status_codes.inc

@@ -0,0 +1,64 @@
+#define HTTP_STATUS_CODES(XX)\
+  XX(100, "Continue");\
+  XX(101, "Switching Protocols");\
+  XX(102, "Processing");\
+  XX(200, "OK");\
+  XX(201, "Created");\
+  XX(202, "Accepted");\
+  XX(203, "Non-Authoritative Information");\
+  XX(204, "No Content");\
+  XX(205, "Reset Content");\
+  XX(206, "Partial Content");\
+  XX(207, "Multi-Status");\
+  XX(208, "Already Reported");\
+  XX(226, "IM Used");\
+  XX(300, "Multiple Choices");\
+  XX(301, "Moved Permanently");\
+  XX(302, "Found");\
+  XX(303, "See Other");\
+  XX(304, "Not Modified");\
+  XX(305, "Use Proxy");\
+  XX(306, "Reserved");\
+  XX(307, "Temporary Redirect");\
+  XX(308, "Permanent Redirect");\
+  XX(400, "Bad Request");\
+  XX(401, "Unauthorized");\
+  XX(402, "Payment Required");\
+  XX(403, "Forbidden");\
+  XX(404, "Not Found");\
+  XX(405, "Method Not Allowed");\
+  XX(406, "Not Acceptable");\
+  XX(407, "Proxy Authentication Required");\
+  XX(408, "Request Timeout");\
+  XX(409, "Conflict");\
+  XX(410, "Gone");\
+  XX(411, "Length Required");\
+  XX(412, "Precondition Failed");\
+  XX(413, "Request Entity Too Large");\
+  XX(414, "Request-URI Too Long");\
+  XX(415, "Unsupported Media Type");\
+  XX(416, "Requested Range Not Satisfiable");\
+  XX(417, "Expectation Failed");\
+  XX(422, "Unprocessable Entity");\
+  XX(423, "Locked");\
+  XX(424, "Failed Dependency");\
+  XX(425, "Unassigned");\
+  XX(426, "Upgrade Required");\
+  XX(427, "Unassigned");\
+  XX(428, "Precondition Required");\
+  XX(429, "Too Many Requests");\
+  XX(430, "Unassigned");\
+  XX(431, "Request Header Fields Too Large");\
+  XX(500, "Internal Server Error");\
+  XX(501, "Not Implemented");\
+  XX(502, "Bad Gateway");\
+  XX(503, "Service Unavailable");\
+  XX(504, "Gateway Timeout");\
+  XX(505, "HTTP Version Not Supported");\
+  XX(506, "Variant Also Negotiates (Experimental)");\
+  XX(507, "Insufficient Storage");\
+  XX(508, "Loop Detected");\
+  XX(509, "Unassigned");\
+  XX(510, "Not Extended");\
+  XX(511, "Network Authentication Required");\
+// end define

data/ext/inc/str_intern.h

@@ -0,0 +1,66 @@
+#pragma once
+
+// from string.c
+
+#define RUBY_MAX_CHAR_LEN 16
+#define STR_TMPLOCK FL_USER7
+#define STR_NOEMBED FL_USER1
+#define STR_SHARED  FL_USER2 /* = ELTS_SHARED */
+#define STR_ASSOC   FL_USER3
+#define STR_SHARED_P(s) FL_ALL((s), STR_NOEMBED|ELTS_SHARED)
+#define STR_ASSOC_P(s)  FL_ALL((s), STR_NOEMBED|STR_ASSOC)
+#define STR_NOCAPA  (STR_NOEMBED|ELTS_SHARED|STR_ASSOC)
+#define STR_NOCAPA_P(s) (FL_TEST((s),STR_NOEMBED) && FL_ANY((s),ELTS_SHARED|STR_ASSOC))
+#define STR_UNSET_NOCAPA(s) do {\
+    if (FL_TEST((s),STR_NOEMBED)) FL_UNSET((s),(ELTS_SHARED|STR_ASSOC));\
+} while (0)
+
+#define STR_SET_NOEMBED(str) do {\
+    FL_SET((str), STR_NOEMBED);\
+    STR_SET_EMBED_LEN((str), 0);\
+} while (0)
+#define STR_SET_EMBED(str) FL_UNSET((str), STR_NOEMBED)
+#define STR_EMBED_P(str) (!FL_TEST((str), STR_NOEMBED))
+#define STR_SET_EMBED_LEN(str, n) do { \
+    long tmp_n = (n);\
+    RBASIC(str)->flags &= ~RSTRING_EMBED_LEN_MASK;\
+    RBASIC(str)->flags |= (tmp_n) << RSTRING_EMBED_LEN_SHIFT;\
+} while (0)
+
+#define STR_SET_LEN(str, n) do { \
+    if (STR_EMBED_P(str)) {\
+        STR_SET_EMBED_LEN((str), (n));\
+    }\
+    else {\
+        RSTRING(str)->as.heap.len = (n);\
+    }\
+} while (0)
+
+#define STR_DEC_LEN(str) do {\
+    if (STR_EMBED_P(str)) {\
+        long n = RSTRING_LEN(str);\
+        n--;\
+        STR_SET_EMBED_LEN((str), n);\
+    }\
+    else {\
+        RSTRING(str)->as.heap.len--;\
+    }\
+} while (0)
+
+#define RESIZE_CAPA(str,capacity) do {\
+    if (STR_EMBED_P(str)) {\
+        if ((capacity) > RSTRING_EMBED_LEN_MAX) {\
+            char *tmp = ALLOC_N(char, (capacity)+1);\
+            memcpy(tmp, RSTRING_PTR(str), RSTRING_LEN(str));\
+            RSTRING(str)->as.heap.ptr = tmp;\
+            RSTRING(str)->as.heap.len = RSTRING_LEN(str);\
+            STR_SET_NOEMBED(str);\
+            RSTRING(str)->as.heap.aux.capa = (capacity);\
+        }\
+    }\
+    else {\
+        REALLOC_N(RSTRING(str)->as.heap.ptr, char, (capacity)+1);\
+        if (!STR_NOCAPA_P(str))\
+            RSTRING(str)->as.heap.aux.capa = (capacity);\
+    }\
+} while (0)

data/ext/inc/version.inc

@@ -0,0 +1 @@
+#define NYARA_VERSION "0.0.1.pre"

data/ext/mime.c

@@ -0,0 +1,107 @@
+#include "nyara.h"
+#include <string.h>
+#include <ctype.h>
+#include "inc/str_intern.h"
+
+static const char* _strnchr(const char* s, long len, char c) {
+  for (long i = 0; i < len; i++) {
+    if (s[i] == c) {
+      return s + i;
+    }
+  }
+  return NULL;
+}
+
+static bool mime_match_seg(const char* m1_ptr, long m1_len, VALUE v1, VALUE v2) {
+  const char* m2_ptr = _strnchr(m1_ptr, m1_len, '/');
+  long m2_len;
+  if (m2_ptr) {
+    m2_ptr++;
+    m2_len = m1_len - (m2_ptr - m1_ptr);
+    m1_len = (m2_ptr - m1_ptr) - 1;
+  } else {
+    m2_len = 0;
+  }
+
+  const char* v1_ptr = RSTRING_PTR(v1);
+  const char* v2_ptr = RSTRING_PTR(v2);
+  const long  v1_len = RSTRING_LEN(v1);
+  const long  v2_len = RSTRING_LEN(v2);
+
+# define EQL_STAR(s, len) (len == 1 && s[0] == '*')
+# define EQL(s1, len1, s2, len2) (len1 == len2 && strncmp(s1, s2, len1) == 0)
+
+  /*
+  if m1 == '*'
+    if m2.nil? || m2 == '*'
+      return true
+    elsif m2 == v2
+      return true
+    else
+      return false
+    end
+  end
+  return false if v1 != m1
+  return true if m2.nil? || m2 == '*'
+  m2 == v2
+  */
+
+  if (EQL_STAR(m1_ptr, m1_len)) {
+    if (m2_len == 0 || EQL_STAR(m2_ptr, m2_len)) {
+      return true;
+    } else if (EQL(m2_ptr, m2_len, v2_ptr, v2_len)) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  if (!EQL(v1_ptr, v1_len, m1_ptr, m1_len)) {
+    return false;
+  }
+  if (m2_len == 0 || EQL_STAR(m2_ptr, m2_len)) {
+    return true;
+  }
+  return EQL(m2_ptr, m2_len, v2_ptr, v2_len);
+
+# undef EQL
+# undef EQL_STAR
+}
+
+// for test
+static VALUE ext_mime_match_seg(VALUE self, VALUE m, VALUE v1, VALUE v2) {
+  if (mime_match_seg(RSTRING_PTR(m), RSTRING_LEN(m), v1, v2)) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+// returns matched ext or nil
+VALUE ext_mime_match(VALUE self, VALUE request_accept, VALUE accept_mimes) {
+  Check_Type(request_accept, T_ARRAY);
+  Check_Type(accept_mimes, T_ARRAY);
+
+  VALUE* accepts = RARRAY_PTR(request_accept);
+  long accepts_len = RARRAY_LEN(request_accept);
+  VALUE* values = RARRAY_PTR(accept_mimes);
+  long values_len = RARRAY_LEN(accept_mimes);
+
+  for (long j = 0; j < accepts_len; j++) {
+    char* s = RSTRING_PTR(accepts[j]);
+    long len = RSTRING_LEN(accepts[j]);
+    for (long i = 0; i < values_len; i++) {
+      Check_Type(values[i], T_ARRAY);
+      VALUE* arr = RARRAY_PTR(values[i]);
+      if (mime_match_seg(s, len, arr[0], arr[1])) {
+        return arr[2];
+      }
+    }
+  }
+  return Qnil;
+}
+
+void Init_mime(VALUE ext) {
+  rb_define_singleton_method(ext, "mime_match", ext_mime_match, 2);
+  // for test
+  rb_define_singleton_method(ext, "mime_match_seg", ext_mime_match_seg, 3);
+}

data/ext/multipart-parser-c/README.md

@@ -0,0 +1,18 @@
+## Multipart form data parser
+
+### Features
+* No dependencies
+* Works with chunks of a data - no need to buffer the whole request
+* Almost no internal buffering. Buffer size doesn't exceed the size of the boundary (~60-70 bytes)
+
+Tested as part of [Cosmonaut](https://github.com/iafonov/cosmonaut) HTTP server.
+
+Implementation based on [node-formidable](https://github.com/felixge/node-formidable) by [Felix Geisendörfer](https://github.com/felixge).
+
+Inspired by [http-parser](https://github.com/joyent/http-parser) by [Ryan Dahl](https://github.com/ry).
+
+### Contributors:
+* [Daniel T. Wagner](http://www.danieltwagner.de/)
+* [James McLaughlin](http://udp.github.com/)
+
+© 2012 [Igor Afonov](http://iafonov.github.com)

data/ext/multipart-parser-c/multipart_parser.c

@@ -0,0 +1,309 @@
+/* Based on node-formidable by Felix Geisendörfer 
+ * Igor Afonov - afonov@gmail.com - 2012
+ * MIT License - http://www.opensource.org/licenses/mit-license.php
+ */
+
+#include "multipart_parser.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
+static void multipart_log(const char * format, ...)
+{
+#ifdef DEBUG_MULTIPART
+    va_list args;
+    va_start(args, format);
+
+    fprintf(stderr, "[HTTP_MULTIPART_PARSER] %s:%d: ", __FILE__, __LINE__);
+    vfprintf(stderr, format, args);
+    fprintf(stderr, "\n");
+#endif
+}
+
+#define NOTIFY_CB(FOR)                                                 \
+do {                                                                   \
+  if (p->settings->on_##FOR) {                                     \
+    if (p->settings->on_##FOR(p) != 0) {                           \
+      return i;                                                        \
+    }                                                                  \
+  }                                                                    \
+} while (0)
+
+#define EMIT_DATA_CB(FOR, ptr, len)                                    \
+do {                                                                   \
+  if (p->settings->on_##FOR) {                                         \
+    if (p->settings->on_##FOR(p, ptr, len) != 0) {                     \
+      return i;                                                        \
+    }                                                                  \
+  }                                                                    \
+} while (0)
+
+
+#define LF 10
+#define CR 13
+
+struct multipart_parser {
+  void * data;
+
+  size_t index;
+  size_t boundary_length;
+
+  unsigned char state;
+
+  const multipart_parser_settings* settings;
+
+  char* lookbehind;
+  char multipart_boundary[1];
+};
+
+enum state {
+  s_uninitialized = 1,
+  s_start,
+  s_start_boundary,
+  s_header_field_start,
+  s_header_field,
+  s_headers_almost_done,
+  s_header_value_start,
+  s_header_value,
+  s_header_value_almost_done,
+  s_part_data_start,
+  s_part_data,
+  s_part_data_almost_boundary,
+  s_part_data_boundary,
+  s_part_data_almost_end,
+  s_part_data_end,
+  s_part_data_final_hyphen,
+  s_end
+};
+
+multipart_parser* multipart_parser_init
+    (const char *boundary, const multipart_parser_settings* settings) {
+
+  multipart_parser* p = malloc(sizeof(multipart_parser) +
+                               strlen(boundary) +
+                               strlen(boundary) + 9);
+
+  strcpy(p->multipart_boundary, boundary);
+  p->boundary_length = strlen(boundary);
+  
+  p->lookbehind = (p->multipart_boundary + p->boundary_length + 1);
+
+  p->index = 0;
+  p->state = s_start;
+  p->settings = settings;
+
+  return p;
+}
+
+void multipart_parser_free(multipart_parser* p) {
+  free(p);
+}
+
+void multipart_parser_set_data(multipart_parser *p, void *data) {
+    p->data = data;
+}
+
+void *multipart_parser_get_data(multipart_parser *p) {
+    return p->data;
+}
+
+size_t multipart_parser_execute(multipart_parser* p, const char *buf, size_t len) {
+  size_t i = 0;
+  size_t mark = 0;
+  char c, cl;
+  int is_last = 0;
+
+  while(!is_last) {
+    c = buf[i];
+    is_last = (i == (len - 1));
+    switch (p->state) {
+      case s_start:
+        multipart_log("s_start");
+        p->index = 0;
+        p->state = s_start_boundary;
+
+      /* fallthrough */
+      case s_start_boundary:
+        multipart_log("s_start_boundary");
+        if (p->index == p->boundary_length) {
+          if (c != CR) {
+            return i;
+          }
+          p->index++;
+          break;
+        } else if (p->index == (p->boundary_length + 1)) {
+          if (c != LF) {
+            return i;
+          }
+          p->index = 0;
+          NOTIFY_CB(part_data_begin);
+          p->state = s_header_field_start;
+          break;
+        }
+        if (c != p->multipart_boundary[p->index]) {
+          return i;
+        }
+        p->index++;
+        break;
+
+      case s_header_field_start:
+        multipart_log("s_header_field_start");
+        mark = i;
+        p->state = s_header_field;
+
+      /* fallthrough */
+      case s_header_field:
+        multipart_log("s_header_field");
+        if (c == CR) {
+          p->state = s_headers_almost_done;
+          break;
+        }
+
+        if (c == '-') {
+          break;
+        }
+
+        if (c == ':') {
+          EMIT_DATA_CB(header_field, buf + mark, i - mark);
+          p->state = s_header_value_start;
+          break;
+        }
+
+        cl = tolower(c);
+        if (cl < 'a' || cl > 'z') {
+          multipart_log("invalid character in header name");
+          return i;
+        }
+        if (is_last)
+            EMIT_DATA_CB(header_field, buf + mark, (i - mark) + 1);
+        break;
+
+      case s_headers_almost_done:
+        multipart_log("s_headers_almost_done");
+        if (c != LF) {
+          return i;
+        }
+
+        p->state = s_part_data_start;
+        break;
+
+      case s_header_value_start:
+        multipart_log("s_header_value_start");
+        if (c == ' ') {
+          break;
+        }
+
+        mark = i;
+        p->state = s_header_value;
+
+      /* fallthrough */
+      case s_header_value:
+        multipart_log("s_header_value");
+        if (c == CR) {
+          EMIT_DATA_CB(header_value, buf + mark, i - mark);
+          p->state = s_header_value_almost_done;
+        }
+        if (is_last)
+            EMIT_DATA_CB(header_value, buf + mark, (i - mark) + 1);
+        break;
+
+      case s_header_value_almost_done:
+        multipart_log("s_header_value_almost_done");
+        if (c != LF) {
+          return i;
+        }
+        p->state = s_header_field_start;
+        break;
+
+      case s_part_data_start:
+        multipart_log("s_part_data_start");
+        NOTIFY_CB(headers_complete);
+        mark = i;
+        p->state = s_part_data;
+
+      /* fallthrough */
+      case s_part_data:
+        multipart_log("s_part_data");
+        if (c == CR) {
+            EMIT_DATA_CB(part_data, buf + mark, i - mark);
+            mark = i;
+            p->state = s_part_data_almost_boundary;
+            p->lookbehind[0] = CR;
+            break;
+        }
+        if (is_last)
+            EMIT_DATA_CB(part_data, buf + mark, (i - mark) + 1);
+        break;
+
+      case s_part_data_almost_boundary:
+        multipart_log("s_part_data_almost_boundary");
+        if (c == LF) {
+            p->state = s_part_data_boundary;
+            p->lookbehind[1] = LF;
+            p->index = 0;
+            break;
+        }
+        EMIT_DATA_CB(part_data, p->lookbehind, 1);
+        p->state = s_part_data;
+        mark = i --;
+        break;
+
+      case s_part_data_boundary:
+        multipart_log("s_part_data_boundary");
+        if (p->multipart_boundary[p->index] != c) {
+          EMIT_DATA_CB(part_data, p->lookbehind, 2 + p->index);
+          p->state = s_part_data;
+          mark = i --;
+          break;
+        }
+        p->lookbehind[2 + p->index] = c;
+        if ((++ p->index) == p->boundary_length) {
+            NOTIFY_CB(part_data_end);
+            p->state = s_part_data_almost_end;
+        }
+        break;
+
+      case s_part_data_almost_end:
+        multipart_log("s_part_data_almost_end");
+        if (c == '-') {
+            p->state = s_part_data_final_hyphen;
+            break;
+        }
+        if (c == CR) {
+            p->state = s_part_data_end;
+            break;
+        }
+        return i;
+   
+      case s_part_data_final_hyphen:
+        multipart_log("s_part_data_final_hyphen");
+        if (c == '-') {
+            NOTIFY_CB(body_end);
+            p->state = s_end;
+            break;
+        }
+        return i;
+
+      case s_part_data_end:
+        multipart_log("s_part_data_end");
+        if (c == LF) {
+            p->state = s_header_field_start;
+            NOTIFY_CB(part_data_begin);
+            break;
+        }
+        return i;
+
+      case s_end:
+        multipart_log("s_end: %02X", (int) c);
+        break;
+
+      default:
+        multipart_log("Multipart parser unrecoverable error");
+        return 0;
+    }
+    ++ i;
+  }
+
+  return len;
+}