rev 0.2.0 → 0.2.1

data/ext/rev/rev_ssl.c

@@ -38,6 +38,44 @@ static VALUE Rev_SSL_IO_start_ssl(VALUE self, int (*func)(), const char *funcnam
 static VALUE Rev_SSL_IO_read_nonblock(int argc, VALUE *argv, VALUE self);
 static VALUE Rev_SSL_IO_write_nonblock(VALUE self, VALUE str);
 
+/*
+ * Time to monkey patch some C code!
+ */
+
+/* Ruby 1.8 leaves us no recourse but to commonly couple to the OpenSSL native
+   extension through externs.  Ugh */
+#if RUBY_VERSION_CODE < 190
+ 
+/* Externs from Ruby's OpenSSL native extension , in ossl_ssl.c*/
+extern int ossl_ssl_ex_vcb_idx;
+extern int ossl_ssl_ex_store_p;
+extern int ossl_ssl_ex_ptr_idx;
+extern int ossl_ssl_ex_client_cert_cb_idx;
+extern int ossl_ssl_ex_tmp_dh_callback_idx;
+
+/* #defines shamelessly copied and pasted from ossl_ssl.c */
+#define ossl_ssl_get_io(o)                rb_iv_get((o),"@io")
+#define ossl_ssl_get_ctx(o)               rb_iv_get((o),"@context")
+#define ossl_sslctx_get_verify_cb(o)      rb_iv_get((o),"@verify_callback")
+#define ossl_sslctx_get_client_cert_cb(o) rb_iv_get((o),"@client_cert_cb")
+#define ossl_sslctx_get_tmp_dh_cb(o)      rb_iv_get((o),"@tmp_dh_callback")
+
+#ifdef _WIN32
+#  define TO_SOCKET(s) _get_osfhandle(s)
+#else
+#  define TO_SOCKET(s) s
+#endif
+
+#endif
+
+#ifndef HAVE_RB_STR_SET_LEN
+static void rb_str_set_len(VALUE str, long len)
+{
+  RSTRING(str)->len = len;
+  RSTRING(str)->ptr[len] = '\0';
+}
+#endif
+
 void Init_rev_ssl()
 {
   rb_require("openssl");
@@ -63,6 +101,47 @@ void Init_rev_ssl()
   rb_define_method(cRev_SSL_IO, "write_nonblock", Rev_SSL_IO_write_nonblock, 1);
 }
 
+#if RUBY_VERSION_CODE < 190 
+/* SSL initialization for Ruby 1.8 */
+static VALUE
+Rev_SSL_IO_ssl_setup(VALUE self)
+{
+  VALUE io, v_ctx, cb;
+  SSL_CTX *ctx;
+  SSL *ssl;
+  OpenFile *fptr;
+
+  Data_Get_Struct(self, SSL, ssl);
+  if(!ssl) {
+    v_ctx = ossl_ssl_get_ctx(self);
+    Data_Get_Struct(v_ctx, SSL_CTX, ctx);
+
+    ssl = SSL_new(ctx);
+    if (!ssl) {
+      ossl_raise(eSSLError, "SSL_new:");
+    }
+    DATA_PTR(self) = ssl;
+
+    io = ossl_ssl_get_io(self);
+    GetOpenFile(io, fptr);
+    rb_io_check_readable(fptr);
+    rb_io_check_writable(fptr);
+    SSL_set_fd(ssl, TO_SOCKET(fileno(fptr->f)));
+    SSL_set_ex_data(ssl, ossl_ssl_ex_ptr_idx, (void*)self);
+    cb = ossl_sslctx_get_verify_cb(v_ctx);
+    SSL_set_ex_data(ssl, ossl_ssl_ex_vcb_idx, (void*)cb);
+    cb = ossl_sslctx_get_client_cert_cb(v_ctx);
+    SSL_set_ex_data(ssl, ossl_ssl_ex_client_cert_cb_idx, (void*)cb);
+    cb = ossl_sslctx_get_tmp_dh_cb(v_ctx);
+    SSL_set_ex_data(ssl, ossl_ssl_ex_tmp_dh_callback_idx, (void*)cb);
+  }
+
+  return Qtrue;
+}  
+#endif
+
+#if RUBY_VERSION_CODE >= 190
+/* Slightly less insane SSL setup for Ruby 1.9 */
 static VALUE
 Rev_SSL_IO_ssl_setup(VALUE self)
 {
@@ -95,15 +174,13 @@ Rev_SSL_IO_ssl_setup(VALUE self)
    */
    rb_funcall(self, rb_intern("session="), 1, Qnil);
 }
+#endif
 
 /* Ensure the error raised by calling #session= with a dummy argument is 
  * the one we were expecting */
 static VALUE 
 Rev_SSL_IO_ssl_setup_check(VALUE dummy, VALUE err)
 {
-  if(!rb_obj_is_kind_of(err, rb_eTypeError))
-    rb_raise(rb_eRuntimeError, "Rev::SSL not supported in this Ruby version, sorry");
-
   return Qnil;
 }
 
@@ -114,7 +191,12 @@ Rev_SSL_IO_ssl_setup_check(VALUE dummy, VALUE err)
 static VALUE
 Rev_SSL_IO_connect_nonblock(VALUE self)
 {
+#if RUBY_VERSION_CODE >= 190
   rb_rescue(Rev_SSL_IO_ssl_setup, self, Rev_SSL_IO_ssl_setup_check, Qnil);
+#else
+  Rev_SSL_IO_ssl_setup(self);
+#endif
+  
   return Rev_SSL_IO_start_ssl(self, SSL_connect, "SSL_connect");
 }
 
@@ -125,7 +207,12 @@ Rev_SSL_IO_connect_nonblock(VALUE self)
 static VALUE
 Rev_SSL_IO_accept_nonblock(VALUE self)
 {
+#if RUBY_VERSION_CODE >= 190
   rb_rescue(Rev_SSL_IO_ssl_setup, self, 0, 0);
+#else
+  Rev_SSL_IO_ssl_setup(self);
+#endif
+
   return Rev_SSL_IO_start_ssl(self, SSL_accept, "SSL_accept");
 }
 

data/lib/rev.rb

@@ -4,9 +4,15 @@
 # See file LICENSE for details
 #++
 
+# Pull in the OpenSSL extension if available
+begin
+  require 'openssl'
+rescue LoadError
+end
+
 require File.dirname(__FILE__) + '/rev_ext'
 require File.dirname(__FILE__) + '/rev/loop'
-require File.dirname(__FILE__) + '/rev/watcher'
+require File.dirname(__FILE__) + '/rev/meta'
 require File.dirname(__FILE__) + '/rev/io_watcher'
 require File.dirname(__FILE__) + '/rev/timer_watcher'
 require File.dirname(__FILE__) + '/rev/async_watcher'
@@ -18,6 +24,6 @@ require File.dirname(__FILE__) + '/rev/server'
 require File.dirname(__FILE__) + '/rev/http_client'
 
 module Rev
-  Rev::VERSION = '0.2.0' unless defined? Rev::VERSION
+  Rev::VERSION = '0.2.1' unless defined? Rev::VERSION
   def self.version() VERSION end
 end

data/lib/rev/http_client.rb

@@ -68,7 +68,7 @@ module Rev
 
     # Map all header keys to a downcased string version
     def munge_header_keys(head)
-      head.reduce({}) { |h, (k, v)| h[k.to_s.downcase] = v; h }
+      head.inject({}) { |h, (k, v)| h[k.to_s.downcase] = v; h }
     end
 
     # HTTP is kind of retarded that you have to specify
@@ -98,15 +98,15 @@ module Rev
     end
 
     def encode_headers(head)
-      head.reduce('') do |result, (k, v)|
+      head.inject('') do |result, (key, value)|
         # Munge keys from foo-bar-baz to Foo-Bar-Baz
-        k = k.split('-').map(&:capitalize).join('-')
-      result << encode_field(k, v)
+        key = key.split('-').map { |k| k.capitalize }.join('-')
+      result << encode_field(key, value)
       end
     end
 
     def encode_cookies(cookies)
-      cookies.reduce('') { |result, (k, v)| result << encode_field('Cookie', encode_param(k, v)) }
+      cookies.inject('') { |result, (k, v)| result << encode_field('Cookie', encode_param(k, v)) }
     end
   end
 
@@ -167,7 +167,7 @@ module Rev
     #     Specify the request body (you must encode it for now)
     #
     def request(method, path, options = {})
-      raise ArgumentError, "invalid request path" unless path[0] == '/'
+      raise ArgumentError, "invalid request path" unless /^\// === path
       raise RuntimeError, "request already sent" if @requested
 
       @method, @path, @options = method, path, options

data/lib/rev/io.rb

@@ -13,16 +13,44 @@ module Rev
   # This class is primarily meant as a base class for other streams
   # which need non-blocking writing, and is used to implement Rev's
   # Socket class and its associated subclasses.
-  class IO < IOWatcher
+  class IO
+    extend Meta
+    
     # Maximum number of bytes to consume at once
     INPUT_SIZE = 16384
 
     def initialize(io)
-      @io = io
-      @write_buffer = Rev::Buffer.new
-      super(@io)
+      @_io = io
+      @_write_buffer  = Rev::Buffer.new
+      @_read_watcher  = Watcher.new(io, self, :r)
+      @_write_watcher = Watcher.new(io, self, :w)
     end
 
+    #
+    # Watcher methods, delegated to @_read_watcher
+    #
+    
+    # Attach to the event loop
+    def attach(loop); @_read_watcher.attach loop; self; end
+    
+    # Detach from the event loop
+    def detach; @_read_watcher.detach; self; end
+    
+    # Enable the watcher
+    def enable; @_read_watcher.enable; self; end
+    
+    # Disable the watcher
+    def disable; @_read_watcher.disable; self; end
+    
+    # Is the watcher attached?
+    def attached?; @_read_watcher.attached?; end
+    
+    # Is the watcher enabled?
+    def enabled?; @_read_watcher.enabled?; end
+    
+    # Obtain the event loop associated with this object
+    def evloop; @_read_watcher.evloop; end
+    
     #
     # Callbacks for asynchronous events
     #
@@ -45,21 +73,21 @@ module Rev
 
     # Write data in a buffered, non-blocking manner
     def write(data)
-      @write_buffer << data
+      @_write_buffer << data
       schedule_write
       data.size
     end
 
     # Number of bytes are currently in the output buffer
     def output_buffer_size
-      @write_buffer.size
+      @_write_buffer.size
     end
 
     # Close the IO stream
     def close
       detach if attached?
       detach_write_watcher
-      @io.close unless @io.closed?
+      @_io.close unless @_io.closed?
 
       on_close
       nil
@@ -67,7 +95,7 @@ module Rev
 
     # Is the IO object closed?
     def closed?
-      @io.closed?
+      @_io.closed?
     end
 
     #########
@@ -77,7 +105,8 @@ module Rev
     # Read from the input buffer and dispatch to on_read
     def on_readable
       begin
-        on_read @io.read_nonblock(INPUT_SIZE)
+        on_read @_io.read_nonblock(INPUT_SIZE)
+      rescue Errno::EAGAIN
       rescue Errno::ECONNRESET, EOFError
         close
       end
@@ -86,12 +115,12 @@ module Rev
     # Write the contents of the output buffer
     def on_writable
       begin
-        @write_buffer.write_to(@io)
+        @_write_buffer.write_to(@_io)
       rescue Errno::EPIPE, Errno::ECONNRESET
         return close
       end
       
-      if @write_buffer.empty?
+      if @_write_buffer.empty?
         disable_write_watcher
         on_write_complete
       end
@@ -105,37 +134,32 @@ module Rev
       end
     end
     
-    # Return a handle to the writing IOWatcher
-    def write_watcher
-      @write_watcher ||= WriteWatcher.new(@io, self)
-    end
-    
     def enable_write_watcher
-      if write_watcher.attached?
-        write_watcher.enable unless write_watcher.enabled?
+      if @_write_watcher.attached?
+        @_write_watcher.enable unless @_write_watcher.enabled?
       else
-        write_watcher.attach(evloop)
+        @_write_watcher.attach(evloop)
       end
     end
     
     def disable_write_watcher
-      @write_watcher.disable if @write_watcher and @write_watcher.enabled?
+      @_write_watcher.disable if @_write_watcher and @_write_watcher.enabled?
     end
     
     def detach_write_watcher
-      @write_watcher.detach if @write_watcher and @write_watcher.attached?
+      @_write_watcher.detach if @_write_watcher and @_write_watcher.attached?
     end
-
-    class WriteWatcher < IOWatcher
-      def initialize(ruby_io, rev_io)
+    
+    # Internal class implementing watchers used by Rev::IO
+    class Watcher < IOWatcher
+      def initialize(ruby_io, rev_io, flags)
         @rev_io = rev_io
-        super(ruby_io, :w)
+        super(ruby_io, flags)
       end
 
-      # Delegate on_writable to the Rev::IO object
-      def on_writable
-        @rev_io.__send__(:on_writable)
-      end
+      # Configure IOWatcher event callbacks to call the method passed to #initialize
+      def on_readable; @rev_io.__send__(:on_readable); end
+      def on_writable; @rev_io.__send__(:on_writable); end
     end
   end
 end

data/lib/rev/io_watcher.rb

@@ -5,12 +5,13 @@
 #++
 
 module Rev
-  class IOWatcher
+  class IOWatcher 
     # The actual implementation of this class resides in the C extension
     # Here we metaprogram proper event_callbacks for the callback methods
     # These can take a block and store it to be called when the event
     # is actually fired.
 
+    extend Meta
     event_callback :on_readable, :on_writable
   end
 end

data/lib/rev/{watcher.rb → meta.rb}

@@ -5,12 +5,12 @@
 #++
 
 module Rev
-  class Watcher
+  module Meta
     # Use an alternate watcher with the attach/detach/enable/disable methods
     # if it is presently assigned.  This is useful if you are waiting for
     # an event to occur before the current watcher can be used in earnest,
     # such as making an outgoing TCP connection.
-    def self.watcher_delegate(proxy_var)
+    def watcher_delegate(proxy_var)
       %w{attach detach enable disable}.each do |method|
         module_eval <<-EOD
           def #{method}(*args)
@@ -29,7 +29,7 @@ module Rev
     # This is done by giving a block to the callback method, which is captured
     # as a proc and stored for later.  If the method is called without a block,
     # the stored block is executed if present, otherwise it's a noop.
-    def self.event_callback(*methods)
+    def event_callback(*methods)
       methods.each do |method|
         module_eval <<-EOD
           def #{method}(*args, &block)

data/lib/rev/server.rb

@@ -11,8 +11,8 @@ module Rev
     # connections is a Socket, but any subclass of IOWatcher is acceptable.
     def initialize(listen_socket, klass = Socket, *args, &block)
       # Ensure the provided class responds to attach
-      unless klass.allocate.is_a? IOWatcher
-        raise ArgumentError, "provided class must descend from IOWatcher"
+      unless klass.allocate.is_a? IO
+        raise ArgumentError, "can't convert #{klass} to Rev::IO"
       end
 
       # Verify the arity of the provided arguments

data/lib/rev/socket.rb

@@ -10,19 +10,19 @@ require 'resolv'
 module Rev
   class Socket < IO    
     def self.connect(socket, *args)
-      new(socket, *args).instance_eval {
-        @connector = Connector.new(self, socket)
+      new(socket, *args).instance_eval do
+        @_connector = Connector.new(self, socket)
         self
-      }
+      end
     end
     
-    watcher_delegate :@connector
+    watcher_delegate :@_connector
 
     def attach(evloop)
-      raise RuntimeError, "connection failed" if @failed
+      raise RuntimeError, "connection failed" if @_failed
       
-      if @connector
-        @connector.attach(evloop)
+      if @_connector
+        @_connector.attach(evloop)
         return self
       end
       
@@ -56,11 +56,11 @@ module Rev
         detach
 
         if connect_successful?
-          @rev_socket.instance_eval { @connector = nil }
+          @rev_socket.instance_eval { @_connector = nil }
           @rev_socket.attach(evl)
           @rev_socket.__send__(:on_connect)
         else
-          @rev_socket.instance_eval { @failed = true }
+          @rev_socket.instance_eval { @_failed = true }
           @rev_socket.__send__(:on_connect_failed)
         end
       end      
@@ -77,7 +77,7 @@ module Rev
   
   class TCPSocket < Socket
     attr_reader :remote_host, :remote_addr, :remote_port, :address_family
-    watcher_delegate :@resolver
+    watcher_delegate :@_resolver
     
     # Similar to .new, but used in cases where the resulting object is in a
     # "half-open" state.  This is primarily used for when asynchronous
@@ -114,7 +114,7 @@ module Rev
     # Called by precreate during asyncronous DNS resolution
     def preinitialize(addr, port, *args)
       @remote_host, @remote_addr, @remote_port = addr, addr, port
-      @resolver = TCPConnectResolver.new(self, addr, port, *args)
+      @_resolver = TCPConnectResolver.new(self, addr, port, *args)
     end
     
     private :preinitialize
@@ -168,22 +168,28 @@ module Rev
       def on_success(addr)
         host, port, args = @host, @port, @args
 
-        @sock.instance_eval {
-          # DNSResolver only supports IPv4 so we can safely assume an IPv4 address
-          socket = TCPConnectSocket.new(::Socket::AF_INET, addr, port, host)
+        @sock.instance_eval do
+          # DNSResolver only supports IPv4 so we can safely assume IPv4 address
+          begin
+            socket = TCPConnectSocket.new(::Socket::AF_INET, addr, port, host)
+          rescue Errno::ENETUNREACH
+            on_connect_failed
+            return
+          end
+
           initialize(socket, *args)
-          @connector = Socket::Connector.new(self, socket)
-          @resolver = nil
-        }
+          @_connector = Socket::Connector.new(self, socket)
+          @_resolver = nil
+        end
         @sock.attach(evloop)
       end
 
       def on_failure
         @sock.__send__(:on_resolve_failed)
-        @sock.instance_eval { 
-          @resolver = nil 
-          @failed = true
-        }
+        @sock.instance_eval do 
+          @_resolver = nil 
+          @_failed = true
+        end
         return
       end
     end