sonixlabs-eventmachine-java 1.0.0.rc.7-java → 1.0.3.1-java

data/java/src/com/rubyeventmachine/SslBox.java

@@ -0,0 +1,310 @@
+package com.rubyeventmachine;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.SocketChannel;
+import java.security.KeyManagementException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.UnrecoverableKeyException;
+
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.SSLEngineResult;
+import javax.net.ssl.SSLEngineResult.HandshakeStatus;
+import javax.net.ssl.SSLEngineResult.Status;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
+
+public class SslBox {
+
+	private final SSLContext sslContext;
+	private final SSLEngine sslEngine;
+	
+    private final ByteBuffer netInBuffer;
+    private final ByteBuffer netOutBuffer;
+    private final ByteBuffer anotherBuffer;
+
+    public static ByteBuffer emptyBuf = ByteBuffer.allocate(0);
+    private final SocketChannel channel;
+
+	private boolean handshakeComplete;
+    protected HandshakeStatus handshakeStatus; //gets set by handshake
+    
+	public SslBox(boolean isServer, SocketChannel channel, KeyStore keyStore, X509TrustManager tm, boolean verifyPeer, String host, int port) {
+		try {
+			sslContext = SSLContext.getInstance("TLS");
+			KeyManager[] keyManagers = null;
+
+			if (keyStore != null) {
+				KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
+				kmf.init(keyStore, null);
+				keyManagers = kmf.getKeyManagers();
+			}
+
+			sslContext.init(keyManagers, new TrustManager[] { tm }, null);
+			sslEngine = sslContext.createSSLEngine(host, port);
+			sslEngine.setUseClientMode(!isServer);
+			sslEngine.setNeedClientAuth(verifyPeer);
+			
+			this.channel = channel;
+			
+			int netBufSize = sslEngine.getSession().getPacketBufferSize();
+			netInBuffer = ByteBuffer.allocate(netBufSize);
+			netOutBuffer = ByteBuffer.allocate(netBufSize);
+			anotherBuffer = ByteBuffer.allocate(netBufSize);
+			reset();
+		} catch (NoSuchAlgorithmException e) {
+			throw new RuntimeException("unable to start TLS: " + e.getMessage(), e);
+		} catch (UnrecoverableKeyException e) {
+			throw new RuntimeException("unable to start TLS: " + e.getMessage(), e);
+		} catch (KeyStoreException e) {
+			throw new RuntimeException("unable to start TLS: " + e.getMessage(), e);
+		} catch (KeyManagementException e) {
+			throw new RuntimeException("unable to start TLS: " + e.getMessage(), e);
+		} catch (IOException e) {
+			throw new RuntimeException("unable to start TLS: " + e.getMessage(), e);
+		}
+	}
+
+    public void reset() throws IOException {
+        netOutBuffer.position(0);
+        netOutBuffer.limit(0);
+        netInBuffer.position(0);
+        netInBuffer.limit(0);
+        handshakeComplete = false;
+        //initiate handshake
+        sslEngine.beginHandshake();
+        handshakeStatus = sslEngine.getHandshakeStatus();
+    }
+
+	public boolean handshake(SelectionKey channelKey) {
+		try {
+			int newOps = do_handshake(channelKey.isReadable(), channelKey.isWritable());
+			channelKey.interestOps(newOps);
+		} catch (IOException e) {
+			return false;
+		}
+		return true;
+	}
+
+	public boolean handshakeNeeded() {
+		return !handshakeComplete;
+	}
+	
+	private int do_handshake(boolean read, boolean write) throws IOException {
+        if (!flush(netOutBuffer)) return SelectionKey.OP_WRITE; //we still have data to write
+
+        SSLEngineResult handshake = null;
+
+        while (!handshakeComplete) {
+            switch ( handshakeStatus ) {
+                case FINISHED: {
+                    //we are complete if we have delivered the last package
+                    handshakeComplete = !netOutBuffer.hasRemaining();
+                    //return 0 if we are complete, otherwise we still have data to write
+                    return handshakeComplete?0:SelectionKey.OP_WRITE;
+                }
+                case NEED_WRAP: {
+                    //perform the wrap function
+                    handshake = handshakeWrap(write);
+                    if ( handshake.getStatus() == Status.OK ){
+                        if (handshakeStatus == HandshakeStatus.NEED_TASK)
+                            handshakeStatus = tasks();
+                    } else {
+                        //wrap should always work with our buffers
+                        throw new IOException("Unexpected status:" + handshake.getStatus() + " during handshake WRAP.");
+                    }
+                    if ( handshakeStatus != HandshakeStatus.NEED_UNWRAP || (!flush(netOutBuffer)) ) {
+                        //should actually return OP_READ if we have NEED_UNWRAP
+                        return SelectionKey.OP_WRITE;
+                    }
+                    //fall down to NEED_UNWRAP on the same call, will result in a
+                    //BUFFER_UNDERFLOW if it needs data
+                }
+                //$FALL-THROUGH$
+                case NEED_UNWRAP: {
+                    //perform the unwrap function
+                    handshake = handshakeUnwrap(read);
+                    if ( handshake.getStatus() == Status.OK ) {
+                        if (handshakeStatus == HandshakeStatus.NEED_TASK)
+                            handshakeStatus = tasks();
+                    } else if ( handshake.getStatus() == Status.BUFFER_UNDERFLOW ){
+                        //read more data, reregister for OP_READ
+                        return SelectionKey.OP_READ;
+                    } else {
+                        throw new IOException("Invalid handshake status:"+handshakeStatus+" during handshake UNWRAP.");
+                    }//switch
+                    break;
+                }
+                case NEED_TASK: {
+                    handshakeStatus = tasks();
+                    break;
+                }
+                default: throw new IllegalStateException("Invalid handshake status:"+handshakeStatus);
+            }//switch
+        }//while
+        //return 0 if we are complete, otherwise reregister for any activity that
+        //would cause this method to be called again.
+        return handshakeComplete?0:(SelectionKey.OP_WRITE|SelectionKey.OP_READ);
+	}
+	
+	
+    /**
+     * Performs the WRAP function
+     * @param doWrite boolean
+     * @return SSLEngineResult
+     * @throws IOException
+     */
+    private SSLEngineResult handshakeWrap(boolean doWrite) throws IOException {
+        //this should never be called with a network buffer that contains data
+        //so we can clear it here.
+        netOutBuffer.clear();
+        //perform the wrap
+        SSLEngineResult result = sslEngine.wrap(emptyBuf, netOutBuffer);
+        //prepare the results to be written
+        netOutBuffer.flip();
+        //set the status
+        handshakeStatus = result.getHandshakeStatus();
+        //optimization, if we do have a writable channel, write it now
+        if ( doWrite ) flush(netOutBuffer);
+        return result;
+    }
+
+    /**
+     * Perform handshake unwrap
+     * @param doread boolean
+     * @return SSLEngineResult
+     * @throws IOException
+     */
+    private SSLEngineResult handshakeUnwrap(boolean doread) throws IOException {
+
+        if (netInBuffer.position() == netInBuffer.limit()) {
+            //clear the buffer if we have emptied it out on data
+            netInBuffer.clear();
+        }
+        if ( doread )  {
+            //if we have data to read, read it
+            int read = channel.read(netInBuffer);
+            if (read == -1) throw new IOException("EOF encountered during handshake.");
+        }
+        SSLEngineResult result;
+        boolean cont = false;
+        //loop while we can perform pure SSLEngine data
+        do {
+            //prepare the buffer with the incoming data
+            netInBuffer.flip();
+            //call unwrap
+            result = sslEngine.unwrap(netInBuffer, anotherBuffer);
+            //compact the buffer, this is an optional method, wonder what would happen if we didn't
+            netInBuffer.compact();
+            //read in the status
+            handshakeStatus = result.getHandshakeStatus();
+            if ( result.getStatus() == SSLEngineResult.Status.OK &&
+                 result.getHandshakeStatus() == HandshakeStatus.NEED_TASK ) {
+                //execute tasks if we need to
+                handshakeStatus = tasks();
+            }
+            //perform another unwrap?
+            cont = result.getStatus() == SSLEngineResult.Status.OK &&
+                   handshakeStatus == HandshakeStatus.NEED_UNWRAP;
+        }while ( cont );
+        return result;
+    }
+
+    /**
+     * Executes all the tasks needed on the same thread.
+     * @return HandshakeStatus
+     */
+    private SSLEngineResult.HandshakeStatus tasks() {
+        Runnable r = null;
+        while ( (r = sslEngine.getDelegatedTask()) != null) {
+            r.run();
+        }
+        return sslEngine.getHandshakeStatus();
+    }
+    
+    protected boolean flush(ByteBuffer buf) throws IOException {
+        int remaining = buf.remaining();
+        if ( remaining > 0 ) {
+            int written = channel.write(buf);
+            return written >= remaining;
+        }else {
+            return true;
+        }
+    }
+
+	public javax.security.cert.X509Certificate getPeerCert() throws SSLPeerUnverifiedException {
+		return sslEngine.getSession().getPeerCertificateChain()[0];
+	}
+	
+    public int write(ByteBuffer src) throws IOException {
+        if (!flush(netOutBuffer)) return 0;
+
+        netOutBuffer.clear();
+
+        SSLEngineResult result = sslEngine.wrap(src, netOutBuffer);
+        int written = result.bytesConsumed();
+        netOutBuffer.flip();
+
+        if (result.getStatus() == Status.OK) {
+        	if (result.getHandshakeStatus() == HandshakeStatus.NEED_TASK)
+        		tasks();
+        } else {
+            throw new IOException("Unable to wrap data, invalid engine state: " +result.getStatus());
+        }
+
+        //force a flush
+        flush(netOutBuffer);
+
+        return written;
+    }
+    
+    public int read(ByteBuffer dst) throws IOException {
+        //did we finish our handshake?
+        if (!handshakeComplete) throw new IllegalStateException("Handshake incomplete, you must complete handshake before reading data.");
+
+        //read from the network
+        int netread = channel.read(netInBuffer);
+        //did we reach EOF? if so send EOF up one layer.
+        if (netread == -1) return -1;
+
+        //the data read
+        int read = 0;
+        //the SSL engine result
+        SSLEngineResult unwrap;
+        do {
+            //prepare the buffer
+            netInBuffer.flip();
+            //unwrap the data
+            unwrap = sslEngine.unwrap(netInBuffer, dst);
+            //compact the buffer
+            netInBuffer.compact();
+
+            if ( unwrap.getStatus()==Status.OK || unwrap.getStatus()==Status.BUFFER_UNDERFLOW ) {
+                //we did receive some data, add it to our total
+                read += unwrap.bytesProduced();
+                //perform any tasks if needed
+                if (unwrap.getHandshakeStatus() == HandshakeStatus.NEED_TASK) tasks();
+                //if we need more network data, then bail out for now.
+                if ( unwrap.getStatus() == Status.BUFFER_UNDERFLOW ) break;
+            }else if ( unwrap.getStatus()==Status.BUFFER_OVERFLOW && read>0 ) {
+                //buffer overflow can happen, if we have read data, then
+                //empty out the dst buffer before we do another read
+                break;
+            }else {
+                //here we should trap BUFFER_OVERFLOW and call expand on the buffer
+                //for now, throw an exception, as we initialized the buffers
+                //in the constructor
+                throw new IOException("Unable to unwrap data, invalid status: " + unwrap.getStatus());
+            }
+        } while ( (netInBuffer.position() != 0)); //continue to unwrapping as long as the input buffer has stuff
+        return (read);
+    }
+
+}

data/lib/em/iterator.rb

@@ -50,6 +50,7 @@ module EventMachine
     #
     def initialize(list, concurrency = 1)
       raise ArgumentError, 'argument must be an array' unless list.respond_to?(:to_a)
+      raise ArgumentError, 'concurrency must be bigger than zero' unless (concurrency > 0)
       @list = list.to_a.dup
       @concurrency = concurrency
 
@@ -224,47 +225,7 @@ module EventMachine
   end
 end
 
-if __FILE__ == $0
-  $:.unshift File.join(File.dirname(__FILE__), '..')
-  require 'eventmachine'
-
-  # TODO: real tests
-  # TODO: pass in one object instead of two? .each{ |iter| puts iter.current; iter.next }
-  # TODO: support iter.pause/resume/stop/break/continue?
-  # TODO: create some exceptions instead of using RuntimeError
-  # TODO: support proc instead of enumerable? EM::Iterator.new(proc{ return queue.pop })
-
-  EM.run{
-    EM::Iterator.new(1..50).each{ |num,iter| p num; iter.next }
-    EM::Iterator.new([1,2,3], 10).each{ |num,iter| p num; iter.next }
-
-    i = EM::Iterator.new(1..100, 5)
-    i.each(proc{|num,iter|
-      p num.to_s
-      iter.next
-    }, proc{
-      p :done
-    })
-    EM.add_timer(0.03){
-      i.concurrency = 1
-    }
-    EM.add_timer(0.04){
-      i.concurrency = 3
-    }
-
-    EM::Iterator.new(100..150).map(proc{ |num,iter|
-      EM.add_timer(0.01){ iter.return(num) }
-    }, proc{ |results|
-      p results
-    })
-
-    EM::Iterator.new(%w[ pwd uptime uname date ], 2).inject({}, proc{ |hash,cmd,iter|
-      EM.system(cmd){ |output,status|
-        hash[cmd] = status.exitstatus == 0 ? output.strip : nil
-        iter.return(hash)
-      }
-    }, proc{ |results|
-      p results
-    })
-  }
-end
+# TODO: pass in one object instead of two? .each{ |iter| puts iter.current; iter.next }
+# TODO: support iter.pause/resume/stop/break/continue?
+# TODO: create some exceptions instead of using RuntimeError
+# TODO: support proc instead of enumerable? EM::Iterator.new(proc{ return queue.pop })

data/lib/em/processes.rb

@@ -114,7 +114,7 @@ module EventMachine
     init = args.pop if args.last.is_a? Proc
 
     # merge remaining arguments into the command
-    cmd = ([cmd] + args.map{|a|a.to_s.dump}).join(' ')
+    cmd = [cmd, *args] if args.any?
 
     EM.get_subprocess_pid(EM.popen(cmd, SystemCmd, cb) do |c|
       init[c] if init

data/lib/em/protocols/httpclient.rb

@@ -127,7 +127,7 @@ module EventMachine
         # Allow an override for the host header if it's not the connect-string.
         host = args[:host_header] || args[:host] || "_"
         # For now, ALWAYS tuck in the port string, although we may want to omit it if it's the default.
-        port = args[:port]
+        port = args[:port].to_i != 80 ? ":#{args[:port]}" : ""
 
         # POST items.
         postcontenttype = args[:contenttype] || "application/octet-stream"
@@ -138,7 +138,7 @@ module EventMachine
         # TODO: We ASSUME the caller wants to send a 1.1 request. May not be a good assumption.
         req = [
           "#{verb} #{request}#{qs} HTTP/#{version}",
-          "Host: #{host}:#{port}",
+          "Host: #{host}#{port}",
           "User-agent: Ruby EventMachine",
         ]
 

data/lib/em/protocols/line_protocol.rb

@@ -15,8 +15,8 @@ module EventMachine
       def receive_data data
         (@buf ||= '') << data
 
-        while line = @buf.slice!(/(.*)\r?\n/)
-          receive_line(line)
+        while @buf.slice!(/(.*?)\r?\n/)
+          receive_line($1)
         end
       end
 

data/lib/em/protocols/smtpclient.rb

@@ -271,7 +271,7 @@ module EventMachine
               psw = psw.call
             end
             #str = Base64::encode64("\0#{@args[:auth][:username]}\0#{psw}").chomp
-            str = ["\0#{@args[:auth][:username]}\0#{psw}"].pack("m").chomp
+            str = ["\0#{@args[:auth][:username]}\0#{psw}"].pack("m").gsub(/\n/, '')
             send_data "AUTH PLAIN #{str}\r\n"
             @responder = :receive_auth_response
           else

data/lib/em/protocols/smtpserver.rb

@@ -506,11 +506,13 @@ module EventMachine
       # Since we clear the chunk array every time we submit it, the caller needs to be
       # aware to do things like dup it if he wants to keep it around across calls.
       #
-      # DON'T reset the transaction upon disposition of the incoming message.
-      # This means another DATA command can be accepted with the same sender and recipients.
-      # If the client wants to reset, he can call RSET.
-      # Not sure whether the standard requires a transaction-reset at this point, but it
-      # appears not to.
+      # Resets the transaction upon disposition of the incoming message.
+      # RFC5321 says this about the MAIL FROM command:
+      #  "This command tells the SMTP-receiver that a new mail transaction is
+      #   starting and to reset all its state tables and buffers, including any
+      #   recipients or mail data."
+      #
+      # Equivalent behaviour is implemented by resetting after a completed transaction.
       #
       # User-written code can return a Deferrable as a response from receive_message.
       #
@@ -524,11 +526,12 @@ module EventMachine
 
           succeeded = proc {
             send_data "250 Message accepted\r\n"
+            reset_protocol_state
           }
           failed = proc {
             send_data "550 Message rejected\r\n"
+            reset_protocol_state
           }
-
           d = receive_message
 
           if d.respond_to?(:set_deferred_status)
@@ -541,7 +544,7 @@ module EventMachine
           @state.delete :data
         else
           # slice off leading . if any
-          ln.slice!(0...1) if ln[0] == 46
+          ln.slice!(0...1) if ln[0] == ?.
           @databuffer << ln
           if @databuffer.length > @@parms[:chunksize]
             receive_data_chunk @databuffer

data/lib/em/protocols/stomp.rb

@@ -104,12 +104,15 @@ module EventMachine
 
       # @private
       def send_frame verb, headers={}, body=""
+        body = body.to_s
         ary = [verb, "\n"]
+        body_bytesize = body.bytesize if body.respond_to? :bytesize
+        body_bytesize ||= body.size
         headers.each {|k,v| ary << "#{k}:#{v}\n" }
-        ary << "content-length: #{body.to_s.length}\n"
+        ary << "content-length: #{body_bytesize}\n"
         ary << "content-type: text/plain; charset=UTF-8\n" unless headers.has_key? 'content-type'
         ary << "\n"
-        ary << body.to_s
+        ary << body
         ary << "\0"
         send_data ary.join
       end

data/lib/em/protocols.rb

@@ -32,5 +32,6 @@ module EventMachine
     autoload :Postgres3, 'em/protocols/postgres3'
     autoload :ObjectProtocol, 'em/protocols/object_protocol'
     autoload :Socks4, 'em/protocols/socks4'
+    autoload :LineProtocol, 'em/protocols/line_protocol'
   end
 end

data/lib/em/version.rb

@@ -1,3 +1,3 @@
 module EventMachine
-  VERSION = "1.0.0.rc.7"
+  VERSION = "1.0.3.1"
 end

data/lib/eventmachine.rb

@@ -1,8 +1,8 @@
-if RUBY_PLATFORM =~ /java/
+if defined?(EventMachine.library_type) and EventMachine.library_type == :pure_ruby
+  # assume 'em/pure_ruby' was loaded already
+elsif RUBY_PLATFORM =~ /java/
   require 'java'
   require 'jeventmachine'
-elsif defined?(EventMachine.library_type) and EventMachine.library_type == :pure_ruby
-  # assume 'em/pure_ruby' was loaded already
 else
   begin
     require 'rubyeventmachine'
@@ -156,7 +156,7 @@ module EventMachine
     # will start without release_machine being called and will immediately throw
 
     #
-    if reactor_running? and @reactor_pid != Process.pid
+    if @reactor_running and @reactor_pid != Process.pid
       # Reactor was started in a different parent, meaning we have forked.
       # Clean up reactor state so a new reactor boots up in this child.
       stop_event_loop
@@ -531,6 +531,15 @@ module EventMachine
     s
   end
 
+  # Attach to an existing socket's file descriptor. The socket may have been
+  # started with {EventMachine.start_server}.
+  def self.attach_server sock, handler=nil, *args, &block
+    klass = klass_from_handler(Connection, handler, *args)
+    sd = sock.respond_to?(:fileno) ? sock.fileno : sock
+    s = attach_sd(sd)
+    @acceptors[s] = [klass,args,block,sock]
+    s
+  end
 
   # Stop a TCP server socket that was started with {EventMachine.start_server}.
   # @see EventMachine.start_server
@@ -1156,7 +1165,12 @@ module EventMachine
     # Perhaps misnamed since the underlying function uses socketpair and is full-duplex.
 
     klass = klass_from_handler(Connection, handler, *args)
-    w = Shellwords::shellwords( cmd )
+    w = case cmd
+        when Array
+          cmd
+        when String
+          Shellwords::shellwords( cmd )
+        end
     w.unshift( w.first ) if w.first
     s = invoke_popen( w )
     c = klass.new s, *args
@@ -1176,7 +1190,7 @@ module EventMachine
   #
   # @return [Boolean] true if the EventMachine reactor loop is currently running
   def self.reactor_running?
-    (@reactor_running || false)
+    @reactor_running && Process.pid == @reactor_pid
   end
 
 
@@ -1426,7 +1440,8 @@ module EventMachine
     # runs down open connections). It should go on the other calls to user
     # code, but the performance impact may be too large.
     #
-    if opcode == ConnectionUnbound
+    case opcode
+    when ConnectionUnbound
       if c = @conns.delete( conn_binding )
         begin
           if c.original_method(:unbind).arity != 0
@@ -1456,7 +1471,7 @@ module EventMachine
           raise ConnectionNotBound, "received ConnectionUnbound for an unknown signature: #{conn_binding}"
         end
       end
-    elsif opcode == ConnectionAccepted
+    when ConnectionAccepted
       accep,args,blk = @acceptors[conn_binding]
       raise NoHandlerForAcceptedConnection unless accep
       c = accep.new data, *args
@@ -1466,25 +1481,31 @@ module EventMachine
       ##
       # The remaining code is a fallback for the pure ruby and java reactors.
       # In the C++ reactor, these events are handled in the C event_callback() in rubymain.cpp
-    elsif opcode == ConnectionCompleted
+    when ConnectionCompleted
       c = @conns[conn_binding] or raise ConnectionNotBound, "received ConnectionCompleted for unknown signature: #{conn_binding}"
       c.connection_completed
-    elsif opcode == TimerFired
+    when TimerFired
       t = @timers.delete( data )
       return if t == false # timer cancelled
       t or raise UnknownTimerFired, "timer data: #{data}"
       t.call
-    elsif opcode == ConnectionData
+    when ConnectionData
       c = @conns[conn_binding] or raise ConnectionNotBound, "received data #{data} for unknown signature: #{conn_binding}"
       c.receive_data data
-    elsif opcode == LoopbreakSignalled
+    when LoopbreakSignalled
       run_deferred_callbacks
-    elsif opcode == ConnectionNotifyReadable
+    when ConnectionNotifyReadable
       c = @conns[conn_binding] or raise ConnectionNotBound
       c.notify_readable
-    elsif opcode == ConnectionNotifyWritable
+    when ConnectionNotifyWritable
       c = @conns[conn_binding] or raise ConnectionNotBound
       c.notify_writable
+    when SslHandshakeCompleted
+      c = @conns[conn_binding] or raise ConnectionNotBound
+      c.ssl_handshake_completed
+    when SslVerify
+      c = @conns[conn_binding] or raise ConnectionNotBound
+      EventMachine::ssl_verify_peer c, data
     end
   end