ebb 0.0.2 → 0.0.3

data/README

@@ -74,10 +74,8 @@ allows Ebb to continue to process other clients while the upload is in
 progress. The cliff at 40k here is because Ebb's internal request
 buffer is set at 40 kilobytes before it writes to file.
 
-
 ## Contributions
 
-
 Contributions (patches, criticism, advice) are very welcome! The source code
 is hosted at [repo.or.cz](http://repo.or.cz/w/ebb.git). It can be retrieved 
 by executing
@@ -86,9 +84,9 @@ by executing
 
 I intend to keep the C code base very small, so do email me before writing any
 large additions. Here are some features that I would like to add:
-
-* Multipart parser
-* Streaming responses
+* Streaming responses!
+* HTTP 1.1 Expect/Continue (RFC 2616, sections 8.2.3 and 10.1.1)
+* A parser for multipart/form-data
 * Optimize and clean up upload handling
 * Option to listen on unix sockets instead of TCP
 * Python binding

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/bin/ebb_rails

@@ -15,9 +15,7 @@ options = {
   :env      => 'development',
   :hort     => '0.0.0.0',
   :port     => 3000,
-  :timeout  => 60,
-  :log_file => 'log/ebb.log',
-  :pid_file => 'tmp/pids/ebb.pid'
+  :timeout  => 60
 }
 
 
@@ -27,20 +25,16 @@ opts = OptionParser.new do |opts|
   opts.separator ""
   opts.separator "Server options:"
 
-  opts.on("-s", "--socket SOCKET", "listen on socket")                   { |socket| options[:socket] = socket }
+#  opts.on("-s", "--socket SOCKET", "listen on socket")                   { |socket| options[:socket] = socket }
   opts.on("-p", "--port PORT", "use PORT (default: 3000)")               { |port| options[:port] = port }
   opts.on("-e", "--env ENV", "Rails environment (default: development)") { |env| options[:env] = env }
   opts.on("-c", "--chdir PATH", "Rails root dir (default: current dir)") { |dir| options[:root] = dir }
   opts.on("-d", "--daemonize", "Daemonize")                              { options[:daemonize] = true }
-  opts.on("-l", "--log-file FILE", "File to redirect output",
-                                   "(default: #{options[:log_file]})")   { |file| options[:log_file] = file }
-  opts.on("-P", "--pid-file FILE", "File to store PID",
-                                   "(default: #{options[:pid_file]})")   { |file| options[:pid_file] = file }
+  opts.on("-l", "--log-file FILE", "File to redirect output")            { |file| options[:log_file] = file }
+  opts.on("-P", "--pid-file FILE", "File to store PID")                  { |file| options[:pid_file] = file }
   opts.on("-t", "--timeout SEC", "Request or command timeout in sec",    
-                                 "(default: #{options[:timeout]})")      { |sec| options[:timeout] = sec; raise NotImplementedError } # TODO: fix me
-  opts.on("-u", "--user NAME", "User to run daemon as (use with -g)")    { |user| options[:user] = user }
-  opts.on("-g", "--group NAME", "Group to run daemon as (use with -u)")  { |group| options[:group] = group }
-  
+                                 "(default: #{options[:timeout]})")      { |sec| options[:timeout] = sec }
+ 
   opts.separator ""
   opts.separator "Common options:"
 
@@ -65,13 +59,10 @@ when 'start'
   
   server.pid_file = options[:pid_file]
   server.log_file = options[:log_file]
-  # server.timeout  = options[:timeout]
+  server.timeout  = options[:timeout]
+  
+  server.daemonize if options[:daemonize]
   
-  if options[:daemonize]
-    server.change_privilege options[:user], options[:group] if options[:user] && options[:group]
-    server.daemonize
-  end
-
   server.start
 
 when 'stop'

data/ruby_lib/daemonizable.rb

@@ -1,5 +1,4 @@
-# Copyright (c) 2007 Marc-André Cournoyer
-require 'etc'
+# Simplified version of Thin::Daemonizable by Marc-André Cournoyer
 
 module Kernel
   unless respond_to? :daemonize # Already part of Ruby 1.9, yeah!
@@ -29,27 +28,13 @@ module Process
   module_function :running?
 end
 
-# Module included in classes that can be turned into a daemon.
+# Moadule included in classes that can be turned into a daemon.
 # Handle stuff like:
 # * storing the PID in a file
 # * redirecting output to the log file
-# * changing processs privileges
 # * killing the process gracefully
 module Daemonizable
-  attr_accessor :pid_file, :log_file
-  
-  def self.included(base)
-    base.extend ClassMethods
-  end
-  
-  def daemonizable_init(options)
-    pid_file = options[:pid_file]
-    log_file = options[:log_file]
-    if options[:daemonize]
-      change_privilege options[:user], options[:group] if options[:user] && options[:group]
-      daemonize
-    end
-  end
+  attr_accessor :pid_file, :log_file, :timeout
   
   def pid
     File.exist?(pid_file) ? open(pid_file).read : nil
@@ -60,11 +45,11 @@ module Daemonizable
     raise ArgumentError, 'You must specify a pid_file to deamonize' unless @pid_file
     
     pwd = Dir.pwd # Current directory is changed during daemonization, so store it
-    super         # Calls Kernel#daemonize
+    Kernel.daemonize 
     Dir.chdir pwd
     
     trap('HUP', 'IGNORE') # Don't die upon logout
-
+    
     # Redirect output to the logfile
     [STDOUT, STDERR].each { |f| f.reopen @log_file, 'a' } if @log_file
     
@@ -75,60 +60,39 @@ module Daemonizable
     end
   end
   
-  # Change privileges of the process
-  # to the specified user and group.
-  def change_privilege(user, group=user)
-    log ">> Changing process privilege to #{user}:#{group}"
-    
-    uid, gid = Process.euid, Process.egid
-    target_uid = Etc.getpwnam(user).uid
-    target_gid = Etc.getgrnam(group).gid
-
-    if uid != target_uid || gid != target_gid
-      # Change process ownership
-      Process.initgroups(user, target_gid)
-      Process::GID.change_privilege(target_gid)
-      Process::UID.change_privilege(target_uid)
-    end
-  rescue Errno::EPERM => e
-    log "Couldn't change user and group to #{user}:#{group}: #{e}"
-  end
-  
-  module ClassMethods
-    # Kill the process which PID is stored in +pid_file+.
-    def kill(pid_file, timeout=60)
-      if pid = open(pid_file).read
-        pid = pid.to_i
-        print "Sending INT signal to process #{pid} ... "
-        begin
-          Process.kill('INT', pid)
-          Timeout.timeout(timeout) do
-            sleep 0.1 while Process.running?(pid)
-          end
-        rescue Timeout::Error
-          print "timeout, Sending KILL signal ... "
-          Process.kill('KILL', pid)
+  # Kill the process which PID is stored in +pid_file+.
+  def self.kill(pid_file, timeout=60)
+    if pid = open(pid_file).read
+      pid = pid.to_i
+      print "Sending INT signal to process #{pid} ... "
+      begin
+        Process.kill('INT', pid)
+        Timeout.timeout(timeout) do
+          sleep 0.1 while Process.running?(pid)
         end
-        puts "stopped!"
-      else
-        puts "Can't stop process, no PID found in #{@pid_file}"
+      rescue Timeout::Error
+        print "timeout, Sending KILL signal ... "
+        Process.kill('KILL', pid)
       end
-    rescue Errno::ESRCH # No such process
-      puts "process not found!"
-    ensure
-      File.delete(pid_file) rescue nil
+      puts "stopped!"
+    else
+      puts "Can't stop process, no PID found in #{@pid_file}"
     end
+  rescue Errno::ESRCH # No such process
+    puts "process not found!"
+  ensure
+    File.delete(pid_file) rescue nil
   end
   
   private
-    def remove_pid_file
-      File.delete(@pid_file) if @pid_file && File.exists?(@pid_file)
-    end
-
-    def write_pid_file
-      log ">> Writing PID to #{@pid_file}"
-      FileUtils.mkdir_p File.dirname(@pid_file)
-      open(@pid_file,"w") { |f| f.write(Process.pid) }
-      File.chmod(0644, @pid_file)
-    end
+  
+  def remove_pid_file
+    File.delete(@pid_file) if @pid_file && File.exists?(@pid_file)
+  end
+  
+  def write_pid_file
+    log ">> Writing PID to #{@pid_file}"
+    open(@pid_file,"w+") { |f| f.write(Process.pid) }
+    File.chmod(0644, @pid_file)
+  end
 end

data/ruby_lib/ebb.rb

@@ -39,6 +39,14 @@ module Ebb
     def write(data)
       FFI::client_write(self, data)
     end
+    
+    def write_status(status)
+      FFI::client_write_status(self, status.to_i, HTTP_STATUS_CODES[status])
+    end
+    
+    def write_header(field, value)
+      FFI::client_write_header(self, field.to_s, value.to_s)
+    end
   end
   
   class RequestBody
@@ -73,9 +81,6 @@ module Ebb
       @port = (options[:port] || 4001).to_i
       @timeout =  options[:timeout]
       @app = app
-      
-      daemonizable_init(options)
-      FFI::server_initialize(self)
     end
     
     def start
@@ -116,14 +121,15 @@ module Ebb
         body = "Internal Server Error\n"
       end
       
-      client.write "HTTP/1.1 %d %s\r\n" % [status, HTTP_STATUS_CODES[status]]
+      client.write_status(status)
       
       if body.respond_to? :length and status != 304
-        client.write "Connection: close\r\n"
+        headers['Connection'] = 'close'
         headers['Content-Length'] = body.length
       end
       
-      headers.each { |k, v| client.write "#{k}: #{v}\r\n" }
+      headers.each { |k, v| client.write_header(k,v) }
+      
       client.write "\r\n"
       
       # Not many apps use streaming yet so i'll hold off on that feature
@@ -135,6 +141,10 @@ module Ebb
       end
       client.finished
     end
+    
+    def log(msg)
+      puts msg
+    end
   end
   
   HTTP_STATUS_CODES = {  

data/src/ebb.c

@@ -1,6 +1,6 @@
-/* Ebb Web Server
- * Copyright (c) 2007 Ry Dahl
- * This software is released under the "MIT License". See README file for details.
+/* The Ebb Web Server
+ * Copyright (c) 2008 Ry Dahl. This software is released under the MIT 
+ * License. See README file for details.
  */
 #include <unistd.h>
 #include <fcntl.h>
@@ -32,54 +32,40 @@
 static int server_socket(const int port);
 static int server_socket_unix(const char *path, int access_mask);
 
-#define env_add(client, field,flen,value,vlen)                              \
-  client->env_fields[client->env_size] = field;                             \
-  client->env_field_lengths[client->env_size] = flen;                       \
-  client->env_values[client->env_size] = value;                             \
-  client->env_value_lengths[client->env_size] = vlen;                       \
-  client->env_size += 1;                                                     
-#define env_add_const(client,field,value,vlen)                              \
-  client->env_fields[client->env_size] = NULL;                              \
-  client->env_field_lengths[client->env_size] = field;                      \
-  client->env_values[client->env_size] = value;                             \
-  client->env_value_lengths[client->env_size] = vlen;                       \
-  client->env_size += 1;                                                     
-#define env_error(client)                                                   \
-  client->env_fields[client->env_size] = NULL;                              \
-  client->env_field_lengths[client->env_size] = -1;                         \
-  client->env_values[client->env_size] = NULL;                              \
-  client->env_value_lengths[client->env_size] = -1;                         \
-  client->env_size += 1;                                                     
-
-int env_has_error(ebb_client *client)
+void env_add(ebb_client *client, const char *field, int flen, const char *value, int vlen)
 {
-  int i;
-  for(i = 0; i < client->env_size; i++)
-    if(client->env_field_lengths[i] < 0)
-      return TRUE;
-  return FALSE;
+  if(client->env_size >= EBB_MAX_ENV) {
+    client->parser.overflow_error = TRUE;
+    return;
+  }
+  client->env[client->env_size].type = EBB_FIELD_VALUE_PAIR;
+  client->env[client->env_size].field = field;
+  client->env[client->env_size].field_length = flen;
+  client->env[client->env_size].value = value;
+  client->env[client->env_size].value_length = vlen;
+  client->env_size += 1;
 }
 
-/** Defines common length and error messages for input length validation. */
-#define DEF_MAX_LENGTH(N,length) const size_t MAX_##N##_LENGTH = length; const char *MAX_##N##_LENGTH_ERR = "HTTP Parse Error: HTTP element " # N  " is longer than the " # length " allowed length."
-
-/** Validates the max length of given input and throws an exception if over. */
-#define VALIDATE_MAX_LENGTH(len, N) if(len > MAX_##N##_LENGTH) { env_error(client); g_message(MAX_##N##_LENGTH_ERR); }
 
-/* Defines the maximum allowed lengths for various input elements.*/
-DEF_MAX_LENGTH(FIELD_NAME, 256);
-DEF_MAX_LENGTH(FIELD_VALUE, 80 * 1024);
-DEF_MAX_LENGTH(REQUEST_URI, 1024 * 12);
-DEF_MAX_LENGTH(FRAGMENT, 1024); /* Don't know if this length is specified somewhere or not */
-DEF_MAX_LENGTH(REQUEST_PATH, 1024);
-DEF_MAX_LENGTH(QUERY_STRING, (1024 * 10));
-DEF_MAX_LENGTH(HEADER, (1024 * (80 + 32)));
+void env_add_const(ebb_client *client, int type, const char *value, int vlen)
+{
+  if(client->env_size >= EBB_MAX_ENV) {
+    client->parser.overflow_error = TRUE;
+    return;
+  }
+  client->env[client->env_size].type = type;
+  client->env[client->env_size].field = NULL;
+  client->env[client->env_size].field_length = -1;
+  client->env[client->env_size].value = value;
+  client->env[client->env_size].value_length = vlen;
+  client->env_size += 1;
+}
 
 void http_field_cb(void *data, const char *field, size_t flen, const char *value, size_t vlen)
 {
   ebb_client *client = (ebb_client*)(data);
-  VALIDATE_MAX_LENGTH(flen, FIELD_NAME);
-  VALIDATE_MAX_LENGTH(vlen, FIELD_VALUE);
+  assert(field != NULL);
+  assert(value != NULL);
   env_add(client, field, flen, value, vlen);
 }
 
@@ -94,7 +80,6 @@ void request_method_cb(void *data, const char *at, size_t length)
 void request_uri_cb(void *data, const char *at, size_t length)
 {
   ebb_client *client = (ebb_client*)(data);
-  VALIDATE_MAX_LENGTH(length, REQUEST_URI);
   env_add_const(client, EBB_REQUEST_URI, at, length);
 }
 
@@ -102,7 +87,6 @@ void request_uri_cb(void *data, const char *at, size_t length)
 void fragment_cb(void *data, const char *at, size_t length)
 {
   ebb_client *client = (ebb_client*)(data);
-  VALIDATE_MAX_LENGTH(length, FRAGMENT);
   env_add_const(client, EBB_FRAGMENT, at, length);
 }
 
@@ -110,7 +94,6 @@ void fragment_cb(void *data, const char *at, size_t length)
 void request_path_cb(void *data, const char *at, size_t length)
 {
   ebb_client *client = (ebb_client*)(data);
-  VALIDATE_MAX_LENGTH(length, REQUEST_PATH);
   env_add_const(client, EBB_REQUEST_PATH, at, length);
 }
 
@@ -118,7 +101,6 @@ void request_path_cb(void *data, const char *at, size_t length)
 void query_string_cb(void *data, const char *at, size_t length)
 {
   ebb_client *client = (ebb_client*)(data);
-  VALIDATE_MAX_LENGTH(length, QUERY_STRING);
   env_add_const(client, EBB_QUERY_STRING, at, length);
 }
 
@@ -246,6 +228,7 @@ void* read_body_into_file(void *_client)
   }
   rewind(tmpfile);
   // g_debug("%d bytes written to file %s", written, client->upload_file_filename);
+  dispatch(client);
   return NULL;
 error:
   ebb_client_close(client);
@@ -264,15 +247,17 @@ void on_readable(struct ev_loop *loop, ev_io *watcher, int revents)
   
   ssize_t read = recv( client->fd
                      , client->request_buffer + client->read
-                     , EBB_BUFFERSIZE - client->read - 1 /* -1 is for making ragel happy below */
+                     , EBB_BUFFERSIZE - client->read
                      , 0
                      );
-  if(read <= 0) goto error; /* XXX is this the right action to take for read==0 ? */
+  if(read < 0) goto error; /* XXX is this the right action to take for read==0 ? */
+  if(read == 0) return;
   client->read += read;
   ev_timer_again(loop, &client->timeout_watcher);
   
+  if(client->read == EBB_BUFFERSIZE) goto error;
+  
   if(FALSE == client_finished_parsing) {
-    client->request_buffer[client->read] = '\0'; /* make ragel happy */
     http_parser_execute( &client->parser
                        , client->request_buffer
                        , client->read
@@ -281,21 +266,21 @@ void on_readable(struct ev_loop *loop, ev_io *watcher, int revents)
     if(http_parser_has_error(&client->parser)) goto error;
   }
   
-  if(total_request_size == client->read) {
-    ev_io_stop(loop, watcher);
-    client->nread_from_body = 0;
-    dispatch(client);
-    return;
-  }
-  
-  if(client_finished_parsing && total_request_size > EBB_BUFFERSIZE ) {
-    /* read body into file - in a thread */
-    pthread_t thread;
-    ev_io_stop(loop, watcher);
-    assert(0 <= pthread_create(&thread, NULL, read_body_into_file, client));
-    pthread_join(thread, NULL);
-    dispatch(client);
-    return;
+  if(client_finished_parsing) {
+    if(total_request_size == client->read) {
+      ev_io_stop(loop, watcher);
+      client->nread_from_body = 0;
+      dispatch(client);
+      return;
+    }
+    if(total_request_size > EBB_BUFFERSIZE ) {
+      /* read body into file - in a thread */
+      ev_io_stop(loop, watcher);
+      pthread_t thread;
+      assert(0 <= pthread_create(&thread, NULL, read_body_into_file, client));
+      pthread_detach(thread);
+      return;
+    }
   }
   return;
 error:
@@ -338,7 +323,12 @@ void on_request(struct ev_loop *loop, ev_io *watcher, int revents)
   for(i = 0; i < EBB_MAX_CLIENTS; i++)
     if(server->clients[i].open) count += 1;
   g_debug("%d open connections", count);
+  
+  /* does ragel fuck up if request buffer isn't null? */
+  for(i=0; i< EBB_BUFFERSIZE; i++)
+    client->request_buffer[i] = 'A';
 #endif
+  
   client->open = TRUE;
   client->server = server;
   
@@ -362,11 +352,16 @@ void on_request(struct ev_loop *loop, ev_io *watcher, int revents)
   client->parser.content_length = content_length_cb;
   
   /* OTHER */
+
   client->env_size = 0;
   client->read = client->nread_from_body = 0;
   client->response_buffer->len = 0; /* see note in ebb_client_close */
   client->content_length = 0;
   
+  client->status_sent = FALSE;
+  client->headers_sent = FALSE;
+  client->body_sent = FALSE;
+  
   /* SETUP READ AND TIMEOUT WATCHERS */
   client->read_watcher.data = client;
   ev_init(&client->read_watcher, on_readable);
@@ -426,11 +421,8 @@ void ebb_server_free(ebb_server *server)
 void ebb_server_unlisten(ebb_server *server)
 {
   if(server->open) {
-    //g_message("Stopping Ebb server");
     int i;
     ebb_client *client;
-    //for(i=0; i < EBB_MAX_CLIENTS; i++)
-    //  ebb_client_close(client);
     ev_io_stop(server->loop, &server->request_watcher);
     close(server->fd);
     if(server->socketpath)
@@ -538,6 +530,27 @@ void on_client_writable(struct ev_loop *loop, ev_io *watcher, int revents)
     ebb_client_close(client);
 }
 
+void ebb_client_write_status(ebb_client *client, int status, const char *human_status)
+{
+  assert(client->status_sent == FALSE);
+  g_string_append_printf( client->response_buffer
+                        , "HTTP/1.1 %d %s\r\n"
+                        , status
+                        , human_status
+                        );
+  client->status_sent = TRUE;
+}
+
+void ebb_client_write_header(ebb_client *client, const char *field, const char *value)
+{
+  assert(client->status_sent == TRUE);
+  assert(client->headers_sent == FALSE);
+  g_string_append_printf( client->response_buffer
+                        , "%s: %s\r\n"
+                        , field
+                        , value
+                        );
+}
 
 void ebb_client_write(ebb_client *client, const char *data, int length)
 {
@@ -705,5 +718,4 @@ static int server_socket_unix(const char *path, int access_mask) {
         return -1;
     }
     return sfd;
-}
-
+}