stomp 1.3.1 → 1.3.2

data/lib/connection/netio.rb

@@ -130,9 +130,7 @@ module Stomp
           @failure = $!
           raise unless @reliable
           errstr = "transmit to #{@host} failed: #{$!}\n"
-          if @logger && @logger.respond_to?(:on_miscerr)
-            @logger.on_miscerr(log_params, "es_trans: " + errstr)
-          else
+          unless slog(:on_miscerr, log_params, "es_trans: " + errstr)
             $stderr.print errstr
           end
           # !!! This loop initiates a re-connect !!!
@@ -200,15 +198,10 @@ module Stomp
     # open_tcp_socket opens a TCP socket.
     def open_tcp_socket()
       tcp_socket = nil
-
-      if @logger && @logger.respond_to?(:on_connecting)
-        @logger.on_connecting(log_params)
-      end
-
+      slog(:on_connecting, log_params)
       Timeout::timeout(@connect_timeout, Stomp::Error::SocketOpenTimeout) do
         tcp_socket = TCPSocket.open(@host, @port)
       end
-
       tcp_socket
     end
 
@@ -219,15 +212,19 @@ module Stomp
         ctx = OpenSSL::SSL::SSLContext.new
         ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE # Assume for now
         #
-        # Note: if a client uses :ssl => true this results in the gem using
+        # Note: if a client uses :ssl => true this would result in the gem using
         # the _default_ Ruby ciphers list.  This is _known_ to fail in later
-        # Ruby releases.  The gem provides a default cipher list that may
-        # function in these cases.  To use this connect with:
+        # Ruby releases.  The gem now detects :ssl => true, and replaces that
+        # with:
         # * :ssl => Stomp::SSLParams.new
+        #
+        # The above results in the use of Stomp default parameters.
+        #
+        # To specifically request Stomp default parameters, use:
         # * :ssl => Stomp::SSLParams.new(..., :ciphers => Stomp::DEFAULT_CIPHERS)
         #
         # If connecting with an SSLParams instance, and the _default_ Ruby
-        # ciphers list is required, use:
+        # ciphers list is actually required, use:
         # * :ssl => Stomp::SSLParams.new(..., :use_ruby_ciphers => true)
         #
         # If a custom ciphers list is required, connect with:
@@ -275,16 +272,15 @@ module Stomp
             if @ssl.ciphers # User ciphers list?
               ctx.ciphers = @ssl.ciphers # Accept user supplied ciphers
             else
+              ctx.ciphers = Stomp::DEFAULT_CIPHERS # Just use Stomp defaults
             end
           end
         end
 
         #
         ssl = nil
-        if @logger && @logger.respond_to?(:on_ssl_connecting)
-          @logger.on_ssl_connecting(log_params)
-        end
-
+        slog(:on_ssl_connecting, log_params)
+        # _dump_ctx(ctx)
         Timeout::timeout(@connect_timeout, Stomp::Error::SocketOpenTimeout) do
           tcp_socket = TCPSocket.open(@host, @port)
           ssl = OpenSSL::SSL::SSLSocket.new(tcp_socket, ctx)
@@ -304,16 +300,12 @@ module Stomp
           end
           @ssl.peer_cert = ssl.peer_cert
         end
-        if @logger && @logger.respond_to?(:on_ssl_connected)
-          @logger.on_ssl_connected(log_params)
-        end
+        slog(:on_ssl_connected, log_params)
         ssl
       rescue Exception => ex
-        if @logger && @logger.respond_to?(:on_ssl_connectfail)
-          lp = log_params.clone
-          lp[:ssl_exception] = ex
-          @logger.on_ssl_connectfail(lp)
-        end
+        lp = log_params.clone
+        lp[:ssl_exception] = ex
+        slog(:on_ssl_connectfail, lp)
         #
         raise # Reraise
       end
@@ -401,6 +393,11 @@ module Stomp
         line
     end
 
+    # Used for debugging
+    def _dump_ctx(ctx)
+      p [ "dc01", ctx.inspect ]
+      p [ "dc02ciphers", ctx.ciphers ]
+    end
   end # class Connection
 
 end # module Stomp

data/lib/connection/utils.rb

@@ -116,9 +116,7 @@ module Stomp
             used_socket = open_socket() # sets @closed = false if OK
             # Open is complete
             connect(used_socket)
-            if @logger && @logger.respond_to?(:on_connected)
-              @logger.on_connected(log_params)
-            end
+            slog(:on_connected, log_params)
             @connection_attempts = 0
           rescue
             @failure = $!
@@ -132,20 +130,16 @@ module Stomp
             # b) should never be retried
             raise if @failure.is_a?(Stomp::Error::ProtocolError11p)
 
-            if @logger && @logger.respond_to?(:on_connectfail)
-              # on_connectfail may raise
-              begin
-                @logger.on_connectfail(log_params)
-              rescue Exception => aex
-                raise if aex.is_a?(Stomp::Error::LoggerConnectionError)
+            begin
+              unless slog(:on_connectfail,log_params)
+                $stderr.print "connect to #{@host} failed: #{$!} will retry(##{@connection_attempts}) in #{@reconnect_delay}\n"
               end
-            else
-              $stderr.print "connect to #{@host} failed: #{$!} will retry(##{@connection_attempts}) in #{@reconnect_delay}\n"
+            rescue Exception => aex
+              raise if aex.is_a?(Stomp::Error::LoggerConnectionError)
             end
-            raise Stomp::Error::MaxReconnectAttempts if max_reconnect_attempts?
 
+            raise Stomp::Error::MaxReconnectAttempts if max_reconnect_attempts?
             sleep(@reconnect_delay)
-
             @connection_attempts += 1
 
             if @parameters
@@ -183,7 +177,8 @@ module Stomp
         :max_hbrlck_fails => 0,
         :fast_hbs_adjust => 0.0,
         :connread_timeout => 0,
-        :tcp_nodelay => true
+        :tcp_nodelay => true,
+        :start_timeout => 10,
       }
 
       res_params = default_params.merge(params)
@@ -208,6 +203,18 @@ module Stomp
       @passcode = current_host[:passcode] || ""
     end
 
+    # Duplicate parameters hash
+    def _hdup(h)
+      ldup = {}
+      ldup.merge!(h)
+      ldup[:hosts] = []
+      hvals = h[:hosts].nil? ? h["hosts"] : h[:hosts]
+      hvals.each do |hv|
+        ldup[:hosts] << hv.dup
+      end
+      ldup
+    end
+
     # max_reconnect_attempts? returns nil or the number of maximum reconnect
     # attempts.
     def max_reconnect_attempts?
@@ -237,9 +244,7 @@ module Stomp
           @failure = $!
           raise unless @reliable
           errstr = "receive failed: #{$!}"
-          if @logger && @logger.respond_to?(:on_miscerr)
-            @logger.on_miscerr(log_params, "es_oldrecv: " + errstr)
-          else
+          unless slog(:on_miscerr, log_params, "es_oldrecv: " + errstr)
             $stderr.print errstr
           end
 

data/lib/stomp/client.rb

@@ -50,6 +50,8 @@ module Stomp
     #     :max_hbrlck_fails => 0,
     #     :fast_hbs_adjust => 0.0,
     #     :connread_timeout => 0,
+    #     :tcp_nodelay => true,
+    #     :start_timeout => 10,
     #   }
     #
     #   e.g. c = Stomp::Client.new(hash)
@@ -84,10 +86,15 @@ module Stomp
       @logger = @parameters[:logger] ||= Stomp::NullLogger.new
 
       @start_timeout = @parameters[:start_timeout] || 10
-      Timeout.timeout(@start_timeout, Stomp::Error::StartTimeoutException.new(@start_timeout)) do
-        create_error_handler
-        create_connection(autoflush)
-        start_listeners()
+      begin
+        timeout(@start_timeout) {
+          create_error_handler
+          create_connection(autoflush)
+          start_listeners()
+        }
+      rescue TimeoutError
+        ex = Stomp::Error::StartTimeoutException.new(@start_timeout)
+        raise ex
       end
     end
 
@@ -190,14 +197,8 @@ module Stomp
       if block_given?
         headers['receipt'] = register_receipt_listener lambda {|r| yield r}
       end
-      if protocol() == Stomp::SPL_12
-        @connection.ack(message.headers['ack'], headers)
-      elsif protocol == Stomp::SPL_11
-        headers.merge!(:subscription => message.headers['subscription'])
-        @connection.ack(message.headers['message-id'], headers)
-      else
-        @connection.ack(message.headers['message-id'], headers)
-      end
+      context = ack_context_for(message, headers)
+      @connection.ack context[:message_id], context[:headers]
     end
 
     # For posterity, we alias:
@@ -205,7 +206,22 @@ module Stomp
 
     # Stomp 1.1+ NACK.
     def nack(message, headers = {})
-      @connection.nack(message, headers)
+      context = ack_context_for(message, headers)
+      @connection.nack context[:message_id], context[:headers]
+    end
+
+    #
+    def ack_context_for(message, headers)
+      id = case protocol
+        when Stomp::SPL_12
+         'ack'
+        when Stomp::SPL_11
+         headers.merge!(:subscription => message.headers['subscription'])
+         'message-id'
+        else
+         'message-id'
+      end
+      {:message_id => message.headers[id], :headers => headers}
     end
 
     # Unreceive a message, sending it back to its queue or to the DLQ.

data/lib/stomp/connection.rb

@@ -75,6 +75,8 @@ module Stomp
     #     :max_hbrlck_fails => 0,
     #     :fast_hbs_adjust => 0.0,
     #     :connread_timeout => 0,
+    #     :tcp_nodelay => true,
+    #     :start_timeout => 10,
     #   }
     #
     #   e.g. c = Stomp::Connection.new(hash)
@@ -123,6 +125,8 @@ module Stomp
         @max_hbrlck_fails = 0 # 0 means never retry for HB read lock failures
         @fast_hbs_adjust = 0.0 # Fast heartbeat senders sleep adjustment
         @connread_timeout = 0 # Connect read CONNECTED/ERROR timeout
+        @tcp_nodelay = true # Disable Nagle
+        @start_timeout = 10 # Client only, startup timeout
         warn "login looks like a URL, do you have the correct parameters?" if @login =~ /:\/\//
       end
 
@@ -142,7 +146,8 @@ module Stomp
     # hashed_initialize prepares a new connection with a Hash of initialization
     # parameters.
     def hashed_initialize(params)
-      @parameters = refine_params(params)
+      lp = _hdup(params)
+      @parameters = refine_params(lp)
       @reliable =  @parameters[:reliable]
       @reconnect_delay = @parameters[:initial_reconnect_delay]
       @connect_headers = @parameters[:connect_headers]
@@ -158,6 +163,13 @@ module Stomp
       @max_hbrlck_fails = @parameters[:max_hbrlck_fails]
       @fast_hbs_adjust = @parameters[:fast_hbs_adjust]
       @connread_timeout = @parameters[:connread_timeout]
+      #
+      # Try to support Ruby 1.9.x and 2.x ssl.
+      unless defined?(RSpec)
+        @parameters[:hosts].each do |ah|
+          ah[:ssl] = Stomp::SSLParams.new if ah[:ssl] == true
+        end
+      end
       #sets the first host to connect
       change_host
     end
@@ -183,7 +195,7 @@ module Stomp
       headers = headers.symbolize_keys
       headers[:transaction] = name
       _headerCheck(headers)
-      @logger.on_begin(log_params, headers)
+      slog(:on_begin, log_params, headers)
       transmit(Stomp::CMD_BEGIN, headers)
     end
 
@@ -214,7 +226,7 @@ module Stomp
           headers[:'message-id'] = message_id
       end
       _headerCheck(headers)
-      @logger.on_ack(log_params, headers)
+      slog(:on_ack, log_params, headers)
       transmit(Stomp::CMD_ACK, headers)
     end
 
@@ -226,11 +238,11 @@ module Stomp
       headers = headers.symbolize_keys
       case @protocol
         when Stomp::SPL_12
-          # The ACK frame MUST include an id header matching the ack header 
+          # The NACK frame MUST include an id header matching the ack header 
           # of the MESSAGE being acknowledged.
           headers[:id] = message_id
         else # Stomp::SPL_11 only
-          # ACK has two REQUIRED headers: message-id, which MUST contain a value 
+          # NACK has two REQUIRED headers: message-id, which MUST contain a value 
           # matching the message-id for the MESSAGE being acknowledged and 
           # subscription, which MUST be set to match the value of the subscription's 
           # id header.
@@ -238,7 +250,7 @@ module Stomp
           raise Stomp::Error::SubscriptionRequiredError unless headers[:subscription]
       end
       _headerCheck(headers)
-      @logger.on_nack(log_params, headers)
+      slog(:on_nack, log_params, headers)
       transmit(Stomp::CMD_NACK, headers)
     end
 
@@ -248,7 +260,7 @@ module Stomp
       headers = headers.symbolize_keys
       headers[:transaction] = name
       _headerCheck(headers)
-      @logger.on_commit(log_params, headers)
+      slog(:on_commit, log_params, headers)
       transmit(Stomp::CMD_COMMIT, headers)
     end
 
@@ -258,7 +270,7 @@ module Stomp
       headers = headers.symbolize_keys
       headers[:transaction] = name
       _headerCheck(headers)
-      @logger.on_abort(log_params, headers)
+      slog(:on_abort, log_params, headers)
       transmit(Stomp::CMD_ABORT, headers)
     end
 
@@ -273,7 +285,7 @@ module Stomp
         headers[:id] = subId if headers[:id].nil?
       end
       _headerCheck(headers)
-      @logger.on_subscribe(log_params, headers)
+      slog(:on_subscribe, log_params, headers)
 
       # Store the subscription so that we can replay if we reconnect.
       if @reliable
@@ -296,7 +308,7 @@ module Stomp
         headers[:id] = subId unless headers[:id]
       end
       _headerCheck(headers)
-      @logger.on_unsubscribe(log_params, headers)
+      slog(:on_unsubscribe, log_params, headers)
       transmit(Stomp::CMD_UNSUBSCRIBE, headers)
       if @reliable
         subId = dest if subId.nil?
@@ -312,7 +324,7 @@ module Stomp
       headers = headers.symbolize_keys
       headers[:destination] = destination
       _headerCheck(headers)
-      @logger.on_publish(log_params, message, headers)
+      slog(:on_publish, log_params, message, headers)
       transmit(Stomp::CMD_SEND, headers, message)
     end
 
@@ -375,7 +387,7 @@ module Stomp
       end
       transmit(Stomp::CMD_DISCONNECT, headers)
       @disconnect_receipt = receive if headers[:receipt]
-      @logger.on_disconnect(log_params)
+      slog(:on_disconnect, log_params)
       close_socket
     end
 
@@ -398,7 +410,7 @@ module Stomp
       super_result = __old_receive()
       if super_result.nil? && @reliable && !closed?
         errstr = "connection.receive returning EOF as nil - resetting connection.\n"
-        @logger.on_miscerr(log_params, "es_recv: " + errstr)
+        slog(:on_miscerr, log_params, "es_recv: " + errstr)
         $stderr.print errstr
 
         # !!! This initiates a re-connect !!!
@@ -417,7 +429,7 @@ module Stomp
         @closed = true
         warn 'warning: broker sent EOF, and connection not reliable' unless defined?(Test)
       end
-      @logger.on_receive(log_params, super_result)
+      slog(:on_receive, log_params, super_result)
       return super_result
     end
 
@@ -480,6 +492,13 @@ module Stomp
       @hbrecv_count
     end
 
+    # log call router
+    def slog(name, *parms)
+      return false unless @logger
+      @logger.send(name, *parms) if @logger.respond_to?(:"#{name}")
+      @logger.respond_to?(:"#{name}")
+    end
+
   end # class
 
 end # module

data/lib/stomp/constants.rb

@@ -90,25 +90,89 @@ module Stomp
 
   # A fairly safe and generally supported ciphers list.
   DEFAULT_CIPHERS = [
-    ["DHE-RSA-AES256-SHA", "TLSv1/SSLv3", 256, 256], 
-    ["DHE-DSS-AES256-SHA", "TLSv1/SSLv3", 256, 256], 
-    ["AES256-SHA", "TLSv1/SSLv3", 256, 256], 
-    ["EDH-RSA-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], 
-    ["EDH-DSS-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], 
-    ["DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], 
-    ["DHE-RSA-AES128-SHA", "TLSv1/SSLv3", 128, 128], 
-    ["DHE-DSS-AES128-SHA", "TLSv1/SSLv3", 128, 128], 
-    ["AES128-SHA", "TLSv1/SSLv3", 128, 128], 
-    ["RC4-SHA", "TLSv1/SSLv3", 128, 128], 
-    ["RC4-MD5", "TLSv1/SSLv3", 128, 128], 
-    ["EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], 
+    ["AES128-GCM-SHA256","TLSv1/SSLv3",128,128],
+    ["AES128-SHA256","TLSv1/SSLv3",128,128],
+    ["AES128-SHA","TLSv1/SSLv3",128,128],
+    ["AES256-GCM-SHA384","TLSv1/SSLv3",256,256],
+    ["AES256-SHA256","TLSv1/SSLv3",256,256],
+    ["AES256-SHA","TLSv1/SSLv3",256,256],
+    ["CAMELLIA128-SHA","TLSv1/SSLv3",128,128],
+    ["CAMELLIA256-SHA","TLSv1/SSLv3",256,256],
+    ["DES-CBC3-SHA","TLSv1/SSLv3",168,168],
+    ["DES-CBC-SHA","TLSv1/SSLv3",56,56],
+    ["DHE-DSS-AES128-GCM-SHA256","TLSv1/SSLv3",128,128],
+    ["DHE-DSS-AES128-SHA256","TLSv1/SSLv3",128,128],
+    ["DHE-DSS-AES128-SHA","TLSv1/SSLv3",128,128],
+    ["DHE-DSS-AES256-GCM-SHA384","TLSv1/SSLv3",256,256],
+    ["DHE-DSS-AES256-SHA256","TLSv1/SSLv3",256,256],
+    ["DHE-DSS-AES256-SHA","TLSv1/SSLv3",256,256],
+    ["DHE-DSS-CAMELLIA128-SHA","TLSv1/SSLv3",128,128],
+    ["DHE-DSS-CAMELLIA256-SHA","TLSv1/SSLv3",256,256],
+    ["DHE-DSS-SEED-SHA","TLSv1/SSLv3",128,128],
+    ["DHE-RSA-AES128-GCM-SHA256","TLSv1/SSLv3",128,128],
+    ["DHE-RSA-AES128-SHA256","TLSv1/SSLv3",128,128],
+    ["DHE-RSA-AES128-SHA","TLSv1/SSLv3",128,128],
+    ["DHE-RSA-AES256-GCM-SHA384","TLSv1/SSLv3",256,256],
+    ["DHE-RSA-AES256-SHA256","TLSv1/SSLv3",256,256],
+    ["DHE-RSA-AES256-SHA","TLSv1/SSLv3",256,256],
+    ["DHE-RSA-CAMELLIA128-SHA","TLSv1/SSLv3",128,128],
+    ["DHE-RSA-CAMELLIA256-SHA","TLSv1/SSLv3",256,256],
+    ["DHE-RSA-SEED-SHA","TLSv1/SSLv3",128,128],
+    ["ECDH-ECDSA-AES128-GCM-SHA256","TLSv1/SSLv3",128,128],
+    ["ECDH-ECDSA-AES128-SHA256","TLSv1/SSLv3",128,128],
+    ["ECDH-ECDSA-AES128-SHA","TLSv1/SSLv3",128,128],
+    ["ECDH-ECDSA-AES256-GCM-SHA384","TLSv1/SSLv3",256,256],
+    ["ECDH-ECDSA-AES256-SHA384","TLSv1/SSLv3",256,256],
+    ["ECDH-ECDSA-AES256-SHA","TLSv1/SSLv3",256,256],
+    ["ECDH-ECDSA-DES-CBC3-SHA","TLSv1/SSLv3",168,168],
+    ["ECDH-ECDSA-RC4-SHA","TLSv1/SSLv3",128,128],
+    ["ECDHE-ECDSA-AES128-GCM-SHA256","TLSv1/SSLv3",128,128],
+    ["ECDHE-ECDSA-AES128-SHA256","TLSv1/SSLv3",128,128],
+    ["ECDHE-ECDSA-AES128-SHA","TLSv1/SSLv3",128,128],
+    ["ECDHE-ECDSA-AES256-GCM-SHA384","TLSv1/SSLv3",256,256],
+    ["ECDHE-ECDSA-AES256-SHA384","TLSv1/SSLv3",256,256],
+    ["ECDHE-ECDSA-AES256-SHA","TLSv1/SSLv3",256,256],
+    ["ECDHE-ECDSA-DES-CBC3-SHA","TLSv1/SSLv3",168,168],
+    ["ECDHE-ECDSA-RC4-SHA","TLSv1/SSLv3",128,128],
+    ["ECDHE-RSA-AES128-GCM-SHA256","TLSv1/SSLv3",128,128],
+    ["ECDHE-RSA-AES128-SHA256","TLSv1/SSLv3",128,128],
+    ["ECDHE-RSA-AES128-SHA","TLSv1/SSLv3",128,128],
+    ["ECDHE-RSA-AES256-GCM-SHA384","TLSv1/SSLv3",256,256],
+    ["ECDHE-RSA-AES256-SHA384","TLSv1/SSLv3",256,256],
+    ["ECDHE-RSA-AES256-SHA","TLSv1/SSLv3",256,256],
+    ["ECDHE-RSA-DES-CBC3-SHA","TLSv1/SSLv3",168,168],
+    ["ECDHE-RSA-RC4-SHA","TLSv1/SSLv3",128,128],
+    ["ECDH-RSA-AES128-GCM-SHA256","TLSv1/SSLv3",128,128],
+    ["ECDH-RSA-AES128-SHA256","TLSv1/SSLv3",128,128],
+    ["ECDH-RSA-AES128-SHA","TLSv1/SSLv3",128,128],
+    ["ECDH-RSA-AES256-GCM-SHA384","TLSv1/SSLv3",256,256],
+    ["ECDH-RSA-AES256-SHA384","TLSv1/SSLv3",256,256],
+    ["ECDH-RSA-AES256-SHA","TLSv1/SSLv3",256,256],
+    ["ECDH-RSA-DES-CBC3-SHA","TLSv1/SSLv3",168,168],
+    ["ECDH-RSA-RC4-SHA","TLSv1/SSLv3",128,128],
+    ["EDH-DSS-DES-CBC3-SHA","TLSv1/SSLv3",168,168],
     ["EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56],
-    ["DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], 
-    ["EXP-EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], 
-    ["EXP-EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], 
-    ["EXP-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], 
-    ["EXP-RC2-CBC-MD5", "TLSv1/SSLv3", 40, 128], 
+    ["EDH-DSS-DES-CBC-SHA","TLSv1/SSLv3",56,56],
+    ["EDH-RSA-DES-CBC3-SHA","TLSv1/SSLv3",168,168],
+    ["EDH-RSA-DES-CBC-SHA","TLSv1/SSLv3",56,56],
+    ["EXP-DES-CBC-SHA","TLSv1/SSLv3",40,56],
+    ["EXP-EDH-DSS-DES-CBC-SHA","TLSv1/SSLv3",40,56],
+    ["EXP-EDH-RSA-DES-CBC-SHA","TLSv1/SSLv3",40,56],
+    ["EXP-RC2-CBC-MD5","TLSv1/SSLv3",40,128],
     ["EXP-RC4-MD5", "TLSv1/SSLv3", 40, 128],
+    ["PSK-3DES-EDE-CBC-SHA","TLSv1/SSLv3",168,168],
+    ["PSK-AES128-CBC-SHA","TLSv1/SSLv3",128,128],
+    ["PSK-AES256-CBC-SHA","TLSv1/SSLv3",256,256],
+    ["PSK-RC4-SHA","TLSv1/SSLv3",128,128],
+    ["RC4-MD5","TLSv1/SSLv3",128,128],
+    ["RC4-SHA","TLSv1/SSLv3",128,128],
+    ["SEED-SHA","TLSv1/SSLv3",128,128],
+    ["SRP-DSS-3DES-EDE-CBC-SHA","TLSv1/SSLv3",168,168],
+    ["SRP-DSS-AES-128-CBC-SHA","TLSv1/SSLv3",128,128],
+    ["SRP-DSS-AES-256-CBC-SHA","TLSv1/SSLv3",256,256],
+    ["SRP-RSA-3DES-EDE-CBC-SHA","TLSv1/SSLv3",168,168],
+    ["SRP-RSA-AES-128-CBC-SHA","TLSv1/SSLv3",128,128],
+    ["SRP-RSA-AES-256-CBC-SHA","TLSv1/SSLv3",256,256],
   ]
 
   # stomp URL regex pattern, for e.g. login:passcode@host:port or host:port