eventmachine 1.2.0.1-x64-mingw32 → 1.2.1-x64-mingw32

data/java/src/com/rubyeventmachine/EmReactor.java

@@ -521,11 +521,27 @@ public class EmReactor {
 	}
 
 	public Object[] getPeerName (long sig) {
-		return Connections.get(sig).getPeerName();
+	    EventableChannel channel = Connections.get(sig);
+	    if (channel != null) {
+	        return Connections.get(sig).getPeerName();
+	    }
+	    else { 
+	        ServerSocketChannel acceptor = Acceptors.get(sig);
+	        return  new Object[] { acceptor.socket().getLocalPort(),
+	                acceptor.socket().getInetAddress().getHostAddress() };   
+	    }
 	}
 
 	public Object[] getSockName (long sig) {
-		return Connections.get(sig).getSockName();
+    	EventableChannel channel = Connections.get(sig);
+    	if (channel != null) {
+    	    return Connections.get(sig).getSockName();
+    	}
+    	else {
+    	    ServerSocketChannel acceptor = Acceptors.get(sig);
+    	    return new Object[] { acceptor.socket().getLocalPort(),
+    	            acceptor.socket().getInetAddress().getHostAddress() };
+    	}
 	}
 
 	public long attachChannel (SocketChannel sc, boolean watch_mode) {

data/lib/em/pool.rb

@@ -1,41 +1,41 @@
 module EventMachine
-  # = EventMachine::Pool
-  #
   # A simple async resource pool based on a resource and work queue. Resources
   # are enqueued and work waits for resources to become available.
   #
-  # Example:
+  # @example
+  #   require 'em-http-request'
+  #
+  #   EM.run do
+  #     pool  = EM::Pool.new
+  #     spawn = lambda { pool.add EM::HttpRequest.new('http://example.org') }
+  #     10.times { spawn[] }
+  #     done, scheduled = 0, 0
+  #
+  #     check = lambda do
+  #       done += 1
+  #       if done >= scheduled
+  #         EM.stop
+  #       end
+  #     end
+  #
+  #     pool.on_error { |conn| spawn[] }
+  #
+  #     100.times do |i|
+  #       scheduled += 1
+  #       pool.perform do |conn|
+  #         req = conn.get :path => '/', :keepalive => true
+  #
+  #         req.callback do
+  #           p [:success, conn.object_id, i, req.response.size]
+  #           check[]
+  #         end
+  #
+  #         req.errback { check[] }
   #
-  #    EM.run do
-  #      pool  = EM::Pool.new
-  #      spawn = lambda { pool.add EM::HttpRequest.new('http://example.org') }
-  #      10.times { spawn[] }
-  #      done, scheduled = 0, 0
-  #    
-  #      check = lambda do
-  #        done += 1
-  #        if done >= scheduled
-  #          EM.stop
-  #        end
-  #      end
-  #    
-  #      pool.on_error { |conn| spawn[] }
-  #    
-  #      100.times do
-  #        pool.perform do |conn|
-  #          req = conn.get :path => '/', :keepalive => true
-  #    
-  #          req.callback do
-  #            p [:success, conn.object_id, i, req.response.size]
-  #            check[]
-  #          end
-  #    
-  #          req.errback { check[] }
-  #    
-  #          req
-  #        end
-  #      end
-  #    end
+  #         req
+  #       end
+  #     end
+  #   end
   #
   # Resources are expected to be controlled by an object responding to a
   # deferrable/completion style API with callback and errback blocks.
@@ -64,8 +64,8 @@ module EventMachine
     # example use case is periodic statistics collection against a set of
     # connection resources.
     #
-    # For example: 
-    #     pool.contents.inject(0) { |sum, connection| connection.num_bytes }
+    # @example
+    #   pool.contents.inject(0) { |sum, connection| connection.num_bytes }
     def contents
       @contents.dup
     end

data/lib/em/protocols/linetext2.rb

@@ -56,7 +56,14 @@ module EventMachine
 
         while remaining_data.length > 0
           if @lt2_mode == :lines
-            if ix = remaining_data.index( @lt2_delimiter )
+            delimiter_string = case @lt2_delimiter
+            when Regexp
+              remaining_data.slice(@lt2_delimiter)
+            else
+              @lt2_delimiter
+            end
+            ix = remaining_data.index(delimiter_string) if delimiter_string
+            if ix
               @lt2_linebuffer << remaining_data[0...ix]
               ln = @lt2_linebuffer.join
               @lt2_linebuffer.clear
@@ -64,7 +71,7 @@ module EventMachine
                 ln.chomp!
               end
               receive_line ln
-              remaining_data = remaining_data[(ix+@lt2_delimiter.length)..-1]
+              remaining_data = remaining_data[(ix+delimiter_string.length)..-1]
             else
               @lt2_linebuffer << remaining_data
               remaining_data = ""
@@ -101,9 +108,16 @@ module EventMachine
         end
       end
 
-
+      # The line delimiter may be a regular expression or a string.  Anything
+      # passed to set_delimiter other than a regular expression will be
+      # converted to a string.
       def set_delimiter delim
-        @lt2_delimiter = delim.to_s
+        @lt2_delimiter = case delim
+        when Regexp
+          delim
+        else
+          delim.to_s
+        end
       end
 
       # Called internally but also exposed to user code, for the case in which
@@ -163,4 +177,3 @@ module EventMachine
     end
   end
 end
-

data/lib/em/pure_ruby.rb

@@ -33,6 +33,88 @@ require 'forwardable'
 require 'socket'
 require 'fcntl'
 require 'set'
+require 'openssl'
+
+module EventMachine
+  # @private
+  class Error < Exception; end
+  # @private
+  class UnknownTimerFired < RuntimeError; end
+  # @private
+  class Unsupported < RuntimeError; end
+  # @private
+  class ConnectionError < RuntimeError; end
+  # @private
+  class ConnectionNotBound < RuntimeError; end
+
+  # Older versions of Ruby may not provide the SSLErrorWaitReadable
+  # OpenSSL class. Create an error class to act as a "proxy".
+  if defined?(OpenSSL::SSL::SSLErrorWaitReadable)
+    SSLConnectionWaitReadable = OpenSSL::SSL::SSLErrorWaitReadable
+  else
+    SSLConnectionWaitReadable = IO::WaitReadable
+  end
+
+  # Older versions of Ruby may not provide the SSLErrorWaitWritable
+  # OpenSSL class. Create an error class to act as a "proxy".
+  if defined?(OpenSSL::SSL::SSLErrorWaitWritable)
+    SSLConnectionWaitWritable = OpenSSL::SSL::SSLErrorWaitWritable
+  else
+    SSLConnectionWaitWritable = IO::WaitWritable
+  end
+end
+
+module EventMachine
+  class CertificateCreator
+    attr_reader :cert, :key
+
+    def initialize
+      @key = OpenSSL::PKey::RSA.new(1024)
+      public_key = @key.public_key
+      subject = "/C=EventMachine/O=EventMachine/OU=EventMachine/CN=EventMachine"
+      @cert = OpenSSL::X509::Certificate.new
+      @cert.subject = @cert.issuer = OpenSSL::X509::Name.parse(subject)
+      @cert.not_before = Time.now
+      @cert.not_after = Time.now + 365 * 24 * 60 * 60
+      @cert.public_key = public_key
+      @cert.serial = 0x0
+      @cert.version = 2
+      factory = OpenSSL::X509::ExtensionFactory.new
+      factory.subject_certificate = @cert
+      factory.issuer_certificate = @cert
+      @cert.extensions = [
+        factory.create_extension("basicConstraints","CA:TRUE", true),
+        factory.create_extension("subjectKeyIdentifier", "hash")
+      ]
+      @cert.add_extension factory.create_extension("authorityKeyIdentifier", "keyid:always,issuer:always")
+      @cert.sign(@key, OpenSSL::Digest::SHA1.new)
+    end
+  end
+
+  # @private
+  DefaultCertificate = CertificateCreator.new
+
+  # @private
+  DefaultDHKey1024 = OpenSSL::PKey::DH.new <<-_end_of_pem_
+-----BEGIN DH PARAMETERS-----
+MIGHAoGBAJ0lOVy0VIr/JebWn0zDwY2h+rqITFOpdNr6ugsgvkDXuucdcChhYExJ
+AV/ZD2AWPbrTqV76mGRgJg4EddgT1zG0jq3rnFdMj2XzkBYx3BVvfR0Arnby0RHR
+T4h7KZ/2zmjvV+eF8kBUHBJAojUlzxKj4QeO2x20FP9X5xmNUXeDAgEC
+-----END DH PARAMETERS-----
+  _end_of_pem_
+
+  # @private
+  DefaultDHKey2048 = OpenSSL::PKey::DH.new <<-_end_of_pem_
+-----BEGIN DH PARAMETERS-----
+MIIBCAKCAQEA7E6kBrYiyvmKAMzQ7i8WvwVk9Y/+f8S7sCTN712KkK3cqd1jhJDY
+JbrYeNV3kUIKhPxWHhObHKpD1R84UpL+s2b55+iMd6GmL7OYmNIT/FccKhTcveab
+VBmZT86BZKYyf45hUF9FOuUM9xPzuK3Vd8oJQvfYMCd7LPC0taAEljQLR4Edf8E6
+YoaOffgTf5qxiwkjnlVZQc3whgnEt9FpVMvQ9eknyeGB5KHfayAc3+hUAvI3/Cr3
+1bNveX5wInh5GDx1FGhKBZ+s1H+aedudCm7sCgRwv8lKWYGiHzObSma8A86KG+MD
+7Lo5JquQ3DlBodj3IDyPrxIv96lvRPFtAwIBAg==
+-----END DH PARAMETERS-----
+  _end_of_pem_
+end
 
 # @private
 module EventMachine
@@ -92,14 +174,10 @@ module EventMachine
       selectable.send_data data
     end
 
-
-    # The extension version does NOT raise any kind of an error if an attempt is made
-    # to close a non-existent connection. Not sure whether we should. For now, we'll
-    # raise an error here in that case.
     # @private
     def close_connection target, after_writing
-      selectable = Reactor.instance.get_selectable( target ) or raise "unknown close_connection target"
-      selectable.schedule_close after_writing
+      selectable = Reactor.instance.get_selectable( target )
+      selectable.schedule_close after_writing if selectable
     end
 
     # @private
@@ -163,10 +241,127 @@ module EventMachine
     def epoll
     end
 
-    # This method is not implemented for pure-Ruby implementation
     # @private
     def ssl?
-      false
+      true
+    end
+
+    def tls_parm_set?(parm)
+      !(parm.nil? || parm.empty?)
+    end
+
+    # This method takes a series of positional arguments for specifying such
+    # things as private keys and certificate chains. It's expected that the
+    # parameter list will grow as we add more supported features. ALL of these
+    # parameters are optional, and can be specified as empty or nil strings.
+    # @private
+    def set_tls_parms signature, priv_key, cert_chain, verify_peer, fail_if_no_peer_cert, sni_hostname, cipher_list, ecdh_curve, dhparam, protocols_bitmask
+      bitmask = protocols_bitmask
+      ssl_options = OpenSSL::SSL::OP_ALL
+      ssl_options |= OpenSSL::SSL::OP_NO_SSLv2 if defined?(OpenSSL::SSL::OP_NO_SSLv2) && EM_PROTO_SSLv2 & bitmask == 0
+      ssl_options |= OpenSSL::SSL::OP_NO_SSLv3 if defined?(OpenSSL::SSL::OP_NO_SSLv3) && EM_PROTO_SSLv3 & bitmask == 0
+      ssl_options |= OpenSSL::SSL::OP_NO_TLSv1 if defined?(OpenSSL::SSL::OP_NO_TLSv1) && EM_PROTO_TLSv1 & bitmask == 0
+      ssl_options |= OpenSSL::SSL::OP_NO_TLSv1_1 if defined?(OpenSSL::SSL::OP_NO_TLSv1_1) && EM_PROTO_TLSv1_1 & bitmask == 0
+      ssl_options |= OpenSSL::SSL::OP_NO_TLSv1_2 if defined?(OpenSSL::SSL::OP_NO_TLSv1_2) && EM_PROTO_TLSv1_2 & bitmask == 0
+      @tls_parms ||= {}
+      @tls_parms[signature] = {
+        :verify_peer => verify_peer,
+        :fail_if_no_peer_cert => fail_if_no_peer_cert,
+        :ssl_options => ssl_options
+      }
+      @tls_parms[signature][:priv_key] = File.read(priv_key) if tls_parm_set?(priv_key)
+      @tls_parms[signature][:cert_chain] = File.read(cert_chain) if tls_parm_set?(cert_chain)
+      @tls_parms[signature][:sni_hostname] = sni_hostname if tls_parm_set?(sni_hostname)
+      @tls_parms[signature][:cipher_list] = cipher_list.gsub(/,\s*/, ':') if tls_parm_set?(cipher_list)
+      @tls_parms[signature][:dhparam] = File.read(dhparam) if tls_parm_set?(dhparam)
+      @tls_parms[signature][:ecdh_curve] = ecdh_curve if tls_parm_set?(ecdh_curve)
+    end
+
+    def start_tls signature
+      selectable = Reactor.instance.get_selectable(signature) or raise "unknown io selectable for start_tls"
+      tls_parms = @tls_parms[signature]
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.options = tls_parms[:ssl_options]
+      ctx.cert = DefaultCertificate.cert
+      ctx.key = DefaultCertificate.key
+      ctx.cert_store = OpenSSL::X509::Store.new
+      ctx.cert_store.set_default_paths
+      ctx.cert = OpenSSL::X509::Certificate.new(tls_parms[:cert_chain]) if tls_parms[:cert_chain]
+      ctx.key = OpenSSL::PKey::RSA.new(tls_parms[:priv_key]) if tls_parms[:priv_key]
+      verify_mode = OpenSSL::SSL::VERIFY_NONE
+      if tls_parms[:verify_peer]
+        verify_mode |= OpenSSL::SSL::VERIFY_PEER
+      end
+      if tls_parms[:fail_if_no_peer_cert]
+        verify_mode |= OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+      end
+      ctx.verify_mode = verify_mode
+      ctx.servername_cb = Proc.new do |_, server_name|
+        tls_parms[:server_name] = server_name
+        nil
+      end
+      ctx.ciphers = tls_parms[:cipher_list] if tls_parms[:cipher_list]
+      if selectable.is_server
+        ctx.tmp_dh_callback = Proc.new do |_, _, key_length|
+          if tls_parms[:dhparam]
+            OpenSSL::PKey::DH.new(tls_parms[:dhparam])
+          else
+            case key_length
+            when 1024 then DefaultDHKey1024
+            when 2048 then DefaultDHKey2048
+            else
+              nil
+            end
+          end
+        end
+        if tls_parms[:ecdh_curve] && ctx.respond_to?(:tmp_ecdh_callback)
+          ctx.tmp_ecdh_callback = Proc.new do
+            OpenSSL::PKey::EC.new(tls_parms[:ecdh_curve])
+          end
+        end
+      end
+      ssl_io = OpenSSL::SSL::SSLSocket.new(selectable, ctx)
+      ssl_io.sync_close = true
+      if tls_parms[:sni_hostname]
+        ssl_io.hostname = tls_parms[:sni_hostname] if ssl_io.respond_to?(:hostname=)
+      end
+      begin
+        selectable.is_server ? ssl_io.accept_nonblock : ssl_io.connect_nonblock
+      rescue; end
+      selectable.io = ssl_io
+    end
+
+    def get_peer_cert signature
+      selectable = Reactor.instance.get_selectable(signature) or raise "unknown get_peer_cert target"
+      if selectable.io.respond_to?(:peer_cert) && selectable.io.peer_cert
+        selectable.io.peer_cert.to_pem
+      else
+        nil
+      end
+    end
+
+    def get_cipher_name signature
+      selectable = Reactor.instance.get_selectable(signature) or raise "unknown get_cipher_name target"
+      selectable.io.respond_to?(:cipher) ? selectable.io.cipher[0] : nil
+    end
+
+    def get_cipher_protocol signature
+      selectable = Reactor.instance.get_selectable(signature) or raise "unknown get_cipher_protocol target"
+      selectable.io.respond_to?(:cipher) ? selectable.io.cipher[1] : nil
+    end
+
+    def get_cipher_bits signature
+      selectable = Reactor.instance.get_selectable(signature) or raise "unknown get_cipher_bits target"
+      selectable.io.respond_to?(:cipher) ? selectable.io.cipher[2] : nil
+    end
+
+    def get_sni_hostname signature
+      @tls_parms ||= {}
+      if @tls_parms[signature]
+        @tls_parms[signature][:server_name]
+      else
+        nil
+      end
     end
 
     # This method is a no-op in the pure-Ruby implementation. We simply return Ruby's built-in
@@ -184,13 +379,13 @@ module EventMachine
 
     # @private
     def get_sock_opt signature, level, optname
-      selectable = Reactor.instance.get_selectable( signature ) or raise "unknown get_peername target"
+      selectable = Reactor.instance.get_selectable( signature ) or raise "unknown get_sock_opt target"
       selectable.getsockopt level, optname
     end
 
     # @private
     def set_sock_opt signature, level, optname, optval
-      selectable = Reactor.instance.get_selectable( signature ) or raise "unknown get_peername target"
+      selectable = Reactor.instance.get_selectable( signature ) or raise "unknown set_sock_opt target"
       selectable.setsockopt level, optname, optval
     end
 
@@ -223,13 +418,13 @@ module EventMachine
       r = Reactor.instance.get_selectable( sig ) or raise "unknown set_comm_inactivity_timeout target"
       r.set_inactivity_timeout tm
     end
-  end
-end
-
 
-module EventMachine
-  # @private
-  class Error < Exception; end
+    # @private
+    def set_pending_connect_timeout sig, tm
+      # Needs to be implemented. Currently a no-op stub to allow
+      # certain software to operate with the EM pure-ruby.
+    end
+  end
 end
 
 module EventMachine
@@ -269,6 +464,24 @@ module EventMachine
   ConnectionCompleted = 104
   # @private
   LoopbreakSignalled = 105
+  # @private
+  ConnectionNotifyReadable = 106
+  # @private
+  ConnectionNotifyWritable = 107
+  # @private
+  SslHandshakeCompleted = 108
+  # @private
+  SslVerify = 109
+  # @private
+  EM_PROTO_SSLv2 = 2
+  # @private
+  EM_PROTO_SSLv3 = 4
+  # @private
+  EM_PROTO_TLSv1 = 8
+  # @private
+  EM_PROTO_TLSv1_1 = 16
+  # @private
+  EM_PROTO_TLSv1_2 = 32
 end
 
 module EventMachine
@@ -376,6 +589,9 @@ module EventMachine
       @selectables.delete_if {|k,io|
         if io.close_scheduled?
           io.close
+          begin
+            EventMachine::event_callback io.uuid, ConnectionUnbound, nil
+          rescue ConnectionNotBound; end
           true
         end
       }
@@ -414,8 +630,9 @@ module EventMachine
     end
 
     def signal_loopbreak
-      #@loopbreak_writer.write '+' if @loopbreak_writer
-      @loopbreak_writer.send('+',0,"127.0.0.1",@loopbreak_port) if @loopbreak_writer
+      begin
+        @loopbreak_writer.send('+',0,"127.0.0.1",@loopbreak_port) if @loopbreak_writer
+      rescue IOError; end
     end
 
     def set_timer_quantum interval_in_seconds
@@ -435,6 +652,8 @@ class IO
   def_delegator :@my_selectable, :eventable_read
   def_delegator :@my_selectable, :eventable_write
   def_delegator :@my_selectable, :uuid
+  def_delegator :@my_selectable, :is_server
+  def_delegator :@my_selectable, :is_server=
   def_delegator :@my_selectable, :send_data
   def_delegator :@my_selectable, :schedule_close
   def_delegator :@my_selectable, :get_peername
@@ -442,17 +661,21 @@ class IO
   def_delegator :@my_selectable, :get_outbound_data_size
   def_delegator :@my_selectable, :set_inactivity_timeout
   def_delegator :@my_selectable, :heartbeat
+  def_delegator :@my_selectable, :io
+  def_delegator :@my_selectable, :io=
 end
 
 module EventMachine
   # @private
   class Selectable
 
-    attr_reader :io, :uuid
+    attr_accessor :io, :is_server
+    attr_reader :uuid
 
     def initialize io
-      @uuid = UuidGenerator.generate
       @io = io
+      @uuid = UuidGenerator.generate
+      @is_server = false
       @last_activity = Reactor.instance.current_loop_time
 
       if defined?(Fcntl::F_GETFL)
@@ -499,6 +722,14 @@ module EventMachine
 
     def heartbeat
     end
+
+    def schedule_close(after_writing=false)
+      if after_writing
+        @close_requested = true
+      else
+        @close_scheduled = true
+      end
+    end
   end
 
 end
@@ -552,9 +783,9 @@ module EventMachine
           data = io.sysread(4096)
           EventMachine::event_callback uuid, ConnectionData, data
         end
-      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK, SSLConnectionWaitReadable
         # no-op
-      rescue Errno::ECONNRESET, Errno::ECONNREFUSED, EOFError
+      rescue Errno::ECONNRESET, Errno::ECONNREFUSED, EOFError, Errno::EPIPE, OpenSSL::SSL::SSLError
         @close_scheduled = true
         EventMachine::event_callback uuid, ConnectionUnbound, nil
       end
@@ -589,9 +820,10 @@ module EventMachine
             @outbound_q.unshift data[w..-1]
             break
           end
-        rescue Errno::EAGAIN
+        rescue Errno::EAGAIN, SSLConnectionWaitReadable, SSLConnectionWaitWritable
           @outbound_q.unshift data
-        rescue EOFError, Errno::ECONNRESET, Errno::ECONNREFUSED
+          break
+        rescue EOFError, Errno::ECONNRESET, Errno::ECONNREFUSED, Errno::EPIPE, OpenSSL::SSL::SSLError
           @close_scheduled = true
           @outbound_q.clear
         end
@@ -607,16 +839,6 @@ module EventMachine
       end
     end
 
-    # #schedule_close
-    # The application wants to close the connection.
-    def schedule_close after_writing
-      if after_writing
-        @close_requested = true
-      else
-        @close_scheduled = true
-      end
-    end
-
     # #get_peername
     # This is defined in the normal way on connected stream objects.
     # Return an object that is suitable for passing to Socket#unpack_sockaddr_in or variants.
@@ -657,39 +879,58 @@ module EventMachine
         # TODO, this assumes a current Ruby snapshot.
         # We need to degrade to a nonblocking connect otherwise.
         sd.connect_nonblock( Socket.pack_sockaddr_in( port, host ))
-      rescue Errno::EINPROGRESS
+      rescue Errno::ECONNREFUSED, Errno::EINPROGRESS
       end
       EvmaTCPClient.new sd
     end
 
-
     def initialize io
       super
       @pending = true
+      @handshake_complete = false
     end
 
-
-    def select_for_writing?
-      @pending ? true : super
+    def ready?
+      if RUBY_PLATFORM =~ /linux/
+        io.getsockopt(Socket::SOL_TCP, Socket::TCP_INFO).unpack("i").first == 1 # TCP_ESTABLISHED
+      else
+        io.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR).unpack("i").first == 0 # NO ERROR
+      end
     end
 
-    def select_for_reading?
-      @pending ? false : super
+    def handshake_complete?
+      if !@handshake_complete && io.respond_to?(:state)
+        if io.state =~ /^SSLOK/
+          @handshake_complete = true
+          EventMachine::event_callback uuid, SslHandshakeCompleted, ""
+          EventMachine::event_callback uuid, SslVerify, io.peer_cert.to_pem if io.peer_cert
+        end
+      else
+        @handshake_complete = true
+      end
+      @handshake_complete
     end
 
-    def eventable_write
+    def pending?
+      handshake_complete?
       if @pending
-        @pending = false
-        if 0 == io.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR).unpack("i").first
+        if ready?
+          @pending = false
           EventMachine::event_callback uuid, ConnectionCompleted, ""
         end
-      else
-        super
       end
+      @pending
     end
 
+    def select_for_writing?
+      pending?
+      super
+    end
 
-
+    def select_for_reading?
+      pending?
+      super
+    end
   end
 end
 
@@ -809,7 +1050,8 @@ module EventMachine
       begin
         10.times {
           descriptor,peername = io.accept_nonblock
-          sd = StreamObject.new descriptor
+          sd = EvmaTCPClient.new descriptor
+          sd.is_server = true
           EventMachine::event_callback uuid, ConnectionAccepted, sd.uuid
         }
       rescue Errno::EWOULDBLOCK, Errno::EAGAIN
@@ -1005,18 +1247,14 @@ module EventMachine
         @close_scheduled = true
         EventMachine::event_callback uuid, ConnectionUnbound, nil
       end
-
     end
 
-
     def send_data data
       send_datagram data, @return_address
     end
-
   end
 end
 
 # load base EM api on top, now that we have the underlying pure ruby
 # implementation defined
 require 'eventmachine'
-