unicorn 0.91.0 → 0.92.0

data/ext/unicorn_http/extconf.rb

@@ -1,7 +1,12 @@
+# -*- encoding: binary -*-
 require 'mkmf'
 
+$CFLAGS += " -fPIC " # needed for Rubinius, MRI already uses it regardless
+
 dir_config("unicorn_http")
 
 have_macro("SIZEOF_OFF_T", "ruby.h") or check_sizeof("off_t", "sys/types.h")
+have_macro("SIZEOF_LONG", "ruby.h") or check_sizeof("long", "sys/types.h")
 have_func("rb_str_set_len", "ruby.h")
+have_func("rb_str_modify", "ruby.h")
 create_makefile("unicorn_http")

data/ext/unicorn_http/unicorn_http.rl

@@ -22,6 +22,7 @@
 #define UH_FL_KAVERSION 0x80
 #define UH_FL_HASHEADER 0x100
 
+/* both of these flags need to be set for keepalive to be supported */
 #define UH_FL_KEEPALIVE (UH_FL_KAMETHOD | UH_FL_KAVERSION)
 
 struct http_parser {
@@ -37,7 +38,7 @@ struct http_parser {
     size_t field_len; /* only used during header processing */
     size_t dest_offset; /* only used during body processing */
   } s;
-  VALUE cont;
+  VALUE cont; /* Qfalse: unset, Qnil: ignored header, T_STRING: append */
   union {
     off_t content;
     off_t chunk;
@@ -52,16 +53,54 @@ static void finalize_header(struct http_parser *hp, VALUE req);
 #define PTR_TO(F) (buffer + hp->F)
 #define STR_NEW(M,FPC) rb_str_new(PTR_TO(M), LEN(M, FPC))
 
+#define HP_FL_TEST(hp,fl) ((hp)->flags & (UH_FL_##fl))
+#define HP_FL_SET(hp,fl) ((hp)->flags |= (UH_FL_##fl))
+#define HP_FL_UNSET(hp,fl) ((hp)->flags &= ~(UH_FL_##fl))
+#define HP_FL_ALL(hp,fl) (HP_FL_TEST(hp, fl) == (UH_FL_##fl))
+
+/*
+ * handles values of the "Connection:" header, keepalive is implied
+ * for HTTP/1.1 but needs to be explicitly enabled with HTTP/1.0
+ * Additionally, we require GET/HEAD requests to support keepalive.
+ */
+static void hp_keepalive_connection(struct http_parser *hp, VALUE val)
+{
+  /* REQUEST_METHOD is always set before any headers */
+  if (HP_FL_TEST(hp, KAMETHOD)) {
+    if (STR_CSTR_CASE_EQ(val, "keep-alive")) {
+      /* basically have HTTP/1.0 masquerade as HTTP/1.1+ */
+      HP_FL_SET(hp, KAVERSION);
+    } else if (STR_CSTR_CASE_EQ(val, "close")) {
+      /*
+       * it doesn't matter what HTTP version or request method we have,
+       * if a client says "Connection: close", we disable keepalive
+       */
+      HP_FL_UNSET(hp, KEEPALIVE);
+    } else {
+      /*
+       * client could've sent anything, ignore it for now.  Maybe
+       * "HP_FL_UNSET(hp, KEEPALIVE);" just in case?
+       * Raising an exception might be too mean...
+       */
+    }
+  }
+}
+
 static void
 request_method(struct http_parser *hp, VALUE req, const char *ptr, size_t len)
 {
   VALUE v;
 
+  /*
+   * we only support keepalive for GET and HEAD requests for now other
+   * methods are too rarely seen to be worth optimizing.  POST is unsafe
+   * since some clients send extra bytes after POST bodies.
+   */
   if (CONST_MEM_EQ("GET", ptr, len)) {
-    hp->flags |= UH_FL_KAMETHOD;
+    HP_FL_SET(hp, KAMETHOD);
     v = g_GET;
   } else if (CONST_MEM_EQ("HEAD", ptr, len)) {
-    hp->flags |= UH_FL_KAMETHOD;
+    HP_FL_SET(hp, KAMETHOD);
     v = g_HEAD;
   } else {
     v = rb_str_new(ptr, len);
@@ -74,10 +113,11 @@ http_version(struct http_parser *hp, VALUE req, const char *ptr, size_t len)
 {
   VALUE v;
 
-  hp->flags |= UH_FL_HASHEADER;
+  HP_FL_SET(hp, HASHEADER);
 
   if (CONST_MEM_EQ("HTTP/1.1", ptr, len)) {
-    hp->flags |= UH_FL_KAVERSION;
+    /* HTTP/1.1 implies keepalive unless "Connection: close" is set */
+    HP_FL_SET(hp, KAVERSION);
     v = g_http_11;
   } else if (CONST_MEM_EQ("HTTP/1.0", ptr, len)) {
     v = g_http_10;
@@ -88,9 +128,9 @@ http_version(struct http_parser *hp, VALUE req, const char *ptr, size_t len)
   rb_hash_aset(req, g_http_version, v);
 }
 
-static void invalid_if_trailer(int flags)
+static inline void hp_invalid_if_trailer(struct http_parser *hp)
 {
-  if (flags & UH_FL_INTRAILER)
+  if (HP_FL_TEST(hp, INTRAILER))
     rb_raise(eHttpParserError, "invalid Trailer");
 }
 
@@ -99,10 +139,13 @@ static void write_cont_value(struct http_parser *hp,
 {
   char *vptr;
 
-  if (!hp->cont)
-    rb_raise(eHttpParserError, "invalid continuation line");
+  if (hp->cont == Qfalse)
+     rb_raise(eHttpParserError, "invalid continuation line");
+  if (NIL_P(hp->cont))
+     return; /* we're ignoring this header (probably Host:) */
 
-  assert(hp->mark > 0);
+  assert(TYPE(hp->cont) == T_STRING && "continuation line is not a string");
+  assert(hp->mark > 0 && "impossible continuation line offset");
 
   if (LEN(mark, p) == 0)
     return;
@@ -113,7 +156,7 @@ static void write_cont_value(struct http_parser *hp,
   vptr = (char *)PTR_TO(mark);
 
   if (RSTRING_LEN(hp->cont) > 0) {
-    assert(' ' == *vptr || '\t' == *vptr);
+    assert((' ' == *vptr || '\t' == *vptr) && "invalid leading white space");
     *vptr = ' ';
   }
   rb_str_buf_cat(hp->cont, vptr, LEN(mark, p));
@@ -127,37 +170,42 @@ static void write_value(VALUE req, struct http_parser *hp,
   VALUE e;
 
   VALIDATE_MAX_LENGTH(LEN(mark, p), FIELD_VALUE);
-  v = STR_NEW(mark, p);
-  if (f == Qnil) {
+  v = LEN(mark, p) == 0 ? rb_str_buf_new(128) : STR_NEW(mark, p);
+  if (NIL_P(f)) {
     VALIDATE_MAX_LENGTH(hp->s.field_len, FIELD_NAME);
     f = uncommon_field(PTR_TO(start.field), hp->s.field_len);
   } else if (f == g_http_connection) {
-    if (hp->flags & UH_FL_KAMETHOD) {
-      if (STR_CSTR_CASE_EQ(v, "keep-alive"))
-        hp->flags |= UH_FL_KAVERSION;
-      else if (STR_CSTR_CASE_EQ(v, "close"))
-        hp->flags &= ~UH_FL_KEEPALIVE;
-    }
+    hp_keepalive_connection(hp, v);
   } else if (f == g_content_length) {
     hp->len.content = parse_length(RSTRING_PTR(v), RSTRING_LEN(v));
     if (hp->len.content < 0)
       rb_raise(eHttpParserError, "invalid Content-Length");
-    hp->flags |= UH_FL_HASBODY;
-    invalid_if_trailer(hp->flags);
+    HP_FL_SET(hp, HASBODY);
+    hp_invalid_if_trailer(hp);
   } else if (f == g_http_transfer_encoding) {
-    if (STR_CSTR_CASE_EQ(v, "chunked"))
-      hp->flags |= UH_FL_CHUNKED | UH_FL_HASBODY;
-    invalid_if_trailer(hp->flags);
+    if (STR_CSTR_CASE_EQ(v, "chunked")) {
+      HP_FL_SET(hp, CHUNKED);
+      HP_FL_SET(hp, HASBODY);
+    }
+    hp_invalid_if_trailer(hp);
   } else if (f == g_http_trailer) {
-    hp->flags |= UH_FL_HASTRAILER;
-    invalid_if_trailer(hp->flags);
+    HP_FL_SET(hp, HASTRAILER);
+    hp_invalid_if_trailer(hp);
+  } else {
+    assert(TYPE(f) == T_STRING && "memoized object is not a string");
+    assert_frozen(f);
   }
 
   e = rb_hash_aref(req, f);
-  if (e == Qnil) {
+  if (NIL_P(e)) {
     hp->cont = rb_hash_aset(req, f, v);
-  } else if (f != g_http_host) {
-    /* full URLs in REQUEST_URI take precedence for the Host: header */
+  } else if (f == g_http_host) {
+    /*
+     * ignored, absolute URLs in REQUEST_URI take precedence over
+     * the Host: header (ref: rfc 2616, section 5.2.1)
+     */
+     hp->cont = Qnil;
+  } else {
     rb_str_buf_cat(e, ",", 1);
     hp->cont = rb_str_buf_append(e, v);
   }
@@ -232,12 +280,12 @@ static void write_value(VALUE req, struct http_parser *hp,
     finalize_header(hp, req);
 
     cs = http_parser_first_final;
-    if (hp->flags & UH_FL_HASBODY) {
-      hp->flags |= UH_FL_INBODY;
-      if (hp->flags & UH_FL_CHUNKED)
+    if (HP_FL_TEST(hp, HASBODY)) {
+      HP_FL_SET(hp, INBODY);
+      if (HP_FL_TEST(hp, CHUNKED))
         cs = http_parser_en_ChunkedBody;
     } else {
-      assert(!(hp->flags & UH_FL_CHUNKED));
+      assert(!HP_FL_TEST(hp, CHUNKED) && "chunked encoding without body!");
     }
     /*
      * go back to Ruby so we can call the Rack application, we'll reenter
@@ -252,13 +300,14 @@ static void write_value(VALUE req, struct http_parser *hp,
   }
 
   action end_chunked_body {
-    if (hp->flags & UH_FL_HASTRAILER) {
-      hp->flags |= UH_FL_INTRAILER;
+    if (HP_FL_TEST(hp, HASTRAILER)) {
+      HP_FL_SET(hp, INTRAILER);
       cs = http_parser_en_Trailers;
     } else {
       cs = http_parser_first_final;
     }
     ++p;
+    assert(p <= pe && "buffer overflow after chunked body");
     goto post_exec;
   }
 
@@ -269,9 +318,9 @@ static void write_value(VALUE req, struct http_parser *hp,
     hp->s.dest_offset += nr;
     hp->len.chunk -= nr;
     p += nr;
-    assert(hp->len.chunk >= 0);
+    assert(hp->len.chunk >= 0 && "negative chunk length");
     if (hp->len.chunk > REMAINING) {
-      hp->flags |= UH_FL_INCHUNK;
+      HP_FL_SET(hp, INCHUNK);
       goto post_exec;
     } else {
       fhold;
@@ -289,6 +338,7 @@ static void http_parser_init(struct http_parser *hp)
 {
   int cs = 0;
   memset(hp, 0, sizeof(struct http_parser));
+  hp->cont = Qfalse; /* zero on MRI, should be optimized away by above */
   %% write init;
   hp->cs = cs;
 }
@@ -311,8 +361,8 @@ static void http_parser_execute(struct http_parser *hp,
 
   assert(pe - p == len - off && "pointers aren't same distance");
 
-  if (hp->flags & UH_FL_INCHUNK) {
-    hp->flags &= ~(UH_FL_INCHUNK);
+  if (HP_FL_TEST(hp, INCHUNK)) {
+    HP_FL_UNSET(hp, INCHUNK);
     goto skip_chunk_data_hack;
   }
   %% write exec;
@@ -330,7 +380,7 @@ static struct http_parser *data_get(VALUE self)
   struct http_parser *hp;
 
   Data_Get_Struct(self, struct http_parser, hp);
-  assert(hp);
+  assert(hp && "failed to extract http_parser struct");
   return hp;
 }
 
@@ -341,20 +391,22 @@ static void finalize_header(struct http_parser *hp, VALUE req)
   VALUE server_port = g_port_80;
 
   /* set rack.url_scheme to "https" or "http", no others are allowed by Rack */
-  if (temp == Qnil) {
+  if (NIL_P(temp)) {
     temp = rb_hash_aref(req, g_http_x_forwarded_proto);
-    if (temp != Qnil && STR_CSTR_EQ(temp, "https"))
+    if (!NIL_P(temp) && STR_CSTR_EQ(temp, "https"))
       server_port = g_port_443;
     else
       temp = g_http;
     rb_hash_aset(req, g_rack_url_scheme, temp);
   } else if (STR_CSTR_EQ(temp, "https")) {
     server_port = g_port_443;
+  } else {
+    assert(server_port == g_port_80 && "server_port not set");
   }
 
   /* parse and set the SERVER_NAME and SERVER_PORT variables */
   temp = rb_hash_aref(req, g_http_host);
-  if (temp != Qnil) {
+  if (!NIL_P(temp)) {
     char *colon = memchr(RSTRING_PTR(temp), ':', RSTRING_LEN(temp));
     if (colon) {
       long port_start = colon - RSTRING_PTR(temp) + 1;
@@ -368,11 +420,11 @@ static void finalize_header(struct http_parser *hp, VALUE req)
   }
   rb_hash_aset(req, g_server_name, server_name);
   rb_hash_aset(req, g_server_port, server_port);
-  if (!(hp->flags & UH_FL_HASHEADER))
+  if (!HP_FL_TEST(hp, HASHEADER))
     rb_hash_aset(req, g_server_protocol, g_http_09);
 
   /* rack requires QUERY_STRING */
-  if (rb_hash_aref(req, g_query_string) == Qnil)
+  if (NIL_P(rb_hash_aref(req, g_query_string)))
     rb_hash_aset(req, g_query_string, rb_str_new(NULL, 0));
 }
 
@@ -380,8 +432,7 @@ static void hp_mark(void *ptr)
 {
   struct http_parser *hp = ptr;
 
-  if (hp->cont)
-    rb_gc_mark(hp->cont);
+  rb_gc_mark(hp->cont);
 }
 
 static VALUE HttpParser_alloc(VALUE klass)
@@ -427,7 +478,7 @@ static void advance_str(VALUE str, off_t nr)
 
   rb_str_modify(str);
 
-  assert(nr <= len);
+  assert(nr <= len && "trying to advance past end of buffer");
   len -= nr;
   if (len > 0) /* unlikely, len is usually 0 */
     memmove(RSTRING_PTR(str), RSTRING_PTR(str) + nr, len);
@@ -450,7 +501,7 @@ static VALUE HttpParser_content_length(VALUE self)
 {
   struct http_parser *hp = data_get(self);
 
-  return (hp->flags & UH_FL_CHUNKED) ? Qnil : OFFT2NUM(hp->len.content);
+  return HP_FL_TEST(hp, CHUNKED) ? Qnil : OFFT2NUM(hp->len.content);
 }
 
 /**
@@ -477,6 +528,8 @@ static VALUE HttpParser_headers(VALUE self, VALUE req, VALUE data)
 {
   struct http_parser *hp = data_get(self);
 
+  rb_str_update(data);
+
   http_parser_execute(hp, req, RSTRING_PTR(data), RSTRING_LEN(data));
   VALIDATE_MAX_LENGTH(hp->start.offset, HEADER);
 
@@ -496,8 +549,7 @@ static VALUE HttpParser_headers(VALUE self, VALUE req, VALUE data)
 
 static int chunked_eof(struct http_parser *hp)
 {
-  return ((hp->cs == http_parser_first_final) ||
-          (hp->flags & UH_FL_INTRAILER));
+  return ((hp->cs == http_parser_first_final) || HP_FL_TEST(hp, INTRAILER));
 }
 
 /**
@@ -511,7 +563,7 @@ static VALUE HttpParser_body_eof(VALUE self)
 {
   struct http_parser *hp = data_get(self);
 
-  if (hp->flags & UH_FL_CHUNKED)
+  if (HP_FL_TEST(hp, CHUNKED))
     return chunked_eof(hp) ? Qtrue : Qfalse;
 
   return hp->len.content == 0 ? Qtrue : Qfalse;
@@ -532,7 +584,7 @@ static VALUE HttpParser_keepalive(VALUE self)
 {
   struct http_parser *hp = data_get(self);
 
-  return (hp->flags & UH_FL_KEEPALIVE) == UH_FL_KEEPALIVE ? Qtrue : Qfalse;
+  return HP_FL_ALL(hp, KEEPALIVE) ? Qtrue : Qfalse;
 }
 
 /**
@@ -547,7 +599,7 @@ static VALUE HttpParser_has_headers(VALUE self)
 {
   struct http_parser *hp = data_get(self);
 
-  return (hp->flags & UH_FL_HASHEADER) ? Qtrue : Qfalse;
+  return HP_FL_TEST(hp, HASHEADER) ? Qtrue : Qfalse;
 }
 
 /**
@@ -567,34 +619,38 @@ static VALUE HttpParser_has_headers(VALUE self)
 static VALUE HttpParser_filter_body(VALUE self, VALUE buf, VALUE data)
 {
   struct http_parser *hp = data_get(self);
-  char *dptr = RSTRING_PTR(data);
-  long dlen = RSTRING_LEN(data);
+  char *dptr;
+  long dlen;
+
+  rb_str_update(data);
+  dptr = RSTRING_PTR(data);
+  dlen = RSTRING_LEN(data);
 
   StringValue(buf);
   rb_str_resize(buf, dlen); /* we can never copy more than dlen bytes */
   OBJ_TAINT(buf); /* keep weirdo $SAFE users happy */
 
-  if (hp->flags & UH_FL_CHUNKED) {
-    if (chunked_eof(hp))
-      goto end_of_body;
-
-    hp->s.dest_offset = 0;
-    http_parser_execute(hp, buf, dptr, dlen);
-    if (hp->cs == http_parser_error)
-      rb_raise(eHttpParserError, "Invalid HTTP format, parsing fails.");
-
-    assert(hp->s.dest_offset <= hp->start.offset);
-    advance_str(data, hp->start.offset);
-    rb_str_set_len(buf, hp->s.dest_offset);
-
-    if (RSTRING_LEN(buf) == 0 && chunked_eof(hp)) {
-      assert(hp->len.chunk == 0);
-    } else {
-      data = Qnil;
+  if (HP_FL_TEST(hp, CHUNKED)) {
+    if (!chunked_eof(hp)) {
+      hp->s.dest_offset = 0;
+      http_parser_execute(hp, buf, dptr, dlen);
+      if (hp->cs == http_parser_error)
+        rb_raise(eHttpParserError, "Invalid HTTP format, parsing fails.");
+
+      assert(hp->s.dest_offset <= hp->start.offset &&
+             "destination buffer overflow");
+      advance_str(data, hp->start.offset);
+      rb_str_set_len(buf, hp->s.dest_offset);
+
+      if (RSTRING_LEN(buf) == 0 && chunked_eof(hp)) {
+        assert(hp->len.chunk == 0 && "chunk at EOF but more to parse");
+      } else {
+        data = Qnil;
+      }
     }
   } else {
     /* no need to enter the Ragel machine for unchunked transfers */
-    assert(hp->len.content >= 0);
+    assert(hp->len.content >= 0 && "negative Content-Length");
     if (hp->len.content > 0) {
       long nr = MIN(dlen, hp->len.content);
 
@@ -607,14 +663,13 @@ static VALUE HttpParser_filter_body(VALUE self, VALUE buf, VALUE data)
       data = Qnil;
     }
   }
-end_of_body:
   hp->start.offset = 0; /* for trailer parsing */
   return data;
 }
 
 #define SET_GLOBAL(var,str) do { \
   var = find_common_field(str, sizeof(str) - 1); \
-  assert(var != Qnil); \
+  assert(!NIL_P(var) && "missed global field"); \
 } while (0)
 
 void Init_unicorn_http(void)

data/lib/unicorn.rb

@@ -1,3 +1,5 @@
+# -*- encoding: binary -*-
+
 require 'fcntl'
 require 'unicorn/socket_helper'
 autoload :Rack, 'rack'
@@ -108,6 +110,8 @@ module Unicorn
       config_listeners -= listener_names
       if config_listeners.empty? && LISTENERS.empty?
         config_listeners << Unicorn::Const::DEFAULT_LISTEN
+        init_listeners << Unicorn::Const::DEFAULT_LISTEN
+        START_CTX[:argv] << "-l#{Unicorn::Const::DEFAULT_LISTEN}"
       end
       config_listeners.each { |addr| listen(addr) }
       raise ArgumentError, "no listeners" if LISTENERS.empty?
@@ -283,7 +287,7 @@ module Unicorn
 
     # list of signals we care about and trap in master.
     QUEUE_SIGS = [ :WINCH, :QUIT, :INT, :TERM, :USR1, :USR2, :HUP,
-                   :TTIN, :TTOU ].freeze
+                   :TTIN, :TTOU ]
 
     # defer a signal for later processing in #join (master process)
     def trap_deferred(signal)
@@ -535,7 +539,7 @@ module Unicorn
 
         # make the following bet: if we accepted clients this round,
         # we're probably reasonably busy, so avoid calling select()
-        # and do a speculative accept_nonblock on every listener
+        # and do a speculative accept_nonblock on ready listeners
         # before we sleep again in select().
         redo unless nr == 0 # (nr < 0) => reopen logs