stomp 1.4.4 → 1.4.5

data/examples/{ssl_uc3.rb → ssl/uc3/ssl_uc3.rb}

@@ -4,12 +4,15 @@
 # Reference: https://github.com/stompgem/stomp/wiki/extended-ssl-overview
 #
 if Kernel.respond_to?(:require_relative)
-  require_relative("./ssl_common")
+  require_relative("../ssl_common")
+  require_relative("../../stomp_common")
 else
   $LOAD_PATH << File.dirname(__FILE__)
-  require "ssl_common"
+  require "../ssl_common"
+  require("../../stomp_common")
 end
 include SSLCommon
+include Stomp1xCommon
 #
 # == SSL Use Case 3 - server *does* authenticate client, client does *not* authenticate server
 #
@@ -29,23 +32,25 @@ class ExampleSSL3
   # Initialize.
   def initialize
 		# Change the following as needed.
-		@host = ENV['STOMP_HOST'] ? ENV['STOMP_HOST'] : "localhost"
+    @host = host()
+    # It is very likely that you will have to specify your specific port number.
+    # 61612 is currently my AMQ local port number for ssl client auth is required.    
 		@port = ENV['STOMP_PORT'] ? ENV['STOMP_PORT'].to_i : 61612
   end
   # Run example.
   def run
-		puts "Connect host: #{@host}, port: #{@port}"
+		puts "SSLUC3 Connect host: #{@host}, port: #{@port}"
 
     # Possibly change the cert file(s) name(s) here.    
     ssl_opts = Stomp::SSLParams.new(
-      :key_file => "#{cli_loc()}/#{pck()}", # the client's private key, private data
+      :key_file => "#{cli_loc()}/#{cli_key()}", # the client's private key, private data
       :cert_file => "#{cli_loc()}/#{cli_cert()}", # the client's signed certificate
       :fsck => true # Check that the files exist first
     )
-
+    puts "SSLOPTS: #{ssl_opts.inspect}"
     #
     hash = { :hosts => [
-        {:login => 'guest', :passcode => 'guest', :host => @host, :port => @port, :ssl => ssl_opts},
+        {:login => login(), :passcode => passcode(), :host => @host, :port => @port, :ssl => ssl_opts},
       ],
       :reliable => false, # YMMV, to test this in a sane manner
     }
@@ -54,18 +59,12 @@ class ExampleSSL3
     c = Stomp::Connection.new(hash)
     puts "Connect completed"
     puts "SSL Verify Result: #{ssl_opts.verify_result}"
-    # puts "SSL Peer Certificate:\n#{ssl_opts.peer_cert}"
-    c.disconnect
+    puts "SSL Peer Certificate:\n#{ssl_opts.peer_cert}" if showPeerCert()
+    c.disconnect()
   end
 
-	private
-
-	def pck()
-		"client.key"
-	end
-
 end
 #
-e = ExampleSSL3.new
+e = ExampleSSL3.new()
 e.run
 

data/examples/ssl/uc3/ssl_uc3_ciphers.rb

@@ -0,0 +1,65 @@
+# -*- encoding: utf-8 -*-
+
+#
+# Reference: https://github.com/stompgem/stomp/wiki/extended-ssl-overview
+#
+if Kernel.respond_to?(:require_relative)
+  require_relative("../ssl_common")
+  require_relative("../../stomp_common")
+else
+  $LOAD_PATH << File.dirname(__FILE__)
+  require "../ssl_common"
+  require("../../stomp_common")
+end
+include SSLCommon
+include Stomp1xCommon
+#
+# == SSL Use Case 3 - User Supplied Ciphers
+#
+# If you need your own ciphers list, this is how.
+# Stomp's default list will work in many cases.  If you need to use this, you
+# will know it because SSL connect will fail.  In that case, determining
+# _what_ should be in the list is your responsibility.
+#
+class ExampleSSL3C
+  # Initialize.
+  def initialize		# Change the following as needed.
+    @host = host()
+    # It is very likely that you will have to specify your specific port number.
+    # 61612 is currently my AMQ local port number for ssl client auth is required.    
+		@port = ENV['STOMP_PORT'] ? ENV['STOMP_PORT'].to_i : 61612
+  end
+  # Run example.
+  def run
+		puts "SSLUC3C Connect host: #{@host}, port: #{@port}"
+    #
+    # SSL Use Case 3
+    #
+    # Possibly change the cert file(s) name(s) here.    
+    ssl_opts = Stomp::SSLParams.new(
+      :key_file => "#{cli_loc()}/#{cli_key()}",   # the client's private key, private data
+      :cert_file => "#{cli_loc()}/#{cli_cert()}", # the client's signed certificate
+      :ciphers => ciphers_list(),                 # The cipher list
+      :fsck => true                               # Check that the files exist first
+    )
+    #
+    puts "SSLOPTS: #{ssl_opts.inspect}"
+    hash = { :hosts => [
+        {:login => login(), :passcode => passcode(), :host => @host, :port => @port, :ssl => ssl_opts},
+      ],
+      :reliable => false, # YMMV, to test this in a sane manner
+    }
+    #
+    puts "Connect starts, SSL Use Case 3"
+    c = Stomp::Connection.new(hash)
+    puts "Connect completed"
+    puts "SSL Verify Result: #{ssl_opts.verify_result}"
+    puts "SSL Peer Certificate:\n#{ssl_opts.peer_cert}" if showPeerCert()
+    c.disconnect()
+  end
+
+end
+#
+e = ExampleSSL3C.new()
+e.run
+

data/examples/{ssl_uc4.rb → ssl/uc4/ssl_uc4.rb}

@@ -4,12 +4,15 @@
 # Reference: https://github.com/stompgem/stomp/wiki/extended-ssl-overview
 #
 if Kernel.respond_to?(:require_relative)
-  require_relative("./ssl_common")
+  require_relative("../ssl_common")
+  require_relative("../../stomp_common")
 else
   $LOAD_PATH << File.dirname(__FILE__)
-  require "ssl_common"
+  require "../ssl_common"
+  require("../../stomp_common")
 end
 include SSLCommon
+include Stomp1xCommon
 #
 # == SSL Use Case 4 - server *does* authenticate client, client *does* authenticate server
 #
@@ -29,23 +32,26 @@ class ExampleSSL4
   # Initialize.
   def initialize
 		# Change the following as needed.
-		@host = ENV['STOMP_HOST'] ? ENV['STOMP_HOST'] : "localhost"
+    @host = host()
+    # It is very likely that you will have to specify your specific port number.
+    # 61612 is currently my AMQ local port number for ssl client auth is required.        
 		@port = ENV['STOMP_PORT'] ? ENV['STOMP_PORT'].to_i : 61612
   end
   # Run example.
   def run
-		puts "Connect host: #{@host}, port: #{@port}"
+		puts "SSLUC4 Connect host: #{@host}, port: #{@port}"
 
     # Possibly change the cert file(s) name(s) here.    
     ssl_opts = Stomp::SSLParams.new(
-      :key_file => "#{cli_loc()}/#{pck()}", # the client's private key, private data
+      :key_file => "#{cli_loc()}/#{cli_key()}", # the client's private key, private data
       :cert_file => "#{cli_loc()}/#{cli_cert()}", # the client's signed certificate
       :ts_files => "#{ca_loc()}/#{ca_cert()}", # The CA's signed sertificate
       :fsck => true # Check that files exist first
     )
+    puts "SSLOPTS: #{ssl_opts.inspect}"
     #
     hash = { :hosts => [
-        {:login => 'guest', :passcode => 'guest', :host => @host, :port => @port, :ssl => ssl_opts},
+        {:login => login(), :passcode => passcode(), :host => @host, :port => @port, :ssl => ssl_opts},
       ],
       :reliable => false, # YMMV, to test this in a sane manner
     }
@@ -54,18 +60,12 @@ class ExampleSSL4
     c = Stomp::Connection.new(hash)
     puts "Connect completed"
     puts "SSL Verify Result: #{ssl_opts.verify_result}"
-    # puts "SSL Peer Certificate:\n#{ssl_opts.peer_cert}"
-    c.disconnect
+    puts "SSL Peer Certificate:\n#{ssl_opts.peer_cert}" if showPeerCert()
+    c.disconnect()
   end
 
-	private
-
-	def pck()
-		"client.key"
-	end
-
 end
 #
-e = ExampleSSL4.new
+e = ExampleSSL4.new()
 e.run
 

data/examples/ssl/uc4/ssl_uc4_ciphers.rb

@@ -0,0 +1,66 @@
+# -*- encoding: utf-8 -*-
+
+#
+# Reference: https://github.com/stompgem/stomp/wiki/extended-ssl-overview
+#
+if Kernel.respond_to?(:require_relative)
+  require_relative("../ssl_common")
+  require_relative("../../stomp_common")
+else
+  $LOAD_PATH << File.dirname(__FILE__)
+  require "../ssl_common"
+  require("../../stomp_common")
+end
+include SSLCommon
+include Stomp1xCommon
+#
+# == SSL Use Case 4 - User Supplied Ciphers
+#
+# If you need your own ciphers list, this is how.
+# Stomp's default list will work in many cases.  If you need to use this, you
+# will know it because SSL connect will fail.  In that case, determining
+# _what_ should be in the list is your responsibility.
+#
+class ExampleSSL4C
+  # Initialize.
+  def initialize		# Change the following as needed.
+    @host = host()
+    # It is very likely that you will have to specify your specific port number.
+    # 61612 is currently my AMQ local port number for ssl client auth is required.            
+		@port = ENV['STOMP_PORT'] ? ENV['STOMP_PORT'].to_i : 61612
+  end
+  # Run example.
+  def run
+    puts "SSLUC4C Connect host: #{@host}, port: #{@port}"
+    #
+    # SSL Use Case 4
+    #
+    # Possibly change the cert file(s) name(s) here.    
+    ssl_opts = Stomp::SSLParams.new(
+      :key_file => "#{cli_loc()}/#{cli_key()}",   # the client's private key, private data
+      :cert_file => "#{cli_loc()}/#{cli_cert()}", # the client's signed certificate
+      :ts_files => "#{ca_loc()}/#{ca_cert()}",    # The CA's signed sertificate
+      :ciphers => ciphers_list(),                 # The cipher list
+      :fsck => true                               # Check that files exist first
+    )
+    puts "SSLOPTS: #{ssl_opts.inspect}"    
+    #
+    hash = { :hosts => [
+        {:login => login(), :passcode => passcode(), :host => @host, :port => @port, :ssl => ssl_opts},
+      ],
+      :reliable => false, # YMMV, to test this in a sane manner
+    }
+    #
+    puts "Connect starts, SSL Use Case 4"
+    c = Stomp::Connection.new(hash)
+    puts "Connect completed"
+    puts "SSL Verify Result: #{ssl_opts.verify_result}"
+    puts "SSL Peer Certificate:\n#{ssl_opts.peer_cert}" if showPeerCert()
+    c.disconnect()
+  end
+
+end
+#
+e = ExampleSSL4C.new()
+e.run
+

data/examples/stomp_common.rb

@@ -0,0 +1,97 @@
+# -*- encoding: utf-8 -*-
+
+#
+# Common Stomp 1.x code.
+#
+require "rubygems" if RUBY_VERSION < "1.9"
+require "stomp"
+#
+module Stomp1xCommon
+  # User id
+  def login()
+    ENV['STOMP_LOGIN'] || 'guest'
+  end
+  # Password
+  def passcode()
+    ENV['STOMP_PASSCODE'] || 'guest'
+  end
+  # Server host
+  def host()
+    ENV['STOMP_HOST'] || "localhost" # The connect host name
+  end
+  # Server port
+  def port()
+    (ENV['STOMP_PORT'] || 61613).to_i # !! The author runs AMQ listening here
+  end
+  # Required vhost name
+  def virt_host()
+    ENV['STOMP_VHOST'] || "localhost" # The 1.1 virtual host name
+  end
+  # Protocol level
+  def protocol()
+    ENV['STOMP_PROTOCOL'] || "1.2" # The default protocol level
+  end
+  # Heartbeats
+  def heartbeats()
+    ENV['STOMP_HEARTBEATS'] || nil
+  end
+  # Destination
+  def dest()
+    ENV['STOMP_DEST'] || "/queue/#{Time.now.to_f}"
+  end
+
+  # Create a 1.x commection
+  def get_connection()
+    conn_hdrs = {"accept-version" => protocol(),
+      "host" => virt_host(),                     # the vhost
+    }
+    if heartbeats()
+      conn_hdrs['heart-beat'] = heartbeats()
+    end
+
+    conn_hash = { :hosts => [
+      {:login => login(), :passcode => passcode(), :host => host(), :port => port(),
+        :ssl => usessl()},
+      ],
+      :connect_headers => conn_hdrs,
+    }
+    conn = Stomp::Connection.new(conn_hash)
+  end
+
+  # Create a 1.x client
+  def get_client()
+    conn_hdrs = {"accept-version" => protocol(),
+      "host" => virt_host(),                     # the vhost
+    }
+    if heartbeats()
+      conn_hdrs['heart-beat'] = heartbeats()
+    end
+
+    conn_hash = { :hosts => [
+      {:login => login(), :passcode => passcode(), :host => host(), :port => port(),
+        :ssl => usessl()},
+      ],
+      :connect_headers => conn_hdrs,
+    }
+    conn = Stomp::Client.new(conn_hash)
+  end
+
+  # Number of messages
+  def nmsgs()
+    (ENV['STOMP_NMSGS'] || 1).to_i # Number of messages
+  end
+
+  # Include "suppress-content-length' header
+  def suppresscl()
+    ENV['STOMP_SUPPRESS_CL']
+  end
+
+  # Use SSL or not
+  def usessl()
+    if ENV['STOMP_SSL']
+      return true
+    end
+    return false
+  end
+end
+

data/lib/connection/netio.rb

@@ -23,13 +23,19 @@ module Stomp
       private
 
       # Really read from the wire.
-      def _receive(read_socket, connread = false)
-        # p [ "ioscheck", @iosto, connread ]
+      def _receive(read_socket, connread = false, noiosel = false)
+
+        # p [ "ioscheck", @iosto, connread, noiosel, @nto_cmd_read ]
         # _dump_callstack()
-        # drdbg = true
-        drdbg = false
+        drdbg = ENV['DRDBG'] ? true : false
+
         @read_semaphore.synchronize do
+          p [ "_receive_lock", Thread::current() ] if drdbg
           line = nil
+
+          # =====
+          # Read COMMAND (frame name)
+          # =====
           if connread
             begin
               Timeout::timeout(@connread_timeout, Stomp::Error::ConnectReadTimeout) do
@@ -42,65 +48,79 @@ module Stomp
               raise ex
             end
           else
-            p [ "CONR01" ] if drdbg
+            p [ "_receive_COMMAND" ] if drdbg
             _dump_callstack() if drdbg
             line = _init_line_read(read_socket)
           end
           #
-          p [ "nilcheck", line.nil? ] if drdbg
+          p [ "_receive_nilcheck", line.nil? ] if drdbg
           return nil if line.nil?
           #An extra \n at the beginning of the frame, possibly not caught by is_ready?
           line = '' if line == "\n"
           if line == HAND_SHAKE_DATA
             raise Stomp::Error::HandShakeDetectedError
           end
-          p [ "wiredatain_01A", line, Time.now ] if drdbg
+
+          # Check for a valid frame name from the server.
+          frname = line.chomp
+          p [ "_receive_frame_name_check", frname ] if drdbg
+          unless  SERVER_FRAMES[frname]
+            sfex = Stomp::Error::ServerFrameNameError.new(frname)
+            raise sfex
+          end
+
+          p [ "_receive_norm_lend", line, Time.now ] if drdbg
           line = _normalize_line_end(line) if @protocol >= Stomp::SPL_12
-          p [ "wiredatain_01B", line, Time.now ] if drdbg
-          # Reads the beginning of the message until it runs into a empty line
+
+          # =====
+          # Read Headers (if any)
+          # =====
+          # Reads the headers until it runs into a empty line
+          p [ "_receive_start_headers", line, Time.now ] if drdbg
           message_header = ''
           begin
             message_header += line
-            p [ "wiredatain_02A", line, Time.now ] if drdbg
-            unless connread || @ssl
+            unless connread || noiosel || @nto_cmd_read
               raise Stomp::Error::ReceiveTimeout unless IO.select([read_socket], nil, nil, @iosto)
             end
-            p [ "wiredatain_02B", line, Time.now ] if drdbg
+            p [ "_receive_next_header", line, Time.now ] if drdbg
             line = _interruptible_gets(read_socket)
-            p [ "wiredatain_02C", line ] if drdbg
-            raise  if line.nil?
+            p [ "_receive_normle_header", line ] if drdbg
+            raise  Stomp::Error::StompServerError if line.nil?
             line = _normalize_line_end(line) if @protocol >= Stomp::SPL_12
-            p [ "wiredatain_02D", line ] if drdbg
           end until line =~ /^\s?\n$/
-          p [ "wiredatain_03A" ] if drdbg
+          p [ "_receive_end_headers" ] if drdbg
           # Checks if it includes content_length header
           content_length = message_header.match(/content-length\s?:\s?(\d+)\s?\n/)
           message_body = ''
 
-          p [ "wiredatain_03B", content_length ] if drdbg
+          # =====
+          # Read message body (if any)
+          # =====
+          p [ "_receive_start_body", content_length ] if drdbg
           # If content_length is present, read the specified amount of bytes
           if content_length
-            unless connread || @ssl
+            unless connread || noiosel
               raise Stomp::Error::ReceiveTimeout unless IO.select([read_socket], nil, nil, @iosto)
             end
-            p [ "CL01" ] if drdbg
+            p [ "_receive_have_content_length" ] if drdbg
             message_body = read_socket.read content_length[1].to_i
-            unless connread || @ssl
+            unless connread || noiosel
               raise Stomp::Error::ReceiveTimeout unless IO.select([read_socket], nil, nil, @iosto)
             end
             raise Stomp::Error::InvalidMessageLength unless parse_char(read_socket.getc) == "\0"
             # Else read the rest of the message until the first \0
           else
-            unless connread || @ssl
+            unless connread || noiosel
               raise Stomp::Error::ReceiveTimeout unless IO.select([read_socket], nil, nil, @iosto)
             end
-            p [ "NOCL01" ] if drdbg
+            p [ "no_content_length" ] if drdbg
             message_body = read_socket.readline("\0")
             message_body.chop!
           end
 
-          p [ "wiredatain_04" ] if drdbg
-          # If the buffer isn't empty, reads trailing new lines.
+          # =====
+          # If the buffer isn't empty, reads/drains trailing new lines.
           #
           # Note: experiments with JRuby seem to show that socket.ready? never
           # returns true.  It appears that in cases where Ruby returns true
@@ -111,12 +131,13 @@ module Stomp
           # is read.  Do _not_ leave them on the wire and attempt to drain them
           # at the start of the next read.  Attempting to do that breaks the
           # asynchronous nature of the 'poll' method.
-          p [ "wiredatain_05_prep", "isr", _is_ready?(read_socket) ] if drdbg
+          # =====
+          p [ "_receive_start_drain_loop", "isr", _is_ready?(read_socket) ] if drdbg
           while _is_ready?(read_socket)
-            unless connread || @ssl
+            unless connread || noiosel
               raise Stomp::Error::ReceiveTimeout unless IO.select([read_socket], nil, nil, @iosto)
             end
-            p [ "WHIR01" ] if drdbg
+            p [ "_receive_next_drain" ] if drdbg
             last_char = read_socket.getc
             break unless last_char
             if parse_char(last_char) != "\n"
@@ -124,19 +145,24 @@ module Stomp
               break
             end
           end
-          p [ "wiredatain_05A" ] if drdbg
+
+          # =====
+          # Complete receive processing
+          # =====
+          p [ "_receive_hb_update" ] if drdbg
           if @protocol >= Stomp::SPL_11
             @lr = Time.now.to_f if @hbr
           end
           # Adds the excluded \n and \0 and tries to create a new message with it
-          p [ "wiredatain_05B" ] if drdbg
+          p [ "_receive_new_message" ] if drdbg
           msg = Message.new(message_header + "\n" + message_body + "\0", @protocol >= Stomp::SPL_11)
-          p [ "wiredatain_06", msg.command, msg.headers ] if drdbg
+          p [ "_receive_decode_headers", msg.command, msg.headers ] if drdbg
           #
           if @protocol >= Stomp::SPL_11 && msg.command != Stomp::CMD_CONNECTED
             msg.headers = _decodeHeaders(msg.headers)
           end
-          p [ "wiredatain_99", msg.command, msg.headers ] if drdbg
+          p [ "_receive_ends", msg.command, msg.headers ] if drdbg
+          p [ "_receive_UNlock", Thread::current() ] if drdbg
           msg
         end
       end
@@ -175,6 +201,7 @@ module Stomp
 
       # transmit logically puts a Message on the wire.
       def transmit(command, headers = {}, body = '')
+        # p [ "XMIT01", command, headers ]
         # The transmit may fail so we may need to retry.
         while true
           begin
@@ -199,7 +226,7 @@ module Stomp
 
       # _transmit is the real wire write logic.
       def _transmit(used_socket, command, headers = {}, body = '')
-
+        dtrdbg = ENV['DTRDBG'] ? true : false
         # p [ "wirewrite" ]
         # _dump_callstack()
 
@@ -207,6 +234,7 @@ module Stomp
           headers = _encodeHeaders(headers)
         end
         @transmit_semaphore.synchronize do
+          p [ "_transmit_lock", Thread::current() ] if dtrdbg
           # Handle nil body
           body = '' if body.nil?
           # The content-length should be expressed in bytes.
@@ -250,20 +278,32 @@ module Stomp
           if @protocol >= Stomp::SPL_11
             @ls = Time.now.to_f if @hbs
           end
-
+          p [ "_transmit_UNlock", Thread::current() ] if dtrdbg
         end
       end
 
       # Use CRLF if protocol is >= 1.2, and the client requested CRLF
       def _wire_write(sock, data)
         # p [ "debug_01", @protocol, @usecrlf ]
+        dwrdbg = ENV['DWRDBG'] ? true : false
         if @protocol >= Stomp::SPL_12 && @usecrlf
           wiredata = "#{data}#{Stomp::CR}#{Stomp::LF}"
           # p [ "wiredataout_01:", wiredata ]
           sock.write(wiredata)
         else
-          # p [ "wiredataout_02:", "#{data}\n" ]
-          sock.puts data
+          p [ "_wire_write_begin:", "#{data}" ] if dwrdbg
+          if @jruby && @ssl
+            p [ "_wire_write_jrbeg:" ] if dwrdbg
+            # Same results for all of these write methods.
+            # sock.puts data
+            # sock.print "#{data}\n"
+            # sock.syswrite "#{data}\n"
+            sock.write "#{data}\n"
+            p [ "_wire_write_jrend:" ] if dwrdbg
+          else
+            sock.puts data
+          end
+          p [ "_wire_write_end:" ] if dwrdbg
         end
       end
 
@@ -376,8 +416,12 @@ module Stomp
             end
           end
           def ssl.ready?
-            ! @rbuffer.empty? || @io.ready?
+            @ssl_ready_lock ||= Mutex.new
+            @ssl_ready_lock.synchronize do
+              ! @rbuffer.empty? || @io.ready?
+            end
           end
+
           if @ssl != true
             # Pass back results if possible
             if RUBY_VERSION =~ /1\.8\.[56]/
@@ -454,7 +498,9 @@ module Stomp
         else
           _transmit(used_socket, Stomp::CMD_CONNECT, headers)
         end
-        @connection_frame = _receive(used_socket, true)
+        connread = true
+        noiosel = false
+        @connection_frame = _receive(used_socket, connread, noiosel)
         _post_connect
         @disconnect_receipt = nil
         @session = @connection_frame.headers["session"] if @connection_frame