webroar 0.2.2

data/src/vendor/libebb/ebb_request_parser.h

@@ -0,0 +1,117 @@
+/* This file is part of the libebb web server library
+ *
+ * Copyright (c) 2008 Ryan Dahl (ry@ndahl.us)
+ * All rights reserved.
+ *
+ * This parser is based on code from Zed Shaw's Mongrel.
+ * Copyright (c) 2005 Zed A. Shaw
+ * 
+ * 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 ebb_request_parser_h
+#define ebb_request_parser_h
+#ifdef __cplusplus
+extern "C" {
+#endif 
+
+
+#include <sys/types.h> 
+
+typedef struct ebb_request ebb_request;
+typedef struct ebb_request_parser  ebb_request_parser;
+typedef void (*ebb_header_cb)(ebb_request*, const char *at, size_t length, int header_index);
+typedef void (*ebb_element_cb)(ebb_request*, const char *at, size_t length);
+
+#define EBB_MAX_MULTIPART_BOUNDARY_LEN 20
+
+/* HTTP Methods */
+#define EBB_COPY       0x00000001
+#define EBB_DELETE     0x00000002
+#define EBB_GET        0x00000004
+#define EBB_HEAD       0x00000008
+#define EBB_LOCK       0x00000010
+#define EBB_MKCOL      0x00000020
+#define EBB_MOVE       0x00000040
+#define EBB_OPTIONS    0x00000080
+#define EBB_POST       0x00000100
+#define EBB_PROPFIND   0x00000200
+#define EBB_PROPPATCH  0x00000400
+#define EBB_PUT        0x00000800
+#define EBB_TRACE      0x00001000
+#define EBB_UNLOCK     0x00002000
+
+/* Transfer Encodings */
+#define EBB_IDENTITY   0x00000001
+#define EBB_CHUNKED    0x00000002
+
+struct ebb_request {
+  int method;
+  int transfer_encoding;         /* ro */
+  int expect_continue;               /* ro */
+  unsigned int version_major;        /* ro */
+  unsigned int version_minor;        /* ro */
+  int number_of_headers;             /* ro */
+  int keep_alive;                    /* private - use ebb_request_should_keep_alive */
+  size_t content_length;             /* ro - 0 if unknown */
+  size_t body_read;                  /* ro */
+
+  /* Public  - ordered list of callbacks */
+  ebb_element_cb on_path;
+  ebb_element_cb on_query_string;
+  ebb_element_cb on_uri;
+  ebb_element_cb on_fragment;
+  ebb_header_cb  on_header_field;
+  ebb_header_cb  on_header_value;
+  void (*on_headers_complete)(ebb_request *);
+  ebb_element_cb on_body;
+  void (*on_complete)(ebb_request *);
+  void *data;
+};
+
+struct ebb_request_parser {
+  int cs;                           /* private */
+  size_t chunk_size;                /* private */
+  unsigned eating:1;                /* private */
+  ebb_request *current_request;     /* ro */
+  const char *header_field_mark; 
+  const char *header_value_mark; 
+  const char *query_string_mark; 
+  const char *path_mark; 
+  const char *uri_mark; 
+  const char *fragment_mark; 
+
+  /* Public */
+  ebb_request* (*new_request)(void*);
+  void *data;
+};
+
+void ebb_request_parser_init(ebb_request_parser *parser);
+size_t ebb_request_parser_execute(ebb_request_parser *parser, const char *data, size_t len);
+int ebb_request_parser_has_error(ebb_request_parser *parser);
+int ebb_request_parser_is_finished(ebb_request_parser *parser);
+void ebb_request_init(ebb_request *);
+int ebb_request_should_keep_alive(ebb_request *request);
+#define ebb_request_has_body(request) \
+  (request->transfer_encoding == EBB_CHUNKED || request->content_length > 0 )
+
+#ifdef __cplusplus
+}
+#endif 
+#endif

data/src/vendor/libebb/ebb_request_parser.rl

@@ -0,0 +1,421 @@
+/* This file is part of the libebb web server library
+ *
+ * Copyright (c) 2008 Ryan Dahl (ry@ndahl.us)
+ * All rights reserved.
+ *
+ * This parser is based on code from Zed Shaw's Mongrel.
+ * Copyright (c) 2005 Zed A. Shaw
+ * 
+ * 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 "ebb_request_parser.h"
+
+#include <stdio.h>
+#include <assert.h>
+
+static int unhex[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+                     ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+                     ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+                     , 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1
+                     ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
+                     ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+                     ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
+                     ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+                     };
+#define TRUE 1
+#define FALSE 0
+#define MIN(a,b) (a < b ? a : b)
+
+#define REMAINING (pe - p)
+#define CURRENT (parser->current_request)
+#define CONTENT_LENGTH (parser->current_request->content_length)
+#define CALLBACK(FOR)                               \
+  if(CURRENT && parser->FOR##_mark && CURRENT->on_##FOR) {     \
+    CURRENT->on_##FOR( CURRENT                      \
+                , parser->FOR##_mark                \
+                , p - parser->FOR##_mark            \
+                );                                  \
+ }
+#define HEADER_CALLBACK(FOR)                        \
+  if(CURRENT && parser->FOR##_mark && CURRENT->on_##FOR) {     \
+    CURRENT->on_##FOR( CURRENT                      \
+                , parser->FOR##_mark                \
+                , p - parser->FOR##_mark            \
+                , CURRENT->number_of_headers        \
+                );                                  \
+ }
+#define END_REQUEST                        \
+    if(CURRENT && CURRENT->on_complete)               \
+      CURRENT->on_complete(CURRENT);       \
+    CURRENT = NULL;
+
+
+%%{
+  machine ebb_request_parser;
+
+  action mark_header_field   { parser->header_field_mark   = p; }
+  action mark_header_value   { parser->header_value_mark   = p; }
+  action mark_fragment       { parser->fragment_mark       = p; }
+  action mark_query_string   { parser->query_string_mark   = p; }
+  action mark_request_path   { parser->path_mark           = p; }
+  action mark_request_uri    { parser->uri_mark            = p; }
+
+  action write_field { 
+    HEADER_CALLBACK(header_field);
+    parser->header_field_mark = NULL;
+  }
+
+  action write_value {
+    HEADER_CALLBACK(header_value);
+    parser->header_value_mark = NULL;
+  }
+
+  action request_uri { 
+    CALLBACK(uri);
+    parser->uri_mark = NULL;
+  }
+
+  action fragment { 
+    CALLBACK(fragment);
+    parser->fragment_mark = NULL;
+  }
+
+  action query_string { 
+    CALLBACK(query_string);
+    parser->query_string_mark = NULL;
+  }
+
+  action request_path {
+    CALLBACK(path);
+    parser->path_mark = NULL;
+  }
+
+  action content_length {
+    if(CURRENT){
+      CURRENT->content_length *= 10;
+      CURRENT->content_length += *p - '0';
+    }
+  }
+
+  action use_identity_encoding { if(CURRENT) CURRENT->transfer_encoding = EBB_IDENTITY; }
+  action use_chunked_encoding { if(CURRENT) CURRENT->transfer_encoding = EBB_CHUNKED; }
+
+  action set_keep_alive { if(CURRENT) CURRENT->keep_alive = TRUE; }
+  action set_not_keep_alive { if(CURRENT) CURRENT->keep_alive = FALSE; }
+
+  action expect_continue {
+    if(CURRENT) CURRENT->expect_continue = TRUE;
+  }
+
+  action trailer {
+    /* not implemenetd yet. (do requests even have trailing headers?) */
+  }
+
+  action version_major {
+    if(CURRENT) {
+      CURRENT->version_major *= 10;
+      CURRENT->version_major += *p - '0';
+    }
+  }
+
+  action version_minor {
+  	if(CURRENT) {
+      CURRENT->version_minor *= 10;
+      CURRENT->version_minor += *p - '0';
+    }
+  }
+
+  action end_header_line {
+    if(CURRENT) CURRENT->number_of_headers++;
+  }
+
+  action end_headers {
+    if(CURRENT && CURRENT->on_headers_complete)
+      CURRENT->on_headers_complete(CURRENT);
+  }
+
+  action add_to_chunk_size {
+    parser->chunk_size *= 16;
+    parser->chunk_size += unhex[(int)*p];
+  }
+
+  action skip_chunk_data {
+    skip_body(&p, parser, MIN(parser->chunk_size, REMAINING));
+    fhold; 
+    if(parser->chunk_size > REMAINING) {
+      fbreak;
+    } else {
+      fgoto chunk_end; 
+    }
+  }
+
+  action end_chunked_body {
+    END_REQUEST;
+    fnext main;
+  }
+
+  action start_req {
+    assert(CURRENT == NULL);
+    CURRENT = parser->new_request(parser->data);
+  }
+
+  action body_logic {
+    if(CURRENT) { 
+      if(CURRENT->transfer_encoding == EBB_CHUNKED) {
+        fnext ChunkedBody;
+      } else {
+        /* this is pretty stupid. i'd prefer to combine this with skip_chunk_data */
+        parser->chunk_size = CURRENT->content_length;
+        p += 1;  
+        skip_body(&p, parser, MIN(REMAINING, CURRENT->content_length));
+        fhold;
+        if(parser->chunk_size > REMAINING) {
+          fbreak;
+        } 
+      }
+    }
+  }
+
+#
+##
+###
+#### HTTP/1.1 STATE MACHINE
+###
+##   RequestHeaders and character types are from
+#    Zed Shaw's beautiful Mongrel parser.
+
+  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));
+  quote = "\"";
+#  qdtext = token -- "\""; 
+#  quoted_pair = "\" ascii;
+#  quoted_string = "\"" (qdtext | quoted_pair )* "\"";
+
+#  headers
+
+  Method = ( "COPY"      %{ if(CURRENT) CURRENT->method = EBB_COPY;      }
+           | "DELETE"    %{ if(CURRENT) CURRENT->method = EBB_DELETE;    }
+           | "GET"       %{ if(CURRENT) CURRENT->method = EBB_GET;       }
+           | "HEAD"      %{ if(CURRENT) CURRENT->method = EBB_HEAD;      }
+           | "LOCK"      %{ if(CURRENT) CURRENT->method = EBB_LOCK;      }
+           | "MKCOL"     %{ if(CURRENT) CURRENT->method = EBB_MKCOL;     }
+           | "MOVE"      %{ if(CURRENT) CURRENT->method = EBB_MOVE;      }
+           | "OPTIONS"   %{ if(CURRENT) CURRENT->method = EBB_OPTIONS;   }
+           | "POST"      %{ if(CURRENT) CURRENT->method = EBB_POST;      }
+           | "PROPFIND"  %{ if(CURRENT) CURRENT->method = EBB_PROPFIND;  }
+           | "PROPPATCH" %{ if(CURRENT) CURRENT->method = EBB_PROPPATCH; }
+           | "PUT"       %{ if(CURRENT) CURRENT->method = EBB_PUT;       }
+           | "TRACE"     %{ if(CURRENT) CURRENT->method = EBB_TRACE;     }
+           | "UNLOCK"    %{ if(CURRENT) CURRENT->method = EBB_UNLOCK;    }
+           ); # Not allowing extension methods
+
+  HTTP_Version = "HTTP/" digit+ $version_major "." digit+ $version_minor;
+
+  scheme = ( alpha | digit | "+" | "-" | "." )* ;
+  absolute_uri = (scheme ":" (uchar | reserved )*);
+  path = ( pchar+ ( "/" pchar* )* ) ;
+  query = ( uchar | reserved )* >mark_query_string %query_string ;
+  param = ( pchar | "/" )* ;
+  params = ( param ( ";" param )* ) ;
+  rel_path = ( path? (";" params)? ) ;
+  absolute_path = ( "/"+ rel_path ) >mark_request_path %request_path ("?" query)?;
+  Request_URI = ( "*" | absolute_uri | absolute_path ) >mark_request_uri %request_uri;
+  Fragment = ( uchar | reserved )* >mark_fragment %fragment;
+
+  field_name = ( token -- ":" )+;
+  Field_Name = field_name >mark_header_field %write_field;
+
+  field_value = ((any - " ") any*)?;
+  Field_Value = field_value >mark_header_value %write_value;
+
+  hsep = ":" " "*;
+  header = (field_name hsep field_value) :> CRLF;
+  Header = ( ("Content-Length"i hsep digit+ $content_length)
+           | ("Connection"i hsep 
+               ( "Keep-Alive"i %set_keep_alive
+               | "close"i %set_not_keep_alive
+               )
+             )
+           | ("Transfer-Encoding"i %use_chunked_encoding hsep "identity" %use_identity_encoding)
+         # | ("Expect"i hsep "100-continue"i %expect_continue)
+         # | ("Trailer"i hsep field_value %trailer)
+           | (Field_Name hsep Field_Value)
+           ) :> CRLF;
+
+  Request_Line = ( Method " " Request_URI ("#" Fragment)? " " HTTP_Version CRLF ) ;
+  RequestHeader = Request_Line (Header %end_header_line)* :> CRLF @end_headers;
+
+# chunked message
+  trailing_headers = header*;
+  #chunk_ext_val   = token | quoted_string;
+  chunk_ext_val = token*;
+  chunk_ext_name = token*;
+  chunk_extension = ( ";" " "* chunk_ext_name ("=" chunk_ext_val)? )*;
+  last_chunk = "0"+ chunk_extension CRLF;
+  chunk_size = (xdigit* [1-9a-fA-F] xdigit*) $add_to_chunk_size;
+  chunk_end  = CRLF;
+  chunk_body = any >skip_chunk_data;
+  chunk_begin = chunk_size chunk_extension CRLF;
+  chunk = chunk_begin chunk_body chunk_end;
+  ChunkedBody := chunk* last_chunk trailing_headers CRLF @end_chunked_body;
+
+  Request = RequestHeader >start_req @body_logic;
+
+  main := Request*; # sequence of requests (for keep-alive)
+}%%
+
+%% write data;
+
+static void
+skip_body(const char **p, ebb_request_parser *parser, size_t nskip) {
+  if(CURRENT && CURRENT->on_body && nskip > 0) {
+    CURRENT->on_body(CURRENT, *p, nskip);
+  }
+  if(CURRENT) CURRENT->body_read += nskip;
+  parser->chunk_size -= nskip;
+  *p += nskip;
+  if(0 == parser->chunk_size) {
+    parser->eating = FALSE;
+    if(CURRENT && CURRENT->transfer_encoding == EBB_IDENTITY) {
+      END_REQUEST;
+    }
+  } else {
+    parser->eating = TRUE;
+  }
+}
+
+void ebb_request_parser_init(ebb_request_parser *parser) 
+{
+  int cs = 0;
+  %% write init;
+  parser->cs = cs;
+
+  parser->chunk_size = 0;
+  parser->eating = 0;
+  
+  parser->current_request = NULL;
+
+  parser->header_field_mark = parser->header_value_mark   = 
+  parser->query_string_mark = parser->path_mark           = 
+  parser->uri_mark          = parser->fragment_mark       = NULL;
+
+  parser->new_request = NULL;
+}
+
+
+/** exec **/
+size_t ebb_request_parser_execute(ebb_request_parser *parser, const char *buffer, size_t len)
+{
+  const char *p, *pe;
+  int cs = parser->cs;
+
+  assert(parser->new_request && "undefined callback");
+
+  p = buffer;
+  pe = buffer+len;
+
+  if(0 < parser->chunk_size && parser->eating) {
+    /* eat body */
+    size_t eat = MIN(len, parser->chunk_size);
+    skip_body(&p, parser, eat);
+  } 
+
+  if(parser->header_field_mark)   parser->header_field_mark   = buffer;
+  if(parser->header_value_mark)   parser->header_value_mark   = buffer;
+  if(parser->fragment_mark)       parser->fragment_mark       = buffer;
+  if(parser->query_string_mark)   parser->query_string_mark   = buffer;
+  if(parser->path_mark)           parser->path_mark           = buffer;
+  if(parser->uri_mark)            parser->uri_mark            = buffer;
+
+  %% write exec;
+
+  parser->cs = cs;
+
+  HEADER_CALLBACK(header_field);
+  HEADER_CALLBACK(header_value);
+  CALLBACK(fragment);
+  CALLBACK(query_string);
+  CALLBACK(path);
+  CALLBACK(uri);
+
+  assert(p <= pe && "buffer overflow after parsing execute");
+
+  return(p - buffer);
+}
+
+int ebb_request_parser_has_error(ebb_request_parser *parser) 
+{
+  return parser->cs == ebb_request_parser_error;
+}
+
+int ebb_request_parser_is_finished(ebb_request_parser *parser) 
+{
+  return parser->cs == ebb_request_parser_first_final;
+}
+
+void ebb_request_init(ebb_request *request)
+{
+  request->expect_continue = FALSE;
+  request->body_read = 0;
+  request->content_length = 0;
+  request->version_major = 0;
+  request->version_minor = 0;
+  request->number_of_headers = 0;
+  request->transfer_encoding = EBB_IDENTITY;
+  request->keep_alive = -1;
+
+  request->on_complete = NULL;
+  request->on_headers_complete = NULL;
+  request->on_body = NULL;
+  request->on_header_field = NULL;
+  request->on_header_value = NULL;
+  request->on_uri = NULL;
+  request->on_fragment = NULL;
+  request->on_path = NULL;
+  request->on_query_string = NULL;
+}
+
+int ebb_request_should_keep_alive(ebb_request *request)
+{
+  if(request->keep_alive == -1)
+    if(request->version_major == 1)
+      return (request->version_minor != 0);
+    else if(request->version_major == 0)
+      return FALSE;
+    else
+      return TRUE;
+  else
+    return request->keep_alive;
+}

data/src/vendor/libebb/examples/ca-cert.pem

@@ -0,0 +1,12 @@
+-----BEGIN CERTIFICATE-----
+MIIBzDCCATegAwIBAgIESIuNVTALBgkqhkiG9w0BAQUwADAeFw0wODA3MjYyMDQ3
+MTlaFw0xMTA0MjIyMDQ3MjVaMAAwgZwwCwYJKoZIhvcNAQEBA4GMADCBiAKBgOm9
+l/FoXbTIcEusk/QlS5YrlR04+oWIbSdZIf3GJBEWEUPljDxAX96qHsTcaVnGK+EP
+keU4cIZvdY+hzbqa5cc1j2/9IeJNejL8gpQ/ocyMM69yq5Ib2F8K4mGWm1xr30hU
+bYpY5D0MrZ1b0HtYFVc8KVAr0ADGG+pye0P9c3B/AgMBAAGjWjBYMAwGA1UdEwEB
+/wQCMAAwFAYDVR0RBA0wC4IJbG9jYWxob3N0MBMGA1UdJQQMMAoGCCsGAQUFBwMB
+MB0GA1UdDgQWBBTYgVB7kJnnm+jgX9DgrapzGfUmxjALBgkqhkiG9w0BAQUDgYEA
+GkadA2H8CAzU3w4oCGZu9Ry9Tj/9Agw1XMFKvoJuG7VLPk7+B25JvNFVsmpROLxO
+0TJ6mIU2hz5/rLvEfTBGQ+DYtbsjIxCz1fD7R5c1kKBtA0d0u8mY8pTlPNlxFPSW
+3ymx5DB2zyDa/HuX6m6/VmzMYmA0vp7Dp1cl+pA9Nhs=
+-----END CERTIFICATE-----

data/src/vendor/libebb/examples/ca-key.pem

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXQIBAAKBgQDpvZfxaF20yHBLrJP0JUuWK5UdOPqFiG0nWSH9xiQRFhFD5Yw8
+QF/eqh7E3GlZxivhD5HlOHCGb3WPoc26muXHNY9v/SHiTXoy/IKUP6HMjDOvcquS
+G9hfCuJhlptca99IVG2KWOQ9DK2dW9B7WBVXPClQK9AAxhvqcntD/XNwfwIDAQAB
+AoGAJqo3LTbfcV1KvinhG5zjwQaalwfq4RXtQHoNFmalZrIozvt01C6t7S5lApmX
+T8NpVMR3lNxeOM7NOqJAXuLqqVVqk81YEYuMx6E4gB/Ifl7jVZk1jstmLILhh59D
+pXrlpzvvm5X2hVsI7lp/YGAvtdLS1iVy37bGgmQWfCeeZiECQQDtZLfcJb4oE1yR
+ZfLOcPDlBCw02wGMNFpAjwbspf/du3Yn3ONWHVfhSCCcCe262h9PLblL97LoB+gF
+OHOlM9JvAkEA/A+U3/p9pwL4L742pxZP62/rmk6p5mZFIykk2jIUTpdilXBWBlcT
+OjgjnpquZpwnaClmvgFpkzdhIPF7Nq4K8QJBAITVKagOmnOUOeTF1fI78h9DkXTV
+4uzP0nxzS52ZWS16Gqg9ihuCecz97flB+Prn2EMWw6tFY58/5U0ehF85OxMCQQDF
+08TYdVSg+6emcPeb89sNwW18UjjuZ13j1qrhxWRCunXZK62YlEa27tCl7mjqh6w2
+CChm/9zIejJ1FJHLvJVBAkBj63ZbwggMYkxuj60jIBbNrEtDx9y7zM0sXkiJqcKp
+5uGtJNafG+yZrLAHE6/b4aqUOtGsCGsiZpT9ms7CoaVr
+-----END RSA PRIVATE KEY-----

data/src/vendor/libebb/examples/hello_world.c

@@ -0,0 +1,101 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <assert.h>
+
+#include <ev.h>
+#include "ebb.h"
+
+#define MSG ("HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 12\r\n\r\nhello world\n")
+static int c = 0;
+
+struct hello_connection {
+  unsigned int responses_to_write;
+};
+
+void on_close(ebb_connection *connection)
+{
+  free(connection->data);
+  free(connection);
+}
+
+static void continue_responding(ebb_connection *connection)
+{
+  int r;
+  struct hello_connection *connection_data = connection->data;
+  //printf("response complete \n");
+  if(--connection_data->responses_to_write > 0) {
+    /* write another response */
+    r = ebb_connection_write(connection, MSG, sizeof MSG, continue_responding);
+    assert(r);
+  } else {
+    ebb_connection_schedule_close(connection);
+  }
+}
+
+static void request_complete(ebb_request *request)
+{
+  //printf("request complete \n");
+  ebb_connection *connection = request->data;
+  struct hello_connection *connection_data = connection->data;
+
+  if(ebb_request_should_keep_alive(request))
+    connection_data->responses_to_write++;
+  else
+    connection_data->responses_to_write = 1;
+
+  ebb_connection_write(connection, MSG, sizeof MSG, continue_responding);
+  free(request);
+}
+
+static ebb_request* new_request(ebb_connection *connection)
+{
+  //printf("request %d\n", ++c);
+  ebb_request *request = malloc(sizeof(ebb_request));
+  ebb_request_init(request);
+  request->data = connection;
+  request->on_complete = request_complete;
+  return request;
+}
+
+ebb_connection* new_connection(ebb_server *server, struct sockaddr_in *addr)
+{
+  struct hello_connection *connection_data = malloc(sizeof(struct hello_connection));
+  if(connection_data == NULL)
+    return NULL;
+  connection_data->responses_to_write = 0;
+
+  ebb_connection *connection = malloc(sizeof(ebb_connection));
+  if(connection == NULL) {
+    free(connection_data);
+    return NULL;
+  }
+
+  ebb_connection_init(connection);
+  connection->data = connection_data;
+  connection->new_request = new_request;
+  connection->on_close = on_close;
+  
+  printf("connection: %d\n", c++);
+  return connection;
+}
+
+int main(int argc, char **_) 
+{
+  struct ev_loop *loop = ev_default_loop(0);
+  ebb_server server;
+
+  ebb_server_init(&server, loop);
+  if(argc > 1) {
+    printf("using SSL\n");
+    ebb_server_set_secure(&server, "ca-cert.pem", "ca-key.pem");
+  }
+  server.new_connection = new_connection;
+
+  printf("hello_world listening on port 5000\n");
+  ebb_server_listen_on_port(&server, 5000);
+  ev_loop(loop, 0);
+
+  return 0;
+}