nyara 0.0.1.pre.9 → 0.1.pre.0

data/ext/inc/version.inc

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

data/ext/nyara.c

@@ -5,6 +5,7 @@
 #include <sys/socket.h>
 #include <sys/resource.h>
 #include <sys/fcntl.h>
+#include "inc/rdtsc.h"
 
 rb_encoding* u8_encoding;
 static VALUE nyara;
@@ -31,17 +32,16 @@ static void set_fd_limit(int nofiles) {
   }
 }
 
-static bool summary_request = false;
-void nyara_summary_request(int method, VALUE path, VALUE controller) {
-  if (summary_request) {
-    rb_funcall(nyara, rb_intern("summary_request"), 3, INT2NUM(method), path, controller);
-  }
+static unsigned long long last_rdtsc = 0;
+
+static VALUE ext_rdtsc_start(VALUE _) {
+  last_rdtsc = rdtsc();
+  return Qnil;
 }
 
-// set whether should log summary of request
-static VALUE ext_summary_request(VALUE _, VALUE toggle) {
-  summary_request = RTEST(toggle);
-  return toggle;
+static VALUE ext_rdtsc(VALUE _) {
+  unsigned long long diff = rdtsc() - last_rdtsc;
+  return ULL2NUM(diff);
 }
 
 void Init_nyara() {
@@ -80,7 +80,9 @@ void Init_nyara() {
   OBJ_FREEZE(status_map);
 
   VALUE ext = rb_define_module_under(nyara, "Ext");
-  rb_define_singleton_method(ext, "summary_request", ext_summary_request, 1);
+  rb_define_singleton_method(ext, "rdtsc_start", ext_rdtsc_start, 0);
+  rb_define_singleton_method(ext, "rdtsc", ext_rdtsc, 0);
+
   Init_accept(ext);
   Init_mime(ext);
   Init_request(nyara, ext);

data/ext/nyara.h

@@ -14,6 +14,7 @@
     printf("%s: %.*s\n", __func__, (int)RSTRING_LEN(_xx), RSTRING_PTR(_xx));\
   } while(0)
 
+
 /* event.c */
 void Init_event(VALUE ext);
 void nyara_detach_rid(VALUE rid);
@@ -25,7 +26,6 @@ void Init_request_parse(VALUE nyara, VALUE ext);
 
 /* request.c */
 void Init_request(VALUE nyara, VALUE ext);
-void nyara_request_init_env(VALUE request);
 void nyara_request_term_close(VALUE request);
 bool nyara_send_data(int fd, const char* s, long len);
 
@@ -37,8 +37,7 @@ void Init_test_response(VALUE nyara);
 /* url_encoded.c */
 void Init_url_encoded(VALUE ext);
 long nyara_parse_path(VALUE path, const char*s, long len);
-void nyara_parse_param(VALUE output, const char* s, long len);
-VALUE ext_parse_cookie(VALUE self, VALUE output, VALUE str);
+void nyara_decode_uri_kv(volatile VALUE key, volatile VALUE value, const char* kv_s, long kv_len);
 
 
 /* accept.c */
@@ -53,11 +52,13 @@ VALUE ext_mime_match(VALUE _, VALUE request_accept, VALUE accept_mimes);
 
 /* hashes.c */
 void Init_hashes(VALUE nyara);
+void nyara_parse_query(VALUE output, const char* s, long len);
+
 
 // "ab-cd" => "Ab-Cd"
 // note str must be string created by nyara code
 void nyara_headerlize(VALUE str);
-int nyara_rb_hash_has_key(VALUE hash, VALUE key);
+// int nyara_rb_hash_has_key(VALUE hash, VALUE key);
 
 extern VALUE nyara_param_hash_class;
 extern VALUE nyara_header_hash_class;
@@ -78,5 +79,4 @@ extern RouteResult nyara_lookup_route(enum http_method method_num, VALUE vpath,
 
 /* nyara.c */
 void nyara_set_nonblock(int fd);
-void nyara_summary_request(int method, VALUE path, VALUE controller);
 extern rb_encoding* u8_encoding;

data/ext/request.c

@@ -109,30 +109,6 @@ Request* nyara_request_new(int fd) {
   return p;
 }
 
-void nyara_request_init_env(VALUE self) {
-  static VALUE session_mod = Qnil;
-  static VALUE flash_class = Qnil;
-  static VALUE str_cookie = Qnil;
-  static ID id_decode = 0;
-  if (session_mod == Qnil) {
-    VALUE nyara = rb_const_get(rb_cModule, rb_intern("Nyara"));
-    session_mod = rb_const_get(nyara, rb_intern("Session"));
-    flash_class = rb_const_get(nyara, rb_intern("Flash"));
-    str_cookie = rb_enc_str_new("Cookie", strlen("Cookie"), u8_encoding);
-    rb_gc_register_mark_object(str_cookie);
-    id_decode = rb_intern("decode");
-  }
-
-  P;
-  p->cookie = rb_class_new_instance(0, NULL, nyara_param_hash_class);
-  VALUE cookie = rb_hash_aref(p->header, str_cookie);
-  if (cookie != Qnil) {
-    ext_parse_cookie(Qnil, p->cookie, cookie);
-  }
-  p->session = rb_funcall(session_mod, id_decode, 1, p->cookie);
-  p->flash = rb_class_new_instance(1, &p->session, flash_class);
-}
-
 void nyara_request_term_close(VALUE self) {
   P;
   VALUE transfer_enc = rb_hash_aref(p->response_header, str_transfer_encoding);
@@ -202,11 +178,27 @@ static VALUE request_session(VALUE self) {
   return p->session;
 }
 
+static VALUE request_session_eq(VALUE self, VALUE session) {
+  P;
+  if (p->session != Qnil) {
+    rb_raise(rb_eRuntimeError, "request.session already initialized");
+  }
+  return p->session = session;
+}
+
 static VALUE request_flash(VALUE self) {
   P;
   return p->flash;
 }
 
+static VALUE request_flash_eq(VALUE self, VALUE flash) {
+  P;
+  if (p->flash != Qnil) {
+    rb_raise(rb_eRuntimeError, "request.flash already initialized");
+  }
+  return p->flash = flash;
+}
+
 static VALUE request_body(VALUE self) {
   P;
   while (p->parse_state != PS_MESSAGE_COMPLETE) {
@@ -388,7 +380,9 @@ void Init_request(VALUE nyara, VALUE ext) {
   rb_define_method(request_class, "format", request_format, 0);
   rb_define_method(request_class, "cookie", request_cookie, 0);
   rb_define_method(request_class, "session", request_session, 0);
+  rb_define_method(request_class, "session=", request_session_eq, 1);
   rb_define_method(request_class, "flash", request_flash, 0);
+  rb_define_method(request_class, "flash=", request_flash_eq, 1);
   rb_define_method(request_class, "body", request_body, 0);
   rb_define_method(request_class, "message_complete?", request_message_complete_p, 0);
 

data/ext/request_parse.c

@@ -138,7 +138,7 @@ static void _parse_path_and_query(Request* p) {
   long len = RSTRING_LEN(p->path_with_query);
   long query_i = nyara_parse_path(p->path, s, len);
   if (query_i < len) {
-    nyara_parse_param(p->query, s + query_i, len - query_i);
+    nyara_parse_query(p->query, s + query_i, len - query_i);
 
     // do method override with _method=xxx in query
     if (p->method == HTTP_POST) {

data/ext/route.cc

@@ -187,8 +187,7 @@ static VALUE ext_list_route(VALUE self) {
   return route_hash;
 }
 
-static VALUE build_args(const char* suffix, std::vector<ID>& conv) {
-  volatile VALUE args = rb_ary_new();
+static VALUE build_args(const char* suffix, std::vector<ID>& conv, volatile VALUE args) {
   volatile VALUE str = rb_str_new2(""); // tmp for conversion, no need encoding
   long last_len = 0;
   for (size_t j = 0; j < conv.size(); j++) {
@@ -271,8 +270,7 @@ RouteResult nyara_lookup_route(enum http_method method_num, VALUE vpath, VALUE a
               break;
             }
           }
-          r.args = build_args(suffix, i->conv);
-          rb_ary_push(r.args, i->id);
+          r.args = build_args(suffix, i->conv, rb_ary_new3(1, i->id));
           r.controller = i->controller;
           break;
         }

data/ext/url_encoded.c

@@ -74,6 +74,8 @@ static long _decode_url_seg(VALUE output, const char*s, long len, char stop_char
 // NOTE it's similar to _decode_url_seg, but:
 // - "+" is not escaped
 // - matrix uri params (segments starting with ";") are ignored
+//
+// returns parsed length, including matrix uri params
 long nyara_parse_path(VALUE output, const char* s, long len) {
   const char* last_s = s;
   long last_len = 0;
@@ -133,75 +135,6 @@ long nyara_parse_path(VALUE output, const char* s, long len) {
   return i;
 }
 
-static VALUE ext_parse_path(VALUE self, VALUE output, VALUE input) {
-  long parsed = nyara_parse_path(output, RSTRING_PTR(input), RSTRING_LEN(input));
-  return ULONG2NUM(parsed);
-}
-
-static void _error(const char* msg, const char* s, long len, long segment_i) {
-  if (s) {
-    rb_raise(rb_eRuntimeError,
-      "error parsing \"%.*s\": segments[%ld] is %s",
-      (int)len, s, segment_i, msg);
-  } else {
-    rb_raise(rb_eRuntimeError, "%s", msg);
-  }
-}
-
-static VALUE _new_child(long hash) {
-  return hash ? rb_class_new_instance(0, NULL, nyara_param_hash_class) : rb_ary_new();
-}
-
-// a, b, c = keys; h[a][b][c] = value
-// the last 2 args are for error report
-static void _aset_keys(VALUE output, volatile VALUE keys, VALUE value, const char* kv_s, long kv_len) {
-  VALUE* arr = RARRAY_PTR(keys);
-  long len = RARRAY_LEN(keys);
-  if (!len) {
-    rb_bug("bug: aset 0 length key");
-    return;
-  }
-
-  // first key seg
-  long is_hash_key = 1;
-
-  // middle key segs
-  for (long i = 0; i < len - 1; i++) {
-    long next_is_hash_key = RSTRING_LEN(arr[i + 1]);
-    if (is_hash_key) {
-      if (nyara_rb_hash_has_key(output, arr[i])) {
-        output = rb_hash_aref(output, arr[i]);
-        if (next_is_hash_key) {
-          if (TYPE(output) != T_HASH) {
-            // note: StringValueCStr requires VALUE* as param, and can raise another error if there's nul in the string
-            _error("not array index (expect to be empty)", kv_s, kv_len, i);
-          }
-        } else {
-          if (TYPE(output) != T_ARRAY) {
-            _error("not hash key (expect to be non-empty)", kv_s, kv_len, i);
-          }
-        }
-      } else {
-        volatile VALUE child = _new_child(next_is_hash_key);
-        rb_hash_aset(output, arr[i], child);
-        output = child;
-      }
-    } else {
-      volatile VALUE child = _new_child(next_is_hash_key);
-      rb_ary_push(output, child);
-      output = child;
-    }
-    is_hash_key = next_is_hash_key;
-  }
-
-  // terminate key seg: add value
-  if (is_hash_key) {
-    rb_hash_aset(output, arr[len - 1], value);
-  } else {
-    rb_ary_push(output, value);
-  }
-}
-
 static const char* _strnchr(const char* s, long len, char c) {
   for (long i = 0; i < len; i++) {
     if (s[i] == c) {
@@ -215,16 +148,16 @@ static inline VALUE _new_blank_str() {
   return rb_enc_str_new("", 0, u8_encoding);
 }
 
-static void _url_encoded_seg(VALUE output, const char* kv_s, long kv_len, int nested_mode) {
-  // (note if we _decode_url_seg with '&' first, then there may be multiple '='s in one kv)
+// key and value are for output
+// usually should be blank string
+// decode into key and value
+void nyara_decode_uri_kv(volatile VALUE key, volatile VALUE value, const char* kv_s, long kv_len) {
   const char* s = kv_s;
   long len = kv_len;
   if (!len) {
-    return;
+    rb_raise(rb_eArgError, "empty key=value segment");
   }
 
-  volatile VALUE value = _new_blank_str();
-
   // rule out the value part
   {
     // strnstr is not available on linux :(
@@ -232,125 +165,34 @@ static void _url_encoded_seg(VALUE output, const char* kv_s, long kv_len, int ne
     if (value_s) {
       value_s++;
       long value_len = s + len - value_s;
-      long parsed = _decode_url_seg(value, value_s, value_len, '&');
-      if (parsed != value_len) {
+      long skipped = 0;
+      for (;skipped < value_len; skipped++) {
+        if (!isspace(value_s[skipped])) {
+          break;
+        }
+      }
+      long parsed = _decode_url_seg(value, value_s + skipped, value_len - skipped, '&');
+      if (parsed != value_len - skipped) {
         rb_raise(rb_eArgError, "separator & in param segment");
       }
       len = value_s - s - 1;
     }
     // starts with '='
     if (value_s == s) {
-      rb_hash_aset(output, _new_blank_str(), value);
       return;
     }
   }
-
-  volatile VALUE key = _new_blank_str();
-  if (nested_mode) {
-    // todo fault-tolerant?
-    long parsed = _decode_url_seg(key, s, len, '[');
-    if (parsed == len) {
-      rb_hash_aset(output, key, value);
-      return;
-    }
-    s += parsed;
-    len -= parsed;
-    volatile VALUE keys = rb_ary_new3(1, key);
-    while (len) {
-      key = _new_blank_str();
-      parsed = _decode_url_seg(key, s, len, ']');
-      rb_ary_push(keys, key);
-      s += parsed;
-      len -= parsed;
-      if (len) {
-        if (s[0] == '[') {
-          s++;
-          len--;
-        } else {
-          rb_raise(rb_eRuntimeError, "malformed params: remaining chars in key but not starting with '['");
-          return;
-        }
-      }
-    }
-    _aset_keys(output, keys, value, kv_s, kv_len);
-  } else {
-    _decode_url_seg(key, s, len, '=');
-    rb_hash_aset(output, key, value);
-  }
-
-  return;
-}
-
-// "a[%20][][b]=c" ===> output["a", "\x20", nil, "b"] = "c"
-static VALUE ext_parse_url_encoded_seg(VALUE self, VALUE output, VALUE kv, VALUE v_nested_mode) {
-  _url_encoded_seg(output, RSTRING_PTR(kv), RSTRING_LEN(kv), RTEST(v_nested_mode));
-  return output;
-}
-
-void nyara_parse_param(VALUE output, const char* s, long len) {
-  // split with /[&;] */
-  long last_i = 0;
-  long i = 0;
-  for (; i < len; i++) {
-    if (s[i] == '&' || s[i] == ';') {
-      if (i > last_i) {
-        _url_encoded_seg(output, s + last_i, i - last_i, 1);
-      }
-      while(i + 1 < len && s[i + 1] == ' ') {
-        i++;
-      }
-      last_i = i + 1;
-    }
-  }
-  if (i > last_i) {
-    _url_encoded_seg(output, s + last_i, i - last_i, 1);
+  while (len > 0 && isspace(s[len - 1])) {
+    len--;
   }
+  _decode_url_seg(key, s, len, '=');
 }
 
-static VALUE ext_parse_param(VALUE self, VALUE output, VALUE s) {
-  nyara_parse_param(output, RSTRING_PTR(s), RSTRING_LEN(s));
-  return output;
-}
-
-static VALUE _cookie_seg_str_new(const char* s, long len) {
-  // trim tailing space
-  for (; len > 0; len--) {
-    if (s[len - 1] != ' ') {
-      break;
-    }
-  }
-  return rb_enc_str_new(s, len, u8_encoding);
-}
-
-VALUE ext_parse_cookie(VALUE self, VALUE output, VALUE str) {
-  volatile VALUE arr = rb_ary_new();
-  const char* s = RSTRING_PTR(str);
-  long len = RSTRING_LEN(str);
-
-  // split with / *[,;] */
-  long last_i = 0;
-  long i = 0;
-  for (; i < len; i++) {
-    if (s[i] == ',' || s[i] == ';') {
-      // char* and len parse_seg
-      if (i > last_i) {
-        rb_ary_push(arr, _cookie_seg_str_new(s + last_i, i - last_i));
-      }
-      while(i + 1 < len && s[i + 1] == ' ') {
-        i++;
-      }
-      last_i = i + 1;
-    }
-  }
-  if (i > last_i) {
-    rb_ary_push(arr, _cookie_seg_str_new(s + last_i, i - last_i));
-  }
-
-  VALUE* arr_p = RARRAY_PTR(arr);
-  for (long j = RARRAY_LEN(arr) - 1; j >= 0; j--) {
-    _url_encoded_seg(output, RSTRING_PTR(arr_p[j]), RSTRING_LEN(arr_p[j]), 0);
-  }
-  return output;
+static VALUE ext_decode_uri_kv(VALUE _, VALUE str) {
+  volatile VALUE k = _new_blank_str();
+  volatile VALUE v = _new_blank_str();
+  nyara_decode_uri_kv(k, v, RSTRING_PTR(str), RSTRING_LEN(str));
+  return rb_ary_new3(2, k, v);
 }
 
 static bool _should_escape(char c) {
@@ -391,7 +233,8 @@ static void _concat_char(VALUE s, char c, bool ispath) {
   }
 }
 
-// escape for uri path ('/', '+' are not changed) or component ('/', '+' are changed)
+// escape for uri path ('/', '+' are not changed)
+// or component ('/', '+' are changed)
 static VALUE ext_escape(VALUE _, VALUE s, VALUE v_ispath) {
   Check_Type(s, T_STRING);
   long len = RSTRING_LEN(s);
@@ -405,20 +248,35 @@ static VALUE ext_escape(VALUE _, VALUE s, VALUE v_ispath) {
   return res;
 }
 
-// nil in keys will be interpreted as array key
-static VALUE ext_param_hash_nested_aset(VALUE _, VALUE output, VALUE keys, VALUE value) {
-  // todo check output is ParamHash
-  Check_Type(keys, T_ARRAY);
-  _aset_keys(output, keys, value, NULL, 0);
-  return Qnil;
+// caveats:
+// - stops at '='
+// - matrix uri params and query are ignored
+static VALUE ext_unescape(VALUE _, volatile VALUE s, VALUE v_is_path) {
+  Check_Type(s, T_STRING);
+  if (RTEST(v_is_path)) {
+    volatile VALUE output = _new_blank_str();
+    if (nyara_parse_path(output, RSTRING_PTR(s), RSTRING_LEN(s))) {
+    }
+    return output;
+  } else {
+    volatile VALUE output = _new_blank_str();
+    _decode_url_seg(output, RSTRING_PTR(s), RSTRING_LEN(s), '=');
+    return output;
+  }
+}
+
+// concats result into output<br>
+// returns parsed length
+static VALUE ext_parse_path(VALUE self, VALUE output, VALUE input) {
+  long parsed = nyara_parse_path(output, RSTRING_PTR(input), RSTRING_LEN(input));
+  return ULONG2NUM(parsed);
 }
 
 void Init_url_encoded(VALUE ext) {
-  rb_define_singleton_method(ext, "parse_param", ext_parse_param, 2);
-  rb_define_singleton_method(ext, "parse_cookie", ext_parse_cookie, 2);
   rb_define_singleton_method(ext, "escape", ext_escape, 2);
-  rb_define_singleton_method(ext, "param_hash_nested_aset", ext_param_hash_nested_aset, 3);
-  // for test
-  rb_define_singleton_method(ext, "parse_url_encoded_seg", ext_parse_url_encoded_seg, 3);
+  rb_define_singleton_method(ext, "unescape", ext_unescape, 2);
+
+  // test only
+  rb_define_singleton_method(ext, "decode_uri_kv", ext_decode_uri_kv, 1);
   rb_define_singleton_method(ext, "parse_path", ext_parse_path, 2);
 }