http_parser.rb 0.5.1 → 0.6.0.beta.1

data/ext/ruby_http_parser/vendor/http-parser-java/http_parser.gyp

@@ -0,0 +1,79 @@
+# This file is used with the GYP meta build system.
+# http://code.google.com/p/gyp/
+# To build try this:
+#   svn co http://gyp.googlecode.com/svn/trunk gyp
+#   ./gyp/gyp -f make --depth=`pwd` http_parser.gyp 
+#   ./out/Debug/test 
+{
+  'target_defaults': {
+    'default_configuration': 'Debug',
+    'configurations': {
+      # TODO: hoist these out and put them somewhere common, because
+      #       RuntimeLibrary MUST MATCH across the entire project
+      'Debug': {
+        'defines': [ 'DEBUG', '_DEBUG' ],
+        'msvs_settings': {
+          'VCCLCompilerTool': {
+            'RuntimeLibrary': 1, # static debug
+          },
+        },
+      },
+      'Release': {
+        'defines': [ 'NDEBUG' ],
+        'msvs_settings': {
+          'VCCLCompilerTool': {
+            'RuntimeLibrary': 0, # static release
+          },
+        },
+      }
+    },
+    'msvs_settings': {
+      'VCCLCompilerTool': {
+      },
+      'VCLibrarianTool': {
+      },
+      'VCLinkerTool': {
+        'GenerateDebugInformation': 'true',
+      },
+    },
+    'conditions': [
+      ['OS == "win"', {
+        'defines': [
+          'WIN32'
+        ],
+      }]
+    ],
+  },
+
+  'targets': [
+    {
+      'target_name': 'http_parser',
+      'type': 'static_library',
+      'include_dirs': [ '.' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+      },
+      'defines': [ 'HTTP_PARSER_STRICT=0' ],
+      'sources': [ './http_parser.c', ],
+      'conditions': [
+        ['OS=="win"', {
+          'msvs_settings': {
+            'VCCLCompilerTool': {
+              # Compile as C++. http_parser.c is actually C99, but C++ is
+              # close enough in this case.
+              'CompileAs': 2,
+            },
+          },
+        }]
+      ],
+    },
+
+    {
+      'target_name': 'test',
+      'type': 'executable',
+      'dependencies': [ 'http_parser' ],
+      'sources': [ 'test.c' ]
+    }
+  ]
+}
+

data/ext/ruby_http_parser/vendor/http-parser-java/http_parser.h

@@ -1,4 +1,4 @@
-/* Copyright 2009,2010 Ryan Dahl <ry@tinyclouds.org>
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to
@@ -24,13 +24,24 @@
 extern "C" {
 #endif
 
+#define HTTP_PARSER_VERSION_MAJOR 1
+#define HTTP_PARSER_VERSION_MINOR 0
 
 #include <sys/types.h>
-#include <stdint.h>
+#if defined(_WIN32) && !defined(__MINGW32__) && (!defined(_MSC_VER) || _MSC_VER<1600)
+typedef __int8 int8_t;
+typedef unsigned __int8 uint8_t;
+typedef __int16 int16_t;
+typedef unsigned __int16 uint16_t;
+typedef __int32 int32_t;
+typedef unsigned __int32 uint32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
 
-#ifdef _WIN32
 typedef unsigned int size_t;
 typedef int ssize_t;
+#else
+#include <stdint.h>
 #endif
 
 /* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run
@@ -38,8 +49,13 @@ typedef int ssize_t;
  */
 #ifndef HTTP_PARSER_STRICT
 # define HTTP_PARSER_STRICT 1
-#else
-# define HTTP_PARSER_STRICT 0
+#endif
+
+/* Compile with -DHTTP_PARSER_DEBUG=1 to add extra debugging information to
+ * the error reporting facility.
+ */
+#ifndef HTTP_PARSER_DEBUG
+# define HTTP_PARSER_DEBUG 0
 #endif
 
 
@@ -69,58 +85,152 @@ typedef int (*http_cb) (http_parser*);
 
 
 /* Request Methods */
+#define HTTP_METHOD_MAP(XX) \
+  XX(0, DELETE) \
+  XX(1, GET) \
+  XX(2, HEAD) \
+  XX(3, POST) \
+  XX(4, PUT) \
+  /* pathological */ \
+  XX(5, CONNECT) \
+  XX(6, OPTIONS) \
+  XX(7, TRACE) \
+  /* webdav */ \
+  XX(8, COPY) \
+  XX(9, LOCK) \
+  XX(10, MKCOL) \
+  XX(11, MOVE) \
+  XX(12, PROPFIND) \
+  XX(13, PROPPATCH) \
+  XX(14, UNLOCK) \
+  /* subversion */ \
+  XX(15, REPORT) \
+  XX(16, MKACTIVITY) \
+  XX(17, CHECKOUT) \
+  XX(18, MERGE) \
+  /* upnp */ \
+  XX(19, MSEARCH) \
+  XX(20, NOTIFY) \
+  XX(21, SUBSCRIBE) \
+  XX(22, UNSUBSCRIBE) \
+  /* RFC-5789 */ \
+  XX(23, PATCH) \
+  XX(24, PURGE) \
+
 enum http_method
-  { HTTP_DELETE    = 0
-  , HTTP_GET
-  , HTTP_HEAD
-  , HTTP_POST
-  , HTTP_PUT
-  /* pathological */
-  , HTTP_CONNECT
-  , HTTP_OPTIONS
-  , HTTP_TRACE
-  /* webdav */
-  , HTTP_COPY
-  , HTTP_LOCK
-  , HTTP_MKCOL
-  , HTTP_MOVE
-  , HTTP_PROPFIND
-  , HTTP_PROPPATCH
-  , HTTP_UNLOCK
-  /* subversion */
-  , HTTP_REPORT
-  , HTTP_MKACTIVITY
-  , HTTP_CHECKOUT
-  , HTTP_MERGE
+  {
+#define XX(num, name) HTTP_##name = num,
+  HTTP_METHOD_MAP(XX)
+#undef X
   };
 
 
 enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH };
 
 
+/* Flag values for http_parser.flags field */
+enum flags
+  { F_CHUNKED               = 1 << 0
+  , F_CONNECTION_KEEP_ALIVE = 1 << 1
+  , F_CONNECTION_CLOSE      = 1 << 2
+  , F_TRAILING              = 1 << 3
+  , F_UPGRADE               = 1 << 4
+  , F_SKIPBODY              = 1 << 5
+  };
+
+
+/* Map for errno-related constants
+ * 
+ * The provided argument should be a macro that takes 2 arguments.
+ */
+#define HTTP_ERRNO_MAP(XX)                                           \
+  /* No error */                                                     \
+  XX(OK, "success")                                                  \
+                                                                     \
+  /* Callback-related errors */                                      \
+  XX(CB_message_begin, "the on_message_begin callback failed")       \
+  XX(CB_url, "the on_url callback failed")                           \
+  XX(CB_header_field, "the on_header_field callback failed")         \
+  XX(CB_header_value, "the on_header_value callback failed")         \
+  XX(CB_headers_complete, "the on_headers_complete callback failed") \
+  XX(CB_body, "the on_body callback failed")                         \
+  XX(CB_message_complete, "the on_message_complete callback failed") \
+                                                                     \
+  /* Parsing-related errors */                                       \
+  XX(INVALID_EOF_STATE, "stream ended at an unexpected time")        \
+  XX(HEADER_OVERFLOW,                                                \
+     "too many header bytes seen; overflow detected")                \
+  XX(CLOSED_CONNECTION,                                              \
+     "data received after completed connection: close message")      \
+  XX(INVALID_VERSION, "invalid HTTP version")                        \
+  XX(INVALID_STATUS, "invalid HTTP status code")                     \
+  XX(INVALID_METHOD, "invalid HTTP method")                          \
+  XX(INVALID_URL, "invalid URL")                                     \
+  XX(INVALID_HOST, "invalid host")                                   \
+  XX(INVALID_PORT, "invalid port")                                   \
+  XX(INVALID_PATH, "invalid path")                                   \
+  XX(INVALID_QUERY_STRING, "invalid query string")                   \
+  XX(INVALID_FRAGMENT, "invalid fragment")                           \
+  XX(LF_EXPECTED, "LF character expected")                           \
+  XX(INVALID_HEADER_TOKEN, "invalid character in header")            \
+  XX(INVALID_CONTENT_LENGTH,                                         \
+     "invalid character in content-length header")                   \
+  XX(INVALID_CHUNK_SIZE,                                             \
+     "invalid character in chunk size header")                       \
+  XX(INVALID_CONSTANT, "invalid constant string")                    \
+  XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state")\
+  XX(STRICT, "strict mode assertion failed")                         \
+  XX(PAUSED, "parser is paused")                                     \
+  XX(UNKNOWN, "an unknown error occurred")
+
+
+/* Define HPE_* values for each errno value above */
+#define HTTP_ERRNO_GEN(n, s) HPE_##n,
+enum http_errno {
+  HTTP_ERRNO_MAP(HTTP_ERRNO_GEN)
+};
+#undef HTTP_ERRNO_GEN
+
+
+/* Get an http_errno value from an http_parser */
+#define HTTP_PARSER_ERRNO(p)            ((enum http_errno) (p)->http_errno)
+
+/* Get the line number that generated the current error */
+#if HTTP_PARSER_DEBUG
+#define HTTP_PARSER_ERRNO_LINE(p)       ((p)->error_lineno)
+#else
+#define HTTP_PARSER_ERRNO_LINE(p)       0
+#endif
+
+
 struct http_parser {
   /** PRIVATE **/
-  unsigned char type : 2;
-  unsigned char flags : 6;
-  unsigned char state;
-  unsigned char header_state;
-  unsigned char index;
+  unsigned char type : 2;     /* enum http_parser_type */
+  unsigned char flags : 6;    /* F_* values from 'flags' enum; semi-public */
+  unsigned char state;        /* enum state from http_parser.c */
+  unsigned char header_state; /* enum header_state from http_parser.c */
+  unsigned char index;        /* index into current matcher */
 
-  uint32_t nread;
-  int64_t content_length;
+  uint32_t nread;          /* # bytes read in various scenarios */
+  uint64_t content_length; /* # bytes in body (0 if no Content-Length header) */
 
   /** READ-ONLY **/
   unsigned short http_major;
   unsigned short http_minor;
   unsigned short status_code; /* responses only */
-  unsigned char method;    /* requests only */
+  unsigned char method;       /* requests only */
+  unsigned char http_errno : 7;
 
   /* 1 = Upgrade header was present and the parser has exited because of that.
    * 0 = No upgrade header present.
    * Should be checked when http_parser_execute() returns in addition to
    * error checking.
    */
-  char upgrade;
+  unsigned char upgrade : 1;
+
+#if HTTP_PARSER_DEBUG
+  uint32_t error_lineno;
+#endif
 
   /** PUBLIC **/
   void *data; /* A pointer to get hook to the "connection" or "socket" object */
@@ -129,10 +239,7 @@ struct http_parser {
 
 struct http_parser_settings {
   http_cb      on_message_begin;
-  http_data_cb on_path;
-  http_data_cb on_query_string;
   http_data_cb on_url;
-  http_data_cb on_fragment;
   http_data_cb on_header_field;
   http_data_cb on_header_value;
   http_cb      on_headers_complete;
@@ -141,6 +248,35 @@ struct http_parser_settings {
 };
 
 
+enum http_parser_url_fields
+  { UF_SCHEMA           = 0
+  , UF_HOST             = 1
+  , UF_PORT             = 2
+  , UF_PATH             = 3
+  , UF_QUERY            = 4
+  , UF_FRAGMENT         = 5
+  , UF_MAX              = 6
+  };
+
+
+/* Result structure for http_parser_parse_url().
+ *
+ * Callers should index into field_data[] with UF_* values iff field_set
+ * has the relevant (1 << UF_*) bit set. As a courtesy to clients (and
+ * because we probably have padding left over), we convert any port to
+ * a uint16_t.
+ */
+struct http_parser_url {
+  uint16_t field_set;           /* Bitmask of (1 << UF_*) values */
+  uint16_t port;                /* Converted UF_PORT string */
+
+  struct {
+    uint16_t off;               /* Offset into buffer in which field starts */
+    uint16_t len;               /* Length of run in buffer */
+  } field_data[UF_MAX];
+};
+
+
 void http_parser_init(http_parser *parser, enum http_parser_type type);
 
 
@@ -159,7 +295,21 @@ size_t http_parser_execute(http_parser *parser,
 int http_should_keep_alive(http_parser *parser);
 
 /* Returns a string version of the HTTP method. */
-const char *http_method_str(enum http_method);
+const char *http_method_str(enum http_method m);
+
+/* Return a string name of the given error */
+const char *http_errno_name(enum http_errno err);
+
+/* Return a string description of the given error */
+const char *http_errno_description(enum http_errno err);
+
+/* Parse a URL; return nonzero on failure */
+int http_parser_parse_url(const char *buf, size_t buflen,
+                          int is_connect,
+                          struct http_parser_url *u);
+
+/* Pause or un-pause the parser; a nonzero value pauses */
+void http_parser_pause(http_parser *parser, int paused);
 
 #ifdef __cplusplus
 }

data/ext/ruby_http_parser/vendor/http-parser-java/src/Http-parser.java.iml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/impl" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library">
+      <library>
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/../ext/primitives.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+  </component>
+</module>
+

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

@@ -0,0 +1,41 @@
+package http_parser;
+
+public class FieldData {
+  public int off;
+  public int len;
+
+  public FieldData(){}
+
+  public FieldData(int off, int len){
+    this.off = off;
+    this.len = len;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    FieldData fieldData = (FieldData) o;
+
+    if (len != fieldData.len) return false;
+    if (off != fieldData.off) return false;
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    int result = off;
+    result = 31 * result + len;
+    return result;
+  }
+
+  @Override
+  public String toString() {
+    return "FieldData{" +
+        "off=" + off +
+        ", len=" + len +
+        '}';
+  }
+}

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

@@ -0,0 +1,8 @@
+package http_parser;
+
+public abstract class HTTPCallback implements http_parser.lolevel.HTTPCallback{
+	public int cb (http_parser.lolevel.HTTPParser parser) {
+	  return this.cb((HTTPParser)parser);
+	}
+	public abstract int cb (HTTPParser parser);
+}

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

@@ -0,0 +1,34 @@
+package http_parser;
+
+import java.nio.ByteBuffer;
+
+public abstract class HTTPDataCallback implements  http_parser.lolevel.HTTPDataCallback{
+	/*
+		Very raw and extremly foolhardy! DANGER!
+		The whole Buffer concept is difficult enough to grasp as it is,
+		we pass in a buffer with an arbitrary position.
+
+		The interesting data is located at position pos and is len 
+		bytes long.
+		
+		The contract of this callback is that the buffer is
+		returned in the state that it was passed in, so implementing
+		this require good citizenship, you'll need to remember the current
+		position, change the position to get at the data you're interested 
+		in and then set the position back to how you found it...
+
+		Therefore: there is an abstract implementation that implements
+		cb as described above, and provides a new callback
+		with signature @see cb(byte[], int, int)
+	*/
+	public int cb(http_parser.lolevel.HTTPParser p, ByteBuffer buf, int pos, int len) {
+	  byte [] by = new byte[len];
+    int saved = buf.position();
+    buf.position(pos);
+    buf.get(by);
+    buf.position(saved);
+    return cb((HTTPParser)p, by, 0, len);
+	}
+
+  public abstract int cb(HTTPParser p, byte[] by, int pos, int len);
+}

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

@@ -0,0 +1,12 @@
+package http_parser;
+
+
+import java.nio.ByteBuffer;
+
+public abstract class HTTPErrorCallback implements http_parser.lolevel.HTTPErrorCallback{
+	public void cb (http_parser.lolevel.HTTPParser parser, String mes, ByteBuffer buf, int initial_position) {
+	  this.cb((HTTPParser)parser, Util.error(mes, buf, initial_position));
+	}
+
+  public abstract void cb(HTTPParser parser, String error); 
+}

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

@@ -1,7 +1,9 @@
 package http_parser;
 
+@SuppressWarnings("serial")
 public class HTTPException extends RuntimeException {
-  public HTTPException(String mes) {
+  
+public HTTPException(String mes) {
     super(mes);
-  }
+  }  
 }

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

@@ -0,0 +1,13 @@
+package http_parser;
+
+/**
+ * Special interface for headers_complete callback.
+ * This is somewhat different than other callbacks because if the user returns 1, we
+ * will interpret that as saying that this message has no body. This
+ * is needed for the annoying case of receiving a response to a HEAD
+ * request.
+ */
+public abstract class HTTPHeadersCompleteCallback extends HTTPCallback
+    implements http_parser.lolevel.HTTPHeadersCompleteCallback{
+
+}

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

@@ -23,54 +23,61 @@ public enum HTTPMethod {
   , HTTP_REPORT("REPORT")
   , HTTP_MKACTIVITY("MKACTIVITY")
   , HTTP_CHECKOUT("CHECKOUT")
-  , HTTP_MERGE("MERGE");
+  , HTTP_MERGE("MERGE")
+  , HTTP_MSEARCH("M-SEARCH")
+  , HTTP_NOTIFY("NOTIFY")
+  , HTTP_SUBSCRIBE("SUBSCRIBE")
+  , HTTP_UNSUBSCRIBE("UNSUBSCRIBE")
+  , HTTP_PATCH("PATCH")
+  , HTTP_PURGE("PURGE")
+  ;
 
-	private static Charset ASCII;
-	static {
-		ASCII = Charset.forName("US-ASCII");;
-	}
-	public byte[] bytes;
+  private static Charset ASCII;
+  static {
+    ASCII = Charset.forName("US-ASCII");;
+  }
+  public byte[] bytes;
 
-	HTTPMethod(String name) {
-		// good grief, Charlie Brown, the following is necessary because 
-		// java is retarded:
-		// illegal reference to static field from initializer
+  HTTPMethod(String name) {
+    // good grief, Charlie Brown, the following is necessary because 
+    // java is retarded:
+    // illegal reference to static field from initializer
     //            this.bytes = name.getBytes(ASCII);
-		// yet it's not illegal to reference static fields from
-		// methods called from initializer.
-		init(name);
-	}
-	public static HTTPMethod parse(String s) {
-				 if ("HTTP_DELETE".equalsIgnoreCase(s))  {return HTTP_DELETE;}
-		else if ("DELETE".equalsIgnoreCase(s))       {return HTTP_DELETE;}
-		else if ("HTTP_GET".equalsIgnoreCase(s))     {return HTTP_GET;}
-		else if ("GET".equalsIgnoreCase(s))          {return HTTP_GET;}
-		else if ("HTTP_HEAD".equalsIgnoreCase(s))    {return HTTP_HEAD;}
-		else if ("HEAD".equalsIgnoreCase(s))         {return HTTP_HEAD;}
-		else if ("HTTP_POST".equalsIgnoreCase(s))    {return HTTP_POST;}
-		else if ("POST".equalsIgnoreCase(s))         {return HTTP_POST;}
-		else if ("HTTP_PUT".equalsIgnoreCase(s))     {return HTTP_PUT;}
-		else if ("PUT".equalsIgnoreCase(s))          {return HTTP_PUT;}
-		else if ("HTTP_CONNECT".equalsIgnoreCase(s)) {return HTTP_CONNECT;}
-		else if ("CONNECT".equalsIgnoreCase(s))      {return HTTP_CONNECT;}
-		else if ("HTTP_OPTIONS".equalsIgnoreCase(s)) {return HTTP_OPTIONS;}
-		else if ("OPTIONS".equalsIgnoreCase(s))      {return HTTP_OPTIONS;}
-		else if ("HTTP_TRACE".equalsIgnoreCase(s))   {return HTTP_TRACE;}
-		else if ("TRACE".equalsIgnoreCase(s))        {return HTTP_TRACE;}
-		else if ("HTTP_COPY".equalsIgnoreCase(s))    {return HTTP_COPY;}
-		else if ("COPY".equalsIgnoreCase(s))         {return HTTP_COPY;}
-		else if ("HTTP_LOCK".equalsIgnoreCase(s))    {return HTTP_LOCK;}
-		else if ("LOCK".equalsIgnoreCase(s))         {return HTTP_LOCK;}
-		else if ("HTTP_MKCOL".equalsIgnoreCase(s))   {return HTTP_MKCOL;}
-		else if ("MKCOL".equalsIgnoreCase(s))        {return HTTP_MKCOL;}
-		else if ("HTTP_MOVE".equalsIgnoreCase(s))    {return HTTP_MOVE;}
-		else if ("MOVE".equalsIgnoreCase(s))         {return HTTP_MOVE;}
-		else if ("HTTP_PROPFIND".equalsIgnoreCase(s)){return HTTP_PROPFIND;}
-		else if ("PROPFIND".equalsIgnoreCase(s))     {return HTTP_PROPFIND;}
-		else if ("HTTP_PROPPATCH".equalsIgnoreCase(s)){return HTTP_PROPPATCH;}
-		else if ("PROPPATCH".equalsIgnoreCase(s))    {return HTTP_PROPPATCH;}
-		else if ("HTTP_UNLOCK".equalsIgnoreCase(s))  {return HTTP_UNLOCK;}
-		else if ("UNLOCK".equalsIgnoreCase(s))       {return HTTP_UNLOCK;}
+    // yet it's not illegal to reference static fields from
+    // methods called from initializer.
+    init(name);
+  }
+  public static HTTPMethod parse(String s) {
+         if ("HTTP_DELETE".equalsIgnoreCase(s))  {return HTTP_DELETE;}
+    else if ("DELETE".equalsIgnoreCase(s))       {return HTTP_DELETE;}
+    else if ("HTTP_GET".equalsIgnoreCase(s))     {return HTTP_GET;}
+    else if ("GET".equalsIgnoreCase(s))          {return HTTP_GET;}
+    else if ("HTTP_HEAD".equalsIgnoreCase(s))    {return HTTP_HEAD;}
+    else if ("HEAD".equalsIgnoreCase(s))         {return HTTP_HEAD;}
+    else if ("HTTP_POST".equalsIgnoreCase(s))    {return HTTP_POST;}
+    else if ("POST".equalsIgnoreCase(s))         {return HTTP_POST;}
+    else if ("HTTP_PUT".equalsIgnoreCase(s))     {return HTTP_PUT;}
+    else if ("PUT".equalsIgnoreCase(s))          {return HTTP_PUT;}
+    else if ("HTTP_CONNECT".equalsIgnoreCase(s)) {return HTTP_CONNECT;}
+    else if ("CONNECT".equalsIgnoreCase(s))      {return HTTP_CONNECT;}
+    else if ("HTTP_OPTIONS".equalsIgnoreCase(s)) {return HTTP_OPTIONS;}
+    else if ("OPTIONS".equalsIgnoreCase(s))      {return HTTP_OPTIONS;}
+    else if ("HTTP_TRACE".equalsIgnoreCase(s))   {return HTTP_TRACE;}
+    else if ("TRACE".equalsIgnoreCase(s))        {return HTTP_TRACE;}
+    else if ("HTTP_COPY".equalsIgnoreCase(s))    {return HTTP_COPY;}
+    else if ("COPY".equalsIgnoreCase(s))         {return HTTP_COPY;}
+    else if ("HTTP_LOCK".equalsIgnoreCase(s))    {return HTTP_LOCK;}
+    else if ("LOCK".equalsIgnoreCase(s))         {return HTTP_LOCK;}
+    else if ("HTTP_MKCOL".equalsIgnoreCase(s))   {return HTTP_MKCOL;}
+    else if ("MKCOL".equalsIgnoreCase(s))        {return HTTP_MKCOL;}
+    else if ("HTTP_MOVE".equalsIgnoreCase(s))    {return HTTP_MOVE;}
+    else if ("MOVE".equalsIgnoreCase(s))         {return HTTP_MOVE;}
+    else if ("HTTP_PROPFIND".equalsIgnoreCase(s)){return HTTP_PROPFIND;}
+    else if ("PROPFIND".equalsIgnoreCase(s))     {return HTTP_PROPFIND;}
+    else if ("HTTP_PROPPATCH".equalsIgnoreCase(s)){return HTTP_PROPPATCH;}
+    else if ("PROPPATCH".equalsIgnoreCase(s))    {return HTTP_PROPPATCH;}
+    else if ("HTTP_UNLOCK".equalsIgnoreCase(s))  {return HTTP_UNLOCK;}
+    else if ("UNLOCK".equalsIgnoreCase(s))       {return HTTP_UNLOCK;}
     else if ("HTTP_REPORT".equalsIgnoreCase(s)) {return HTTP_REPORT;}
     else if ("REPORT".equalsIgnoreCase(s)){return HTTP_REPORT;}
     else if ("HTTP_MKACTIVITY".equalsIgnoreCase(s)) {return HTTP_MKACTIVITY;}
@@ -79,12 +86,20 @@ public enum HTTPMethod {
     else if ("CHECKOUT".equalsIgnoreCase(s)){return HTTP_CHECKOUT;}
     else if ("HTTP_MERGE".equalsIgnoreCase(s)) {return HTTP_MERGE;}
     else if ("MERGE".equalsIgnoreCase(s)){return HTTP_MERGE;}
-
-	  else                                         {return null;}
+    else if ("HTTP_MSEARCH".equalsIgnoreCase(s))     {return HTTP_MSEARCH;}
+    else if ("M-SEARCH".equalsIgnoreCase(s))         {return HTTP_MSEARCH;}
+    else if ("HTTP_NOTIFY".equalsIgnoreCase(s))      {return HTTP_NOTIFY;}
+    else if ("NOTIFY".equalsIgnoreCase(s))           {return HTTP_NOTIFY;}
+    else if ("HTTP_SUBSCRIBE".equalsIgnoreCase(s))   {return HTTP_SUBSCRIBE;}
+    else if ("SUBSCRIBE".equalsIgnoreCase(s))        {return HTTP_SUBSCRIBE;}
+    else if ("HTTP_UNSUBSCRIBE".equalsIgnoreCase(s)) {return HTTP_UNSUBSCRIBE;}
+    else if ("UNSUBSCRIBE".equalsIgnoreCase(s))      {return HTTP_UNSUBSCRIBE;}
+    else if ("PATCH".equalsIgnoreCase(s))            {return HTTP_PATCH;}
+    else if ("PURGE".equalsIgnoreCase(s))            {return HTTP_PURGE;}
+	  else                                             {return null;}
 	}	
-	void init (String name) {
-		ASCII = null == ASCII ? Charset.forName("US-ASCII") : ASCII;
-		this.bytes = name.getBytes(ASCII);
-	}
-
+  void init (String name) {
+    ASCII = null == ASCII ? Charset.forName("US-ASCII") : ASCII;
+    this.bytes = name.getBytes(ASCII);
+  }
 }