rev 0.2.4 → 0.3.0

data/lib/rev/http_client.rb

@@ -145,7 +145,7 @@ module Rev
       @parser_nbytes = 0
 
       @state = :response_header
-      @data = Rev::Buffer.new
+      @data = ::IO::Buffer.new
 
       @response_header = HttpResponseHeader.new
       @chunk_header = HttpChunkHeader.new

data/lib/rev/io.rb

@@ -21,7 +21,7 @@ module Rev
 
     def initialize(io)
       @_io = io
-      @_write_buffer  ||= Rev::Buffer.new
+      @_write_buffer  ||= ::IO::Buffer.new
       @_read_watcher  = Watcher.new(io, self, :r)
       @_write_watcher = Watcher.new(io, self, :w)
     end

data/lib/rev/listener.rb

@@ -15,7 +15,12 @@ module Rev
       @listen_socket = listen_socket
       super(@listen_socket)
     end
-    
+
+    # Returns an integer representing the underlying numeric file descriptor
+    def fileno
+      @listen_socket.fileno
+    end
+
     # Close the listener
     def close
       detach if attached?
@@ -49,11 +54,19 @@ module Rev
     #  :backlog - Max size of the pending connection queue (default 1024)
     #  :reverse_lookup - Retain BasicSocket's reverse DNS functionality (default false)
     #
-    def initialize(addr, port, options = {})
+    # If the specified address is an TCPServer object, it will ignore
+    # the port and :backlog option and create a new Rev::TCPListener out
+    # of the existing TCPServer object.
+    def initialize(addr, port = nil, options = {})
       BasicSocket.do_not_reverse_lookup = true unless options[:reverse_lookup]
       options[:backlog] ||= DEFAULT_BACKLOG
       
-      listen_socket = ::TCPServer.new(addr, port)
+      listen_socket = if ::TCPServer === addr
+        addr
+      else
+        raise ArgumentError, "port must be an integer" if nil == port
+        ::TCPServer.new(addr, port)
+      end
       listen_socket.instance_eval { listen(options[:backlog]) }
       super(listen_socket)
     end
@@ -63,8 +76,10 @@ module Rev
     # Create a new Rev::UNIXListener
     #
     # Accepts the same arguments as UNIXServer.new
+    # Optionally, it can also take anyn existing UNIXServer object
+    # and create a Rev::UNIXListener out of it.
     def initialize(*args)
-      super(::UNIXServer.new(*args))
+      super(::UNIXServer === args.first ? args.first : ::UNIXServer.new(*args))
     end
   end
 end

data/lib/rev/server.rb

@@ -27,6 +27,11 @@ module Rev
       super(listen_socket)
     end
 
+    # Returns an integer representing the underlying numeric file descriptor
+    def fileno
+      @listen_socket.fileno
+    end
+
     #########
     protected
     #########
@@ -41,9 +46,16 @@ module Rev
   # TCP server class.  Listens on the specified host and port and creates
   # new connection objects of the given class. This is the most common server class.
   # Note that the new connection objects will be bound by default to the same event loop that the server is attached to.
+  # Optionally, it can also take any existing core TCPServer object as
+  # +host+ and create a Rev::TCPServer out of it.
   class TCPServer < Server
-    def initialize(host, port, klass = TCPSocket, *args, &block)
-      listen_socket = ::TCPServer.new(host, port)
+    def initialize(host, port = nil, klass = TCPSocket, *args, &block)
+      listen_socket = if ::TCPServer === host
+        host
+      else
+        raise ArgumentError, "port must be an integer" if nil == port
+        ::TCPServer.new(host, port)
+      end
       listen_socket.instance_eval { listen(1024) } # Change listen backlog to 1024
       super(listen_socket, klass, *args, &block)
     end
@@ -51,9 +63,12 @@ module Rev
 
   # UNIX server class.  Listens on the specified UNIX domain socket and
   # creates new connection objects of the given class.
+  # Optionally, it can also take any existing core UNIXServer object as
+  # +path+ and create a Rev::UNIXServer out of it.
   class UNIXServer < Server
     def initialize(path, klass = UNIXSocket, *args, &block)
-      super(::UNIXServer.new(*args), klass, *args, &block)
+      s = ::UNIXServer === path ? path : ::UNIXServer.new(path)
+      super(s, klass, *args, &block)
     end
   end
 end

data/lib/rev/socket.rb

@@ -123,7 +123,7 @@ module Rev
     
     # Called by precreate during asyncronous DNS resolution
     def preinitialize(addr, port, *args)
-      @_write_buffer = Rev::Buffer.new # allow for writing BEFORE the DNS has resolved
+      @_write_buffer = ::IO::Buffer.new # allow for writing BEFORE the DNS has resolved
       @remote_host, @remote_addr, @remote_port = addr, addr, port
       @_resolver = TCPConnectResolver.new(self, addr, port, *args)
     end

data/lib/rev/ssl.rb

@@ -123,7 +123,12 @@ module Rev
     end
   end
   
-  # A socket class for SSL connections
+  # A socket class for SSL connections.  Please note that this class 
+  # internally uses the on_connect callback for doing SSL setup.  If
+  # you would like a callback when the SSL connection is completed,
+  # please use the on_ssl_connect callback instead.  If you really need
+  # a callback which fires before SSL setup begins, use on_connect but
+  # be sure to call super.
   class SSLSocket < TCPSocket
     # Perform a non-blocking connect to the given host and port
     def self.connect(addr, port, *args)

data/lib/revem.rb

@@ -1,9 +1,24 @@
 #--
-# Copyright (C)2007 Tony Arcieri, Roger Pack
+# Copyright (C)2007 Tony Arcieri
 # You can redistribute this under the terms of the Ruby license
 # See file LICENSE for details
 #++
 
+
+# This file creates a an EventMachine class
+# that is actually using rev as its underlying socket layer, but uses the EM API.
+# require it instead of eventmachine
+# i.e. 
+# require 'revem'
+# instead of
+# require 'eventmachine'
+# Note: you may want to do both a require 'eventmachine' THEN a require 'revem'
+# so that eventmachine is loaded once, then rev overrides it, then there's no require confusion 
+# (if simple servers hang, requiring 'eventmachine' after 'revem' could be the cause of it).
+# drawbacks: slightly slower than EM.
+# benefits: timers are more accurate using libev than using EM.  Also rev is sometimes more compatible than EM (ex: 1.9 windows)
+# TODO: some things like connection timeouts aren't implemented yet
+# DONE: timers and normal socket functions are implemented.
 require File.dirname(__FILE__) + '/rev'
 
 module EventMachine

data/rev.gemspec

@@ -2,16 +2,19 @@ require 'rubygems'
 
 GEMSPEC = Gem::Specification.new do |s|
   s.name = "rev"
-  s.version = "0.2.4"
+  s.version = "0.3.0"
   s.authors = "Tony Arcieri"
   s.email = "tony@medioh.com"
-  s.date = "2009-02-01"
+  s.date = "2009-08-26"
   s.summary = "Rev is a Ruby binding to the libev high performance event library"
   s.platform = Gem::Platform::RUBY
   s.required_ruby_version = '>= 1.8.6'
 
   # Gem contents
   s.files = Dir.glob("{lib,ext,examples}/**/*") + ['Rakefile', 'rev.gemspec']
+  
+  # Dependencies
+  s.add_dependency "iobuffer", ">= 0.1.0"
 
   # RubyForge info
   s.homepage = "http://rev.rubyforge.org"
@@ -19,8 +22,8 @@ GEMSPEC = Gem::Specification.new do |s|
 
   # RDoc settings
   s.has_rdoc = true
-  s.rdoc_options = %w(--title Rev --main README --line-numbers)
-  s.extra_rdoc_files = ["LICENSE", "README", "CHANGES"]
+  s.rdoc_options = %w(--title Rev --main README.textile --line-numbers)
+  s.extra_rdoc_files = ["LICENSE", "README.textile", "CHANGES"]
 
   # Extensions
   s.extensions = FileList["ext/**/extconf.rb"].to_a

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rev
 version: !ruby/object:Gem::Version 
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors: 
 - Tony Arcieri
@@ -9,10 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-01 00:00:00 -07:00
+date: 2009-08-26 00:00:00 -06:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: iobuffer
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+    version: 
 description: 
 email: tony@medioh.com
 executables: []
@@ -22,10 +31,9 @@ extensions:
 - ext/rev/extconf.rb
 extra_rdoc_files: 
 - LICENSE
-- README
+- README.textile
 - CHANGES
 files: 
-- lib/rev
 - lib/rev/async_watcher.rb
 - lib/rev/dns_resolver.rb
 - lib/rev/http_client.rb
@@ -40,14 +48,12 @@ files:
 - lib/rev/timer_watcher.rb
 - lib/rev.rb
 - lib/revem.rb
-- ext/http11_client
 - ext/http11_client/ext_help.h
 - ext/http11_client/extconf.rb
 - ext/http11_client/http11_client.c
 - ext/http11_client/http11_parser.c
 - ext/http11_client/http11_parser.h
 - ext/http11_client/http11_parser.rl
-- ext/libev
 - ext/libev/Changes
 - ext/libev/ev.c
 - ext/libev/ev.h
@@ -64,16 +70,15 @@ files:
 - ext/libev/README.embed
 - ext/libev/test_libev_win32.c
 - ext/libev/update_ev_wrap
-- ext/rev
 - ext/rev/ev_wrap.h
 - ext/rev/extconf.rb
 - ext/rev/libev.c
 - ext/rev/rev.h
-- ext/rev/rev_buffer.c
 - ext/rev/rev_ext.c
 - ext/rev/rev_io_watcher.c
 - ext/rev/rev_loop.c
 - ext/rev/rev_ssl.c
+- ext/rev/rev_stat_watcher.c
 - ext/rev/rev_timer_watcher.c
 - ext/rev/rev_utils.c
 - ext/rev/rev_watcher.c
@@ -85,16 +90,18 @@ files:
 - Rakefile
 - rev.gemspec
 - LICENSE
-- README
+- README.textile
 - CHANGES
 has_rdoc: true
 homepage: http://rev.rubyforge.org
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --title
 - Rev
 - --main
-- README
+- README.textile
 - --line-numbers
 require_paths: 
 - lib
@@ -113,9 +120,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rev
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Rev is a Ruby binding to the libev high performance event library
 test_files: []
 

data/ext/rev/rev_buffer.c

@@ -1,629 +0,0 @@
-/*
- * Copyright (C) 2007 Tony Arcieri
- * You may redistribute this under the terms of the Ruby license.
- * See LICENSE for details
- */
-
-#include "ruby.h"
-#include "rubyio.h"
-
-#include "ev_wrap.h"
-
-#include "rev.h"
-
-#include <assert.h>
-
-#include <string.h>
-#include <time.h>
-#include <unistd.h>
-#include <errno.h>
-
-/* Default number of bytes in each node's buffer */
-#define DEFAULT_NODE_SIZE 16384
-
-/* Maximum age of a buffer node in a memory pool, in seconds */
-#define MAX_AGE 60
-
-/* How often to scan the pool for old nodes */
-#define PURGE_INTERVAL 10
-
-struct buffer {
-	time_t last_purged_at;
-  unsigned size, node_size;
-  struct buffer_node *head, *tail;
-  struct buffer_node *pool_head, *pool_tail;
-	
-};
-
-struct buffer_node {
-	time_t last_used_at;
-  unsigned start, end;
-  struct buffer_node *next;
-  unsigned char data[0];
-};
-
-static VALUE mRev = Qnil;
-static VALUE cRev_Buffer = Qnil;
-
-static VALUE Rev_Buffer_allocate(VALUE klass);
-static void Rev_Buffer_mark(struct buffer *);
-static void Rev_Buffer_free(struct buffer *);
-
-static VALUE Rev_Buffer_initialize(int argc, VALUE *argv, VALUE self);
-static VALUE Rev_Buffer_clear(VALUE self);
-static VALUE Rev_Buffer_size(VALUE self);
-static VALUE Rev_Buffer_empty(VALUE self);
-static VALUE Rev_Buffer_append(VALUE self, VALUE data);
-static VALUE Rev_Buffer_prepend(VALUE self, VALUE data);
-static VALUE Rev_Buffer_read(int argc, VALUE *argv, VALUE self);
-static VALUE Rev_Buffer_to_str(VALUE self);
-static VALUE Rev_Buffer_read_from(VALUE self, VALUE io);
-static VALUE Rev_Buffer_write_to(VALUE self, VALUE io);
-
-static struct buffer *buffer_new(void);
-static void buffer_clear(struct buffer *buf);
-static void buffer_free(struct buffer *buf);
-static void buffer_gc(struct buffer *buf);
-static void buffer_prepend(struct buffer *buf, char *str, unsigned len);
-static void buffer_append(struct buffer *buf, char *str, unsigned len);
-static void buffer_read(struct buffer *buf, char *str, unsigned len);
-static void buffer_copy(struct buffer *buf, char *str, unsigned len);
-static int buffer_read_from(struct buffer *buf, int fd);
-static int buffer_write_to(struct buffer *buf, int fd);
-
-/* 
- * High speed buffering geared towards non-blocking I/O.
- *
- * Data is stored in a byte queue implemented as a linked list of equal size
- * chunks.  Since every node in the list is the same size they are easily
- * memory pooled.  Routines are provided for high speed non-blocking reads
- * and writes from Ruby IO objects.
- */
-void Init_rev_buffer()
-{
-  mRev = rb_define_module("Rev");
-  cRev_Buffer = rb_define_class_under(mRev, "Buffer", rb_cObject);
-  rb_define_alloc_func(cRev_Buffer, Rev_Buffer_allocate);
-
-  rb_define_method(cRev_Buffer, "initialize", Rev_Buffer_initialize, -1);
-  rb_define_method(cRev_Buffer, "clear", Rev_Buffer_clear, 0);
-  rb_define_method(cRev_Buffer, "size", Rev_Buffer_size, 0);
-  rb_define_method(cRev_Buffer, "empty?", Rev_Buffer_empty, 0);
-  rb_define_method(cRev_Buffer, "<<", Rev_Buffer_append, 1);
-  rb_define_method(cRev_Buffer, "append", Rev_Buffer_append, 1);
-  rb_define_method(cRev_Buffer, "prepend", Rev_Buffer_prepend, 1);
-  rb_define_method(cRev_Buffer, "read", Rev_Buffer_read, -1);
-	rb_define_method(cRev_Buffer, "to_str", Rev_Buffer_to_str, 0);
-	rb_define_method(cRev_Buffer, "read_from", Rev_Buffer_read_from, 1);
-  rb_define_method(cRev_Buffer, "write_to", Rev_Buffer_write_to, 1);
-}
-
-static VALUE Rev_Buffer_allocate(VALUE klass)
-{
-  return Data_Wrap_Struct(klass, Rev_Buffer_mark, Rev_Buffer_free, buffer_new());
-}
-
-static void Rev_Buffer_mark(struct buffer *buf)
-{
-  /* Walks the pool of unused chunks and frees any that are beyond a certain age */
-  buffer_gc(buf);
-}
-
-static void Rev_Buffer_free(struct buffer *buf)
-{
-  buffer_free(buf);
-}
-
-/**
- *  call-seq:
- *    Rev::Buffer.new(size = DEFAULT_NODE_SIZE) -> Rev::Buffer
- * 
- * Create a new Rev::Buffer with linked segments of the given size
- */
-static VALUE Rev_Buffer_initialize(int argc, VALUE *argv, VALUE self)
-{
-  VALUE node_size_obj;
-  int node_size;
-  struct buffer *buf;
-
-  if(rb_scan_args(argc, argv, "01", &node_size_obj) == 1) {
-    node_size = NUM2INT(node_size_obj);
-
-    if(node_size < 1) rb_raise(rb_eArgError, "invalid buffer size");
-
-    Data_Get_Struct(self, struct buffer, buf);
-
-    /* Make sure we're not changing the buffer size after data has been allocated */
-    assert(!buf->head);
-    assert(!buf->pool_head);
-
-    buf->node_size = node_size;
-  }
-
-  return Qnil;
-}
-
-/**
- *  call-seq:
- *    Rev::Buffer#clear -> nil
- * 
- * Clear all data from the Rev::Buffer
- */
-static VALUE Rev_Buffer_clear(VALUE self)
-{
-  struct buffer *buf;
-  Data_Get_Struct(self, struct buffer, buf);
-
-  buffer_clear(buf);
-
-  return Qnil;
-}
-
-/**
- *  call-seq:
- *    Rev::Buffer#size -> Integer
- * 
- * Return the size of the buffer in bytes
- */
-static VALUE Rev_Buffer_size(VALUE self) 
-{
-  struct buffer *buf;
-  Data_Get_Struct(self, struct buffer, buf);
-
-  return INT2NUM(buf->size);
-}
-
-/**
- *  call-seq:
- *    Rev::Buffer#empty? -> Boolean
- * 
- * Is the buffer empty?
- */
-static VALUE Rev_Buffer_empty(VALUE self) 
-{
-  struct buffer *buf;
-  Data_Get_Struct(self, struct buffer, buf);
-
-  return buf->size > 0 ? Qfalse : Qtrue;	
-}
-
-/**
- *  call-seq:
- *    Rev::Buffer#append(data) -> String
- * 
- * Append the given data to the end of the buffer
- */
-static VALUE Rev_Buffer_append(VALUE self, VALUE data)
-{
-  struct buffer *buf;
-  Data_Get_Struct(self, struct buffer, buf);
-
-  /* Is this needed?  Never seen anyone else do it... */
-  data = rb_convert_type(data, T_STRING, "String", "to_str");
-  buffer_append(buf, RSTRING_PTR(data), RSTRING_LEN(data));
-
-  return data;
-}
-
-/**
- *  call-seq:
- *    Rev::Buffer#prepend(data) -> String
- * 
- * Prepend the given data to the beginning of the buffer
- */
-static VALUE Rev_Buffer_prepend(VALUE self, VALUE data)
-{
-  struct buffer *buf;
-  Data_Get_Struct(self, struct buffer, buf);
-
-  data = rb_convert_type(data, T_STRING, "String", "to_str");
-  buffer_prepend(buf, RSTRING_PTR(data), RSTRING_LEN(data));
-
-  return data;
-}
-
-/**
- *  call-seq:
- *    Rev::Buffer#read(length = nil) -> String
- * 
- * Read the specified abount of data from the buffer.  If no value
- * is given the entire contents of the buffer are returned.  Any data
- * read from the buffer is cleared.
- */
-static VALUE Rev_Buffer_read(int argc, VALUE *argv, VALUE self)
-{
-  VALUE length_obj, str;
-  int length;
-  struct buffer *buf;
-
-  Data_Get_Struct(self, struct buffer, buf);
-
-  if(rb_scan_args(argc, argv, "01", &length_obj) == 1) {
-    length = NUM2INT(length_obj);
-  } else {
-    if(buf->size == 0)
-      return rb_str_new2("");
-
-    length = buf->size;
-  }
-
-  if(length > buf->size)
-    length = buf->size;
-
-  if(length < 1)
-    rb_raise(rb_eArgError, "length must be greater than zero");
-
-  str = rb_str_new(0, length);
-  buffer_read(buf, RSTRING_PTR(str), length);
-
-  return str;
-}
-
-/**
- *  call-seq:
- *    Rev::Buffer#to_str -> String
- * 
- * Convert the Buffer to a String.  The original buffer is unmodified.
- */
-static VALUE Rev_Buffer_to_str(VALUE self) {
-	VALUE str;
-	struct buffer *buf;
-	
-	Data_Get_Struct(self, struct buffer, buf);
-	
-	str = rb_str_new(0, buf->size);
-	buffer_copy(buf, RSTRING_PTR(str), buf->size);
-  
-  return str;
-}
-
-/**
- *  call-seq:
- *    Rev::Buffer#read_from(io) -> Integer
- * 
- * Perform a nonblocking read of the the given IO object and fill
- * the buffer with any data received.  The call will read as much
- * data as it can until the read would block.
- */
-static VALUE Rev_Buffer_read_from(VALUE self, VALUE io) {
-	struct buffer *buf;
-#if HAVE_RB_IO_T
-  rb_io_t *fptr;
-#else
-  OpenFile *fptr;
-#endif
-
-  Data_Get_Struct(self, struct buffer, buf);
-  GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
-  rb_io_set_nonblock(fptr);
-
-  return INT2NUM(buffer_read_from(buf, FPTR_TO_FD(fptr)));
-}
-
-/**
- *  call-seq:
- *    Rev::Buffer#write_to(io) -> Integer
- * 
- * Perform a nonblocking write of the buffer to the given IO object.
- * As much data as possible is written until the call would block.
- * Any data which is written is removed from the buffer.
- */
-static VALUE Rev_Buffer_write_to(VALUE self, VALUE io) {
-  struct buffer *buf;
-#if HAVE_RB_IO_T 
-  rb_io_t *fptr;
-#else
-  OpenFile *fptr;
-#endif
-
-  Data_Get_Struct(self, struct buffer, buf);
-  GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
-  rb_io_set_nonblock(fptr);
-
-  return INT2NUM(buffer_write_to(buf, FPTR_TO_FD(fptr)));
-}
-
-/*
- * Ruby bindings end here.  Below is the actual implementation of 
- * the underlying data structures.
- */
-
-/* Create a new buffer */
-static struct buffer *buffer_new(void)
-{
-  struct buffer *buf;
-
-  buf = (struct buffer *)xmalloc(sizeof(struct buffer));
-  buf->head = buf->tail = buf->pool_head = buf->pool_tail = 0;
-  buf->size = 0;
-  buf->node_size = DEFAULT_NODE_SIZE;
-	time(&buf->last_purged_at);
-	
-  return buf;
-}
-
-/* Clear all data from a buffer */
-static void buffer_clear(struct buffer *buf)
-{
-  struct buffer_node *tmp;
-
-  /* Move everything into the buffer pool */
-  if(!buf->pool_tail)
-    buf->pool_head = buf->pool_tail = buf->head;
-  else
-    buf->pool_tail->next = buf->head;
-
-  buf->head = buf->tail = 0;
-  buf->size = 0;
-}
-
-/* Free a buffer */
-static void buffer_free(struct buffer *buf) 
-{
-  struct buffer_node *tmp;
-
-  buffer_clear(buf);
-
-  while(buf->pool_head) {
-    tmp = buf->pool_head;
-    buf->pool_head = tmp->next;
-    free(tmp);
-  }
-
-  free(buf);
-}
-
-/* Run through the pool and find elements that haven't been used for awhile */
-static void buffer_gc(struct buffer *buf)
-{
-  struct buffer_node *cur, *tmp;
-  time_t now;
-  time(&now);
-
-	/* Only purge if we've passed the purge interval */
-	if(now - buf->last_purged_at < PURGE_INTERVAL)
-		return;
-		
-	buf->last_purged_at = now;
-
-  while(buf->pool_head && now - buf->pool_head->last_used_at >= MAX_AGE) {
-    tmp = buf->pool_head;
-    buf->pool_head = buf->pool_head->next;
-    free(tmp);
-  }
-
-  if(!buf->pool_head)
-		buf->pool_tail = 0;
-}
-
-/* Create a new buffer_node (or pull one from the memory pool) */
-static struct buffer_node *buffer_node_new(struct buffer *buf)
-{
-  struct buffer_node *node;
-
-  /* Pull from the memory pool if available */
-  if(buf->pool_head) {
-    node = buf->pool_head;
-    buf->pool_head = node->next;
-
-    if(node->next)
-      node->next = 0;
-    else
-      buf->pool_tail = 0;
-  } else {
-    node = (struct buffer_node *)xmalloc(sizeof(struct buffer_node) + buf->node_size);
-    node->next = 0;
-  }
-
-  node->start = node->end = 0;
-  return node;
-}
-
-/* Free a buffer node (i.e. return it to the memory pool) */
-static void buffer_node_free(struct buffer *buf, struct buffer_node *node)
-{
-  /* Store when the node was freed */
-  time(&node->last_used_at);
-
-  node->next = buf->pool_head;
-  buf->pool_head = node;
-
-  if(!buf->pool_tail)
-    buf->pool_tail = node;
-}
-
-/* Prepend data to the front of the buffer */
-static void buffer_prepend(struct buffer *buf, char *str, unsigned len)
-{
-  struct buffer_node *node, *tmp;
-  buf->size += len;
-
-  /* If it fits in the beginning of the head */
-  if(buf->head && buf->head->start >= len) {
-    buf->head->start -= len;
-    memcpy(buf->head->data + buf->head->start, str, len);
-  } else {
-    node = buffer_node_new(buf);
-    node->next = buf->head;
-    buf->head = node;
-    if(!buf->tail) buf->tail = node;
-
-    while(len > buf->node_size) {
-      memcpy(node->data, str, buf->node_size);
-      node->end = buf->node_size;
-
-      tmp = buffer_node_new(buf);
-      tmp->next = node->next;
-      node->next = tmp;
-
-      if(buf->tail == node) buf->tail = tmp;
-      node = tmp;
-
-      str += buf->node_size;
-      len -= buf->node_size;
-    }
-
-    if(len > 0) {
-      memcpy(node->data, str, len);
-      node->end = len;
-    }
-  }
-}
-
-/* Append data to the front of the buffer */
-static void buffer_append(struct buffer *buf, char *str, unsigned len)
-{
-  unsigned nbytes;
-  buf->size += len;
-
-  /* If it fits in the remaining space in the tail */
-  if(buf->tail && len <= buf->node_size - buf->tail->end) {
-    memcpy(buf->tail->data + buf->tail->end, str, len);
-    buf->tail->end += len;
-    return;
-  }
-
-  /* Empty list needs initialized */
-  if(!buf->head) {
-    buf->head = buffer_node_new(buf);
-    buf->tail = buf->head;
-  }
-
-  /* Build links out of the data */
-  while(len > 0) {
-    nbytes = buf->node_size - buf->tail->end;
-    if(len < nbytes) nbytes = len;
-    
-    memcpy(buf->tail->data + buf->tail->end, str, nbytes);
-    str += nbytes;    
-    len -= nbytes;
-    
-    buf->tail->end += nbytes;
-
-    if(len > 0) {
-      buf->tail->next = buffer_node_new(buf);
-      buf->tail = buf->tail->next;
-    }
-  }
-}
-
-/* Read data from the buffer (and clear what we've read) */
-static void buffer_read(struct buffer *buf, char *str, unsigned len)
-{
-  unsigned nbytes;
-  struct buffer_node *tmp;
-
-  while(buf->size > 0 && len > 0) {
-    nbytes = buf->head->end - buf->head->start;
-    if(len < nbytes) nbytes = len;
-
-    memcpy(str, buf->head->data + buf->head->start, nbytes);
-    str += nbytes;
-    len -= nbytes;
-
-    buf->head->start += nbytes;
-    buf->size -= nbytes;
-
-    if(buf->head->start == buf->head->end) {
-      tmp = buf->head;
-      buf->head = tmp->next;
-      buffer_node_free(buf, tmp);
-
-      if(!buf->head) buf->tail = 0;
-    }
-  }
-}
-
-/* Copy data from the buffer without clearing it */
-static void buffer_copy(struct buffer *buf, char *str, unsigned len)
-{
-  unsigned nbytes;
-  struct buffer_node *node;
-
-	node = buf->head;
-  while(node && len > 0) {
-    nbytes = node->end - node->start;
-    if(len < nbytes) nbytes = len;
-
-    memcpy(str, node->data + node->start, nbytes);
-    str += nbytes;
-    len -= nbytes;
-
-    if(node->start + nbytes == node->end)
-			node = node->next;
-  }
-}
-
-/* Write data from the buffer to a file descriptor */
-static int buffer_write_to(struct buffer *buf, int fd)
-{
-  int bytes_written, total_bytes_written = 0;
-  struct buffer_node *tmp;
-
-  while(buf->head) {
-    bytes_written = write(fd, buf->head->data + buf->head->start, buf->head->end - buf->head->start);
-
-    /* If the write failed... */
-    if(bytes_written < 0) {
-      if(errno != EAGAIN)
-        rb_sys_fail("write");
-
-      return total_bytes_written;
-    }
-
-    total_bytes_written += bytes_written;
-    buf->size -= bytes_written;
-
-    /* If the write blocked... */
-    if(bytes_written < buf->head->end - buf->head->start) {
-      buf->head->start += bytes_written;
-      return total_bytes_written;
-    }
-
-    /* Otherwise we wrote the whole buffer */
-    tmp = buf->head;
-    buf->head = tmp->next;
-    buffer_node_free(buf, tmp);
-
-    if(!buf->head) buf->tail = 0;
-  }
-
-  return total_bytes_written;
-}
-
-/* Read data from a file descriptor to a buffer */
-/* Append data to the front of the buffer */
-static int buffer_read_from(struct buffer *buf, int fd)
-{
-	int bytes_read, total_bytes_read = 0;
-  unsigned nbytes;
-
-  /* Empty list needs initialized */
-  if(!buf->head) {
-    buf->head = buffer_node_new(buf);
-    buf->tail = buf->head;
-  }
-
-	do {
-	  nbytes = buf->node_size - buf->tail->end;
-		bytes_read = read(fd, buf->tail->data + buf->tail->end, nbytes);
-	
-		if(bytes_read < 1) {
-			if(errno != EAGAIN)
-        rb_sys_fail("read");
-			
-			return total_bytes_read;
-		}
-		
-		total_bytes_read += bytes_read; 
-		buf->tail->end += nbytes;
-		buf->size += nbytes;
-		
-		if(buf->tail->end == buf->node_size) {
-      buf->tail->next = buffer_node_new(buf);
-      buf->tail = buf->tail->next;
-		}
-	} while(bytes_read == nbytes);
-	
-	return total_bytes_read;
-}