stomp 1.4.5 → 1.4.10

data/examples/logexamp.rb

@@ -40,6 +40,9 @@ class LoggerExample
     # //////////////////////////////////////////////////////////////////////////////
     # A hash type connect *MUST* be used to enable callback logging.
     # //////////////////////////////////////////////////////////////////////////////
+    # Note:  running this example will generate a number of connect failures,
+    # because of the fake host in this connect hash.
+    # //////////////////////////////////////////////////////////////////////////////
     hash = { :hosts => [
         {:login => user, :passcode => password, :host => 'noonehome', :port => 2525,
           :ssl => so},

data/examples/putget_file.rb

@@ -38,7 +38,7 @@ class FilePutGet
     conn = get_connection()
     puts "pgf005: Qname is: #{@qname}"
     # Try to gracefully handle files that exceed broker size limits.
-    ph = {:presistent => true}
+    ph = {:persistent => true}
     ph['suppress_content_length'] = 'yes' if suppresscl()
     puts "pgf006: Headers are: #{ph.inspect}"
     begin
@@ -76,4 +76,4 @@ end
 #
 e = FilePutGet.new()
 e.doput()
-e.doget()
+# e.doget()

data/examples/showver.rb

@@ -0,0 +1,4 @@
+#
+require 'stomp'
+#
+puts Stomp::Version::STRING

data/examples/ssl/SSL.md

@@ -120,7 +120,7 @@ Subcase B - When your broker _does_ require client authentication:
 
 * Expect connection failure (broker must be sent a valid client certificate).
 
-### Use Case 3 - Authentification by broker, no authentification by  broker
+### Use Case 3 - Authentification by broker, no authentification by client
 
 Subcase A - When your broker does _not_ require client authentication:
 

data/examples/ssl/ssl_common.rb

@@ -51,6 +51,30 @@ module SSLCommon
 		ENV['CLI_KEY'] || pck() # The client private key File
   end
 
+  # Client cert file name.  Change or specify.
+  # This is the author's default.
+  def cli_cert_text()
+    fake_cert = '------BEGIN CERTIFICATE-----
+    fake_cert
+    ------END CERTIFICATE-----'
+
+    # The client cert text is stored in environmental variable
+    ENV['CLI_CERT_TEXT'] || fake_cert
+    
+  end
+
+  # Client private key .  Change or specify.
+  # This is the author's default.
+  # This file should not be exposed to the outside world.
+  def cli_key_text()
+    fake_key = '-----BEGIN PRIVATE KEY-----
+    fake_key
+    -----END PRIVATE KEY-----'
+
+    # The client private key text is stored in environment variable
+    ENV['CLI_KEY_TEXT'] ||  fake_key
+  end
+
 	# Server Data.
 
   # Server file location/directory.  Change or specify.

data/examples/ssl/uc3/ssl_uc3_without_files.rb

@@ -0,0 +1,69 @@
+# -*- 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 - server *does* authenticate client, client does *not* authenticate server
+#
+# Subcase 3.A - Message broker configuration does *not* require client authentication
+#
+# - Expect connection success
+# - Expect a verify result of 20 becuase the client did not authenticate the
+#   server's certificate.
+#
+# Subcase 3.B - Message broker configuration *does* require client authentication
+#
+# - Expect connection success if the server can authenticate the client certificate
+# - Expect a verify result of 20 because the client did not authenticate the
+#   server's certificate.
+#
+class ExampleSSL3woFiles
+  # 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 "SSLUC3 Connect host: #{@host}, port: #{@port}"
+
+    # Possibly change the cert file(s) name(s) here.    
+    ssl_opts = Stomp::SSLParams.new(
+      :key_text => cli_key_text().to_s,  # the client's private key, private data
+      :cert_text => cli_cert_text().to_s      # the client's signed certificate 
+    )
+    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 = ExampleSSL3woFiles.new()
+e.run
+

data/examples/ssl/uc3/ssl_uc3_without_files_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 not from files
+#
+# 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 ExampleSSLwoFiles3C
+  # 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 without files
+    # certificate information will typically be stored in environmental variables
+    #
+    # Possibly change the cert file(s) name(s) here.    
+    ssl_opts = Stomp::SSLParams.new(
+      :key_text => cli_key_text().to_s,         # the client's private key, private data
+      :cert_text => cli_cert_text().to_s,       # the client's signed certificate
+      :ciphers => ciphers_list()                # The cipher list
+    )
+    #
+    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 without files"
+    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 = ExampleSSLwoFiles3C.new()
+e.run
+

data/examples/stomp_common.rb

@@ -55,6 +55,7 @@ module Stomp1xCommon
       ],
       :connect_headers => conn_hdrs,
     }
+    conn_hash[:stompconn] = ENV["STOMP_USESTOMP"] ? true : false
     conn = Stomp::Connection.new(conn_hash)
   end
 

data/lib/client/utils.rb

@@ -175,6 +175,7 @@ module Stomp
       @replay_messages_by_txn = {}
 
       @listener_map = Hash.new do |message|
+        @failure = nil
         unless @connection.slog(:on_miscerr, @connection.log_params, "Received unknown frame type: '#{message.command}'\n")
           warn "Received unknown frame type: '#{message.command}'\n"
         end

data/lib/connection/heartbeats.rb

@@ -164,7 +164,7 @@ module Stomp
           begin
             delta = curt - @lr
             if delta > sleeptime
-              slog(:on_hbfire, log_params, "receive_heartbeat", {})
+              slog(:on_hbfire, log_params, "receive_heartbeat", {:delta => delta})
               # Client code could be off doing something else (that is, no reading of
               # the socket has been requested by the caller).  Try to  handle that case.
               lock = @read_semaphore.try_lock

data/lib/connection/netio.rb

@@ -61,14 +61,6 @@ module Stomp
             raise Stomp::Error::HandShakeDetectedError
           end
 
-          # 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
 
@@ -124,7 +116,7 @@ module Stomp
           #
           # Note: experiments with JRuby seem to show that socket.ready? never
           # returns true.  It appears that in cases where Ruby returns true
-          # that JRuby returns a Fixnum.  We attempt to adjust for this
+          # that JRuby returns an Integer.  We attempt to adjust for this
           # in the _is_ready? method.
           #
           # Note 2: the draining of new lines must be done _after_ a message
@@ -157,8 +149,15 @@ module Stomp
           p [ "_receive_new_message" ] if drdbg
           msg = Message.new(message_header + "\n" + message_body + "\0", @protocol >= Stomp::SPL_11)
           p [ "_receive_decode_headers", msg.command, msg.headers ] if drdbg
+          # Check for a valid frame name from the server.
+          p [ "_receive_frame_name_check", msg.command ] if drdbg
+          unless  SERVER_FRAMES[msg.command]
+            sfex = Stomp::Error::ServerFrameNameError.new(msg.command)
+            raise sfex
+          end
           #
-          if @protocol >= Stomp::SPL_11 && msg.command != Stomp::CMD_CONNECTED
+          # Always decode headers, even for 1.0. Issue #160.
+          if msg.command != Stomp::CMD_CONNECTED
             msg.headers = _decodeHeaders(msg.headers)
           end
           p [ "_receive_ends", msg.command, msg.headers ] if drdbg
@@ -172,16 +171,16 @@ module Stomp
       #
       def _is_ready?(s)
         rdy = s.ready?
-        ### p [ "isr?", rdy ]
+        #p [ "isr?", rdy ]
         return rdy unless @jruby
-        ### p [ "jrdychk", rdy.class ]
+        #p [ "jrdychk", rdy.class ]
         if rdy.class == NilClass
           # rdy = true
           rdy = false # A test
         else
-          rdy = (rdy.class == Fixnum || rdy.class == TrueClass) ? true : false
+          rdy = (rdy.class == Integer || rdy.class == TrueClass) ? true : false
         end
-        ### p [ "isr?_last", rdy ]
+        #p [ "isr?_last", rdy ]
         rdy
       end
 
@@ -229,9 +228,10 @@ module Stomp
         dtrdbg = ENV['DTRDBG'] ? true : false
         # p [ "wirewrite" ]
         # _dump_callstack()
-
+        p [ "_transmit_headers_in1", headers ] if dtrdbg
         if @protocol >= Stomp::SPL_11 && command != Stomp::CMD_CONNECT
           headers = _encodeHeaders(headers)
+          p [ "_transmit_headers_in2", headers ] if dtrdbg
         end
         @transmit_semaphore.synchronize do
           p [ "_transmit_lock", Thread::current() ] if dtrdbg
@@ -250,7 +250,9 @@ module Stomp
           # Lets send this header in the message, so it can maintain state when using unreceive
           headers[:'content-length'] = "#{body_length_bytes}" unless headers[:suppress_content_length]
           headers[:'content-type'] = "text/plain; charset=UTF-8" unless headers[:'content-type'] || headers[:suppress_content_type]
+          p [ "_transmit_command", command ] if dtrdbg
           _wire_write(used_socket,command)
+          p [ "_transmit_headers", headers ] if dtrdbg
           headers.each do |k,v|
             if v.is_a?(Array)
               v.each do |e|
@@ -260,8 +262,10 @@ module Stomp
               _wire_write(used_socket,"#{k}:#{v}")
             end
           end
+          p [ "_transmit_headers done" ] if dtrdbg
           _wire_write(used_socket,"")
           if body != ''
+            p [ "_transmit_body", body ] if dtrdbg
             if headers[:suppress_content_length]
               if tz = body.index("\00")
                 used_socket.write body[0..tz-1]
@@ -273,7 +277,8 @@ module Stomp
             end
           end
           used_socket.write "\0"
-          used_socket.flush if autoflush
+          used_socket.flush if @autoflush
+          # used_socket.flush
 
           if @protocol >= Stomp::SPL_11
             @ls = Time.now.to_f if @hbs
@@ -323,6 +328,7 @@ module Stomp
       # open_ssl_socket opens an SSL socket.
       def open_ssl_socket()
         require 'openssl' unless defined?(OpenSSL)
+        ossdbg = ENV['OSSDBG'] ? true : false
         begin # Any raised SSL exceptions
           ctx = @sslctx_newparm ? OpenSSL::SSL::SSLContext.new(@sslctx_newparm) : OpenSSL::SSL::SSLContext.new
           ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE # Assume for now
@@ -368,20 +374,66 @@ module Stomp
               end
               ctx.cert_store = truststores
             end
-
-            # Client authentication parameters.
-            # Both cert file and key file must be present or not, it can not be a mix.
-            raise Stomp::Error::SSLClientParamsError if @ssl.cert_file.nil? && !@ssl.key_file.nil?
-            raise Stomp::Error::SSLClientParamsError if !@ssl.cert_file.nil? && @ssl.key_file.nil?
-            if @ssl.cert_file # Any check will do here
+            #
+            p [ "OSSL50", "old code starts" ] if ossdbg
+            usecert = nil
+            usekey = nil
+            # Client authentication
+            # If cert exists as a file, then it should not be input as text
+            raise Stomp::Error::SSLClientParamsError if !@ssl.cert_file.nil? &&
+              !@ssl.cert_text.nil?
+            # If cert exists as file, then key must exist, either as text or file
+            raise Stomp::Error::SSLClientParamsError if !@ssl.cert_file.nil? &&
+              @ssl.key_file.nil? && @ssl.key_text.nil?
+            if @ssl.cert_file
               raise Stomp::Error::SSLNoCertFileError if !File::exists?(@ssl.cert_file)
               raise Stomp::Error::SSLUnreadableCertFileError if !File::readable?(@ssl.cert_file)
-              ctx.cert = OpenSSL::X509::Certificate.new(File.read(@ssl.cert_file))
+              p [ "OSSL51", "old code cert file read" ] if ossdbg
+              usecert = OpenSSL::X509::Certificate.new(File.read(@ssl.cert_file))
+            end
+            # If cert exists as file, then key must exist, either as text or file
+            raise Stomp::Error::SSLClientParamsError if !@ssl.cert_text.nil? &&
+              @ssl.key_file.nil? && @ssl.key_text.nil?
+            if @ssl.cert_text
+              p [ "OSSL52", "old code cert text get" ] if ossdbg
+              usecert = OpenSSL::X509::Certificate.new(@ssl.cert_text)
+            end
+
+            # If key exists as a text, then it should not be input as file
+            raise Stomp::Error::SSLClientParamsError if !@ssl.key_text.nil? &&
+              !@ssl.key_file.nil?
+            if @ssl.key_file
               raise Stomp::Error::SSLNoKeyFileError if !File::exists?(@ssl.key_file)
               raise Stomp::Error::SSLUnreadableKeyFileError if !File::readable?(@ssl.key_file)
-              ctx.key  = OpenSSL::PKey::RSA.new(File.read(@ssl.key_file), @ssl.key_password)
+              p [ "OSSL53", "old code key file read" ] if ossdbg
+              usekey  = OpenSSL::PKey::RSA.new(File.read(@ssl.key_file), @ssl.key_password)
             end
 
+            if @ssl.key_text
+              nt = @ssl.key_text.gsub(/\t/, "")
+              p [ "OSSL54", "old code key text get" ] if ossdbg
+              usekey  = OpenSSL::PKey::RSA.new(nt, @ssl.key_password)
+            end
+            #
+            # This style of code because:  in newer Ruby versions the 'cert'
+            # and 'key' attributes are deprecated.  It is suggested that the
+            # 'add_certificate' method be used instead.
+            #
+            if ctx.respond_to?(:add_certificate)  # Newer Ruby version ??
+              p [ "OSSL55", "new code option", usecert, usekey ] if ossdbg
+              if !usecert.nil? && !usekey.nil?
+                p [ "OSSL55", "new code add_certificate" ] if ossdbg
+                ctx.add_certificate(usecert, usekey)
+              else
+                p [ "OSSL56", "new code SKIP add_certificate" ] if ossdbg
+              end
+            else
+              # Older Ruby versions
+              p [ "OSSL56", "old code option", usecert, usekey ] if ossdbg
+              ctx.cert = usecert
+              ctx.key = usekey
+            end
+            p [ "OSSL99", "old code ends" ] if ossdbg
             # Cipher list
             # As of this writing, there are numerous problems with supplying
             # cipher lists to jruby.  So we do not attempt to do that here.
@@ -442,8 +494,8 @@ module Stomp
             ssl.close
           end
           #
-          puts ex.backtrace
-          $stdout.flush
+          puts ex.backtrace if ossdbg
+          $stdout.flush if ossdbg
           raise # Reraise
         end
       end
@@ -515,17 +567,17 @@ module Stomp
           if @protocol == Stomp::SPL_10 || (@protocol >= Stomp::SPL_11 && !@hbr)
             if @jruby
               # Handle JRuby specific behavior.
-              ### p [ "ilrjr00", _is_ready?(read_socket), RUBY_VERSION ]
+              #p [ "ilrjr00", _is_ready?(read_socket), RUBY_VERSION ]
               if RUBY_VERSION <  "2"
                 while true
-                  ### p [ "ilrjr01A1", _is_ready?(read_socket) ]
+                  #p [ "ilrjr01A1", _is_ready?(read_socket) ]
                   line = _interruptible_gets(read_socket) # Data from wire
                   break unless line == "\n"
                   line = ''
                 end
               else # RUBY_VERSION >= "2"
                 while _is_ready?(read_socket)
-                  ### p [ "ilrjr01B2", _is_ready?(read_socket) ]
+                  #p [ "ilrjr01B2", _is_ready?(read_socket) ]
                   line = _interruptible_gets(read_socket) # Data from wire
                   break unless line == "\n"
                   line = ''