bossan 0.1.6 → 0.1.7

data/ext/bossan/buffer.c

@@ -0,0 +1,74 @@
+#include "buffer.h"
+
+#define LIMIT_MAX 1024 * 1024 * 1024
+
+buffer *
+new_buffer(size_t buf_size, size_t limit)
+{
+  buffer *buf;
+  buf = ruby_xmalloc(sizeof(buffer));
+  memset(buf, 0, sizeof(buffer));
+  buf->buf = ruby_xmalloc(sizeof(char) * buf_size);
+  buf->buf_size = buf_size;
+  if(limit){
+    buf->limit = limit;
+  }else{
+    buf->limit = LIMIT_MAX;
+  }
+  return buf;
+}
+
+
+buffer_result
+write2buf(buffer *buf, const char *c, size_t l)
+{
+  size_t newl;
+  char *newbuf;
+  buffer_result ret = WRITE_OK;
+  newl = buf->len + l;
+    
+  if (newl >= buf->buf_size) {
+    buf->buf_size *= 2;
+    if(buf->buf_size <= newl) {
+      buf->buf_size = (int)(newl + 1);
+    }
+    if(buf->buf_size > buf->limit){
+      buf->buf_size = buf->limit + 1;
+    }
+    newbuf = (char*)ruby_xrealloc(buf->buf, buf->buf_size);
+    buf->buf = newbuf;
+  }
+  if(newl >= buf->buf_size){
+    l = buf->buf_size - buf->len -1;
+    ret = LIMIT_OVER;
+  }
+  memcpy(buf->buf + buf->len, c , l);
+  buf->len += (int)l;
+  return ret;
+}
+
+
+void
+free_buffer(buffer *buf)
+{
+  ruby_xfree(buf->buf);
+  ruby_xfree(buf);
+}
+
+
+VALUE
+getRbString(buffer *buf)
+{
+  VALUE o;
+  o = rb_str_new(buf->buf, buf->len);
+  free_buffer(buf);
+  return o;
+}
+
+
+char *
+getString(buffer *buf)
+{
+  buf->buf[buf->len] = '\0';
+  return buf->buf;
+}

data/ext/bossan/buffer.h

@@ -0,0 +1,43 @@
+#ifndef BUFFER_H
+#define BUFFER_H
+
+#include "ruby.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+typedef enum {
+  WRITE_OK,
+  MEMORY_ERROR,
+  LIMIT_OVER,
+} buffer_result;
+
+typedef struct {
+  char *buf;
+  size_t buf_size;
+  size_t len;
+  size_t limit;
+} buffer;
+
+buffer *
+new_buffer(size_t buf_size, size_t limit);
+
+buffer_result
+write2buf(buffer *buf, const char *c, size_t  l);
+
+void
+free_buffer(buffer *buf);
+
+VALUE
+getRbString(buffer *buf);
+
+char *
+getString(buffer *buf);
+
+
+#endif
+
+
+
+

data/ext/bossan/client.h

@@ -0,0 +1,35 @@
+#ifndef CLIENT_H
+#define CLIENT_H
+
+#include "request.h"
+
+typedef struct _client {
+  int fd;
+  char *remote_addr;
+  uint32_t remote_port;
+  uint8_t keep_alive;
+  request *req;
+  uint32_t body_length;
+  int body_readed;
+  void *body;
+  int bad_request_code;
+  request_body_type body_type;    
+  uint8_t complete;
+
+  http_parser *http;          // http req parser
+  VALUE environ;              // rack environ
+  int status_code;            // response status code
+    
+  VALUE http_status;             // response status line
+  VALUE headers;                 // http response headers
+  uint8_t header_done;            // header write status
+  VALUE response;                // rack response object
+  VALUE response_iter;           // rack response object
+  uint8_t content_length_set;     // content_length_set flag
+  uint32_t content_length;         // content_length
+  uint32_t write_bytes;            // send body length
+  void *bucket;               //write_data
+  uint8_t response_closed;    //response closed flag
+} client_t;
+
+#endif

data/ext/bossan/extconf.rb

@@ -10,4 +10,15 @@ Dir.chdir bossan_dir
 
 dir_config bossan_dir
 
+srcs = Dir.glob("*.c")
+if have_header("sys/epoll.h")
+  srcs.delete("picoev_kqueue.c")
+elsif have_header("sys/event.h")
+  srcs.delete("picoev_epoll.c")
+else
+  $stderr.puts "error: not found kqueue or epoll on your system."
+  exit 1
+end
+$srcs = srcs
+
 create_makefile "bossan/bossan_ext"

data/ext/bossan/picoev_kqueue.c

@@ -0,0 +1,209 @@
+/*
+ * 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.
+ */
+
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/event.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include "picoev.h"
+
+#define EV_QUEUE_SZ 128
+
+#define BACKEND_BUILD(next_fd, events)	\
+  ((unsigned)((next_fd << 8) | (events & 0xff)))
+#define BACKEND_GET_NEXT_FD(backend) ((int)(backend) >> 8)
+#define BACKEND_GET_OLD_EVENTS(backend) ((int)(backend) & 0xff)
+
+typedef struct picoev_loop_kqueue_st {
+  picoev_loop loop;
+  int kq;
+  int changed_fds; /* link list using picoev_fd::_backend, -1 if not changed */
+  struct kevent events[1024];
+  struct kevent changelist[256];
+} picoev_loop_kqueue;
+
+picoev_globals picoev;
+
+static int apply_pending_changes(picoev_loop_kqueue* loop, int apply_all)
+{
+#define SET(op, events)						\
+  EV_SET(loop->changelist + cl_off++, loop->changed_fds,	\
+	 (((events) & PICOEV_READ) != 0 ? EVFILT_READ : 0)	\
+	 | (((events) & PICOEV_WRITE) != 0 ? EVFILT_WRITE : 0), \
+	 (op), 0, 0, NULL)
+  
+  int cl_off = 0, nevents;
+  
+  while (loop->changed_fds != -1) {
+    picoev_fd* changed = picoev.fds + loop->changed_fds;
+    int old_events = BACKEND_GET_OLD_EVENTS(changed->_backend);
+    if (changed->events != old_events) {
+      if (old_events != 0) {
+	SET(EV_DISABLE, old_events);
+      }
+      if (changed->events != 0) {
+	SET(EV_ADD | EV_ENABLE, changed->events);
+      }
+      if ((size_t)cl_off + 1
+	  >= sizeof(loop->changelist) / sizeof(loop->changelist[0])) {
+	nevents = kevent(loop->kq, loop->changelist, cl_off, NULL, 0, NULL);
+	assert(nevents == 0);
+	cl_off = 0;
+      }
+    }
+    loop->changed_fds = BACKEND_GET_NEXT_FD(changed->_backend);
+    changed->_backend = -1;
+  }
+  
+  if (apply_all && cl_off != 0) {
+    nevents = kevent(loop->kq, loop->changelist, cl_off, NULL, 0, NULL);
+    assert(nevents == 0);
+    cl_off = 0;
+  }
+  
+  return cl_off;
+  
+#undef SET
+}
+
+picoev_loop* picoev_create_loop(int max_timeout)
+{
+  picoev_loop_kqueue* loop;
+  
+  /* init parent */
+  assert(PICOEV_IS_INITED);
+  if ((loop = (picoev_loop_kqueue*)malloc(sizeof(picoev_loop_kqueue)))
+      == NULL) {
+    return NULL;
+  }
+  if (picoev_init_loop_internal(&loop->loop, max_timeout) != 0) {
+    free(loop);
+    return NULL;
+  }
+  
+  /* init kqueue */
+  if ((loop->kq = kqueue()) == -1) {
+    picoev_deinit_loop_internal(&loop->loop);
+    free(loop);
+    return NULL;
+  }
+  loop->changed_fds = -1;
+  
+  loop->loop.now = time(NULL);
+  return &loop->loop;
+}
+
+int picoev_destroy_loop(picoev_loop* _loop)
+{
+  picoev_loop_kqueue* loop = (picoev_loop_kqueue*)_loop;
+  
+  if (close(loop->kq) != 0) {
+    return -1;
+  }
+  picoev_deinit_loop_internal(&loop->loop);
+  free(loop);
+  return 0;
+}
+
+int picoev_update_events_internal(picoev_loop* _loop, int fd, int events)
+{
+  picoev_loop_kqueue* loop = (picoev_loop_kqueue*)_loop;
+  picoev_fd* target = picoev.fds + fd;
+  
+  assert(PICOEV_FD_BELONGS_TO_LOOP(&loop->loop, fd));
+  
+  /* initialize if adding the fd */
+  if ((events & PICOEV_ADD) != 0) {
+    target->_backend = -1;
+  }
+  /* return if nothing to do */
+  if (events == PICOEV_DEL
+      ? target->_backend == -1
+      : (events & PICOEV_READWRITE) == target->events) {
+    return 0;
+  }
+  /* add to changed list if not yet being done */
+  if (target->_backend == -1) {
+    target->_backend = BACKEND_BUILD(loop->changed_fds, target->events);
+    loop->changed_fds = fd;
+  }
+  /* update events */
+  target->events = events & PICOEV_READWRITE;
+  /* apply immediately if is a DELETE */
+  if ((events & PICOEV_DEL) != 0) {
+    apply_pending_changes(loop, 1);
+  }
+  
+  return 0;
+}
+
+int picoev_poll_once_internal(picoev_loop* _loop, int max_wait)
+{
+  picoev_loop_kqueue* loop = (picoev_loop_kqueue*)_loop;
+  struct timespec ts;
+  int cl_off = 0, nevents, i;
+  
+  /* apply pending changes, with last changes stored to loop->changelist */
+  cl_off = apply_pending_changes(loop, 0);
+  
+  ts.tv_sec = max_wait;
+  ts.tv_nsec = 0;
+  nevents = kevent(loop->kq, loop->changelist, cl_off, loop->events,
+		   sizeof(loop->events) / sizeof(loop->events[0]), &ts);
+  if (nevents == -1) {
+    /* the errors we can only rescue */
+    assert(errno == EACCES || errno == EFAULT || errno == EINTR);
+    return -1;
+  }
+  for (i = 0; i < nevents; ++i) {
+    struct kevent* event = loop->events + i;
+    picoev_fd* target = picoev.fds + event->ident;
+    assert((event->flags & EV_ERROR) == 0); /* changelist errors are fatal */
+    if (loop->loop.loop_id == target->loop_id
+	&& (event->filter & (EVFILT_READ | EVFILT_WRITE)) != 0) {
+      int revents;
+      switch (event->filter) {
+      case EVFILT_READ:
+	revents = PICOEV_READ;
+	break;
+      case EVFILT_WRITE:
+	revents = PICOEV_WRITE;
+	break;
+      default:
+	assert(0);
+	revents = 0; // suppress compiler warning
+	break;
+      }
+      (*target->callback)(&loop->loop, event->ident, revents, target->cb_arg);
+    }
+  }
+  
+  return 0;
+}

data/ext/bossan/request.c

@@ -0,0 +1,62 @@
+#include "request.h"
+
+
+request *
+new_request(void)
+{
+  request *req = (request *)ruby_xmalloc(sizeof(request));
+  memset(req, 0, sizeof(request));
+  return req;
+}
+
+
+header *
+new_header(size_t fsize, size_t flimit, size_t vsize, size_t vlimit)
+{
+  header *h;
+  h = ruby_xmalloc(sizeof(header));
+  h->field = new_buffer(fsize, flimit);
+  h->value = new_buffer(vsize, vlimit);
+  return h;
+}
+
+
+void
+free_header(header *h)
+{
+  ruby_xfree(h);
+}
+
+
+void
+free_request(request *req)
+{
+  uint32_t i;
+  header *h;
+  if(req->path){
+    free_buffer(req->path);
+    req->path = NULL;
+  }
+  if(req->uri){
+    free_buffer(req->uri); 
+    req->uri = NULL;
+  }
+  if(req->query_string){
+    free_buffer(req->query_string); 
+    req->query_string = NULL;
+  }
+  if(req->fragment){
+    free_buffer(req->fragment); 
+    req->fragment = NULL;
+  }
+  for(i = 0; i < req->num_headers+1; i++){
+    h = req->headers[i];
+    if(h){
+      free_buffer(h->field);
+      free_buffer(h->value);
+      free_header(h);
+      req->headers[i] = NULL;
+    }
+  }
+  ruby_xfree(req);
+}

data/ext/bossan/request.h

@@ -0,0 +1,54 @@
+#ifndef REQUEST_H
+#define REQUEST_H
+
+#include <inttypes.h>
+#include "buffer.h"
+
+#define LIMIT_PATH 1024 * 4
+#define LIMIT_FRAGMENT 1024
+#define LIMIT_URI 1024 * 4
+#define LIMIT_QUERY_STRING 1024 * 8
+
+#define LIMIT_REQUEST_FIELDS 30 
+#define LIMIT_REQUEST_FIELD_SIZE 1024 * 8 
+
+typedef enum {
+  BODY_TYPE_NONE,
+  BODY_TYPE_TMPFILE,
+  BODY_TYPE_BUFFER
+} request_body_type;
+
+typedef enum {
+  FIELD,
+  VAL,
+} field_type;
+
+typedef struct {
+  buffer *field;
+  buffer *value;
+} header;
+
+typedef struct {
+  buffer *path;
+  buffer *uri;
+  buffer *query_string;
+  buffer *fragment;
+  header *headers[LIMIT_REQUEST_FIELDS];
+  uint32_t num_headers;
+  field_type last_header_element;   
+} request;
+
+
+request *
+new_request(void);
+
+header *
+new_header(size_t fsize, size_t flimit, size_t vsize, size_t vlimit);
+
+void
+free_header(header *h);
+
+void
+free_request(request *req);
+
+#endif