gitlab-puma 4.3.1.gitlab.2

data/ext/puma_http11/http11_parser.h

@@ -0,0 +1,65 @@
+/**
+ * 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>
+
+#if defined(_WIN32)
+#include <stddef.h>
+#endif
+
+#define BUFFER_LEN 1024
+
+struct puma_parser;
+
+typedef void (*element_cb)(struct puma_parser* hp,
+                           const char *at, size_t length);
+
+typedef void (*field_cb)(struct puma_parser* hp,
+                         const char *field, size_t flen,
+                         const char *value, size_t vlen);
+
+typedef struct puma_parser {
+  int cs;
+  size_t body_start;
+  int content_len;
+  size_t nread;
+  size_t mark;
+  size_t field_start;
+  size_t field_len;
+  size_t query_start;
+
+  VALUE request;
+  VALUE body;
+
+  field_cb http_field;
+  element_cb request_method;
+  element_cb request_uri;
+  element_cb fragment;
+  element_cb request_path;
+  element_cb query_string;
+  element_cb http_version;
+  element_cb header_done;
+
+  char buf[BUFFER_LEN];
+  
+} puma_parser;
+
+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 puma_parser_has_error(puma_parser *parser);
+int puma_parser_is_finished(puma_parser *parser);
+
+#define puma_parser_nread(parser) (parser)->nread
+
+#endif

data/ext/puma_http11/http11_parser.java.rl

@@ -0,0 +1,145 @@
+package org.jruby.puma;
+
+import org.jruby.Ruby;
+import org.jruby.RubyHash;
+import org.jruby.util.ByteList;
+
+public class Http11Parser {
+
+/** Machine **/
+
+%%{
+
+  machine puma_parser;
+
+  action mark {parser.mark = fpc; }
+
+  action start_field { parser.field_start = fpc; }
+  action snake_upcase_field { /* FIXME stub */ }
+  action write_field { 
+    parser.field_len = fpc-parser.field_start;
+  }
+
+  action start_value { parser.mark = fpc; }
+  action write_value {
+    Http11.http_field(runtime, parser.data, parser.buffer, parser.field_start, parser.field_len, parser.mark, fpc-parser.mark);
+  }
+  action request_method {
+    Http11.request_method(runtime, parser.data, parser.buffer, parser.mark, fpc-parser.mark);
+  }
+  action request_uri {
+    Http11.request_uri(runtime, parser.data, parser.buffer, parser.mark, fpc-parser.mark);
+  }
+  action fragment {
+    Http11.fragment(runtime, parser.data, parser.buffer, parser.mark, fpc-parser.mark);
+  }
+  
+  action start_query {parser.query_start = fpc; }
+  action query_string {
+    Http11.query_string(runtime, parser.data, parser.buffer, parser.query_start, fpc-parser.query_start);
+  }
+
+  action http_version {
+    Http11.http_version(runtime, parser.data, parser.buffer, parser.mark, fpc-parser.mark);
+  }
+
+  action request_path {
+    Http11.request_path(runtime, parser.data, parser.buffer, parser.mark, fpc-parser.mark);
+  }
+
+  action done { 
+    parser.body_start = fpc + 1;
+    http.header_done(runtime, parser.data, parser.buffer, fpc + 1, pe - fpc - 1);
+    fbreak;
+  }
+
+  include puma_parser_common "http11_parser_common.rl";
+
+}%%
+
+/** Data **/
+%% write data;
+
+   public static interface ElementCB {
+     public void call(Ruby runtime, RubyHash data, ByteList buffer, int at, int length);
+   }
+
+   public static interface FieldCB {
+     public void call(Ruby runtime, RubyHash data, ByteList buffer, int field, int flen, int value, int vlen);
+   }
+
+   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;
+
+      RubyHash data;
+      ByteList buffer;
+
+      public void init() {
+          cs = 0;
+
+          %% write init;
+
+          body_start = 0;
+          content_len = 0;
+          mark = 0;
+          nread = 0;
+          field_len = 0;
+          field_start = 0;
+      }
+   }
+
+   public final HttpParser parser = new HttpParser();
+
+   public int execute(Ruby runtime, Http11 http, ByteList buffer, int off) {
+     int p, pe;
+     int cs = parser.cs;
+     int len = buffer.length();
+     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;
+
+     %% write exec;
+
+     parser.cs = cs;
+     parser.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";
+
+     return parser.nread;
+   }
+
+   public int finish() {
+    if(has_error()) {
+      return -1;
+    } else if(is_finished()) {
+      return 1;
+    } else {
+      return 0;
+    }
+  }
+
+  public boolean has_error() {
+    return parser.cs == puma_parser_error;
+  }
+
+  public boolean is_finished() {
+    return parser.cs == puma_parser_first_final;
+  }
+}

data/ext/puma_http11/http11_parser.rl

@@ -0,0 +1,147 @@
+/**
+ * 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>
+#include <assert.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+
+/*
+ * capitalizes all lower-case ASCII characters,
+ * converts dashes to underscores.
+ */
+static void snake_upcase_char(char *c)
+{
+    if (*c >= 'a' && *c <= 'z')
+      *c &= ~0x20;
+    else if (*c == '-')
+      *c = '_';
+}
+
+#define LEN(AT, FPC) (FPC - buffer - parser->AT)
+#define MARK(M,FPC) (parser->M = (FPC) - buffer)
+#define PTR_TO(F) (buffer + parser->F)
+
+/** Machine **/
+
+%%{
+
+  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 {
+    parser->field_len = LEN(field_start, fpc);
+  }
+
+  action start_value { MARK(mark, fpc); }
+  action write_value {
+    parser->http_field(parser, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, fpc));
+  }
+  action request_method {
+    parser->request_method(parser, PTR_TO(mark), LEN(mark, fpc));
+  }
+  action request_uri {
+    parser->request_uri(parser, PTR_TO(mark), LEN(mark, fpc));
+  }
+  action fragment {
+    parser->fragment(parser, PTR_TO(mark), LEN(mark, fpc));
+  }
+
+  action start_query { MARK(query_start, fpc); }
+  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 request_path {
+    parser->request_path(parser, PTR_TO(mark), LEN(mark,fpc));
+  }
+
+  action done {
+    parser->body_start = fpc - buffer + 1;
+    parser->header_done(parser, fpc + 1, pe - fpc - 1);
+    fbreak;
+  }
+
+  include puma_parser_common "http11_parser_common.rl";
+
+}%%
+
+/** Data **/
+%% write data;
+
+int puma_parser_init(puma_parser *parser)  {
+  int cs = 0;
+  %% write init;
+  parser->cs = cs;
+  parser->body_start = 0;
+  parser->content_len = 0;
+  parser->mark = 0;
+  parser->nread = 0;
+  parser->field_len = 0;
+  parser->field_start = 0;
+  parser->request = Qnil;
+  parser->body = Qnil;
+
+  return 1;
+}
+
+
+/** exec **/
+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;
+
+  assert(off <= len && "offset past end of buffer");
+
+  p = buffer+off;
+  pe = buffer+len;
+
+  /* assert(*pe == '\0' && "pointer does not end on NUL"); */
+  assert((size_t) (pe - p) == len - off && "pointers aren't same distance");
+
+  %% write exec;
+
+  if (!puma_parser_has_error(parser))
+    parser->cs = cs;
+  parser->nread += p - (buffer + 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");
+
+  return(parser->nread);
+}
+
+int puma_parser_finish(puma_parser *parser)
+{
+  if (puma_parser_has_error(parser) ) {
+    return -1;
+  } else if (puma_parser_is_finished(parser) ) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int puma_parser_has_error(puma_parser *parser) {
+  return parser->cs == puma_parser_error;
+}
+
+int puma_parser_is_finished(puma_parser *parser) {
+  return parser->cs >= puma_parser_first_final;
+}

data/ext/puma_http11/http11_parser_common.rl

@@ -0,0 +1,54 @@
+%%{
+
+  machine puma_parser_common;
+
+#### HTTP PROTOCOL GRAMMAR
+# line endings
+  CRLF = "\r\n";
+
+# character types
+  CTL = (cntrl | 127);
+  safe = ("$" | "-" | "_" | ".");
+  extra = ("!" | "*" | "'" | "(" | ")" | ",");
+  reserved = (";" | "/" | "?" | ":" | "@" | "&" | "=" | "+");
+  unsafe = (CTL | " " | "\"" | "#" | "%" | "<" | ">");
+  national = any -- (alpha | digit | reserved | extra | safe | unsafe);
+  unreserved = (alpha | digit | safe | extra | national);
+  escape = ("%" xdigit xdigit);
+  uchar = (unreserved | escape | "%");
+  pchar = (uchar | ":" | "@" | "&" | "=" | "+" | ";");
+  tspecials = ("(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\\" | "\"" | "/" | "[" | "]" | "?" | "=" | "{" | "}" | " " | "\t");
+
+# elements
+  token = (ascii -- (CTL | tspecials));
+
+# URI schemes and absolute paths
+  scheme = ( alpha | digit | "+" | "-" | "." )* ;
+  absolute_uri = (scheme ":" (uchar | reserved )*);
+
+  path = ( pchar+ ( "/" pchar* )* ) ;
+  query = ( uchar | reserved )* %query_string ;
+  param = ( pchar | "/" )* ;
+  params = ( param ( ";" param )* ) ;
+  rel_path = ( path? %request_path ) ("?" %start_query query)?;
+  absolute_path = ( "/"+ rel_path );
+
+  Request_URI = ( "*" | absolute_uri | absolute_path ) >mark %request_uri;
+  Fragment = ( uchar | reserved )* >mark %fragment;
+  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 ) ;
+
+  field_name = ( token -- ":" )+ >start_field $snake_upcase_field %write_field;
+
+  field_value = any* >start_value %write_value;
+
+  message_header = field_name ":" " "* field_value :> CRLF;
+
+  Request = Request_Line ( message_header )* ( CRLF @done );
+
+main := Request;
+
+}%%

data/ext/puma_http11/io_buffer.c

@@ -0,0 +1,155 @@
+#define RSTRING_NOT_MODIFIED 1
+#include "ruby.h"
+
+#include <sys/types.h>
+
+struct buf_int {
+  uint8_t* top;
+  uint8_t* cur;
+
+  size_t size;
+};
+
+#define BUF_DEFAULT_SIZE 4096
+#define BUF_TOLERANCE 32
+
+static void buf_free(struct buf_int* internal) {
+  xfree(internal->top);
+  xfree(internal);
+}
+
+static VALUE buf_alloc(VALUE self) {
+  VALUE buf;
+  struct buf_int* internal;
+
+  buf = Data_Make_Struct(self, struct buf_int, 0, buf_free, internal);
+
+  internal->size = BUF_DEFAULT_SIZE;
+  internal->top = ALLOC_N(uint8_t, BUF_DEFAULT_SIZE);
+  internal->cur = internal->top;
+
+  return buf;
+}
+
+static VALUE buf_append(VALUE self, VALUE str) {
+  struct buf_int* b;
+  size_t used, str_len, new_size;
+
+  Data_Get_Struct(self, struct buf_int, b);
+
+  used = b->cur - b->top;
+
+  StringValue(str);
+  str_len = RSTRING_LEN(str);
+
+  new_size = used + str_len;
+
+  if(new_size > b->size) {
+    size_t n = b->size + (b->size / 2);
+    uint8_t* top;
+    uint8_t* old;
+
+    new_size = (n > new_size ? n : new_size + BUF_TOLERANCE);
+
+    top = ALLOC_N(uint8_t, new_size);
+    old = b->top;
+    memcpy(top, old, used);
+    b->top = top;
+    b->cur = top + used;
+    b->size = new_size;
+    xfree(old);
+  }
+
+  memcpy(b->cur, RSTRING_PTR(str), str_len);
+  b->cur += str_len;
+
+  return self;
+}
+
+static VALUE buf_append2(int argc, VALUE* argv, VALUE self) {
+  struct buf_int* b;
+  size_t used, new_size;
+  int i;
+  VALUE str;
+
+  Data_Get_Struct(self, struct buf_int, b);
+
+  used = b->cur - b->top;
+  new_size = used;
+
+  for(i = 0; i < argc; i++) {
+    StringValue(argv[i]);
+
+    str = argv[i];
+
+    new_size += RSTRING_LEN(str);
+  }
+
+  if(new_size > b->size) {
+    size_t n = b->size + (b->size / 2);
+    uint8_t* top;
+    uint8_t* old;
+
+    new_size = (n > new_size ? n : new_size + BUF_TOLERANCE);
+
+    top = ALLOC_N(uint8_t, new_size);
+    old = b->top;
+    memcpy(top, old, used);
+    b->top = top;
+    b->cur = top + used;
+    b->size = new_size;
+    xfree(old);
+  }
+
+  for(i = 0; i < argc; i++) {
+    long str_len;
+    str = argv[i];
+    str_len = RSTRING_LEN(str);
+    memcpy(b->cur, RSTRING_PTR(str), str_len);
+    b->cur += str_len;
+  }
+
+  return self;
+}
+
+static VALUE buf_to_str(VALUE self) {
+  struct buf_int* b;
+  Data_Get_Struct(self, struct buf_int, b);
+
+  return rb_str_new((const char*)(b->top), b->cur - b->top);
+}
+
+static VALUE buf_used(VALUE self) {
+  struct buf_int* b;
+  Data_Get_Struct(self, struct buf_int, b);
+
+  return INT2FIX(b->cur - b->top);
+}
+
+static VALUE buf_capa(VALUE self) {
+  struct buf_int* b;
+  Data_Get_Struct(self, struct buf_int, b);
+
+  return INT2FIX(b->size);
+}
+
+static VALUE buf_reset(VALUE self) {
+  struct buf_int* b;
+  Data_Get_Struct(self, struct buf_int, b);
+
+  b->cur = b->top;
+  return self;
+}
+
+void Init_io_buffer(VALUE puma) {
+  VALUE buf = rb_define_class_under(puma, "IOBuffer", rb_cObject);
+
+  rb_define_alloc_func(buf, buf_alloc);
+  rb_define_method(buf, "<<", buf_append, 1);
+  rb_define_method(buf, "append", buf_append2, -1);
+  rb_define_method(buf, "to_str", buf_to_str, 0);
+  rb_define_method(buf, "to_s", buf_to_str, 0);
+  rb_define_method(buf, "used", buf_used, 0);
+  rb_define_method(buf, "capacity", buf_capa, 0);
+  rb_define_method(buf, "reset", buf_reset, 0);
+}