bossan 0.1.0

data/ext/bossan/http_parser.h

@@ -0,0 +1,169 @@
+/* Copyright 2009,2010 Ryan Dahl <ry@tinyclouds.org>
+ *
+ * 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 http_parser_h
+#define http_parser_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#include <sys/types.h>
+#include <stdint.h>
+
+#ifdef _WIN32
+typedef unsigned int size_t;
+typedef int ssize_t;
+#endif
+
+/* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run
+ * faster
+ */
+#ifndef HTTP_PARSER_STRICT
+# define HTTP_PARSER_STRICT 1
+#else
+# define HTTP_PARSER_STRICT 0
+#endif
+
+
+/* Maximium header size allowed */
+#define HTTP_MAX_HEADER_SIZE (80*1024)
+
+
+typedef struct http_parser http_parser;
+typedef struct http_parser_settings http_parser_settings;
+
+
+/* Callbacks should return non-zero to indicate an error. The parser will
+ * then halt execution.
+ *
+ * The one exception is on_headers_complete. In a HTTP_RESPONSE parser
+ * returning '1' from on_headers_complete will tell the parser that it
+ * should not expect a body. This is used when receiving a response to a
+ * HEAD request which may contain 'Content-Length' or 'Transfer-Encoding:
+ * chunked' headers that indicate the presence of a body.
+ *
+ * http_data_cb does not return data chunks. It will be call arbitrarally
+ * many times for each string. E.G. you might get 10 callbacks for "on_path"
+ * each providing just a few characters more data.
+ */
+typedef int (*http_data_cb) (http_parser*, const char *at, size_t length, char partial);
+typedef int (*http_cb) (http_parser*);
+
+
+/* Request Methods */
+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
+  };
+
+
+enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH };
+
+
+struct http_parser {
+  /** PRIVATE **/
+  unsigned char type;
+  unsigned char state;
+  unsigned char header_state;
+  unsigned char index;
+  char maybe_ml;
+
+  char flags;
+
+  uint64_t nread;
+  int64_t content_length;
+
+  /** READ-ONLY **/
+  unsigned short http_major;
+  unsigned short http_minor;
+  unsigned short status_code; /* responses only */
+  unsigned char method;    /* requests only */
+
+  /* 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;
+
+  /** PUBLIC **/
+  void *data; /* A pointer to get hook to the "connection" or "socket" object */
+};
+
+
+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;
+  http_data_cb on_body;
+  http_cb      on_message_complete;
+};
+
+
+void http_parser_init(http_parser *parser, enum http_parser_type type);
+
+
+size_t http_parser_execute(http_parser *parser,
+                           const http_parser_settings *settings,
+                           const char *data,
+                           size_t len);
+
+
+/* If http_should_keep_alive() in the on_headers_complete or
+ * on_message_complete callback returns true, then this will be should be
+ * the last message on the connection.
+ * If you are the server, respond with the "Connection: close" header.
+ * If you are the client, close the connection.
+ */
+int http_should_keep_alive(http_parser *parser);
+
+/* Returns a string version of the HTTP method. */
+const char *http_method_str(enum http_method);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/bossan/picoev.h

@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) 2009, Cybozu Labs, Inc.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * * Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * * Neither the name of the <ORGANIZATION> nor the names of its contributors
+ *   may be used to endorse or promote products derived from this software
+ *   without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef picoev_h
+#define picoev_h
+
+#ifdef __cplusplus
+extern "C" {
+# define PICOEV_INLINE inline
+#else
+# define PICOEV_INLINE static __inline__
+#endif
+
+#include <assert.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#define PICOEV_IS_INITED (picoev.max_fd != 0)  
+#define PICOEV_IS_INITED_AND_FD_IN_RANGE(fd) \
+  (((unsigned)fd) < (unsigned)picoev.max_fd)
+#define PICOEV_TOO_MANY_LOOPS (picoev.num_loops != 0) /* use after ++ */
+#define PICOEV_FD_BELONGS_TO_LOOP(loop, fd) \
+  ((loop)->loop_id == picoev.fds[fd].loop_id)
+
+#define PICOEV_TIMEOUT_VEC_OF(loop, idx) \
+  ((loop)->timeout.vec + (idx) * picoev.timeout_vec_size)
+#define PICOEV_TIMEOUT_VEC_OF_VEC_OF(loop, idx) \
+  ((loop)->timeout.vec_of_vec + (idx) * picoev.timeout_vec_of_vec_size)
+#define PICOEV_RND_UP(v, d) (((v) + (d) - 1) / (d) * (d))
+
+#define PICOEV_PAGE_SIZE 4096
+#define PICOEV_CACHE_LINE_SIZE 32 /* in bytes, ok if greater than the actual */
+#define PICOEV_SIMD_BITS 128
+#define PICOEV_TIMEOUT_VEC_SIZE 128
+#define PICOEV_SHORT_BITS (sizeof(short) * 8)
+
+#define PICOEV_READ 1
+#define PICOEV_WRITE 2
+#define PICOEV_TIMEOUT 4
+#define PICOEV_ADD 0x40000000
+#define PICOEV_DEL 0x20000000
+#define PICOEV_READWRITE (PICOEV_READ | PICOEV_WRITE)
+  
+#define PICOEV_TIMEOUT_IDX_UNUSED (UCHAR_MAX)
+  
+  typedef unsigned short picoev_loop_id_t;
+  
+  typedef struct picoev_loop_st picoev_loop;
+  
+  typedef void picoev_handler(picoev_loop* loop, int fd, int revents,
+			      void* cb_arg);
+  
+  typedef struct picoev_fd_st {
+    /* use accessors! */
+    /* TODO adjust the size to match that of a cache line */
+    picoev_handler* callback;
+    void* cb_arg;
+    picoev_loop_id_t loop_id;
+    char events;
+    unsigned char timeout_idx; /* PICOEV_TIMEOUT_IDX_UNUSED if not used */
+    int _backend; /* can be used by backends (never modified by core) */
+  } picoev_fd;
+  
+  struct picoev_loop_st {
+    /* read only */
+    picoev_loop_id_t loop_id;
+    struct {
+      short* vec;
+      short* vec_of_vec;
+      size_t base_idx;
+      time_t base_time;
+      int resolution;
+      void* _free_addr;
+    } timeout;
+    time_t now;
+  };
+  
+  typedef struct picoev_globals_st {
+    /* read only */
+    picoev_fd* fds;
+    void* _fds_free_addr;
+    int max_fd;
+    int num_loops;
+    size_t timeout_vec_size; /* # of elements in picoev_loop.timeout.vec[0] */
+    size_t timeout_vec_of_vec_size; /* ... in timeout.vec_of_vec[0] */
+  } picoev_globals;
+  
+  extern picoev_globals picoev;
+  
+  /* creates a new event loop (defined by each backend) */
+  picoev_loop* picoev_create_loop(int max_timeout);
+  
+  /* destroys a loop (defined by each backend) */
+  int picoev_destroy_loop(picoev_loop* loop);
+  
+  /* internal: updates events to be watched (defined by each backend) */
+  int picoev_update_events_internal(picoev_loop* loop, int fd, int events);
+  
+  /* internal: poll once and call the handlers (defined by each backend) */
+  int picoev_poll_once_internal(picoev_loop* loop, int max_wait);
+  
+  /* internal, aligned allocator with address scrambling to avoid cache
+     line contention */
+  PICOEV_INLINE
+  void* picoev_memalign(size_t sz, void** orig_addr, int clear) {
+    sz = sz + PICOEV_PAGE_SIZE + PICOEV_CACHE_LINE_SIZE;
+    if ((*orig_addr = malloc(sz)) == NULL) {
+      return NULL;
+    }
+    if (clear != 0) {
+      memset(*orig_addr, 0, sz);
+    }
+    return
+      (void*)PICOEV_RND_UP((unsigned long)*orig_addr
+			   + (rand() % PICOEV_PAGE_SIZE),
+			   PICOEV_CACHE_LINE_SIZE);
+  }
+  
+  /* initializes picoev */
+  PICOEV_INLINE
+  int picoev_init(int max_fd) {
+    assert(! PICOEV_IS_INITED);
+    assert(max_fd > 0);
+    if ((picoev.fds = (picoev_fd*)picoev_memalign(sizeof(picoev_fd) * max_fd,
+						  &picoev._fds_free_addr, 1))
+	== NULL) {
+      return -1;
+    }
+    picoev.max_fd = max_fd;
+    picoev.num_loops = 0;
+    picoev.timeout_vec_size
+      = PICOEV_RND_UP(picoev.max_fd, PICOEV_SIMD_BITS) / PICOEV_SHORT_BITS;
+    picoev.timeout_vec_of_vec_size
+      = PICOEV_RND_UP(picoev.timeout_vec_size, PICOEV_SIMD_BITS)
+      / PICOEV_SHORT_BITS;
+    return 0;
+  }
+  
+  /* deinitializes picoev */
+  PICOEV_INLINE
+  int picoev_deinit(void) {
+    assert(PICOEV_IS_INITED);
+    free(picoev._fds_free_addr);
+    picoev.fds = NULL;
+    picoev._fds_free_addr = NULL;
+    picoev.max_fd = 0;
+    picoev.num_loops = 0;
+    return 0;
+  }
+  
+  /* updates timeout */
+  PICOEV_INLINE
+  void picoev_set_timeout(picoev_loop* loop, int fd, int secs) {
+    picoev_fd* target;
+    short* vec, * vec_of_vec;
+    size_t vi = fd / PICOEV_SHORT_BITS, delta;
+    assert(PICOEV_IS_INITED_AND_FD_IN_RANGE(fd));
+    assert(PICOEV_FD_BELONGS_TO_LOOP(loop, fd));
+    target = picoev.fds + fd;
+    /* clear timeout */
+    if (target->timeout_idx != PICOEV_TIMEOUT_IDX_UNUSED) {
+      vec = PICOEV_TIMEOUT_VEC_OF(loop, target->timeout_idx);
+      if ((vec[vi] &= ~((unsigned short)SHRT_MIN >> (fd % PICOEV_SHORT_BITS)))
+	  == 0) {
+	vec_of_vec = PICOEV_TIMEOUT_VEC_OF_VEC_OF(loop, target->timeout_idx);
+	vec_of_vec[vi / PICOEV_SHORT_BITS]
+	  &= ~((unsigned short)SHRT_MIN >> (vi % PICOEV_SHORT_BITS));
+      }
+      target->timeout_idx = PICOEV_TIMEOUT_IDX_UNUSED;
+    }
+    if (secs != 0) {
+      delta = (loop->now + secs - loop->timeout.base_time)
+	/ loop->timeout.resolution;
+      if (delta >= PICOEV_TIMEOUT_VEC_SIZE) {
+	delta = PICOEV_TIMEOUT_VEC_SIZE - 1;
+      }
+      target->timeout_idx =
+	(loop->timeout.base_idx + delta) % PICOEV_TIMEOUT_VEC_SIZE;
+      vec = PICOEV_TIMEOUT_VEC_OF(loop, target->timeout_idx);
+      vec[vi] |= (unsigned short)SHRT_MIN >> (fd % PICOEV_SHORT_BITS);
+      vec_of_vec = PICOEV_TIMEOUT_VEC_OF_VEC_OF(loop, target->timeout_idx);
+      vec_of_vec[vi / PICOEV_SHORT_BITS]
+	|= (unsigned short)SHRT_MIN >> (vi % PICOEV_SHORT_BITS);
+    }
+  }
+  
+  /* registers a file descriptor and callback argument to a event loop */
+  PICOEV_INLINE
+  int picoev_add(picoev_loop* loop, int fd, int events, int timeout_in_secs,
+		 picoev_handler* callback, void* cb_arg) {
+    picoev_fd* target;
+    assert(PICOEV_IS_INITED_AND_FD_IN_RANGE(fd));
+    target = picoev.fds + fd;
+    assert(target->loop_id == 0);
+    target->callback = callback;
+    target->cb_arg = cb_arg;
+    target->loop_id = loop->loop_id;
+    target->events = 0;
+    target->timeout_idx = PICOEV_TIMEOUT_IDX_UNUSED;
+    if (picoev_update_events_internal(loop, fd, events | PICOEV_ADD) != 0) {
+      target->loop_id = 0;
+      return -1;
+    }
+    picoev_set_timeout(loop, fd, timeout_in_secs);
+    return 0;
+  }
+  
+  /* unregisters a file descriptor from event loop */
+  PICOEV_INLINE
+  int picoev_del(picoev_loop* loop, int fd) {
+    picoev_fd* target;
+    assert(PICOEV_IS_INITED_AND_FD_IN_RANGE(fd));
+    target = picoev.fds + fd;
+    if (picoev_update_events_internal(loop, fd, PICOEV_DEL) != 0) {
+      return -1;
+    }
+    picoev_set_timeout(loop, fd, 0);
+    target->loop_id = 0;
+    return 0;
+  }
+  
+  /* check if fd is registered (checks all loops if loop == NULL) */
+  PICOEV_INLINE
+  int picoev_is_active(picoev_loop* loop, int fd) {
+    assert(PICOEV_IS_INITED_AND_FD_IN_RANGE(fd));
+    return loop != NULL
+      ? picoev.fds[fd].loop_id == loop->loop_id
+      : picoev.fds[fd].loop_id != 0;
+  }
+  
+  /* returns events being watched for given descriptor */
+  PICOEV_INLINE
+  int picoev_get_events(picoev_loop* loop __attribute__((unused)), int fd) {
+    assert(PICOEV_IS_INITED_AND_FD_IN_RANGE(fd));
+    return picoev.fds[fd].events & PICOEV_READWRITE;
+  }
+  
+  /* sets events to be watched for given desriptor */
+  PICOEV_INLINE
+  int picoev_set_events(picoev_loop* loop, int fd, int events) {
+    assert(PICOEV_IS_INITED_AND_FD_IN_RANGE(fd));
+    if (picoev.fds[fd].events != events
+	&& picoev_update_events_internal(loop, fd, events) != 0) {
+      return -1;
+    }
+    return 0;
+  }
+  
+  /* function to iterate registered information. To start iteration, set curfd
+     to -1 and call the function until -1 is returned */
+  PICOEV_INLINE
+  int picoev_next_fd(picoev_loop* loop, int curfd) {
+    if (curfd != -1) {
+      assert(PICOEV_IS_INITED_AND_FD_IN_RANGE(curfd));
+    }
+    while (++curfd < picoev.max_fd) {
+      if (loop->loop_id == picoev.fds[curfd].loop_id) {
+	return curfd;
+      }
+    }
+    return -1;
+  }
+  
+  /* internal function */
+  PICOEV_INLINE
+  int picoev_init_loop_internal(picoev_loop* loop, int max_timeout) {
+    loop->loop_id = ++picoev.num_loops;
+    assert(PICOEV_TOO_MANY_LOOPS);
+    if ((loop->timeout.vec_of_vec
+	 = (short*)picoev_memalign((picoev.timeout_vec_of_vec_size
+				    + picoev.timeout_vec_size)
+				   * sizeof(short) * PICOEV_TIMEOUT_VEC_SIZE,
+				   &loop->timeout._free_addr, 1))
+	== NULL) {
+      --picoev.num_loops;
+      return -1;
+    }
+    loop->timeout.vec = loop->timeout.vec_of_vec
+      + picoev.timeout_vec_of_vec_size * PICOEV_TIMEOUT_VEC_SIZE;
+    loop->timeout.base_idx = 0;
+    loop->timeout.base_time = time(NULL);
+    loop->timeout.resolution
+      = PICOEV_RND_UP(max_timeout, PICOEV_TIMEOUT_VEC_SIZE)
+      / PICOEV_TIMEOUT_VEC_SIZE;
+    return 0;
+  }
+  
+  /* internal function */
+  PICOEV_INLINE
+  void picoev_deinit_loop_internal(picoev_loop* loop) {
+    free(loop->timeout._free_addr);
+  }
+  
+  /* internal function */
+  PICOEV_INLINE
+  void picoev_handle_timeout_internal(picoev_loop* loop) {
+    size_t i, j, k;
+    for (;
+	 loop->timeout.base_time <= loop->now - loop->timeout.resolution; 
+	 loop->timeout.base_idx
+	   = (loop->timeout.base_idx + 1) % PICOEV_TIMEOUT_VEC_SIZE,
+	   loop->timeout.base_time += loop->timeout.resolution) {
+      /* TODO use SIMD instructions */
+      short* vec = PICOEV_TIMEOUT_VEC_OF(loop, loop->timeout.base_idx);
+      short* vec_of_vec
+	= PICOEV_TIMEOUT_VEC_OF_VEC_OF(loop, loop->timeout.base_idx);
+      for (i = 0; i < picoev.timeout_vec_of_vec_size; ++i) {
+	short vv = vec_of_vec[i];
+	if (vv != 0) {
+	  for (j = i * PICOEV_SHORT_BITS; vv != 0; j++, vv <<= 1) {
+	    if (vv < 0) {
+	      short v = vec[j];
+	      assert(v != 0);
+	      for (k = j * PICOEV_SHORT_BITS; v != 0; k++, v <<= 1) {
+		if (v < 0) {
+		  picoev_fd* fd = picoev.fds + k;
+		  assert(fd->loop_id == loop->loop_id);
+		  fd->timeout_idx = PICOEV_TIMEOUT_IDX_UNUSED;
+		  (*fd->callback)(loop, k, PICOEV_TIMEOUT, fd->cb_arg);
+		}
+	      }
+	      vec[j] = 0;
+	    }
+	  }
+	  vec_of_vec[i] = 0;
+	}
+      }
+    }
+  }
+  
+  /* loop once */
+  PICOEV_INLINE
+  int picoev_loop_once(picoev_loop* loop, int max_wait) {
+    loop->now = time(NULL);
+    if (max_wait > loop->timeout.resolution) {
+      max_wait = loop->timeout.resolution;
+    }
+    if (picoev_poll_once_internal(loop, max_wait) != 0) {
+      return -1;
+    }
+    if (max_wait != 0) {
+      loop->now = time(NULL);
+    }
+    picoev_handle_timeout_internal(loop);
+    return 0;
+  }
+  
+#undef PICOEV_INLINE
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif