puma 2.2.0 → 8.0.2

data/ext/puma_http11/http11_parser.h

@@ -1,11 +1,13 @@
 /**
  * Copyright (c) 2005 Zed A. Shaw
  * You can redistribute it and/or modify it under the same terms as Ruby.
+ * License 3-clause BSD
  */
 
 #ifndef http11_parser_h
 #define http11_parser_h
 
+#define RSTRING_NOT_MODIFIED 1
 #include "ruby.h"
 
 #include <sys/types.h>
@@ -16,19 +18,19 @@
 
 #define BUFFER_LEN 1024
 
-struct http_parser;
+struct puma_parser;
 
-typedef void (*element_cb)(struct http_parser* hp,
+typedef void (*element_cb)(struct puma_parser* hp,
                            const char *at, size_t length);
 
-typedef void (*field_cb)(struct http_parser* hp,
+typedef void (*field_cb)(struct puma_parser* hp,
                          const char *field, size_t flen,
                          const char *value, size_t vlen);
 
-typedef struct http_parser { 
+typedef struct puma_parser {
   int cs;
-  size_t body_start;
   int content_len;
+  size_t body_start;
   size_t nread;
   size_t mark;
   size_t field_start;
@@ -44,20 +46,20 @@ typedef struct http_parser {
   element_cb fragment;
   element_cb request_path;
   element_cb query_string;
-  element_cb http_version;
+  element_cb server_protocol;
   element_cb header_done;
 
   char buf[BUFFER_LEN];
   
-} http_parser;
+} puma_parser;
 
-int http_parser_init(http_parser *parser);
-int http_parser_finish(http_parser *parser);
-size_t http_parser_execute(http_parser *parser, const char *data,
+int puma_parser_init(puma_parser *parser);
+int puma_parser_finish(puma_parser *parser);
+size_t puma_parser_execute(puma_parser *parser, const char *data,
                            size_t len, size_t off);
-int http_parser_has_error(http_parser *parser);
-int http_parser_is_finished(http_parser *parser);
+int puma_parser_has_error(puma_parser *parser);
+int puma_parser_is_finished(puma_parser *parser);
 
-#define http_parser_nread(parser) (parser)->nread 
+#define puma_parser_nread(parser) (parser)->nread
 
 #endif

data/ext/puma_http11/http11_parser.java.rl

@@ -1,5 +1,8 @@
 package org.jruby.puma;
 
+import org.jruby.Ruby;
+import org.jruby.RubyHash;
+import org.jruby.RubyString;
 import org.jruby.util.ByteList;
 
 public class Http11Parser {
@@ -7,138 +10,105 @@ public class Http11Parser {
 /** Machine **/
 
 %%{
-  
-  machine http_parser;
 
-  action mark {parser.mark = fpc; }
+  machine puma_parser;
+
+  action mark {this.mark = fpc; }
 
-  action start_field { parser.field_start = fpc; }
-  action snake_upcase_field { /* FIXME stub */ }
+  action start_field { this.field_start = fpc; }
+  action snake_upcase_field { /* done lazily as needed */ }
   action write_field { 
-    parser.field_len = fpc-parser.field_start;
+    this.field_len = fpc-this.field_start;
   }
 
-  action start_value { parser.mark = fpc; }
-  action write_value { 
-    if(parser.http_field != null) {
-      parser.http_field.call(parser.data, parser.field_start, parser.field_len, parser.mark, fpc-parser.mark);
-    }
+  action start_value { this.mark = fpc; }
+  action write_value {
+    Http11.http_field(runtime, envStrings, this, fpc-this.mark);
   }
-  action request_method { 
-    if(parser.request_method != null) 
-      parser.request_method.call(parser.data, parser.mark, fpc-parser.mark);
+  action request_method {
+    Http11.request_method(runtime, envStrings, this, fpc-this.mark);
   }
-  action request_uri { 
-    if(parser.request_uri != null)
-      parser.request_uri.call(parser.data, parser.mark, fpc-parser.mark);
+  action request_uri {
+    Http11.request_uri(runtime, envStrings, this, fpc-this.mark);
   }
-  action fragment { 
-    if(parser.fragment != null)
-      parser.fragment.call(parser.data, parser.mark, fpc-parser.mark);
+  action fragment {
+    Http11.fragment(runtime, envStrings, this, fpc-this.mark);
   }
   
-  action start_query {parser.query_start = fpc; }
-  action query_string { 
-    if(parser.query_string != null)
-      parser.query_string.call(parser.data, parser.query_start, fpc-parser.query_start);
+  action start_query {this.query_start = fpc; }
+  action query_string {
+    Http11.query_string(runtime, envStrings, this, fpc-this.query_start);
   }
 
-  action http_version {	
-    if(parser.http_version != null)
-      parser.http_version.call(parser.data, parser.mark, fpc-parser.mark);
+  action server_protocol {
+    Http11.server_protocol(runtime, envStrings, this, fpc-this.mark);
   }
 
   action request_path {
-    if(parser.request_path != null)
-      parser.request_path.call(parser.data, parser.mark, fpc-parser.mark);
+    Http11.request_path(runtime, envStrings, this, fpc-this.mark);
   }
 
   action done { 
-    parser.body_start = fpc + 1; 
-    if(parser.header_done != null)
-      parser.header_done.call(parser.data, fpc + 1, pe - fpc - 1);
+    this.body_start = fpc + 1;
+    http.header_done(runtime, this, fpc + 1, pe - fpc - 1);
     fbreak;
   }
 
-  include http_parser_common "http11_parser_common.rl";
+  include puma_parser_common "http11_parser_common.rl";
 
 }%%
 
 /** Data **/
-%% write data;
+%% write data noentry;
 
-   public static interface ElementCB {
-     public void call(Object data, int at, int length);
-   }
+   int cs;
+   int body_start;
+   int nread;
+   int mark;
+   int field_start;
+   int field_len;
+   int query_start;
 
-   public static interface FieldCB {
-     public void call(Object data, int field, int flen, int value, int vlen);
-   }
+   RubyHash data;
+   byte[] buffer;
 
-   public static class HttpParser {
-      int cs;
-      int body_start;
-      int content_len;
-      int nread;
-      int mark;
-      int field_start;
-      int field_len;
-      int query_start;
-
-      Object data;
-      ByteList buffer;
-
-      public FieldCB http_field;
-      public ElementCB request_method;
-      public ElementCB request_uri;
-      public ElementCB fragment;
-      public ElementCB request_path;
-      public ElementCB query_string;
-      public ElementCB http_version;
-      public ElementCB header_done;
-
-      public void init() {
-          cs = 0;
-
-          %% write init;
-
-          body_start = 0;
-          content_len = 0;
-          mark = 0;
-          nread = 0;
-          field_len = 0;
-          field_start = 0;
-      }
-   }
+   public void init() {
 
-   public final HttpParser parser = new HttpParser();
+       %% write init;
+
+       body_start = 0;
+       mark = 0;
+       nread = 0;
+       field_len = 0;
+       field_start = 0;
+   }
 
-   public int execute(ByteList buffer, int off) {
+   public int execute(Ruby runtime, Http11 http, ByteList buffer, int off) {
      int p, pe;
-     int cs = parser.cs;
+     int cs = this.cs;
      int len = buffer.length();
+     int beg = buffer.begin();
+     RubyString[] envStrings = http.envStrings;
      assert off<=len : "offset past end of buffer";
 
-     p = off;
-     pe = len;
-     // get a copy of the bytes, since it may not start at 0
-     // FIXME: figure out how to just use the bytes in-place
-     byte[] data = buffer.bytes();
-     parser.buffer = buffer;
+     p = beg + off;
+     pe = beg + len;
+     byte[] data = buffer.unsafeBytes();
+     this.buffer = data;
 
      %% write exec;
 
-     parser.cs = cs;
-     parser.nread += (p - off);
+     this.cs = cs;
+     this.nread += (p - off);
      
      assert p <= pe                  : "buffer overflow after parsing execute";
-     assert parser.nread <= len      : "nread longer than length";
-     assert parser.body_start <= len : "body starts after buffer end";
-     assert parser.mark < len        : "mark is after buffer end";
-     assert parser.field_len <= len  : "field has length longer than whole buffer";
-     assert parser.field_start < len : "field starts after buffer end";
+     assert this.nread <= len      : "nread longer than length";
+     assert this.body_start <= len : "body starts after buffer end";
+     assert this.mark < len        : "mark is after buffer end";
+     assert this.field_len <= len  : "field has length longer than whole buffer";
+     assert this.field_start < len : "field starts after buffer end";
 
-     return parser.nread;
+     return this.nread;
    }
 
    public int finish() {
@@ -152,10 +122,10 @@ public class Http11Parser {
   }
 
   public boolean has_error() {
-    return parser.cs == http_parser_error;
+    return this.cs == puma_parser_error;
   }
 
   public boolean is_finished() {
-    return parser.cs == http_parser_first_final;
+    return this.cs == puma_parser_first_final;
   }
 }

data/ext/puma_http11/http11_parser.rl

@@ -1,6 +1,7 @@
 /**
  * Copyright (c) 2005 Zed A. Shaw
  * You can redistribute it and/or modify it under the same terms as Ruby.
+ * License 3-clause BSD
  */
 #include "http11_parser.h"
 #include <stdio.h>
@@ -11,12 +12,14 @@
 
 /*
  * capitalizes all lower-case ASCII characters,
- * converts dashes to underscores.
+ * converts dashes to underscores, and underscores to commas.
  */
 static void snake_upcase_char(char *c)
 {
     if (*c >= 'a' && *c <= 'z')
       *c &= ~0x20;
+    else if (*c == '_')
+      *c = ',';
     else if (*c == '-')
       *c = '_';
 }
@@ -28,15 +31,15 @@ static void snake_upcase_char(char *c)
 /** Machine **/
 
 %%{
-  
-  machine http_parser;
+
+  machine puma_parser;
 
   action mark { MARK(mark, fpc); }
 
 
   action start_field { MARK(field_start, fpc); }
   action snake_upcase_field { snake_upcase_char((char *)fpc); }
-  action write_field { 
+  action write_field {
     parser->field_len = LEN(field_start, fpc);
   }
 
@@ -44,10 +47,10 @@ static void snake_upcase_char(char *c)
   action write_value {
     parser->http_field(parser, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, fpc));
   }
-  action request_method { 
+  action request_method {
     parser->request_method(parser, PTR_TO(mark), LEN(mark, fpc));
   }
-  action request_uri { 
+  action request_uri {
     parser->request_uri(parser, PTR_TO(mark), LEN(mark, fpc));
   }
   action fragment {
@@ -55,32 +58,32 @@ static void snake_upcase_char(char *c)
   }
 
   action start_query { MARK(query_start, fpc); }
-  action query_string { 
+  action query_string {
     parser->query_string(parser, PTR_TO(query_start), LEN(query_start, fpc));
   }
 
-  action http_version {	
-    parser->http_version(parser, PTR_TO(mark), LEN(mark, fpc));
+  action server_protocol {
+    parser->server_protocol(parser, PTR_TO(mark), LEN(mark, fpc));
   }
 
   action request_path {
     parser->request_path(parser, PTR_TO(mark), LEN(mark,fpc));
   }
 
-  action done { 
-    parser->body_start = fpc - buffer + 1; 
+  action done {
+    parser->body_start = fpc - buffer + 1;
     parser->header_done(parser, fpc + 1, pe - fpc - 1);
     fbreak;
   }
 
-  include http_parser_common "http11_parser_common.rl";
+  include puma_parser_common "http11_parser_common.rl";
 
 }%%
 
 /** Data **/
-%% write data;
+%% write data noentry;
 
-int http_parser_init(http_parser *parser)  {
+int puma_parser_init(puma_parser *parser)  {
   int cs = 0;
   %% write init;
   parser->cs = cs;
@@ -98,7 +101,7 @@ int http_parser_init(http_parser *parser)  {
 
 
 /** exec **/
-size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off)  {
+size_t puma_parser_execute(puma_parser *parser, const char *buffer, size_t len, size_t off)  {
   const char *p, *pe;
   int cs = parser->cs;
 
@@ -108,11 +111,11 @@ size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len,
   pe = buffer+len;
 
   /* assert(*pe == '\0' && "pointer does not end on NUL"); */
-  assert(pe - p == len - off && "pointers aren't same distance");
+  assert((size_t) (pe - p) == len - off && "pointers aren't same distance");
 
   %% write exec;
 
-  if (!http_parser_has_error(parser))
+  if (!puma_parser_has_error(parser))
     parser->cs = cs;
   parser->nread += p - (buffer + off);
 
@@ -126,21 +129,21 @@ size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len,
   return(parser->nread);
 }
 
-int http_parser_finish(http_parser *parser)
+int puma_parser_finish(puma_parser *parser)
 {
-  if (http_parser_has_error(parser) ) {
+  if (puma_parser_has_error(parser) ) {
     return -1;
-  } else if (http_parser_is_finished(parser) ) {
+  } else if (puma_parser_is_finished(parser) ) {
     return 1;
   } else {
     return 0;
   }
 }
 
-int http_parser_has_error(http_parser *parser) {
-  return parser->cs == http_parser_error;
+int puma_parser_has_error(puma_parser *parser) {
+  return parser->cs == puma_parser_error;
 }
 
-int http_parser_is_finished(http_parser *parser) {
-  return parser->cs >= http_parser_first_final;
+int puma_parser_is_finished(puma_parser *parser) {
+  return parser->cs >= puma_parser_first_final;
 }

data/ext/puma_http11/http11_parser_common.rl

@@ -1,6 +1,6 @@
 %%{
-  
-  machine http_parser_common;
+
+  machine puma_parser_common;
 
 #### HTTP PROTOCOL GRAMMAR
 # line endings
@@ -15,8 +15,8 @@
   national = any -- (alpha | digit | reserved | extra | safe | unsafe);
   unreserved = (alpha | digit | safe | extra | national);
   escape = ("%" xdigit xdigit);
-  uchar = (unreserved | escape);
-  pchar = (uchar | ":" | "@" | "&" | "=" | "+");
+  uchar = (unreserved | escape | "%");
+  pchar = (uchar | ":" | "@" | "&" | "=" | "+" | ";");
   tspecials = ("(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\\" | "\"" | "/" | "[" | "]" | "?" | "=" | "{" | "}" | " " | "\t");
 
 # elements
@@ -30,7 +30,7 @@
   query = ( uchar | reserved )* %query_string ;
   param = ( pchar | "/" )* ;
   params = ( param ( ";" param )* ) ;
-  rel_path = ( path? %request_path (";" params)? ) ("?" %start_query query)?;
+  rel_path = ( path? %request_path ) ("?" %start_query query)?;
   absolute_path = ( "/"+ rel_path );
 
   Request_URI = ( "*" | absolute_uri | absolute_path ) >mark %request_uri;
@@ -38,12 +38,12 @@
   Method = ( upper | digit | safe ){1,20} >mark %request_method;
 
   http_number = ( digit+ "." digit+ ) ;
-  HTTP_Version = ( "HTTP/" http_number ) >mark %http_version ;
-  Request_Line = ( Method " " Request_URI ("#" Fragment){0,1} " " HTTP_Version CRLF ) ;
+  Server_Protocol = ( "HTTP/" http_number ) >mark %server_protocol ;
+  Request_Line = ( Method " " Request_URI ("#" Fragment){0,1} " " Server_Protocol CRLF ) ;
 
   field_name = ( token -- ":" )+ >start_field $snake_upcase_field %write_field;
 
-  field_value = any* >start_value %write_value;
+  field_value = ( (any -- CTL) | "\t" )* >start_value %write_value;
 
   message_header = field_name ":" " "* field_value :> CRLF;