http_parser.rb 0.5.0-x86-mingw32

data/ext/ruby_http_parser/vendor/http-parser-java/src/impl/http_parser/lolevel/ParserSettings.java

@@ -0,0 +1,78 @@
+package http_parser.lolevel;
+import java.nio.ByteBuffer;
+import http_parser.HTTPException;
+public class ParserSettings {
+	
+  public HTTPCallback       on_message_begin;
+  public HTTPDataCallback 	on_path;
+  public HTTPDataCallback 	on_query_string;
+  public HTTPDataCallback 	on_url;
+  public HTTPDataCallback 	on_fragment;
+  public HTTPDataCallback 	on_header_field;
+  public HTTPDataCallback 	on_header_value;
+  public HTTPCallback       on_headers_complete;
+  public HTTPDataCallback 	on_body;
+  public HTTPCallback       on_message_complete;
+  public HTTPErrorCallback  on_error;
+
+	void call_on_message_begin (HTTPParser p) {
+		call_on(on_message_begin, p);
+	}
+
+	void call_on_message_complete (HTTPParser p) {
+		call_on(on_message_complete, p);
+	}
+  
+  // this one is a little bit different:
+  // the current `position` of the buffer is the location of the
+  // error, `ini_pos` indicates where the position of
+  // the buffer when it was passed to the `execute` method of the parser, i.e.
+  // using this information and `limit` we'll know all the valid data
+  // in the buffer around the error we can use to print pretty error
+  // messages.
+  void call_on_error (HTTPParser p, String mes, ByteBuffer buf, int ini_pos) {
+    if (null != on_error) {
+      on_error.cb(p, mes, buf, ini_pos);
+    }
+    // if on_error gets called it MUST throw an exception, else the parser 
+    // will attempt to continue parsing, which it can't because it's
+    // in an invalid state.
+    throw new HTTPException(mes);
+	}
+
+	void call_on_header_field (HTTPParser p, ByteBuffer buf, int pos, int len) {
+		call_on(on_header_field, p, buf, pos, len);
+	}
+	void call_on_query_string (HTTPParser p, ByteBuffer buf, int pos, int len) {
+		call_on(on_query_string, p, buf, pos, len);
+	}
+	void call_on_fragment (HTTPParser p, ByteBuffer buf, int pos, int len) {
+		call_on(on_fragment, p, buf, pos, len);
+	}
+	void call_on_path (HTTPParser p, ByteBuffer buf, int pos, int len) {
+		call_on(on_path, p, buf, pos, len);
+	}
+	void call_on_header_value (HTTPParser p, ByteBuffer buf, int pos, int len) {
+		call_on(on_header_value, p, buf, pos, len);
+	}
+	void call_on_url (HTTPParser p, ByteBuffer buf, int pos, int len) {
+		call_on(on_url, p, buf, pos, len);
+	}
+	void call_on_body(HTTPParser p, ByteBuffer buf, int pos, int len) {
+		call_on(on_body, p, buf, pos, len);
+	}
+	void call_on_headers_complete(HTTPParser p) {
+		call_on(on_headers_complete, p);
+	} 
+	void call_on (HTTPCallback cb, HTTPParser p) {
+		// cf. CALLBACK2 macro
+		if (null != cb) {
+			cb.cb(p);
+		}
+	}
+	void call_on (HTTPDataCallback cb, HTTPParser p, ByteBuffer buf, int pos, int len) {
+		if (null != cb && -1 != pos) {
+			cb.cb(p,buf,pos,len);
+		}
+	}
+}

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

@@ -0,0 +1,112 @@
+package http_parser.lolevel;
+
+import java.nio.ByteBuffer;
+import http_parser.HTTPException;
+
+public class Util {
+  public static String toString(HTTPParser p) {
+    StringBuilder builder = new StringBuilder();
+    
+    // the stuff up to the break is ephermeral and only meaningful
+    // while the parser is parsing. In general, this method is 
+    // probably only useful during debugging.
+
+    builder.append("state :"); builder.append(p.state); builder.append("\n");
+    builder.append("header_state :"); builder.append(p.header_state); builder.append("\n");
+    builder.append("strict :"); builder.append(p.strict); builder.append("\n");
+    builder.append("index :"); builder.append(p.index); builder.append("\n");
+    builder.append("flags :"); builder.append(p.flags); builder.append("\n");
+    builder.append("nread :"); builder.append(p.nread); builder.append("\n");
+    builder.append("content_length :"); builder.append(p.content_length); builder.append("\n");
+
+
+    builder.append("type :"); builder.append(p.type); builder.append("\n");
+    builder.append("http_major :"); builder.append(p.http_major); builder.append("\n");
+    builder.append("http_minor :"); builder.append(p.http_minor); builder.append("\n");
+    builder.append("status_code :"); builder.append(p.status_code); builder.append("\n");
+    builder.append("method :"); builder.append(p.method); builder.append("\n");
+    builder.append("upgrade :"); builder.append(p.upgrade); builder.append("\n");
+
+    return builder.toString();
+
+  }
+
+  public static String error (String mes, ByteBuffer b, int begining) {
+      // the error message should look like this:
+      //
+      // Bla expected something, but it's not there (mes)
+      // GEt / HTTP 1_1
+      // ............^.
+      //
+      // |----------------- 72 -------------------------|
+
+      // This is ridiculously complicated and probably riddled with
+      // off-by-one errors, should be moved into high level interface.
+      // TODO.
+      
+      // also: need to keep track of the initial buffer position in
+      // execute so that we don't screw up any `mark()` that may have
+      // been set outside of our control to be nice.
+
+      final int mes_width = 72;
+      int p   = b.position();      // error position
+      int end = b.limit();         // this is the end
+      int m   = end - begining;    // max mes length  
+      
+      StringBuilder builder = new StringBuilder();
+      int p_adj = p;
+
+      byte [] orig = new byte[0];
+      if (m <= mes_width) {
+        orig = new byte[m];
+        b.position(begining);
+        b.get(orig, 0, m);
+        p_adj = p-begining;
+        
+        
+      } else {
+        // we'll need to trim bit off the beginning and/or end
+        orig = new byte[mes_width];
+        // three possibilities:
+        // a.) plenty of stuff around p
+        // b.) plenty of stuff in front of p
+        // c.) plenty of stuff behind p
+        // CAN'T be not enough stuff aorund p in total, because 
+        // m>meswidth (see if to this else)
+
+        int before = p-begining;
+        int after  = end - p;
+        if ( (before > mes_width/2) && (after > mes_width/2)) {
+          // plenty of stuff in front of and behind error
+          p_adj = mes_width/2;
+          b.position(p - mes_width/2);
+          b.get(orig, 0, mes_width);
+        } else if  (before <= mes_width/2) {
+          // take all of the begining.
+          b.position(begining);
+          // and as much of the rest as possible
+          
+          b.get(orig, 0, mes_width);
+
+        } else {
+          // plenty of stuff before
+          before = end-mes_width;
+          b.position(before);
+          p_adj = p - before;
+          b.get(orig, 0, mes_width);
+        }
+      }
+
+      builder.append(new String(orig));
+      builder.append("\n");
+      for (int i = 0; i!= p_adj; ++i) {
+        builder.append(".");
+      }
+      builder.append("^");
+
+
+      b.position(p); // restore position
+      return builder.toString();
+
+  }
+}

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

@@ -0,0 +1,487 @@
+package http_parser.lolevel;
+// name  : 200 trailing space on chunked body
+// raw   : "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nTransfer-Encoding: chunked\r\n\r\n25  \r\nThis is the data in the first chunk\r\n\r\n1C\r\nand this is the second one\r\n\r\n0  \r\n\r\n"
+// type  : HTTP_RESPONSE
+// method: HTTP_DELETE
+// status code :200
+// request_path:
+// request_url :
+// fragment    :
+// query_string:
+// body        :"This is the data in the first chunk\r\nand this is the second one\r\n"
+// body_size   :65
+// header_0 :{ "Content-Type": "text/plain"}
+// header_1 :{ "Transfer-Encoding": "chunked"}
+// should_keep_alive         :1
+// upgrade                   :0
+// http_major                :1
+// http_minor                :1
+
+
+import java.io.FileReader;
+import java.io.BufferedReader;
+
+import java.util.*;
+import java.util.regex.*;
+
+import java.nio.ByteBuffer;
+
+import http_parser.HTTPMethod;
+import http_parser.ParserType;
+
+public class TestLoaderNG {
+	String fn;
+	public TestLoaderNG(String filename) {
+		this.fn = filename;
+	}
+	static void p(Object o) {
+		System.out.println(o);
+	}
+	public List<Test> load () throws Throwable {
+		List<Test>    list = new LinkedList<Test>();
+		BufferedReader buf = new BufferedReader(new FileReader(fn));
+		String        line = null;
+		Test          curr = new Test();
+		Pattern    pattern = Pattern.compile("(\\S+)\\s*:(.*)");
+		while (null != (line = buf.readLine()) ){
+			if ("".equals(line.trim())) {
+				list.add (curr);
+				curr = new Test();
+				continue;
+			}
+			Matcher m = pattern.matcher(line);
+			if (m.matches()) {
+				// you can not be fucking serious!?
+				// this has got to be the most retarded regex 
+				// interface in the history of the world ...
+				// (though I'm sure there's worse c++ regexp libs...)
+				MatchResult r = m.toMatchResult();
+				String    key = r.group(1).trim();
+				String  value = r.group(2).trim();
+				     if ("name".equals(key))         {curr.name = value;}
+				else if ("raw".equals(key))          {curr.raw = toByteArray(value);} //!
+				else if ("type".equals(key))         {curr.type = ParserType.parse(value);}
+				else if ("method".equals(key))       {curr.method = HTTPMethod.parse(value);}
+				else if ("status_code".equals(key))  {curr.status_code = Integer.parseInt(value);}
+				else if ("request_path".equals(key)) {curr.request_path = value;}
+				else if ("request_url".equals(key))  {curr.request_url = value;}
+			
+				else if ("fragment".equals(key))     {curr.fragment = value;}
+				else if ("query_string".equals(key)) {curr.query_string = value;}
+				else if ("body".equals(key))         {curr.body = toByteArray(value);} //!
+				else if ("body_size".equals(key))    {curr.body_size = Integer.parseInt(value);}
+				else if (key.startsWith("header"))   {
+					String [] h = getHeader(value); 
+					curr.header.put(h[0], h[1]);
+				} 
+				else if ("should_keep_alive".equals(key)) 
+				                                     {curr.should_keep_alive = (1 == Integer.parseInt(value));}
+				else if ("upgrade".equals(key))      {curr.upgrade           = (1 == Integer.parseInt(value));}
+				else if ("http_major".equals(key))   {curr.http_major = Integer.parseInt(value);}
+				else if ("http_minor".equals(key))   {curr.http_minor = Integer.parseInt(value);}
+			} else {
+				p("WTF?"+line);
+			}
+
+		}
+		return list;
+	}
+
+	String [] getHeader(String value) {
+		// { "Host": "0.0.0.0=5000"}
+		Pattern p = Pattern.compile("\\{ ?\"([^\"]*)\": ?\"([^\"]*)\"}");
+		Matcher m = p.matcher(value);
+		if (!m.matches()) {
+			p(value);
+			throw new RuntimeException("something wrong");
+		}
+		String [] result = new String[2];
+		MatchResult r = m.toMatchResult();
+		result[0] = r.group(1).trim();
+		result[1] = r.group(2).trim();
+		return result;
+	}
+	
+	static final byte BSLASH = 0x5c;
+	static final byte QUOT   = 0x22;
+	static final byte CR     = 0x0d;
+	static final byte LF     = 0x0a;
+	static final byte n      = 0x6e;
+	static final byte r      = 0x72;
+	
+	static final Byte[] JAVA_GENERICS_ROCK_HARD = new Byte[0];
+
+
+	static byte [] toByteArray (String quotedString) {
+		ArrayList<Byte> bytes = new ArrayList<Byte>();
+		String s = quotedString.substring(1, quotedString.length()-1);
+		byte [] byts = s.getBytes(java.nio.charset.Charset.forName("ASCII"));
+		boolean escaped = false;
+		for (byte b : byts) {
+			switch (b) {
+				case BSLASH:
+					escaped = true;
+					break;
+				case n:
+					if (escaped) {
+						bytes.add(LF);
+						escaped = false;
+					} else {
+						bytes.add(b);
+					}
+					break;
+				case r:
+					if (escaped) {
+						escaped = false;
+						bytes.add(CR);
+					} else {
+						bytes.add(b);
+					}
+					break;
+				case QUOT:
+					escaped = false;
+					bytes.add(QUOT);
+					break;
+				default:
+					bytes.add(b);
+			}
+			
+		}
+		//Byte [] fuckyou = bytes.toArray(JAVA_GENERICS_ROCK_HARD);
+		//return (byte[])fuckyou;
+		byts = new byte[bytes.size()];
+		int i = 0;
+		for (Byte b : bytes) {
+			byts[i++]=b;
+			// OMG, WFTBBQ!?
+		}
+		return byts;
+	}
+
+	public static void main(String [] args) throws Throwable {
+		TestLoaderNG  l = new TestLoaderNG(args[0]);
+		List<Test> ts = l.load();
+
+		for (Test t : ts) {
+			t.execute_permutations();
+		//	t.execute();
+		//	System.exit(0);
+		}
+	}
+
+
+	class Test {
+		String name; 
+		byte [] raw; 
+		ParserType type; 
+		HTTPMethod method;
+		int status_code;
+		String request_path; // byte [] ?
+		String request_url;
+		String fragment ;
+		String query_string;
+		byte [] body;
+		int body_size;
+		Map<String,String> header;
+		boolean should_keep_alive;
+		boolean upgrade;
+		int http_major;
+		int http_minor;
+
+    boolean message_begin_called;
+    boolean message_complete_called;
+    boolean headers_complete_called;
+
+
+		Map<String,String> parsed_header;
+		String currHField;
+		String currHValue;
+		byte [] pbody;
+    
+    public String toString() {
+      StringBuilder b = new StringBuilder();
+      b.append("type: "); b.append(type);b.append("\n");
+      b.append("method: "); b.append(method);b.append("\n");
+      b.append("status_code: "); b.append(status_code);b.append("\n");
+      b.append("request_path: "); b.append(request_path);b.append("\n");
+      b.append("request_url: "); b.append(request_url);b.append("\n");
+      b.append("fragment: "); b.append(fragment);b.append("\n");
+      b.append("query_string: "); b.append(query_string);b.append("\n");
+      b.append("body:\n"); b.append(new String(body));b.append("\n");
+      b.append("should_keep_alive: "); b.append(should_keep_alive);b.append("\n");
+      b.append("upgrade: "); b.append(upgrade);b.append("\n");
+      b.append("http_major: "); b.append(http_major);b.append("\n");
+      b.append("http_minor: "); b.append(http_minor);b.append("\n");
+      b.append("message_complete_called: "); b.append(message_complete_called);b.append("\n");
+      return b.toString();
+    }
+
+		Test () {
+			this.header        = new HashMap<String, String>();
+      reset();
+		}
+    /*
+     *prepare this Test Instance for reuse.
+     * */
+    void reset () {
+			this.parsed_header = new HashMap<String, String>();
+      this.pbody         = null;
+    
+    }
+		void check (boolean val, String mes) {
+			if (!val) {
+				//p(name+" : "+mes);
+				throw new RuntimeException(name+" : "+mes);
+			}
+		}
+
+		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);
+		}
+		
+		HTTPDataCallback getCB (final String value, final String mes, final TestSettings settings) {
+			return new HTTPDataCallback() {
+				public int cb (HTTPParser p, ByteBuffer b, int pos, int len){
+//   if ("url".equals(mes)){
+//    p("pos"+pos);
+//    p("len"+len);
+//    if (8==pos && 5 == len && "connect request".equals(name)) {
+//      //throw new RuntimeException(name);
+//    }
+//   }
+					String str      = str(b, pos, len);
+					String prev_val = settings.map.get(mes);
+					settings.map.put(mes, prev_val + str);
+					//check(value.equals(str), "incorrect "+mes+": "+str);
+					if (-1 == pos) {
+						throw new RuntimeException("he?");
+					}
+					return 0;
+				}
+			};
+		}
+			
+		void execute () {
+			p(name);
+			ByteBuffer   buf = ByteBuffer.wrap(raw);
+			HTTPParser     p = new HTTPParser();
+			TestSettings s = settings();
+
+			
+
+			p.execute(s, buf);
+			if (!s.success) {
+				throw new RuntimeException("Test: "+name+"failed");
+			}
+		} // execute
+
+		void execute_permutations() {
+			/*
+			|-|---------------|	
+			|--|--------------|	
+			|---|-------------|	
+			(...)
+			|---------------|-|	
+			|-----------------|	
+			*/
+			p(name);
+			for (int i = 2; i != raw.length; ++i) {
+ //  p(i);
+				HTTPParser   p = new HTTPParser();
+				TestSettings s = settings();
+				ByteBuffer buf = ByteBuffer.wrap(raw);
+				int olimit = buf.limit();
+				buf.limit(i);
+				
+				parse(p,s,buf);
+
+				buf.position(i);
+				buf.limit(olimit);
+
+				parse(p,s,buf);
+				parse(p,s,buf);
+
+				if (!s.success) {
+          p(this);
+					throw new RuntimeException("Test: "+name+" failed");
+				}
+        reset();
+			}
+			//System.exit(0);
+		} // execute_permutations
+		void parse(HTTPParser p, ParserSettings s, ByteBuffer b) {
+			//p("About to parse: "+b.position() + "->" + b.limit());
+			p.execute(s, b);
+		}
+
+		TestSettings settings() {
+			final TestSettings s = new TestSettings(); 
+			s.on_path         = getCB(request_path, "path", s);
+			s.on_query_string = getCB(query_string, "query_string", s);
+			s.on_url          = getCB(request_url,  "url", s);
+			s.on_fragment     = getCB(fragment,     "fragment", s);
+      s.on_message_begin = new HTTPCallback() {
+        public int cb (HTTPParser p) {
+          message_begin_called = true;
+          return -1;
+        }
+      };
+			s.on_header_field = new HTTPDataCallback() {
+				public int cb (HTTPParser p, ByteBuffer b, int pos, int len){
+					if (null != currHValue && null == currHField) {
+							throw new RuntimeException(name+": shouldn't happen");
+					}
+					if (null != currHField) {
+            if (null == currHValue) {
+              currHField += str(b,pos,len);
+              return 0;
+            } else {
+              parsed_header.put(currHField, currHValue);
+              currHField = null;
+              currHValue = null;
+            }
+					}
+          currHField = str(b,pos,len);
+					return 0;
+				}
+			};
+			s.on_header_value = new HTTPDataCallback() {
+				public int cb (HTTPParser p, ByteBuffer b, int pos, int len){
+					if (null == currHField) {
+						throw new RuntimeException(name+" :shouldn't happen field");
+					}
+          if (null == currHValue) {
+					  currHValue = str(b,pos,len);
+          } else {
+            currHValue += str(b, pos, len);
+          }
+					return 0;
+				}
+			};
+			s.on_headers_complete = new HTTPCallback() {
+				public int cb (HTTPParser p) {
+					headers_complete_called = true;
+					String parsed_path  = s.map.get("path");
+					String parsed_query = s.map.get("query_string");
+					String parsed_url   = s.map.get("url");
+					String parsed_frag  = s.map.get("fragment");
+					
+					if (!request_path.equals(parsed_path)) {
+						throw new RuntimeException(name+": invalid path: "+parsed_path+" should be: "+request_path);
+					}
+					if (!query_string.equals(parsed_query)) {
+						throw new RuntimeException(name+": invalid query: "+parsed_query+" should be: "+query_string);
+					}
+					if (!request_url.equals(parsed_url)) {
+						throw new RuntimeException(">"+name+"<: invalid url: >"+parsed_url+"< should be: >"+request_url+"<");
+					}
+					if (!fragment.equals(parsed_frag)) {
+						throw new RuntimeException(name+": invalid fragement: "+parsed_frag+" should be: "+fragment);
+					}
+					if (null != currHValue || null != currHField) {
+						if (null == currHField || null == currHValue) {
+							throw new RuntimeException("shouldn't happen");
+						}
+					}
+					if (null != currHField) {
+						parsed_header.put(currHField, currHValue);
+						currHField = null;
+						currHValue = null;
+					}
+					
+
+					return 0;
+				}
+			};
+		//	s.on_headers_complete = new HTTPCallback() {
+		//		public int cb (HTTPParser p) {
+		//			p("Complete:"+name);
+		//			return 0;
+		//		}
+		//	};
+
+			s.on_body = new HTTPDataCallback() {
+				public int cb (HTTPParser p, ByteBuffer b, int pos, int len){
+					int l   = pbody == null ? len : len + pbody.length;
+					int off = pbody == null ?   0 : pbody.length;
+					byte [] nbody = new byte[l];
+
+					if (null != pbody) {
+						System.arraycopy(pbody, 0, nbody, 0, pbody.length);
+					}
+
+					int saved = b.position();
+					b.position(pos);
+					b.get(nbody, off, len);
+					b.position(saved);
+					pbody = nbody;
+				  return 0;
+				}
+			};
+
+			s.on_message_complete = new HTTPCallback() {
+				public int cb(HTTPParser p) {
+          message_complete_called = true;
+					if (   p.http_minor  != http_minor
+							|| p.http_major  != http_major
+							|| p.status_code != status_code ) {
+					
+							throw new RuntimeException("major/minor/status_code mismatch");
+					}
+
+          //check headers
+
+					if (header.keySet().size() != parsed_header.keySet().size()) {
+            p(parsed_header);
+						throw new RuntimeException(name+": different amount of headers");
+					}
+					for (String key : header.keySet()) {
+						String pvalue = parsed_header.get(key);
+						if (!header.get(key).equals(pvalue)) {
+							throw new RuntimeException(name+" : different values for :"+key+" is >"+pvalue+"< should: >"+header.get(key)+"<");
+						}
+					}
+          //check body
+					if (null == pbody && (null == body || body.length == 0 || body.length == 1)) {
+						s.success = true;
+						return 0;
+					}
+					if (null == pbody) {
+						throw new RuntimeException(name+": no body, should be: "+new String(body));
+					}
+					if (pbody.length != body.length) {
+						p(pbody.length);
+						p(body.length);
+            p(new String(pbody));
+            p(new String(body));
+						throw new RuntimeException(name+": incorrect body length");
+					}
+					for (int i = 0 ; i!= body.length; ++i) {
+						if (pbody[i] != body[i]) {
+							throw new RuntimeException("different body");
+						}
+					}
+					s.success = true;
+					return 0;
+				}
+			};
+			return s;
+		} // settings
+	}
+	class TestSettings extends ParserSettings {
+		public boolean success;
+		Map<String, String> map;
+		TestSettings () {
+			map = new HashMap<String, String>();
+			map.put("path", "");
+			map.put("query_string", "");
+			map.put("url", "");
+			map.put("fragment", "");
+		}
+	}
+}