/ - Diff - CSE2410 Fall 2014 Bounce - CS Projects

Revision 40c0f755

     # Fancy colors used to beautify the output a bit.
+    #
     if [ "$NOCOLOR" ] ; then
         NORMAL=""
         BOLD=""
         RED=""
         YELLOW=""
         GREEN=""
     else
         NORMAL='\\033[0m'
         BOLD='\\033[01;1m'
         RED='\\033[01;91m'
         YELLOW='\\033[00;33m'
         GREEN='\\033[01;92m'
     fi
     NORMAL=""
     BOLD=""
     RED=""
     YELLOW=""
     GREEN=""
     EXIT_SUCCESS=0
     EXIT_FAILURE=1

deps/libebb/.gitignore
	1	*.o
	2	examples/hello_world
	3	test_request_parser
	4	ebb_request_parser.c
	5	tags

     Copyright (c) 2008 Ryan Dahl (ry@ndahl.us)
     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.

deps/libebb/README
	1	see doc/index.html and examples/hello_world.c for explanation
	2
	3	webpage: http://tinyclouds.org/libebb/
	4	git repository: http://github.com/ry/libebb/tree/master
	5
	6	To build libebb please edit config.mk to reflect your system's parameters.
	7

     PREFIX = $(HOME)/local/libebb
     # libev
     EVINC  = $(HOME)/local/libev/include
     EVLIB  = $(HOME)/local/libev/lib
     EVLIBS = -L${EVLIB} -lev
     # GnuTLS, comment if you don't want it (necessary for HTTPS)
     GNUTLSLIB   = /usr/lib
     GNUTLSINC   = /usr/include
     GNUTLSLIBS  = -L${GNUTLSLIB} -lgnutls
     GNUTLSFLAGS = -DHAVE_GNUTLS
     # includes and libs
     INCS = -I${EVINC} -I${GNUTLSINC}
     LIBS = ${EVLIBS} ${GNUTLSLIBS} -lefence
     # flags
     CPPFLAGS = -DVERSION=\"$(VERSION)\" ${GNUTLSFLAGS}
     CFLAGS   = -O2 -g -Wall ${INCS} ${CPPFLAGS} -fPIC
     LDFLAGS  = -s ${LIBS}
     LDOPT    = -shared
     SUFFIX   = so
     SONAME   = -Wl,-soname,$(OUTPUT_LIB)
     # Solaris
     #CFLAGS  = -fast ${INCS} -DVERSION=\"$(VERSION)\" -fPIC
     #LDFLAGS = ${LIBS}
     #SONAME  =
     # Darwin
     # LDOPT  = -dynamiclib
     # SUFFIX = dylib
     # SONAME = -current_version $(VERSION) -compatibility_version $(VERSION)
     # compiler and linker
     CC = cc
     RANLIB = ranlib

     <html>
       <style>
         body {
           background: #fff;
           color: #2e3436;
           font-size: 12pt;
           line-height: 16pt;
       /*  font-family: Palatino;  */
           margin: 3em 0 3em 3em;
+        }
         code, pre {
+        }
         #contents {
           max-width: 40em;
+        }
         ul {
           padding-left: 0;
+        }
         li {
           margin-top: 0.5em;
           margin-bottom: 0.5em;
+        }
         p {
           text-align: left;
+        }
         img {
           float: left;
           margin: 0 1em 1em 0;
+        }
         p { clear: both; }
       </style>
       <body> <div id="contents">
         <img src="icon.png"/>
         <h1>libebb</h1>
         <p>
           libebb is a lightweight HTTP server library for C.  It lays the
           foundation for writing a web server by providing the socket juggling
           and request parsing. By implementing the HTTP/1.1 grammar provided in
           RFC2612,  libebb understands most most valid HTTP/1.1 connections
           (persistent, pipelined, and chunked requests included) and rejects
           invalid or malicious requests.  libebb supports SSL over HTTP.
         </p>
         <p>
           The library embraces a minimalistic single-threaded evented design.
           No control is removed from the user. For example, all allocations are
           done through callbacks so that the user might implement in optimal
           ways for their specific application.  By design libebb is not
           thread-safe and all provided callbacks must not block.  libebb uses
           the <a href="http://libev.schmorp.de/bench.html">high-performance</a>
           libev event loop, but does not control it. The user of the library may
           start and stop the loop at will, they may attach thier own watchers.
         </p>
         <p>
           libebb depends on POSIX sockets, libev, and optionally GnuTLS.
         </p>
         <p>
           libebb is in the early stages of development and probably contains
           many bugs. The API is subject to radical changes.  If you're
           interested <a href="http://github.com/ry/libebb/tree/master">checkout
             the source code</a> and <a
             href="http://groups.google.com/group/ebbebb">join the mailing
             list</a>.  A release will be made when it proves stable.
         </p>
         <p>libebb is released under <a
           href="http://www.gnu.org/licenses/license-list.html#X11License">the
           X11 license</a>.</p>
         <h2>Usage</h2>
         <p>
           libebb is a simple API, mostly it is providing callbacks.  There are
           two types of callbacks that one will work with:
         </p>
         <ul>
           <li>callbacks to allocate and initialize data for libebb. These are
           named <code>new_*</code> like <code>new_connection</code> and
           <code>new_request</code></li>
           <li>callbacks which happen on an event and might provide a pointer to
           a chunk of data. These are named <code>on_*</code> like
           <code>on_body</code> and <code>on_close</code>.</li>
         </ul>
         <p>
           In libebb there are three important classes: <code>ebb_server</code>,
           <code>ebb_connection</code>, and <code>ebb_request</code>.
           Each server has many peer connections. Each peer connection may have many
           requests.
           There are two additional classes <code>ebb_buf</code> and <code>ebb_request_parser</code>
           which may or may not be useful.
         </p>
         <h3><code>ebb_server</code></h3>
         <p>
           <code>ebb_server</code> represents a single web server listening on a
           single port. The user must allocate the structure themselves, then
           call <code>ebb_server_init()</code> and provide a libev event loop.
           <code>ebb_server_set_secure()</code> will make the server understand
           HTTPS connections.
         </p>
         <p>
           After initialized the <code>ebb_server_listen_on_port()</code> can be
           called to open the server up to new connections. libebb does not
           control the event loop, it is the user's responsibility to start the
           event loop  (using <code>ev_loop()</code>) after
           <code>ebb_server_listen_on_port()</code> is called.
         </p>
         <p>
           To accept connections you must provide the new server with a callback
           called <code>new_connection</code>. This callback must return an allocated
           and initialized <code>ebb_connection</code> structure.
           To set this callback do
         </p>
         <pre>my_server-&gt;new_connection = my_new_connection_callback;</pre>
         <p>
           Additional documentation can be found in <code>ebb.h</code>
         </p>
         <h3><code>ebb_connection</code></h3>
         <p>
           This structure contains information and callbacks for a single client
           connection. It is allocated and initialized through the
           <code>new_connection</code> callback in <code>ebb_server</code>.
           To initialize a newly allocated <code>ebb_connection</code> use
           <code>ebb_connection_init()</code>.
         </p>
         <p>
           After <code>ebb_connection_init()</code> is called a number of
           callbacks can be set: <code>new_request</code>, <code>new_buf</code>,
           <code>on_timeout</code>, and <code>on_close</code>.
         </p>
         <p>
           When an <code>ebb_connection</code> is returned to an
           <code>ebb_server</code>, data is immediately data is read from the
           socket.  This data must be stored somewhere. Because libebb is
           agnostic about allocation decisions, it passes this off to the user in
           the form of a callback: <code>connection-&gt;new_buf</code>.  This
           callback returns a newly allocated and initialized
           <code>ebb_buf</code> structure.  How much libebb attempts to read from
           the socket is determined by how large the returned
           <code>ebb_buf</code> structure is.  Using <code>new_buf</code> is
           optional.  By default libebb reads data into a static buffer
           (allocated at compile time), writing over it on each read. In many
           web server using the static buffer will be sufficent because callbacks
           made during the parsing will buffer the data elsewhere. Providing a
           <code>new_buf</code> callback is necessary only if you want to save
           the raw data coming from the socket.
         </p>
         <p>
           The <code>new_request</code> callback is called at the beginning of a
           request. It must return a newly allocated and initialized
           <code>ebb_request</code> structure. Because HTTP/1.1 supports <a
             href="http://en.wikipedia.org/wiki/HTTP_persistent_connection">peristant</a>
           connections, there may be many requests per connection.
         </p>
         <p>
           You may access the file descriptor for the client socket inside the
           <code>ebb_connection</code> structure. Writing the response, in valid
           HTTP, is the user's responsibility.  Remember, requests must be
           returned to client in the same order that they were received.
         </p>
         <p>
           A convience function, <coe>ebb_connection_write</code>, is provided
           which will write a single string to the peer. You may use
           this function or you may write to the file descriptor directly.
         </p>
         <p>
           To close a peer connection use
           <code>ebb_connnection_schedule_close()</code>. Because SSL may require
           some additional communication to close the connection properly, the
           file descriptor cannot be closed immediately. The
           <code>on_close</code> callback will be made when the peer socket is
           finally closed.
           <em>Only once <code>on_close</code> is called may the
             user free the <code>ebb_connection</code> structure.</em>
         </p>
         <h3><code>ebb_request</code></h3>
         <p>
           This structure provides information about a request. For example,
           <code>request-&gt;method == EBB_POST</code> would mean the method of
           the request is <code>POST</code>. There are also many callbacks
           which can be set to handle data from a request as it is parsed.
         </p>
         <p>
           The <code>on_uri</code> callback and all other
           <code>ebb_element_cb</code> callbacks provide pointers to request
           data.  The annoying thing is they do not necessarily provide a
           complete string.  This is because the reads from the socket may not
           contain an entire request and for efficency libebb does not attempt to
           buffer the data.  Theoretically, one might receive an
           <code>on_uri</code> callback 10 times, each providing just a single
           character of the request's URI.  See <code>ebb_request_parser.h</code> for
           a full list of callbacks that you may provide. (If you don't set them,
           they are ignored.)
         </p>
         <p>
           The <code>on_complete</code> callback is called at the end of
           each request.
           <em>Only once <code>on_complete</code> is called may the
             user free the <code>ebb_request</code> structure.</em>
         </p>
         <h2>Example</h2>
         <p>
           A simple example is provided in <code>examples/hello_world.c</code>.
         </p>
       </div></body>
     </html>

     /* This file is part of libebb.
+     *
      * Copyright (c) 2008 Ryan Dahl (ry@ndahl.us)
      * All rights reserved.
+     *
      * 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 <assert.h>
     #include <string.h>
     #include <fcntl.h>
     #include <sys/types.h>
     #include <sys/socket.h>
     #include <netinet/tcp.h> /* TCP_NODELAY */
     #include <netinet/in.h>  /* inet_ntoa */
     #include <arpa/inet.h>   /* inet_ntoa */
     #include <unistd.h>
     #include <stdio.h>      /* perror */
     #include <errno.h>      /* perror */
     #include <stdlib.h> /* for the default methods */
     #include <ev.h>
     #include "ebb.h"
     #include "ebb_request_parser.h"
     #ifdef HAVE_GNUTLS
     # include <gnutls/gnutls.h>
     # include "rbtree.h" /* for session_cache */
     #endif
     #ifndef TRUE
     # define TRUE 1
     #endif
     #ifndef FALSE
     # define FALSE 0
     #endif
     #ifndef MIN
     # define MIN(a,b) (a < b ? a : b)
     #endif
     #define error(FORMAT, ...) fprintf(stderr, "error: " FORMAT "\n", ##__VA_ARGS__)
     #define CONNECTION_HAS_SOMETHING_TO_WRITE (connection->to_write != NULL)
     static void
     set_nonblock (int fd)
+    {
       int flags = fcntl(fd, F_GETFL, 0);
       int r = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
       assert(0 <= r && "Setting socket non-block failed!");
+    }
     static ssize_t
     nosigpipe_push(void *data, const void *buf, size_t len)
+    {
       int fd = (int)data;
       int flags = 0;
     #ifdef MSG_NOSIGNAL
       flags = MSG_NOSIGNAL;
     #endif
       return send(fd, buf, len, flags);
+    }
     static void
     close_connection(ebb_connection *connection)
+    {
     #ifdef HAVE_GNUTLS
       if(connection->server->secure)
         ev_io_stop(connection->server->loop, &connection->handshake_watcher);
     #endif
       ev_io_stop(connection->server->loop, &connection->read_watcher);
       ev_io_stop(connection->server->loop, &connection->write_watcher);
       ev_timer_stop(connection->server->loop, &connection->timeout_watcher);
       if(0 > close(connection->fd))
         error("problem closing connection fd");
       connection->open = FALSE;
       if(connection->on_close)
         connection->on_close(connection);
       /* No access to the connection past this point!
        * The user is allowed to free in the callback
        */
+    }
     #ifdef HAVE_GNUTLS
     #define GNUTLS_NEED_WRITE (gnutls_record_get_direction(connection->session) == 1)
     #define GNUTLS_NEED_READ (gnutls_record_get_direction(connection->session) == 0)
     #define EBB_MAX_SESSION_KEY 32
     #define EBB_MAX_SESSION_VALUE 512
     struct session_cache {
       struct rbtree_node_t node;
       gnutls_datum_t key;
       gnutls_datum_t value;
       char key_storage[EBB_MAX_SESSION_KEY];
       char value_storage[EBB_MAX_SESSION_VALUE];
     };
     static int
     session_cache_compare (void *left, void *right)
+    {
       gnutls_datum_t *left_key = left;
       gnutls_datum_t *right_key = right;
       if(left_key->size < right_key->size)
         return -1;
       else if(left_key->size > right_key->size)
         return 1;
       else
         return memcmp( left_key->data
                      , right_key->data
                      , MIN(left_key->size, right_key->size)
                      );
+    }
     static int
     session_cache_store(void *data, gnutls_datum_t key, gnutls_datum_t value)
+    {
       rbtree tree = data;
       if( tree == NULL
        || key.size > EBB_MAX_SESSION_KEY
        || value.size > EBB_MAX_SESSION_VALUE
         ) return -1;
       struct session_cache *cache = gnutls_malloc(sizeof(struct session_cache));
       memcpy (cache->key_storage, key.data, key.size);
       cache->key.size = key.size;
       cache->key.data = (void*)cache->key_storage;
       memcpy (cache->value_storage, value.data, value.size);
       cache->value.size = value.size;
       cache->value.data = (void*)cache->value_storage;
       cache->node.key = &cache->key;
       cache->node.value = &cache;
       rbtree_insert(tree, (rbtree_node)cache);
       //printf("session_cache_store\n");
       return 0;
+    }
     static gnutls_datum_t
     session_cache_retrieve (void *data, gnutls_datum_t key)
+    {
       rbtree tree = data;
       gnutls_datum_t res = { NULL, 0 };
       struct session_cache *cache = rbtree_lookup(tree, &key);
       if(cache == NULL)
         return res;
       res.size = cache->value.size;
       res.data = gnutls_malloc (res.size);
       if(res.data == NULL)
         return res;
       memcpy(res.data, cache->value.data, res.size);
       //printf("session_cache_retrieve\n");
       return res;
+    }
     static int
     session_cache_remove (void *data, gnutls_datum_t key)
+    {
       rbtree tree = data;
       if(tree == NULL)
         return -1;
       struct session_cache *cache = (struct session_cache *)rbtree_delete(tree, &key);
       if(cache == NULL)
         return -1;
       gnutls_free(cache);
       //printf("session_cache_remove\n");
       return 0;
+    }
     static void
     on_handshake(struct ev_loop *loop ,ev_io *watcher, int revents)
+    {
       ebb_connection *connection = watcher->data;
       //printf("on_handshake\n");
       assert(ev_is_active(&connection->timeout_watcher));
       assert(!ev_is_active(&connection->read_watcher));
       assert(!ev_is_active(&connection->write_watcher));
       if(EV_ERROR & revents) {
         error("on_handshake() got error event, closing connection.n");
         goto error;
+      }
       int r = gnutls_handshake(connection->session);
       if(r < 0) {
         if(gnutls_error_is_fatal(r)) goto error;
         if(r == GNUTLS_E_INTERRUPTED || r == GNUTLS_E_AGAIN)
           ev_io_set( watcher
                    , connection->fd
                    , (GNUTLS_NEED_WRITE ? EV_WRITE : EV_READ)
                    );
         return;
+      }
       ebb_connection_reset_timeout(connection);
       ev_io_stop(loop, watcher);
       ev_io_start(loop, &connection->read_watcher);
       if(CONNECTION_HAS_SOMETHING_TO_WRITE)
         ev_io_start(loop, &connection->write_watcher);
       return;
     error:
       close_connection(connection);
+    }
     #endif /* HAVE_GNUTLS */
     /* Internal callback
      * called by connection->timeout_watcher
      */
     static void
     on_timeout(struct ev_loop *loop, ev_timer *watcher, int revents)
+    {
       ebb_connection *connection = watcher->data;
       assert(watcher == &connection->timeout_watcher);
       //printf("on_timeout\n");
       /* if on_timeout returns true, we don't time out */
       if(connection->on_timeout) {
         int r = connection->on_timeout(connection);
         if(r == EBB_AGAIN) {
           ebb_connection_reset_timeout(connection);
           return;
+        }
+      }
       ebb_connection_schedule_close(connection);
+    }
     /* Internal callback
      * called by connection->read_watcher
      */
     static void
     on_readable(struct ev_loop *loop, ev_io *watcher, int revents)
+    {
       ebb_connection *connection = watcher->data;
       char recv_buffer[TCP_MAXWIN];
       ssize_t recved;
       //printf("on_readable\n");
       // TODO -- why is this broken?
       //assert(ev_is_active(&connection->timeout_watcher));
       assert(watcher == &connection->read_watcher);
       if(EV_ERROR & revents) {
         error("on_readable() got error event, closing connection.");
         goto error;
+      }
     #ifdef HAVE_GNUTLS
       assert(!ev_is_active(&connection->handshake_watcher));
       if(connection->server->secure) {
         recved = gnutls_record_recv( connection->session
                                    , recv_buffer
                                    , TCP_MAXWIN
                                    );
         if(recved <= 0) {
           if(gnutls_error_is_fatal(recved)) goto error;
           if( (recved == GNUTLS_E_INTERRUPTED || recved == GNUTLS_E_AGAIN)
            && GNUTLS_NEED_WRITE
             ) ev_io_start(loop, &connection->write_watcher);
           return;
+        }
       } else {
     #endif /* HAVE_GNUTLS */
         recved = recv(connection->fd, recv_buffer, TCP_MAXWIN, 0);
         if(recved <= 0) goto error;
     #ifdef HAVE_GNUTLS
+      }
     #endif /* HAVE_GNUTLS */
       ebb_connection_reset_timeout(connection);
       ebb_request_parser_execute(&connection->parser, recv_buffer, recved);
       /* parse error? just drop the client. screw the 400 response */
       if(ebb_request_parser_has_error(&connection->parser)) goto error;
       return;
     error:
       ebb_connection_schedule_close(connection);
+    }
     /* Internal callback
      * called by connection->write_watcher
      */
     static void
     on_writable(struct ev_loop *loop, ev_io *watcher, int revents)
+    {
       ebb_connection *connection = watcher->data;
       ssize_t sent;
       //printf("on_writable\n");
       assert(CONNECTION_HAS_SOMETHING_TO_WRITE);
       assert(connection->written <= connection->to_write_len);
       // TODO -- why is this broken?
       //assert(ev_is_active(&connection->timeout_watcher));
       assert(watcher == &connection->write_watcher);
       if(connection->to_write == 0)
         goto stop_writing;
     #ifdef HAVE_GNUTLS
       assert(!ev_is_active(&connection->handshake_watcher));
       if(connection->server->secure) {
         sent = gnutls_record_send( connection->session
                                  , connection->to_write + connection->written
                                  , connection->to_write_len - connection->written
                                  );
         if(sent < 0) {
           if(gnutls_error_is_fatal(sent)) goto error;
           if( (sent == GNUTLS_E_INTERRUPTED || sent == GNUTLS_E_AGAIN)
            && GNUTLS_NEED_READ
             ) ev_io_stop(loop, watcher);
           return;
+        }
       } else {
     #endif /* HAVE_GNUTLS */
         sent = nosigpipe_push( (void*)connection->fd
                              , connection->to_write + connection->written
                              , connection->to_write_len - connection->written
                              );
         if(sent < 0) goto error;
         if(sent == 0) return;
     #ifdef HAVE_GNUTLS
+      }
     #endif /* HAVE_GNUTLS */
       ebb_connection_reset_timeout(connection);
       connection->written += sent;
       if(connection->written == connection->to_write_len) {
         goto stop_writing;
+      }
       return;
     stop_writing:
       ev_io_stop(loop, watcher);
       connection->to_write = NULL;
       if(connection->after_write_cb)
         connection->after_write_cb(connection);
       return;
     error:
       error("close connection on write.");
       ebb_connection_schedule_close(connection);
+    }
     #ifdef HAVE_GNUTLS
     static void
     on_goodbye_tls(struct ev_loop *loop, ev_io *watcher, int revents)
+    {
       ebb_connection *connection = watcher->data;
       assert(watcher == &connection->goodbye_tls_watcher);
       if(EV_ERROR & revents) {
         error("on_goodbye() got error event, closing connection.");
         goto die;
+      }
       int r = gnutls_bye(connection->session, GNUTLS_SHUT_RDWR);
       if(r < 0) {
         if(gnutls_error_is_fatal(r)) goto die;
         if(r == GNUTLS_E_INTERRUPTED || r == GNUTLS_E_AGAIN)
           ev_io_set( watcher
                    , connection->fd
                    , (GNUTLS_NEED_WRITE ? EV_WRITE : EV_READ)
                    );
         return;
+      }
     die:
       ev_io_stop(loop, watcher);
       if(connection->session)
         gnutls_deinit(connection->session);
       close_connection(connection);
+    }
     #endif /* HAVE_GNUTLS*/
     static void
     on_goodbye(struct ev_loop *loop, ev_timer *watcher, int revents)
+    {
       ebb_connection *connection = watcher->data;
       assert(watcher == &connection->goodbye_watcher);
       close_connection(connection);
+    }
     static ebb_request*
     new_request_wrapper(void *data)
+    {
       ebb_connection *connection = data;
       if(connection->new_request)
         return connection->new_request(connection);
       return NULL;
+    }
     /* Internal callback
      * Called by server->connection_watcher.
      */
     static void
     on_connection(struct ev_loop *loop, ev_io *watcher, int revents)
+    {
       ebb_server *server = watcher->data;
       //printf("on connection!\n");
       assert(server->listening);
       assert(server->loop == loop);
       assert(&server->connection_watcher == watcher);
       if(EV_ERROR & revents) {
         error("on_connection() got error event, closing server.");
         ebb_server_unlisten(server);
         return;
+      }
       struct sockaddr_in addr; // connector's address information
       socklen_t addr_len = sizeof(addr);
       int fd = accept( server->fd
                      , (struct sockaddr*) & addr
                      , & addr_len
                      );
       if(fd < 0) {
         perror("accept()");
         return;
+      }
       ebb_connection *connection = NULL;
       if(server->new_connection)
         connection = server->new_connection(server, &addr);
       if(connection == NULL) {
         close(fd);
         return;
+      }
       set_nonblock(fd);
       connection->fd = fd;
       connection->open = TRUE;
       connection->server = server;
       memcpy(&connection->sockaddr, &addr, addr_len);
       if(server->port[0] != '\0')
         connection->ip = inet_ntoa(connection->sockaddr.sin_addr);
     #ifdef SO_NOSIGPIPE
       int arg = 1;
       setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &arg, sizeof(int));
     #endif
     #ifdef HAVE_GNUTLS
       if(server->secure) {
         gnutls_init(&connection->session, GNUTLS_SERVER);
         gnutls_transport_set_lowat(connection->session, 0);
         gnutls_set_default_priority(connection->session);
         gnutls_credentials_set(connection->session, GNUTLS_CRD_CERTIFICATE, connection->server->credentials);
         gnutls_transport_set_ptr(connection->session, (gnutls_transport_ptr) fd);
         gnutls_transport_set_push_function(connection->session, nosigpipe_push);
         gnutls_db_set_ptr (connection->session, &server->session_cache);
         gnutls_db_set_store_function (connection->session, session_cache_store);
         gnutls_db_set_retrieve_function (connection->session, session_cache_retrieve);
         gnutls_db_set_remove_function (connection->session, session_cache_remove);
+      }
       ev_io_set(&connection->handshake_watcher, connection->fd, EV_READ | EV_WRITE);
     #endif /* HAVE_GNUTLS */
       /* Note: not starting the write watcher until there is data to be written */
       ev_io_set(&connection->write_watcher, connection->fd, EV_WRITE);
       ev_io_set(&connection->read_watcher, connection->fd, EV_READ);
       /* XXX: seperate error watcher? */
       ev_timer_again(loop, &connection->timeout_watcher);
     #ifdef HAVE_GNUTLS
       if(server->secure) {
         ev_io_start(loop, &connection->handshake_watcher);
         return;
+      }
     #endif
       ev_io_start(loop, &connection->read_watcher);
+    }
     /**
      * Begin the server listening on a file descriptor.  This DOES NOT start the
      * event loop.  Start the event loop after making this call.
      */
     int
     ebb_server_listen_on_fd(ebb_server *server, const int fd)
+    {
       assert(server->listening == FALSE);
       if (listen(fd, EBB_MAX_CONNECTIONS) < 0) {
         perror("listen()");
         return -1;
+      }
       set_nonblock(fd); /* XXX superfluous? */
       server->fd = fd;
       server->listening = TRUE;
       ev_io_set (&server->connection_watcher, server->fd, EV_READ);
       ev_io_start (server->loop, &server->connection_watcher);
       return server->fd;
+    }
     /**
      * Begin the server listening on a file descriptor This DOES NOT start the
      * event loop. Start the event loop after making this call.
      */
     int
     ebb_server_listen_on_port(ebb_server *server, const int port)
+    {
       int fd = -1;
       struct linger ling = {0, 0};
       struct sockaddr_in addr;
       int flags = 1;
       if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
         perror("socket()");
         goto error;
+      }
       flags = 1;
       setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags));
       setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&flags, sizeof(flags));
       setsockopt(fd, SOL_SOCKET, SO_LINGER, (void *)&ling, sizeof(ling));
       /* XXX: Sending single byte chunks in a response body? Perhaps there is a
        * need to enable the Nagel algorithm dynamically. For now disabling.
        */
       setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags));
       /* the memset call clears nonstandard fields in some impementations that
        * otherwise mess things up.
        */
       memset(&addr, 0, sizeof(addr));
       addr.sin_family = AF_INET;
       addr.sin_port = htons(port);
       addr.sin_addr.s_addr = htonl(INADDR_ANY);
       if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
         perror("bind()");
         goto error;
+      }
       int ret = ebb_server_listen_on_fd(server, fd);
       if (ret >= 0) {
         sprintf(server->port, "%d", port);
+      }
       return ret;
     error:
       if(fd > 0) close(fd);
       return -1;
+    }
     /**
      * Stops the server. Will not accept new connections.  Does not drop
      * existing connections.
      */
     void
     ebb_server_unlisten(ebb_server *server)
+    {
       if(server->listening) {
         ev_io_stop(server->loop, &server->connection_watcher);
         close(server->fd);
         server->port[0] = '\0';
         server->listening = FALSE;
+      }
+    }
     /**
      * Initialize an ebb_server structure.  After calling ebb_server_init set
      * the callback server->new_connection and, optionally, callback data
      * server->data.  The new connection MUST be initialized with
      * ebb_connection_init before returning it to the server.
+     *
      * @param server the server to initialize
      * @param loop a libev loop
      */
     void
     ebb_server_init(ebb_server *server, struct ev_loop *loop)
+    {
       server->loop = loop;
       server->listening = FALSE;
       server->port[0] = '\0';
       server->fd = -1;
       server->connection_watcher.data = server;
       ev_init (&server->connection_watcher, on_connection);
       server->secure = FALSE;
     #ifdef HAVE_GNUTLS
       rbtree_init(&server->session_cache, session_cache_compare);
       server->credentials = NULL;
     #endif
       server->new_connection = NULL;
       server->data = NULL;
+    }
     #ifdef HAVE_GNUTLS
     /* similar to server_init.
+     *
      * the user of secure server might want to set additional callbacks from
      * GNUTLS. In particular
      * gnutls_global_set_mem_functions()
      * gnutls_global_set_log_function()
      * Also see the note above ebb_connection_init() about setting gnutls cache
      * access functions
+     *
      * cert_file: the filename of a PEM certificate file
+     *
      * key_file: the filename of a private key. Currently only PKCS-1 encoded
      * RSA and DSA private keys are accepted.
      */
     int
     ebb_server_set_secure (ebb_server *server, const char *cert_file, const char *key_file)
+    {
       server->secure = TRUE;
       gnutls_global_init();
       gnutls_certificate_allocate_credentials(&server->credentials);
       /* todo gnutls_certificate_free_credentials */
       int r = gnutls_certificate_set_x509_key_file( server->credentials
                                                   , cert_file
                                                   , key_file
                                                   , GNUTLS_X509_FMT_PEM
                                                   );
       if(r < 0) {
         error("loading certificates");
         return -1;
+      }
       return 1;
+    }
     #endif /* HAVE_GNUTLS */
     /**
      * Initialize an ebb_connection structure. After calling this function you
      * must setup callbacks for the different actions the server can take. See
      * server.h for which callbacks are availible.
+     *
      * This should be called immediately after allocating space for a new
      * ebb_connection structure. Most likely, this will only be called within
      * the ebb_server->new_connection callback which you supply.
+     *
      * If using SSL do consider setting
      *   gnutls_db_set_retrieve_function (connection->session, _);
      *   gnutls_db_set_remove_function (connection->session, _);
      *   gnutls_db_set_store_function (connection->session, _);
      *   gnutls_db_set_ptr (connection->session, _);
      * To provide a better means of storing SSL session caches. libebb provides
      * only a simple default implementation.
+     *
      * @param connection the connection to initialize
      * @param timeout    the timeout in seconds
      */
     void
     ebb_connection_init(ebb_connection *connection)
+    {
       connection->fd = -1;
       connection->server = NULL;
       connection->ip = NULL;
       connection->open = FALSE;
       ebb_request_parser_init( &connection->parser );
       connection->parser.data = connection;
       connection->parser.new_request = new_request_wrapper;
       ev_init (&connection->write_watcher, on_writable);
       connection->write_watcher.data = connection;
       connection->to_write = NULL;
       ev_init(&connection->read_watcher, on_readable);
       connection->read_watcher.data = connection;
     #ifdef HAVE_GNUTLS
       connection->handshake_watcher.data = connection;
       ev_init(&connection->handshake_watcher, on_handshake);
       ev_init(&connection->goodbye_tls_watcher, on_goodbye_tls);
       connection->goodbye_tls_watcher.data = connection;
       connection->session = NULL;
     #endif /* HAVE_GNUTLS */
       ev_timer_init(&connection->goodbye_watcher, on_goodbye, 0., 0.);
       connection->goodbye_watcher.data = connection;
       ev_timer_init(&connection->timeout_watcher, on_timeout, 0., EBB_DEFAULT_TIMEOUT);
       connection->timeout_watcher.data = connection;
       connection->new_request = NULL;
       connection->on_timeout = NULL;
       connection->on_close = NULL;
       connection->data = NULL;
+    }
     void
     ebb_connection_schedule_close (ebb_connection *connection)
+    {
     #ifdef HAVE_GNUTLS
       if(connection->server->secure) {
         ev_io_set(&connection->goodbye_tls_watcher, connection->fd, EV_READ | EV_WRITE);
         ev_io_start(connection->server->loop, &connection->goodbye_tls_watcher);
         return;
+      }
     #endif
       ev_timer_start(connection->server->loop, &connection->goodbye_watcher);
+    }
     /*
      * Resets the timeout to stay alive for another connection->timeout seconds
      */
     void
     ebb_connection_reset_timeout(ebb_connection *connection)
+    {
       ev_timer_again(connection->server->loop, &connection->timeout_watcher);
+    }
     /**
      * Writes a string to the socket. This is actually sets a watcher
      * which may take multiple iterations to write the entire string.
+     *
      * This can only be called once at a time. If you call it again
      * while the connection is writing another buffer the ebb_connection_write
      * will return FALSE and ignore the request.
      */
     int
     ebb_connection_write (ebb_connection *connection, const char *buf, size_t len, ebb_after_write_cb cb)
+    {
       if(ev_is_active(&connection->write_watcher))
         return FALSE;
       assert(!CONNECTION_HAS_SOMETHING_TO_WRITE);
       connection->to_write = buf;
       connection->to_write_len = len;
       connection->written = 0;
       connection->after_write_cb = cb;
       ev_io_start(connection->server->loop, &connection->write_watcher);
       return TRUE;
+    }

     /* This file is part of libebb.
+     *
      * Copyright (c) 2008 Ryan Dahl (ry@ndahl.us)
      * All rights reserved.
+     *
      * 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_H
     #define EBB_H
     #include <sys/socket.h>
     #include <netinet/in.h>
     #include <ev.h>
     #ifdef HAVE_GNUTLS
     # include <gnutls/gnutls.h>
     # include "rbtree.h" /* for ebb_server.session_cache */
     #endif
     #include "ebb_request_parser.h"
     #define EBB_MAX_CONNECTIONS 1024
     #define EBB_DEFAULT_TIMEOUT 30.0
     #define EBB_AGAIN 0
     #define EBB_STOP 1
     typedef struct ebb_server     ebb_server;
     typedef struct ebb_connection ebb_connection;
     typedef void (*ebb_after_write_cb) (ebb_connection *connection);
     typedef void (*ebb_connection_cb)(ebb_connection *connection, void *data);
     struct ebb_server {
       int fd;                                       /* ro */
       struct sockaddr_in sockaddr;                  /* ro */
       socklen_t socklen;                            /* ro */
       char port[6];                                 /* ro */
       struct ev_loop *loop;                         /* ro */
       unsigned listening:1;                         /* ro */
       unsigned secure:1;                            /* ro */
     #ifdef HAVE_GNUTLS
       gnutls_certificate_credentials_t credentials; /* private */
       struct rbtree_t session_cache;                /* private */
     #endif
       ev_io connection_watcher;                     /* private */
       /* Public */
       /* Allocates and initializes an ebb_connection.  NULL by default. */
       ebb_connection* (*new_connection) (ebb_server*, struct sockaddr_in*);
       void *data;
     };
     struct ebb_connection {
       int fd;                      /* ro */
       struct sockaddr_in sockaddr; /* ro */
       socklen_t socklen;           /* ro */
       ebb_server *server;          /* ro */
       char *ip;                    /* ro */
       unsigned open:1;             /* ro */
       const char *to_write;              /* ro */
       size_t to_write_len;               /* ro */
       size_t written;                    /* ro */
       ebb_after_write_cb after_write_cb; /* ro */
       ebb_request_parser parser;   /* private */
       ev_io write_watcher;         /* private */
       ev_io read_watcher;          /* private */
       ev_timer timeout_watcher;    /* private */
       ev_timer goodbye_watcher;    /* private */
     #ifdef HAVE_GNUTLS
       ev_io handshake_watcher;     /* private */
       gnutls_session_t session;    /* private */
       ev_io goodbye_tls_watcher;       /* private */
     #endif
       /* Public */
       ebb_request* (*new_request) (ebb_connection*);
       /* Returns EBB_STOP or EBB_AGAIN. NULL by default.  */
       int (*on_timeout) (ebb_connection*);
       void (*on_close) (ebb_connection*);
       void *data;
     };
     void ebb_server_init (ebb_server *server, struct ev_loop *loop);
     #ifdef HAVE_GNUTLS
     int ebb_server_set_secure (ebb_server *server, const char *cert_file,
                                const char *key_file);
     #endif
     int ebb_server_listen_on_port (ebb_server *server, const int port);
     int ebb_server_listen_on_fd (ebb_server *server, const int sfd);
     void ebb_server_unlisten (ebb_server *server);
     void ebb_connection_init (ebb_connection *);
     void ebb_connection_schedule_close (ebb_connection *);
     void ebb_connection_reset_timeout (ebb_connection *);
     int ebb_connection_write (ebb_connection *, const char *buf, size_t len, ebb_after_write_cb);
     #endif

     /* 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

     /* 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(parser->FOR##_mark && CURRENT->on_##FOR) {     \
         CURRENT->on_##FOR( CURRENT                      \
                     , parser->FOR##_mark                \
                     , p - parser->FOR##_mark            \
                     );                                  \
+     }
     #define HEADER_CALLBACK(FOR)                        \
       if(parser->FOR##_mark && CURRENT->on_##FOR) {     \
         CURRENT->on_##FOR( CURRENT                      \
                     , parser->FOR##_mark                \
                     , p - parser->FOR##_mark            \
                     , CURRENT->number_of_headers        \
                     );                                  \

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff