protocol-zmtp 0.8.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81270e34092271f0e0aaceed0ce882885751def59b75716872d074952e4d6b41
-  data.tar.gz: ccbf823376d70d8654384b99c1bb30b270dc9493cd432c524a3caab175eaa364
+  metadata.gz: 303ee019ebede5cddca93226c136233c19b7ec6e54cad7ef0deba5f5a5f6e347
+  data.tar.gz: 229f46c1a06f1fe7d02a3b1a518fee8958786959fa0b43fe6587d47392c9d602
 SHA512:
-  metadata.gz: f148b0ac01768320f35f2edf7ac67f3d51ad3e5daa4a9c9dafccb57168e8e9f616f6f27425c00b82edcd7e0af898188ae37ea3a78f404a786bdd9a94c01cb675
-  data.tar.gz: bdab4d4b763394ea1f11aec4503a74d68f499671c93851adc96c2e34bcd7134de837b71941119a1aa029a0966c4ed4cfea8def3f5140244e50f9c2a9b3b0355d
+  metadata.gz: 38345cf8abc4d1ed198a90abe714d15dd5cc8877fd22ba25f672c9ff4c02a36e9c7754a6c3998fc3b0cf9dd8972e54595be4c953c4e18d0acecaf3363b5971d2
+  data.tar.gz: 50c74c72d1926d1bd3756cf130d57039337f75f34c47d701b7b7a936e9f3d9b57e9f203e6b841b454b9de5d99624ada8239dbfb6e2f8cf8285ae991aa94b9828

data/lib/protocol/zmtp/codec/command.rb

@@ -70,20 +70,14 @@ module Protocol
         end
 
 
-        # Builds a READY command with Socket-Type, Identity, optional X-QoS,
-        # and any extra properties supplied by upper layers (e.g. an
-        # extension that injects an `X-Compression` property).
+        # Builds a READY command with Socket-Type, Identity, and any
+        # extra properties supplied by upper layers (e.g. an extension
+        # that injects +X-QoS+ or +X-Compression+).
         #
-        # @param qos [Integer] QoS level (0 = omitted)
-        # @param qos_hash [String] supported hash algorithms in preference order (e.g. "xXsS")
-        # @param metadata [Hash{String => String}] additional READY properties
+        # @param metadata [Hash{String => String}, nil] additional READY properties
         # @return [Command]
-        def self.ready(socket_type:, identity: "", qos: 0, qos_hash: "", metadata: nil)
+        def self.ready(socket_type:, identity: "", metadata: nil)
           props = { "Socket-Type" => socket_type, "Identity" => identity }
-          if qos > 0
-            props["X-QoS"]      = qos.to_s
-            props["X-QoS-Hash"] = qos_hash unless qos_hash.empty?
-          end
           props.merge!(metadata) if metadata && !metadata.empty?
           new("READY", encode_properties(props))
         end

data/lib/protocol/zmtp/codec/frame.rb

@@ -28,51 +28,6 @@ module Protocol
         FLAG_BYTES = Array.new(256) { |i| i.chr.b.freeze }.freeze
 
 
-        # @return [String] frame body (binary)
-        attr_reader :body
-
-
-        # @param body [String] frame body
-        # @param more [Boolean] more frames follow
-        # @param command [Boolean] this is a command frame
-        def initialize(body, more: false, command: false)
-          @body    = body.encoding == Encoding::BINARY ? body : body.b
-          @more    = more
-          @command = command
-        end
-
-
-        # @return [Boolean] true if more frames follow in this message
-        def more?
-          @more
-        end
-
-
-        # @return [Boolean] true if this is a command frame
-        def command?
-          @command
-        end
-
-
-        # Encodes to wire bytes.
-        #
-        # @return [String] binary wire representation (flags + size + body)
-        def to_wire
-          size  = @body.bytesize
-          flags = 0
-          flags |= FLAGS_MORE if @more
-          flags |= FLAGS_COMMAND if @command
-
-          if size > SHORT_MAX
-            buf = String.new(capacity: 9 + size, encoding: Encoding::BINARY)
-            buf << FLAG_BYTES[flags | FLAGS_LONG] << [size].pack("Q>") << @body
-          else
-            buf = String.new(capacity: 2 + size, encoding: Encoding::BINARY)
-            buf << FLAG_BYTES[flags] << FLAG_BYTES[size] << @body
-          end
-        end
-
-
         # Encodes a multi-part message into a single wire-format string.
         # The result can be written to multiple connections without
         # re-encoding each time (useful for fan-out patterns like PUB).
@@ -82,33 +37,38 @@ module Protocol
         #
         def self.encode_message(parts)
           if parts.size == 1
-            s = parts[0].bytesize
-            wire_size = s > SHORT_MAX ? 9 + s : 2 + s
+            s    = parts.first.bytesize
+            wire = s > SHORT_MAX ? 9 + s : 2 + s
           else
-            wire_size = 0
-            j = 0
+            wire = 0
+            j    = 0
+
             while j < parts.size
-              s = parts[j].bytesize
-              wire_size += s > SHORT_MAX ? 9 + s : 2 + s
-              j += 1
+              s     = parts[j].bytesize
+              wire += s > SHORT_MAX ? 9 + s : 2 + s
+              j    += 1
             end
           end
 
-          buf  = String.new(capacity: wire_size, encoding: Encoding::BINARY)
+          buf  = String.new(capacity: wire, encoding: Encoding::BINARY)
           last = parts.size - 1
           i    = 0
 
           while i < parts.size
             body  = parts[i]
-            body  = body.b unless body.encoding == Encoding::BINARY
             size  = body.bytesize
             flags = i < last ? FLAGS_MORE : 0
 
             if size > SHORT_MAX
-              buf << FLAG_BYTES[flags | FLAGS_LONG] << [size].pack("Q>") << body
+              buf << FLAG_BYTES[flags | FLAGS_LONG]
+              buf << [size].pack("Q>")
+              buf << body
             else
-              buf << FLAG_BYTES[flags] << FLAG_BYTES[size] << body
+              buf << FLAG_BYTES[flags]
+              buf << FLAG_BYTES[size]
+              buf << body
             end
+
             i += 1
           end
 
@@ -118,49 +78,107 @@ module Protocol
 
         # Reads one frame from an IO-like object.
         #
-        # @param io [#read_exactly] must support read_exactly(n)
+        # Uses #peek to buffer just enough header bytes (2 for short frames,
+        # 9 for long), then drains header + body in a single #read_exactly.
+        # This is 2 calls for both short and long frames, vs the naive 3 for
+        # long. A speculative read_exactly(9) would be unsafe: a <7-byte
+        # short frame at idle would hang waiting for bytes that never arrive,
+        # or consume bytes from the next frame on a mixed stream.
+        #
+        # @param io [#peek, #read_exactly]
         # @return [Frame]
         # @raise [Error] on invalid frame
         # @raise [EOFError] if the connection is closed
         def self.read_from(io, max_message_size: nil)
-          # Every valid frame has at least 2 header bytes (flags + 1 size
-          # byte for short frames, or flags + first size byte for long).
-          # Fetching both up-front gives short frames a 2-call read path
-          # (header + body) instead of 3.
-          head  = io.read_exactly(2)
-          flags = head.getbyte(0)
+          buf = io.peek do |b|
+            next false if b.bytesize < 2
+            (b.getbyte(0) & FLAGS_LONG) == 0 || b.bytesize >= 9
+          end
+
+          raise EOFError, "Stream finished before reading frame header" if buf.bytesize < 2
 
+          flags   = buf.getbyte(0)
           more    = (flags & FLAGS_MORE) != 0
           long    = (flags & FLAGS_LONG) != 0
           command = (flags & FLAGS_COMMAND) != 0
-          size    = long ? read_long_size(io, head.getbyte(1)) : head.getbyte(1)
+
+          if long
+            raise EOFError, "Stream finished before reading long frame size" if buf.bytesize < 9
+
+            size = (buf.getbyte(1) << 56) |
+                   (buf.getbyte(2) << 48) |
+                   (buf.getbyte(3) << 40) |
+                   (buf.getbyte(4) << 32) |
+                   (buf.getbyte(5) << 24) |
+                   (buf.getbyte(6) << 16) |
+                   (buf.getbyte(7) << 8)  |
+                    buf.getbyte(8)
+            header_size = 9
+          else
+            size        = buf.getbyte(1)
+            header_size = 2
+          end
 
           if max_message_size && size > max_message_size
             raise Error, "frame size #{size} exceeds max_message_size #{max_message_size}"
           end
 
-          body = size > 0 ? io.read_exactly(size) : EMPTY_BINARY
+          if size.zero?
+            io.read_exactly(header_size)
+            return new(EMPTY_BINARY, more: more, command: command)
+          end
 
-          new(body, more: more, command: command)
+          wire = io.read_exactly(header_size + size)
+          new(wire.byteslice(header_size, size), more: more, command: command)
         end
 
 
-        # Reads the remaining 7 bytes of a long frame's 8-byte big-endian
-        # size field and combines them with +msb+ (already consumed as the
-        # second byte of the 2-byte speculative header read).
-        #
-        # @param io [#read_exactly]
-        # @param msb [Integer] first (most-significant) byte of the size
-        # @return [Integer] full 64-bit frame size
+        # @return [String] frame body (binary)
+        attr_reader :body
+
+
+        # @param body [String] frame body
+        # @param more [Boolean] more frames follow
+        # @param command [Boolean] this is a command frame
+        def initialize(body, more: false, command: false)
+          @body    = body
+          @more    = more
+          @command = command
+        end
+
+
+        # @return [Boolean] true if more frames follow in this message
+        def more?
+          @more
+        end
+
+
+        # @return [Boolean] true if this is a command frame
+        def command?
+          @command
+        end
+
+
+        # Encodes to wire bytes.
         #
-        def self.read_long_size(io, msb)
-          rest = io.read_exactly(7)
-
-          (msb << 56) |
-            (rest.getbyte(0) << 48) | (rest.getbyte(1) << 40) |
-            (rest.getbyte(2) << 32) | (rest.getbyte(3) << 24) |
-            (rest.getbyte(4) << 16) | (rest.getbyte(5) << 8)  |
-             rest.getbyte(6)
+        # @return [String] binary wire representation (flags + size + body)
+        def to_wire
+          size   = @body.bytesize
+          flags  = 0
+          flags |= FLAGS_MORE if @more
+          flags |= FLAGS_COMMAND if @command
+
+          if size > SHORT_MAX
+            buf = String.new(capacity: 9 + size, encoding: Encoding::BINARY)
+            buf << FLAG_BYTES[flags | FLAGS_LONG]
+            buf << [size].pack("Q>")
+            buf << @body
+          else
+            buf = String.new(capacity: 2 + size, encoding: Encoding::BINARY)
+            buf << FLAG_BYTES[flags]
+            buf << FLAG_BYTES[size]
+            buf << @body
+          end
         end
 
       end

data/lib/protocol/zmtp/connection.rb

@@ -20,16 +20,14 @@ module Protocol
       attr_reader :peer_identity
 
 
-      # @return [Integer] peer's QoS level (from READY handshake, 0 if absent)
-      attr_reader :peer_qos
-
-
-      # @return [String] peer's supported hash algorithms in preference order
-      attr_reader :peer_qos_hash
+      # @return [Object, nil] peer's CURVE long-term public key post-handshake
+      #   (+crypto::PublicKey+ when the mechanism is CURVE; +nil+ for NULL).
+      attr_reader :peer_public_key
 
 
       # @return [Hash{String => String}, nil] full peer READY property hash
-      #   (set after a successful handshake; nil before)
+      #   (set after a successful handshake; nil before).
+      #   Upper layers extract their own X-* properties from here.
       attr_reader :peer_properties
 
 
@@ -42,7 +40,7 @@ module Protocol
       attr_reader :peer_minor
 
 
-      # @return [Object] transport IO (#read_exactly, #write, #flush, #close)
+      # @return [Object] transport IO (#peek, #read_exactly, #write, #flush, #close)
       attr_reader :io
 
 
@@ -50,14 +48,18 @@ module Protocol
       attr_reader :last_received_at
 
 
-      # @param io [#read_exactly, #write, #flush, #close] transport IO
+      # @param io [#peek, #read_exactly, #write, #flush, #close] transport IO
       # @param socket_type [String] our socket type name (e.g. "REQ")
       # @param identity [String] our identity
       # @param as_server [Boolean] whether we are the server side
       # @param mechanism [Mechanism::Null, Mechanism::Curve] security mechanism
       # @param max_message_size [Integer, nil] max frame size in bytes, nil = unlimited
+      # @param opts [Hash{String => String}] extra READY properties to
+      #   advertise (e.g. +"X-QoS" => "1"+). Upper-layer extensions use
+      #   this to inject their own negotiated properties without the
+      #   codec needing to know about them.
       def initialize(io, socket_type:, identity: "", as_server: false,
-                     mechanism: nil, max_message_size: nil, qos: 0, qos_hash: "")
+                     mechanism: nil, max_message_size: nil, **opts)
         @io               = io
         @socket_type      = socket_type
         @identity         = identity
@@ -65,13 +67,11 @@ module Protocol
         @mechanism        = mechanism || Mechanism::Null.new
         @peer_socket_type = nil
         @peer_identity    = nil
-        @peer_qos         = nil
-        @peer_qos_hash    = nil
+        @peer_public_key  = nil
         @peer_properties  = nil
         @peer_major       = nil
         @peer_minor       = nil
-        @qos              = qos
-        @qos_hash         = qos_hash
+        @metadata         = opts.empty? ? nil : opts.transform_keys(&:to_s)
         @mutex            = Mutex.new
         @max_message_size = max_message_size
         @last_received_at = nil
@@ -92,13 +92,11 @@ module Protocol
           as_server:   @as_server,
           socket_type: @socket_type,
           identity:    @identity,
-          qos:         @qos,
-          qos_hash:    @qos_hash
+          metadata:    @metadata
 
         @peer_socket_type = result[:peer_socket_type]
         @peer_identity    = result[:peer_identity]
-        @peer_qos         = result[:peer_qos] || 0
-        @peer_qos_hash    = result[:peer_qos_hash] || ""
+        @peer_public_key  = result[:peer_public_key]
         @peer_properties  = result[:peer_properties]
         @peer_major       = result[:peer_major]
         @peer_minor       = result[:peer_minor]
@@ -114,6 +112,17 @@ module Protocol
       end
 
 
+      # Returns a {PeerInfo} value bundling the peer's CURVE public key
+      # and identity for use as a stable per-peer key (frozen, hash-usable).
+      # Nil before the handshake has completed.
+      #
+      # @return [PeerInfo, nil]
+      def peer_info
+        return nil unless @peer_socket_type
+        PeerInfo.new(public_key: @peer_public_key, identity: @peer_identity)
+      end
+
+
       # Sends a multi-frame message (write + flush).
       #
       # @param parts [Array<String>] message frames
@@ -214,11 +223,11 @@ module Protocol
             next
           end
 
-          frames << frame.body.freeze
+          frames << frame.body
           break unless frame.more?
         end
 
-        frames.freeze
+        frames
       end
 
 

data/lib/protocol/zmtp/mechanism/curve.rb

@@ -23,10 +23,6 @@ module Protocol
       class Curve
         MECHANISM_NAME = "CURVE"
 
-        # Extra READY/INITIATE properties merged in by extensions
-        # (e.g. ZMTP-Zstd's X-Compression). nil = none.
-        attr_accessor :metadata
-
 
         # Nonce prefixes.
         NONCE_PREFIX_HELLO     = "CurveZMQHELLO---"
@@ -100,10 +96,9 @@ module Protocol
             end
           end
 
-          @session_box      = nil
-          @send_nonce       = 0
-          @recv_nonce       = -1
-          @metadata = nil
+          @session_box = nil
+          @send_nonce  = 0
+          @recv_nonce  = -1
         end
 
 
@@ -139,15 +134,14 @@ module Protocol
         # @param as_server [Boolean] ignored -- uses the value from #initialize
         # @param socket_type [String] our socket type name
         # @param identity [String] our identity
-        # @param qos [Integer] QoS level
-        # @param qos_hash [String] supported hash algorithms
-        # @return [Hash] { peer_socket_type:, peer_identity:, peer_qos:, peer_qos_hash: }
+        # @param metadata [Hash{String => String}, nil] extra READY properties
+        # @return [Hash] { peer_socket_type:, peer_identity:, peer_properties: }
         # @raise [Error] on handshake failure
-        def handshake!(io, as_server:, socket_type:, identity:, qos: 0, qos_hash: "")
+        def handshake!(io, as_server:, socket_type:, identity:, metadata: nil)
           if @as_server
-            server_handshake!(io, socket_type:, identity:, qos:, qos_hash:)
+            server_handshake!(io, socket_type:, identity:, metadata:)
           else
-            client_handshake!(io, socket_type:, identity:, qos:, qos_hash:)
+            client_handshake!(io, socket_type:, identity:, metadata:)
           end
         end
 
@@ -227,7 +221,7 @@ module Protocol
         # Client-side handshake
         # ----------------------------------------------------------------
 
-        def client_handshake!(io, socket_type:, identity:, qos: 0, qos_hash: "")
+        def client_handshake!(io, socket_type:, identity:, metadata: nil)
           cn_secret = @crypto::PrivateKey.generate
           cn_public = cn_secret.public_key
 
@@ -288,18 +282,14 @@ module Protocol
           vouch           = @crypto::Box.new(sn_public, @permanent_secret).encrypt(vouch_nonce, vouch_plaintext)
 
           props = { "Socket-Type" => socket_type, "Identity" => identity }
-          if qos > 0
-            props["X-QoS"]      = qos.to_s
-            props["X-QoS-Hash"] = qos_hash unless qos_hash.empty?
-          end
-          props.merge!(@metadata) if @metadata
-          metadata = Codec::Command.encode_properties(props)
+          props.merge!(metadata) if metadata && !metadata.empty?
+          metadata_bytes = Codec::Command.encode_properties(props)
 
           initiate_box_plaintext = "".b
           initiate_box_plaintext << @permanent_public.to_s
           initiate_box_plaintext << vouch_nonce.byteslice(8, 16)
           initiate_box_plaintext << vouch
-          initiate_box_plaintext << metadata
+          initiate_box_plaintext << metadata_bytes
 
           init_short_nonce = [1].pack("Q>")
           init_nonce       = NONCE_PREFIX_INITIATE + init_short_nonce
@@ -336,8 +326,6 @@ module Protocol
           props            = Codec::Command.decode_properties(r_plaintext)
           peer_socket_type = props["Socket-Type"]
           peer_identity    = props["Identity"] || ""
-          peer_qos         = (props["X-QoS"] || "0").to_i
-          peer_qos_hash    = props["X-QoS-Hash"] || ""
 
           @session_box = session
           @send_nonce  = 1
@@ -347,8 +335,7 @@ module Protocol
           {
             peer_socket_type: peer_socket_type,
             peer_identity:    peer_identity,
-            peer_qos:         peer_qos,
-            peer_qos_hash:    peer_qos_hash,
+            peer_public_key:  @server_public,
             peer_properties:  props,
             peer_major:       @peer_major,
             peer_minor:       @peer_minor,
@@ -360,7 +347,7 @@ module Protocol
         # Server-side handshake
         # ----------------------------------------------------------------
 
-        def server_handshake!(io, socket_type:, identity:, qos: 0, qos_hash: "")
+        def server_handshake!(io, socket_type:, identity:, metadata: nil)
           io.write(Codec::Greeting.encode(mechanism: MECHANISM_NAME, as_server: true))
           io.flush
           peer_greeting = Codec::Greeting.read_from(io)
@@ -478,7 +465,7 @@ module Protocol
           end
 
           if @authenticator
-            peer = PeerInfo.new(public_key: client_permanent)
+            peer = PeerInfo.new(public_key: client_permanent, identity: "")
             unless @authenticator.call(peer)
               send_error(io, "client key not authorized")
               raise Error, "client key not authorized"
@@ -488,11 +475,7 @@ module Protocol
 
           # --- READY ---
           ready_props = { "Socket-Type" => socket_type, "Identity" => identity }
-          if qos > 0
-            ready_props["X-QoS"]      = qos.to_s
-            ready_props["X-QoS-Hash"] = qos_hash unless qos_hash.empty?
-          end
-          ready_props.merge!(@metadata) if @metadata
+          ready_props.merge!(metadata) if metadata && !metadata.empty?
           ready_metadata = Codec::Command.encode_properties(ready_props)
 
           r_short_nonce = [1].pack("Q>")
@@ -517,8 +500,7 @@ module Protocol
           {
             peer_socket_type: props["Socket-Type"],
             peer_identity:    props["Identity"] || "",
-            peer_qos:         (props["X-QoS"] || "0").to_i,
-            peer_qos_hash:    props["X-QoS-Hash"] || "",
+            peer_public_key:  client_permanent,
             peer_properties:  props,
             peer_major:       @peer_major,
             peer_minor:       @peer_minor,

data/lib/protocol/zmtp/mechanism/null.rb

@@ -11,16 +11,6 @@ module Protocol
       class Null
         MECHANISM_NAME = "NULL"
 
-        # Extra READY properties an upper layer (e.g. an OMQ extension)
-        # wants this side to advertise. Mutated before #handshake!.
-        # @return [Hash{String => String}]
-        attr_accessor :metadata
-
-
-        def initialize
-          @metadata = nil
-        end
-
 
         # Performs the full NULL handshake over +io+.
         #
@@ -32,9 +22,10 @@ module Protocol
         # @param as_server [Boolean]
         # @param socket_type [String]
         # @param identity [String]
-        # @return [Hash] { peer_socket_type:, peer_identity:, peer_qos:, peer_qos_hash:, peer_properties:, peer_major:, peer_minor: }
+        # @param metadata [Hash{String => String}, nil] extra READY properties
+        # @return [Hash] { peer_socket_type:, peer_identity:, peer_public_key:, peer_properties:, peer_major:, peer_minor: }
         # @raise [Error]
-        def handshake!(io, as_server:, socket_type:, identity:, qos: 0, qos_hash: "")
+        def handshake!(io, as_server:, socket_type:, identity:, metadata: nil)
           io.write(Codec::Greeting.encode(mechanism: MECHANISM_NAME, as_server: as_server))
           io.flush
 
@@ -45,11 +36,9 @@ module Protocol
           end
 
           ready_cmd = Codec::Command.ready(
-            socket_type:      socket_type,
-            identity:         identity,
-            qos:              qos,
-            qos_hash:         qos_hash,
-            metadata: @metadata,
+            socket_type: socket_type,
+            identity:    identity,
+            metadata:    metadata,
           )
           io.write(ready_cmd.to_frame.to_wire)
           io.flush
@@ -67,8 +56,6 @@ module Protocol
           props            = peer_cmd.properties
           peer_socket_type = props["Socket-Type"]
           peer_identity    = props["Identity"] || ""
-          peer_qos         = (props["X-QoS"] || "0").to_i
-          peer_qos_hash    = props["X-QoS-Hash"] || ""
 
           unless peer_socket_type
             raise Error, "peer READY missing Socket-Type"
@@ -77,8 +64,7 @@ module Protocol
           {
             peer_socket_type: peer_socket_type,
             peer_identity:    peer_identity,
-            peer_qos:         peer_qos,
-            peer_qos_hash:    peer_qos_hash,
+            peer_public_key:  nil,
             peer_properties:  props,
             peer_major:       peer_greeting[:major],
             peer_minor:       peer_greeting[:minor],

data/lib/protocol/zmtp/mechanism/plain.rb

@@ -16,22 +16,15 @@ module Protocol
         MECHANISM_NAME = "PLAIN"
 
 
-        # Extra READY/INITIATE properties an upper layer wants this side to
-        # advertise. Mutated before #handshake!.
-        # @return [Hash{String => String}]
-        attr_accessor :metadata
-
-
         # @param username [String] client username (max 255 bytes)
         # @param password [String] client password (max 255 bytes)
         # @param authenticator [#call, nil] server-side credential verifier;
         #   called as +authenticator.call(username, password)+ and must return
         #   truthy to accept the connection.  When +nil+, all credentials pass.
         def initialize(username: "", password: "", authenticator: nil)
-          @username         = username
-          @password         = password
-          @authenticator    = authenticator
-          @metadata = nil
+          @username      = username
+          @password      = password
+          @authenticator = authenticator
         end
 
 
@@ -41,9 +34,10 @@ module Protocol
         # @param as_server [Boolean]
         # @param socket_type [String]
         # @param identity [String]
-        # @return [Hash] { peer_socket_type:, peer_identity: }
+        # @param metadata [Hash{String => String}, nil] extra READY properties
+        # @return [Hash] { peer_socket_type:, peer_identity:, peer_properties: }
         # @raise [Error]
-        def handshake!(io, as_server:, socket_type:, identity:, qos: 0, qos_hash: "")
+        def handshake!(io, as_server:, socket_type:, identity:, metadata: nil)
           io.write(Codec::Greeting.encode(mechanism: MECHANISM_NAME, as_server: as_server))
           io.flush
 
@@ -54,11 +48,9 @@ module Protocol
           end
 
           if as_server
-            server_handshake! io, socket_type: socket_type, identity: identity,
-              qos: qos, qos_hash: qos_hash
+            server_handshake! io, socket_type: socket_type, identity: identity, metadata: metadata
           else
-            client_handshake! io, socket_type: socket_type, identity: identity,
-              qos: qos, qos_hash: qos_hash
+            client_handshake! io, socket_type: socket_type, identity: identity, metadata: metadata
           end
         end
 
@@ -72,7 +64,7 @@ module Protocol
         private
 
 
-        def client_handshake!(io, socket_type:, identity:, qos: 0, qos_hash: "")
+        def client_handshake!(io, socket_type:, identity:, metadata: nil)
           send_command(io, hello_command)
 
           cmd = read_command(io)
@@ -80,15 +72,9 @@ module Protocol
 
           props = {
             "Socket-Type" => socket_type,
-            "Identity" => identity
+            "Identity" => identity,
           }
-
-          if qos > 0
-            props["X-QoS"]      = qos.to_s
-            props["X-QoS-Hash"] = qos_hash unless qos_hash.empty?
-          end
-
-          props.merge!(@metadata) if @metadata && !@metadata.empty?
+          props.merge!(metadata) if metadata && !metadata.empty?
           initiate = Codec::Command.new("INITIATE", Codec::Command.encode_properties(props))
           send_command(io, initiate)
 
@@ -99,7 +85,7 @@ module Protocol
         end
 
 
-        def server_handshake!(io, socket_type:, identity:, qos: 0, qos_hash: "")
+        def server_handshake!(io, socket_type:, identity:, metadata: nil)
           cmd = read_command(io)
           raise Error, "expected HELLO, got #{cmd.name}" unless cmd.name == "HELLO"
 
@@ -116,8 +102,7 @@ module Protocol
 
           peer_info = extract_peer_info(cmd)
 
-          ready = Codec::Command.ready socket_type: socket_type, identity: identity,
-            qos: qos, qos_hash: qos_hash, metadata: @metadata
+          ready = Codec::Command.ready socket_type: socket_type, identity: identity, metadata: metadata
           send_command io, ready
 
           peer_info
@@ -165,9 +150,7 @@ module Protocol
           {
             peer_socket_type: peer_socket_type,
             peer_identity:    props["Identity"] || "",
-            peer_qos:         (props["X-QoS"] || "0").to_i,
-            peer_qos_hash:    props["X-QoS-Hash"] || "",
-            peer_properties:  props
+            peer_properties:  props,
           }
         end
 

data/lib/protocol/zmtp/peer_info.rb

@@ -2,8 +2,19 @@
 
 module Protocol
   module ZMTP
-    # Context passed to an authenticator during authentication.
-    # +public_key+ is a +crypto::PublicKey+ instance.
-    PeerInfo = Data.define(:public_key)
+    # Post-handshake identity of the peer on a {Connection}.
+    #
+    # - +public_key+ is the peer's CURVE long-term +crypto::PublicKey+,
+    #   or +nil+ when the mechanism does not authenticate a key (e.g. NULL).
+    # - +identity+ is the peer's +ZMQ_IDENTITY+ string, or +""+ when no
+    #   identity was advertised in the READY metadata.
+    #
+    # Used as a peer key by upper layers (e.g. omq-qos levels 2/3): the
+    # whole value object is frozen and equality-comparable, so it can be
+    # stored directly in a Hash without picking one anchor over the other.
+    #
+    # Also passed to CURVE authenticators during the handshake (at that
+    # point +identity+ is +""+, since it arrives post-auth).
+    PeerInfo = Data.define(:public_key, :identity)
   end
 end

data/lib/protocol/zmtp/version.rb

@@ -2,6 +2,6 @@
 
 module Protocol
   module ZMTP
-    VERSION = "0.8.1"
+    VERSION = "0.10.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protocol-zmtp
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Patrik Wenger