llhttp 0.0.2 → 0.0.3

data/ext/llhttp/llhttp.h

@@ -0,0 +1,384 @@
+// This software is licensed under the MIT License.
+
+// Copyright Fedor Indutny, 2018.
+
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef INCLUDE_LLHTTP_H_
+#define INCLUDE_LLHTTP_H_
+
+#define LLHTTP_VERSION_MAJOR 1
+#define LLHTTP_VERSION_MINOR 1
+#define LLHTTP_VERSION_PATCH 1
+
+#ifndef INCLUDE_LLHTTP_ITSELF_H_
+#define INCLUDE_LLHTTP_ITSELF_H_
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+typedef struct llhttp__internal_s llhttp__internal_t;
+struct llhttp__internal_s {
+  int32_t _index;
+  void* _span_pos0;
+  void* _span_cb0;
+  int32_t error;
+  const char* reason;
+  const char* error_pos;
+  void* data;
+  void* _current;
+  uint64_t content_length;
+  uint8_t type;
+  uint8_t method;
+  uint8_t http_major;
+  uint8_t http_minor;
+  uint8_t header_state;
+  uint8_t flags;
+  uint8_t upgrade;
+  uint16_t status_code;
+  uint8_t finish;
+  void* settings;
+};
+
+int llhttp__internal_init(llhttp__internal_t* s);
+int llhttp__internal_execute(llhttp__internal_t* s, const char* p, const char* endp);
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+#endif  /* INCLUDE_LLHTTP_ITSELF_H_ */
+
+#ifndef LLLLHTTP_C_HEADERS_
+#define LLLLHTTP_C_HEADERS_
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum llhttp_errno {
+  HPE_OK = 0,
+  HPE_INTERNAL = 1,
+  HPE_STRICT = 2,
+  HPE_LF_EXPECTED = 3,
+  HPE_UNEXPECTED_CONTENT_LENGTH = 4,
+  HPE_CLOSED_CONNECTION = 5,
+  HPE_INVALID_METHOD = 6,
+  HPE_INVALID_URL = 7,
+  HPE_INVALID_CONSTANT = 8,
+  HPE_INVALID_VERSION = 9,
+  HPE_INVALID_HEADER_TOKEN = 10,
+  HPE_INVALID_CONTENT_LENGTH = 11,
+  HPE_INVALID_CHUNK_SIZE = 12,
+  HPE_INVALID_STATUS = 13,
+  HPE_INVALID_EOF_STATE = 14,
+  HPE_CB_MESSAGE_BEGIN = 15,
+  HPE_CB_HEADERS_COMPLETE = 16,
+  HPE_CB_MESSAGE_COMPLETE = 17,
+  HPE_CB_CHUNK_HEADER = 18,
+  HPE_CB_CHUNK_COMPLETE = 19,
+  HPE_PAUSED = 20,
+  HPE_PAUSED_UPGRADE = 21,
+  HPE_USER = 22
+};
+typedef enum llhttp_errno llhttp_errno_t;
+
+enum llhttp_flags {
+  F_CONNECTION_KEEP_ALIVE = 0x1,
+  F_CONNECTION_CLOSE = 0x2,
+  F_CONNECTION_UPGRADE = 0x4,
+  F_CHUNKED = 0x8,
+  F_UPGRADE = 0x10,
+  F_CONTENT_LENGTH = 0x20,
+  F_SKIPBODY = 0x40,
+  F_TRAILING = 0x80
+};
+typedef enum llhttp_flags llhttp_flags_t;
+
+enum llhttp_type {
+  HTTP_BOTH = 0,
+  HTTP_REQUEST = 1,
+  HTTP_RESPONSE = 2
+};
+typedef enum llhttp_type llhttp_type_t;
+
+enum llhttp_finish {
+  HTTP_FINISH_SAFE = 0,
+  HTTP_FINISH_SAFE_WITH_CB = 1,
+  HTTP_FINISH_UNSAFE = 2
+};
+typedef enum llhttp_finish llhttp_finish_t;
+
+enum llhttp_method {
+  HTTP_DELETE = 0,
+  HTTP_GET = 1,
+  HTTP_HEAD = 2,
+  HTTP_POST = 3,
+  HTTP_PUT = 4,
+  HTTP_CONNECT = 5,
+  HTTP_OPTIONS = 6,
+  HTTP_TRACE = 7,
+  HTTP_COPY = 8,
+  HTTP_LOCK = 9,
+  HTTP_MKCOL = 10,
+  HTTP_MOVE = 11,
+  HTTP_PROPFIND = 12,
+  HTTP_PROPPATCH = 13,
+  HTTP_SEARCH = 14,
+  HTTP_UNLOCK = 15,
+  HTTP_BIND = 16,
+  HTTP_REBIND = 17,
+  HTTP_UNBIND = 18,
+  HTTP_ACL = 19,
+  HTTP_REPORT = 20,
+  HTTP_MKACTIVITY = 21,
+  HTTP_CHECKOUT = 22,
+  HTTP_MERGE = 23,
+  HTTP_MSEARCH = 24,
+  HTTP_NOTIFY = 25,
+  HTTP_SUBSCRIBE = 26,
+  HTTP_UNSUBSCRIBE = 27,
+  HTTP_PATCH = 28,
+  HTTP_PURGE = 29,
+  HTTP_MKCALENDAR = 30,
+  HTTP_LINK = 31,
+  HTTP_UNLINK = 32,
+  HTTP_SOURCE = 33
+};
+typedef enum llhttp_method llhttp_method_t;
+
+#define HTTP_ERRNO_MAP(XX) \
+  XX(0, OK, OK) \
+  XX(1, INTERNAL, INTERNAL) \
+  XX(2, STRICT, STRICT) \
+  XX(3, LF_EXPECTED, LF_EXPECTED) \
+  XX(4, UNEXPECTED_CONTENT_LENGTH, UNEXPECTED_CONTENT_LENGTH) \
+  XX(5, CLOSED_CONNECTION, CLOSED_CONNECTION) \
+  XX(6, INVALID_METHOD, INVALID_METHOD) \
+  XX(7, INVALID_URL, INVALID_URL) \
+  XX(8, INVALID_CONSTANT, INVALID_CONSTANT) \
+  XX(9, INVALID_VERSION, INVALID_VERSION) \
+  XX(10, INVALID_HEADER_TOKEN, INVALID_HEADER_TOKEN) \
+  XX(11, INVALID_CONTENT_LENGTH, INVALID_CONTENT_LENGTH) \
+  XX(12, INVALID_CHUNK_SIZE, INVALID_CHUNK_SIZE) \
+  XX(13, INVALID_STATUS, INVALID_STATUS) \
+  XX(14, INVALID_EOF_STATE, INVALID_EOF_STATE) \
+  XX(15, CB_MESSAGE_BEGIN, CB_MESSAGE_BEGIN) \
+  XX(16, CB_HEADERS_COMPLETE, CB_HEADERS_COMPLETE) \
+  XX(17, CB_MESSAGE_COMPLETE, CB_MESSAGE_COMPLETE) \
+  XX(18, CB_CHUNK_HEADER, CB_CHUNK_HEADER) \
+  XX(19, CB_CHUNK_COMPLETE, CB_CHUNK_COMPLETE) \
+  XX(20, PAUSED, PAUSED) \
+  XX(21, PAUSED_UPGRADE, PAUSED_UPGRADE) \
+  XX(22, USER, USER) \
+
+
+#define HTTP_METHOD_MAP(XX) \
+  XX(0, DELETE, DELETE) \
+  XX(1, GET, GET) \
+  XX(2, HEAD, HEAD) \
+  XX(3, POST, POST) \
+  XX(4, PUT, PUT) \
+  XX(5, CONNECT, CONNECT) \
+  XX(6, OPTIONS, OPTIONS) \
+  XX(7, TRACE, TRACE) \
+  XX(8, COPY, COPY) \
+  XX(9, LOCK, LOCK) \
+  XX(10, MKCOL, MKCOL) \
+  XX(11, MOVE, MOVE) \
+  XX(12, PROPFIND, PROPFIND) \
+  XX(13, PROPPATCH, PROPPATCH) \
+  XX(14, SEARCH, SEARCH) \
+  XX(15, UNLOCK, UNLOCK) \
+  XX(16, BIND, BIND) \
+  XX(17, REBIND, REBIND) \
+  XX(18, UNBIND, UNBIND) \
+  XX(19, ACL, ACL) \
+  XX(20, REPORT, REPORT) \
+  XX(21, MKACTIVITY, MKACTIVITY) \
+  XX(22, CHECKOUT, CHECKOUT) \
+  XX(23, MERGE, MERGE) \
+  XX(24, MSEARCH, M-SEARCH) \
+  XX(25, NOTIFY, NOTIFY) \
+  XX(26, SUBSCRIBE, SUBSCRIBE) \
+  XX(27, UNSUBSCRIBE, UNSUBSCRIBE) \
+  XX(28, PATCH, PATCH) \
+  XX(29, PURGE, PURGE) \
+  XX(30, MKCALENDAR, MKCALENDAR) \
+  XX(31, LINK, LINK) \
+  XX(32, UNLINK, UNLINK) \
+  XX(33, SOURCE, SOURCE) \
+
+
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+#endif  /* LLLLHTTP_C_HEADERS_ */
+
+#ifndef INCLUDE_LLHTTP_API_H_
+#define INCLUDE_LLHTTP_API_H_
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <stddef.h>
+
+typedef llhttp__internal_t llhttp_t;
+typedef struct llhttp_settings_s llhttp_settings_t;
+
+typedef int (*llhttp_data_cb)(llhttp_t*, const char *at, size_t length);
+typedef int (*llhttp_cb)(llhttp_t*);
+
+struct llhttp_settings_s {
+  /* Possible return values 0, -1, `HPE_PAUSED` */
+  llhttp_cb      on_message_begin;
+
+  llhttp_data_cb on_url;
+  llhttp_data_cb on_status;
+  llhttp_data_cb on_header_field;
+  llhttp_data_cb on_header_value;
+
+  /* Possible return values:
+   * 0  - Proceed normally
+   * 1  - Assume that request/response has no body, and proceed to parsing the
+   *      next message
+   * 2  - Assume absence of body (as above) and make `llhttp_execute()` return
+   *      `HPE_PAUSED_UPGRADE`
+   * -1 - Error
+   * `HPE_PAUSED`
+   */
+  llhttp_cb      on_headers_complete;
+
+  llhttp_data_cb on_body;
+
+  /* Possible return values 0, -1, `HPE_PAUSED` */
+  llhttp_cb      on_message_complete;
+
+  /* When on_chunk_header is called, the current chunk length is stored
+   * in parser->content_length.
+   * Possible return values 0, -1, `HPE_PAUSED`
+   */
+  llhttp_cb      on_chunk_header;
+  llhttp_cb      on_chunk_complete;
+};
+
+/* Initialize the parser with specific type and user settings */
+void llhttp_init(llhttp_t* parser, llhttp_type_t type,
+                 const llhttp_settings_t* settings);
+
+/* Initialize the settings object */
+void llhttp_settings_init(llhttp_settings_t* settings);
+
+/* Parse full or partial request/response, invoking user callbacks along the
+ * way.
+ *
+ * If any of `llhttp_data_cb` returns errno not equal to `HPE_OK` - the parsing
+ * interrupts, and such errno is returned from `llhttp_execute()`. If
+ * `HPE_PAUSED` was used as a errno, the execution can be resumed with
+ * `llhttp_resume()` call.
+ *
+ * In a special case of CONNECT/Upgrade request/response `HPE_PAUSED_UPGRADE`
+ * is returned after fully parsing the request/response. If the user wishes to
+ * continue parsing, they need to invoke `llhttp_resume_after_upgrade()`.
+ *
+ * NOTE: if this function ever returns a non-pause type error, it will continue
+ * to return the same error upon each successive call up until `llhttp_init()`
+ * call.
+ */
+llhttp_errno_t llhttp_execute(llhttp_t* parser, const char* data, size_t len);
+
+/* This method should be called when the other side has no further bytes to
+ * send (e.g. shutdown of readable side of the TCP connection.)
+ *
+ * Requests without `Content-Length` and other messages might require treating
+ * all incoming bytes as the part of the body, up to the last byte of the
+ * connection. This method will invoke `on_message_complete()` callback if the
+ * request was terminated safely. Otherwise a error code would be returned.
+ */
+llhttp_errno_t llhttp_finish(llhttp_t* parser);
+
+/* Returns `1` if the incoming message is parsed until the last byte, and has
+ * to be completed by calling `llhttp_finish()` on EOF
+ */
+int llhttp_message_needs_eof(const llhttp_t* parser);
+
+/* Returns `1` if there might be any other messages following the last that was
+ * successfuly parsed.
+ */
+int llhttp_should_keep_alive(const llhttp_t* parser);
+
+/* Make further calls of `llhttp_execute()` return `HPE_PAUSED` and set
+ * appropriate error reason.
+ *
+ * Important: do not call this from user callbacks! User callbacks must return
+ * `HPE_PAUSED` if pausing is required.
+ */
+void llhttp_pause(llhttp_t* parser);
+
+/* Might be called to resume the execution after the pause in user's callback.
+ * See `llhttp_execute()` above for details.
+ *
+ * Call this only if `llhttp_execute()` returns `HPE_PAUSED`.
+ */
+void llhttp_resume(llhttp_t* parser);
+
+/* Might be called to resume the execution after the pause in user's callback.
+ * See `llhttp_execute()` above for details.
+ *
+ * Call this only if `llhttp_execute()` returns `HPE_PAUSED_UPGRADE`
+ */
+void llhttp_resume_after_upgrade(llhttp_t* parser);
+
+/* Returns the latest return error */
+llhttp_errno_t llhttp_get_errno(const llhttp_t* parser);
+
+/* Returns the verbal explanation of the latest returned error.
+ *
+ * Note: User callback should set error reason when returning the error. See
+ * `llhttp_set_error_reason()` for details.
+ */
+const char* llhttp_get_error_reason(const llhttp_t* parser);
+
+/* Assign verbal description to the returned error. Must be called in user
+ * callbacks right before returning the errno.
+ *
+ * Note: `HPE_USER` error code might be useful in user callbacks.
+ */
+void llhttp_set_error_reason(llhttp_t* parser, const char* reason);
+
+/* Returns the pointer to the last parsed byte before the returned error. The
+ * pointer is relative to the `data` argument of `llhttp_execute()`.
+ *
+ * Note: this method might be useful for counting the number of parsed bytes.
+ */
+const char* llhttp_get_error_pos(const llhttp_t* parser);
+
+/* Returns textual name of error code */
+const char* llhttp_errno_name(llhttp_errno_t err);
+
+/* Returns textual name of HTTP method */
+const char* llhttp_method_name(llhttp_method_t method);
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+#endif  /* INCLUDE_LLHTTP_API_H_ */
+
+#endif  /* INCLUDE_LLHTTP_H_ */

data/ext/llhttp/llhttp_ext.c

@@ -0,0 +1,243 @@
+// This software is licensed under the MIT License.
+
+// Copyright Bryan Powell, 2020.
+
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#include <ruby/ruby.h>
+
+#include "llhttp.h"
+
+static VALUE mLLHttp, cParser, eError;
+
+static void rb_llhttp_free(llhttp_t *parser) {
+  if (parser) {
+    free(parser->settings);
+    free(parser);
+  }
+}
+
+VALUE rb_llhttp_allocate(VALUE klass) {
+  llhttp_t *parser = (llhttp_t *)malloc(sizeof(llhttp_t));
+  llhttp_settings_t *settings = (llhttp_settings_t *)malloc(sizeof(llhttp_settings_t));
+
+  llhttp_settings_init(settings);
+  llhttp_init(parser, HTTP_BOTH, settings);
+
+  return Data_Wrap_Struct(klass, 0, rb_llhttp_free, parser);
+}
+
+void rb_llhttp_callback_call(VALUE delegate, const char *name) {
+  rb_funcall(delegate, rb_intern(name), 0);
+}
+
+void rb_llhttp_data_callback_call(VALUE delegate, const char *name, char *data, size_t length) {
+  rb_funcall(delegate, rb_intern(name), 1, rb_str_new(data, length));
+}
+
+int rb_llhttp_on_message_begin(llhttp_t *parser) {
+  VALUE delegate = (VALUE)parser->data;
+
+  rb_llhttp_callback_call(delegate, "on_message_begin");
+
+  return 0;
+}
+
+int rb_llhttp_on_url(llhttp_t *parser, char *data, size_t length) {
+  VALUE delegate = (VALUE)parser->data;
+
+  rb_llhttp_data_callback_call(delegate, "on_url", data, length);
+
+  return 0;
+}
+
+int rb_llhttp_on_status(llhttp_t *parser, char *data, size_t length) {
+  VALUE delegate = (VALUE)parser->data;
+
+  rb_llhttp_data_callback_call(delegate, "on_status", data, length);
+
+  return 0;
+}
+
+int rb_llhttp_on_header_field(llhttp_t *parser, char *data, size_t length) {
+  VALUE delegate = (VALUE)parser->data;
+
+  rb_llhttp_data_callback_call(delegate, "on_header_field", data, length);
+
+  return 0;
+}
+
+int rb_llhttp_on_header_value(llhttp_t *parser, char *data, size_t length) {
+  VALUE delegate = (VALUE)parser->data;
+
+  rb_llhttp_data_callback_call(delegate, "on_header_value", data, length);
+
+  return 0;
+}
+
+int rb_llhttp_on_headers_complete(llhttp_t *parser) {
+  VALUE delegate = (VALUE)parser->data;
+
+  rb_llhttp_callback_call(delegate, "on_headers_complete");
+
+  return 0;
+}
+
+int rb_llhttp_on_body(llhttp_t *parser, char *data, size_t length) {
+  VALUE delegate = (VALUE)parser->data;
+
+  rb_llhttp_data_callback_call(delegate, "on_body", data, length);
+
+  return 0;
+}
+
+int rb_llhttp_on_message_complete(llhttp_t *parser) {
+  VALUE delegate = (VALUE)parser->data;
+
+  rb_llhttp_callback_call(delegate, "on_message_complete");
+
+  return 0;
+}
+
+int rb_llhttp_on_chunk_header(llhttp_t *parser) {
+  VALUE delegate = (VALUE)parser->data;
+
+  rb_llhttp_callback_call(delegate, "on_chunk_header");
+
+  return 0;
+}
+
+int rb_llhttp_on_chunk_complete(llhttp_t *parser) {
+  VALUE delegate = (VALUE)parser->data;
+
+  rb_llhttp_callback_call(delegate, "on_chunk_complete");
+
+  return 0;
+}
+
+VALUE rb_llhttp_parse(VALUE self, VALUE data) {
+  llhttp_t *parser;
+
+  Data_Get_Struct(self, llhttp_t, parser);
+
+  enum llhttp_errno err = llhttp_execute(parser, RSTRING_PTR(data), RSTRING_LEN(data));
+
+  if (err != HPE_OK) {
+    rb_raise(eError, "Error Parsing data: %s %s", llhttp_errno_name(err), parser->reason);
+  }
+
+  return Qtrue;
+}
+
+VALUE rb_llhttp_finish(VALUE self) {
+  llhttp_t *parser;
+
+  Data_Get_Struct(self, llhttp_t, parser);
+
+  enum llhttp_errno err = llhttp_finish(parser);
+
+  if (err != HPE_OK) {
+    rb_raise(eError, "Error Parsing data: %s %s", llhttp_errno_name(err), parser->reason);
+  }
+
+  return Qtrue;
+}
+
+VALUE rb_llhttp_content_length(VALUE self) {
+  llhttp_t *parser;
+
+  Data_Get_Struct(self, llhttp_t, parser);
+
+  return UINT2NUM(parser->content_length);
+}
+
+VALUE rb_llhttp_method(VALUE self) {
+  llhttp_t *parser;
+
+  Data_Get_Struct(self, llhttp_t, parser);
+
+  return rb_str_new_cstr(llhttp_method_name(parser->method));
+}
+
+VALUE rb_llhttp_status_code(VALUE self) {
+  llhttp_t *parser;
+
+  Data_Get_Struct(self, llhttp_t, parser);
+
+  return UINT2NUM(parser->status_code);
+}
+
+VALUE rb_llhttp_keep_alive(VALUE self) {
+  llhttp_t *parser;
+
+  Data_Get_Struct(self, llhttp_t, parser);
+
+  int ret = llhttp_should_keep_alive(parser);
+
+  return ret == 1 ? Qtrue : Qfalse;
+}
+
+static VALUE rb_llhttp_init(VALUE self, VALUE type) {
+  llhttp_t *parser;
+
+  Data_Get_Struct(self, llhttp_t, parser);
+
+  llhttp_settings_t *settings = parser->settings;
+
+  settings->on_message_begin = (llhttp_cb)rb_llhttp_on_message_begin;
+  settings->on_url = (llhttp_data_cb)rb_llhttp_on_url;
+  settings->on_status = (llhttp_data_cb)rb_llhttp_on_status;
+  settings->on_header_field = (llhttp_data_cb)rb_llhttp_on_header_field;
+  settings->on_header_value = (llhttp_data_cb)rb_llhttp_on_header_value;
+  settings->on_headers_complete = (llhttp_cb)rb_llhttp_on_headers_complete;
+  settings->on_body = (llhttp_data_cb)rb_llhttp_on_body;
+  settings->on_message_complete = (llhttp_cb)rb_llhttp_on_message_complete;
+  settings->on_chunk_header = (llhttp_cb)rb_llhttp_on_chunk_header;
+  settings->on_chunk_complete = (llhttp_cb)rb_llhttp_on_chunk_complete;
+
+  llhttp_init(parser, FIX2INT(type), settings);
+
+  // Store a pointer to the delegate for lookup in callbacks.
+  //
+  VALUE delegate = rb_iv_get(self, "@delegate");
+  parser->data = (void*)delegate;
+
+  return Qtrue;
+}
+
+void Init_llhttp_ext(void) {
+  mLLHttp = rb_const_get(rb_cObject, rb_intern("LLHttp"));
+  cParser = rb_const_get(mLLHttp, rb_intern("Parser"));
+  eError = rb_const_get(mLLHttp, rb_intern("Error"));
+
+  rb_define_alloc_func(cParser, rb_llhttp_allocate);
+
+  rb_define_method(cParser, "<<", rb_llhttp_parse, 1);
+  rb_define_method(cParser, "parse", rb_llhttp_parse, 1);
+  rb_define_method(cParser, "finish", rb_llhttp_finish, 0);
+
+  rb_define_method(cParser, "content_length", rb_llhttp_content_length, 0);
+  rb_define_method(cParser, "method", rb_llhttp_method, 0);
+  rb_define_method(cParser, "status_code", rb_llhttp_status_code, 0);
+
+  rb_define_method(cParser, "keep_alive?", rb_llhttp_keep_alive, 0);
+
+  rb_define_private_method(cParser, "llhttp_init", rb_llhttp_init, 1);
+}