http_parser.rb 0.5.1 → 0.6.0.beta.1

data/ext/ruby_http_parser/vendor/http-parser-java/src/test/http_parser/lolevel/UnitTest.java

@@ -2,6 +2,7 @@ package http_parser.lolevel;
 
 import java.nio.ByteBuffer;
 import http_parser.HTTPException;
+import http_parser.Util;
 
 public class UnitTest {
 
@@ -108,7 +109,8 @@ public class UnitTest {
   }
 
 
-  public static void main (String [] args) {
+  public static void test () {
+    p(UnitTest.class);
     testErrorFormat();
     testErrorCallback();
   }  

data/ext/ruby_http_parser/vendor/http-parser-java/src/test/http_parser/lolevel/Upgrade.java

@@ -0,0 +1,27 @@
+package http_parser.lolevel;
+
+import java.nio.*;
+import java.util.*;
+
+import http_parser.ParserType;
+
+import static http_parser.lolevel.Util.*;
+
+public class Upgrade {
+  static final String upgrade = "GET /demo HTTP/1.1\r\n" +
+                                "Connection: Upgrade\r\n" +
+                                "Upgrade: WebSocket\r\n\r\n" +
+                                "third key data";
+  static void test () {
+    p(Upgrade.class);
+    HTTPParser parser = new HTTPParser(ParserType.HTTP_REQUEST);
+    ByteBuffer buf    = buffer(upgrade);
+    
+    int read = parser.execute(Util.SETTINGS_NULL, buf);
+    check (63 == read);
+    String s = str(buf);
+    check ("third key data".equals(str(buf)));
+  
+  }
+
+}

data/ext/ruby_http_parser/vendor/http-parser-java/src/test/http_parser/lolevel/Url.java

@@ -0,0 +1,127 @@
+package http_parser.lolevel;
+
+import http_parser.FieldData;
+import http_parser.HTTPParserUrl;
+
+import static http_parser.HTTPParserUrl.*;
+import static http_parser.lolevel.HTTPParser.*;
+
+/**
+ */
+public class Url {
+  
+  public static Url[] URL_TESTS = new Url[]{
+      new Url("proxy request", "http://hostname/", false,
+          new HTTPParserUrl(
+              (1 << UrlFields.UF_SCHEMA.getIndex()) | (1 << UrlFields.UF_HOST.getIndex()) | (1 << UrlFields.UF_PATH.getIndex()),
+              0,
+              new FieldData[]{
+                  new FieldData(0,4),
+                  new FieldData(7,8),
+                  new FieldData(0,0),
+                  new FieldData(15,1),
+                  new FieldData(0,0),
+                  new FieldData(0,0)
+              }),
+          0),
+      new Url("CONNECT request", "hostname:443", true,
+          new HTTPParserUrl(
+              (1 << UrlFields.UF_HOST.getIndex()) | (1 << UrlFields.UF_PORT.getIndex()),
+              443,
+              new FieldData[]{
+                  new FieldData(0,0),
+                  new FieldData(0,8),
+                  new FieldData(9,3),
+                  new FieldData(0,0),
+                  new FieldData(0,0),
+                  new FieldData(0,0)
+              }),
+          0),
+      new Url("proxy ipv6 request", "http://[1:2::3:4]/", false,
+          new HTTPParserUrl(
+              (1 << UrlFields.UF_SCHEMA.getIndex()) | (1 << UrlFields.UF_HOST.getIndex()) | (1 << UrlFields.UF_PATH.getIndex()),
+              0,
+              new FieldData[]{
+                  new FieldData(0,4),
+                  new FieldData(8,8),
+                  new FieldData(0,0),
+                  new FieldData(17,1),
+                  new FieldData(0,0),
+                  new FieldData(0,0)
+              }),
+          0),
+      new Url("CONNECT ipv6 address", "[1:2::3:4]:443", true,
+          new HTTPParserUrl(
+              (1 << UrlFields.UF_HOST.getIndex()) | (1 << UrlFields.UF_PORT.getIndex()),
+              443,
+              new FieldData[]{
+                  new FieldData(0,0),
+                  new FieldData(1,8),
+                  new FieldData(11,3),
+                  new FieldData(0,0),
+                  new FieldData(0,0),
+                  new FieldData(0,0)
+              }),
+          0),
+      new Url("extra ? in query string",
+          "http://a.tbcdn.cn/p/fp/2010c/??fp-header-min.css,fp-base-min.css,fp-channel-min.css,fp-product-min.css,fp-mall-min.css,fp-category-min.css,fp-sub-min.css,fp-gdp4p-min.css,fp-css3-min.css,fp-misc-min.css?t=20101022.css",
+          false,
+          new HTTPParserUrl(
+              (1 << UrlFields.UF_SCHEMA.getIndex()) |
+              (1 << UrlFields.UF_HOST.getIndex()) |
+              (1 << UrlFields.UF_PATH.getIndex()) |
+              (1 << UrlFields.UF_QUERY.getIndex()),
+              0,
+              new FieldData[]{
+                  new FieldData(0,4),
+                  new FieldData(7,10),
+                  new FieldData(0,0),
+                  new FieldData(17,12),
+                  new FieldData(30,187),
+                  new FieldData(0,0)
+              }),
+          0),
+      new Url("proxy empty host",
+          "http://:443/",
+          false,
+          null,
+          1),
+      new Url("proxy empty port",
+          "http://hostname:/",
+          false,
+          null,
+          1),
+      new Url("CONNECT empty host",
+          ":443",
+          true,
+          null,
+          1),
+      new Url("CONNECT empty port",
+          "hostname:",
+          true,
+          null,
+          1),
+      new Url("CONNECT with extra bits",
+          "hostname:443/",
+          true,
+          null,
+          1),
+
+  };
+
+  String name;
+  String url;
+  boolean is_connect;
+  HTTPParserUrl u;
+  int rv;
+  
+  public Url(String name, String url, boolean is_connect, HTTPParserUrl u, int rv) {
+    this.name = name;
+    this.url = url;
+    this.is_connect = is_connect;
+    this.u = u;
+    this.rv = rv;
+  }
+
+
+}

data/ext/ruby_http_parser/vendor/http-parser-java/src/test/http_parser/lolevel/Util.java

@@ -0,0 +1,236 @@
+package http_parser.lolevel;
+
+import java.nio.*;
+import java.util.*;
+
+import primitive.collection.ByteList;
+
+import http_parser.*;
+
+public class Util {
+
+  static final ParserSettings SETTINGS_NULL = new ParserSettings();
+
+  static String str (ByteBuffer b, int pos, int len) {
+    byte [] by = new byte[len];
+    int saved = b.position();
+    b.position(pos);
+    b.get(by);
+    b.position(saved);
+    return new String(by);
+  }
+  static String str (ByteBuffer b) {
+    int len = b.limit() - b.position(); 
+    byte [] by = new byte[len];
+    int saved = b.position();
+    b.get(by);
+    b.position(saved);
+    return new String(by);
+  }
+
+  static ByteBuffer buffer(String str) {
+    return ByteBuffer.wrap(str.getBytes());
+  }
+
+  static ByteBuffer empty() {
+    return ByteBuffer.wrap(new byte[0]);
+  }
+
+  static void check(boolean betterBtrue) {
+    if (!betterBtrue) {
+      throw new RuntimeException("!");
+    }
+  }
+  static void check (int should, int is) {
+    if (should != is) {
+      throw new RuntimeException("should be: "+should+" is:"+is);
+    }
+  }
+
+  static void test_message(Message mes) {
+    int raw_len = mes.raw.length;
+    for (int msg1len = 0; msg1len != raw_len; ++msg1len) {
+      mes.reset();
+      ByteBuffer msg1 = ByteBuffer.wrap(mes.raw, 0, msg1len);
+      ByteBuffer msg2 = ByteBuffer.wrap(mes.raw, msg1len, mes.raw.length - msg1len);
+
+      HTTPParser parser = new HTTPParser(mes.type);
+      ParserSettings settings = mes.settings();
+
+      int read = 0;
+      if (msg1len !=0) {
+        read = parser.execute(settings, msg1);
+        if (mes.upgrade() && parser.upgrade) {
+          // Messages have a settings() that checks itself...
+          check(1 == mes.num_called);
+          continue; 
+        }
+        check(read == msg1len);
+      }
+
+      read = parser.execute(settings, msg2);
+      if (mes.upgrade() && parser.upgrade) {
+        check(1 == mes.num_called);
+        continue; 
+      }
+
+      check( mes.raw.length - msg1len, read);
+      
+      ByteBuffer empty = Util.empty();
+      read = parser.execute(settings, empty);
+      
+      if (mes.upgrade() && parser.upgrade) {
+        check(1 == mes.num_called);
+        continue;
+      }
+      check(empty.position() == empty.limit());
+      check(0 == read);
+      check(1 == mes.num_called);
+
+    }
+  }
+
+  static void test_multiple3(Message r1, Message r2, Message r3) {
+    int message_count = 1;
+    if (!r1.upgrade()) {
+      message_count++;
+      if (!r2.upgrade()) {
+        message_count++;
+      }
+    }
+    boolean has_upgrade = (message_count < 3 || r3.upgrade());
+
+    ByteList blist = new ByteList();
+    blist.addAll(r1.raw);
+    blist.addAll(r2.raw);
+    blist.addAll(r3.raw);
+
+    byte [] raw = blist.toArray();
+    ByteBuffer buf   = ByteBuffer.wrap(raw);
+
+    Util.Settings settings = Util.settings(); 
+    HTTPParser parser = new HTTPParser(r1.type);
+    
+    int read = parser.execute(settings, buf);
+    if (has_upgrade && parser.upgrade) {
+      raw = upgrade_message_fix(raw, read, r1,r2,r3);
+      check(settings.numCalled == message_count); 
+      return;
+    }
+
+    check(read == raw.length);
+
+    buf = Util.empty();    
+    read = parser.execute(settings, buf);
+    if (has_upgrade && parser.upgrade) {
+      check(settings.numCalled == message_count); 
+      return;
+    }
+
+    check(0 == read);
+    check(settings.numCalled == message_count);
+  }  
+
+  /* Given a sequence of bytes and the number of these that we were able to
+   * parse, verify that upgrade bodies are correct.
+   */
+  static byte [] upgrade_message_fix(byte[] body, int nread, Message... msgs) {
+    int off = 0;
+    for (Message m : msgs) {
+      off += m.raw.length;
+      if (m.upgrade()) {
+        off -= m.upgrade.length;
+        // Original C:
+        //     Check the portion of the response after its specified upgrade 
+        //     if (!check_str_eq(m, "upgrade", body + off, body + nread)) {
+        //       abort();
+        //     }
+        // to me, this seems to be equivalent to comparing off and nread ...
+        check (off, nread);
+        
+        // Original C:
+        //   Fix up the response so that message_eq() will verify the beginning
+        //   of the upgrade */
+        // 
+        //   *(body + nread + strlen(m->upgrade)) = '\0';
+        // This only shortens body so the strlen check passes.
+        return new byte[off];
+
+      }
+    }
+    return null;
+  }
+//upgrade_message_fix(char *body, const size_t nread, const size_t nmsgs, ...) {
+//  va_list ap;
+//  size_t i;
+//  size_t off = 0;
+// 
+//  va_start(ap, nmsgs);
+//
+//  for (i = 0; i < nmsgs; i++) {
+//    struct message *m = va_arg(ap, struct message *);
+//
+//    off += strlen(m->raw);
+//
+//    if (m->upgrade) {
+//      off -= strlen(m->upgrade);
+//
+//      /* Check the portion of the response after its specified upgrade */
+//      if (!check_str_eq(m, "upgrade", body + off, body + nread)) {
+//        abort();
+//      }
+//
+//      /* Fix up the response so that message_eq() will verify the beginning
+//       * of the upgrade */
+//      *(body + nread + strlen(m->upgrade)) = '\0';
+//      messages[num_messages -1 ].upgrade = body + nread;
+//
+//      va_end(ap);
+//      return;
+//    }
+//  }
+//
+//  va_end(ap);
+//  printf("\n\n*** Error: expected a message with upgrade ***\n");
+//
+//  abort();
+//}
+  static void p (Object o) {
+    System.out.println(o);
+  }
+
+  static Settings settings() {
+    return new Settings();
+  }
+  static Message find(List<Message> list, String name) {
+    for (Message m : list) {
+      if (name.equals(m.name)) {
+        return m;
+      }
+    }
+    return null;
+  }
+
+  static class Settings extends ParserSettings {
+    public int numCalled;
+    public int bodyCount;
+    Settings() {
+      this.on_message_complete = new HTTPCallback() {
+        public int cb (HTTPParser parser) {
+          numCalled++;
+          return 0;
+        }
+      };
+      this.on_body = new HTTPDataCallback() {
+        public int cb (HTTPParser p, ByteBuffer b, int pos, int len) {
+          bodyCount += len;
+          return 0;
+        }
+      }; 
+    }
+    
+    int numCalled () {
+      return this.numCalled;
+    }
+  }
+}

data/ext/ruby_http_parser/vendor/http-parser-java/src/test/http_parser/lolevel/WrongContentLength.java

@@ -0,0 +1,59 @@
+package http_parser.lolevel;
+
+import java.nio.*;
+import java.util.*;
+
+import http_parser.ParserType;
+
+import static http_parser.lolevel.Util.*;
+
+public class WrongContentLength {
+  static final String contentLength = "GET / HTTP/1.0\r\n" +
+                                      "Content-Length: 5\r\n" +
+                                      "\r\n" +
+                                      "hello" +
+                                      "hello_again";
+  static void test () {
+    p(WrongContentLength.class);
+    HTTPParser parser = new HTTPParser(ParserType.HTTP_REQUEST);
+    ByteBuffer buf    = buffer(contentLength);
+    
+    Settings settings = new Settings();
+
+    int read = parser.execute(settings, buf);
+    check (settings.msg_cmplt_called);
+    check ("invalid method".equals(settings.err));
+  
+  }
+  public static void main(String [] args) {
+    test();
+  }
+
+  static class Settings extends ParserSettings {
+    public int bodyCount;
+    public boolean msg_cmplt_called;
+    public String err;
+    Settings () {
+      this.on_message_complete = new HTTPCallback () {
+        public int cb (HTTPParser p) {
+          check (5 == bodyCount);
+          msg_cmplt_called = true;
+          return 0;
+        }
+      };
+      this.on_body = new HTTPDataCallback() {
+        public int cb (HTTPParser p, ByteBuffer b, int pos, int len) {
+          bodyCount += len;
+          check ("hello".equals(str(b, pos, len)));
+          return 0;
+        }
+      }; 
+      this.on_error = new HTTPErrorCallback() {
+        public void cb (HTTPParser p, String mes, ByteBuffer b, int i) {
+          err = mes;
+        }
+      };
+    }
+  }
+
+}