hop-endpoint 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28842786d70c3471cfb49cc90b3ed1c611de8b109816235d94328f6b470c0f83
-  data.tar.gz: '08a7c7f9782a88233bdb6064213bb47e44ca73360aa05d736e32fddfbf4bed74'
+  metadata.gz: 4444de246ab976e4d12f2e9593e8f1ec56fffe4e12fab129a6a4dbabe08961e5
+  data.tar.gz: 454cc3feaa3444df7f1f938b145815dbbd96594eba9685bfebefedfa926bf577
 SHA512:
-  metadata.gz: 3005f4bfb8aac1a6d5d796a7f39d5d978cd4af34373e3bf9917f1f3733403b74802ff9d21f103da5560eb5d4fa7080334ec14a9285b408720cdd27c4a42164e8
-  data.tar.gz: 82a538d1ea0675abf7e85001c5417abbf556499bf1ff996f3b3731cccb7e45a86a2550ce88d27dae51832e1378f089080b6c7a66a4e64dbb42a01b28cc49b9d3
+  metadata.gz: 82e7ebb9dbf5bf773ce171f3dc1944a9dd5db63eb2e6f660d8feecba8e17e246755f309fc605117a7fb72864f340d205f360d109aebd4ea2cb34d1f287d27a69
+  data.tar.gz: 53f27756553c034c6115119a0349559389520370608c3bea7b8790c306bbdd316e983bdad2e727e3b19a2eb91d11b7367ab9ba943d1a8f2ee09c615484297528

data/lib/hop/endpoint.rb

@@ -25,6 +25,9 @@ module Hop
 
     def initialize(key: nil, tick_ms: 50, cluster: nil, quorum: nil)
       Hop::FFI.assert_abi!
+      if key && key.bytesize != 32
+        raise ArgumentError, "identity key must be exactly 32 bytes, got #{key.bytesize}"
+      end
       @node = key ? Hop::FFI.node_with_secret(key) : Hop::FFI.node_new
       Hop::FFI.tick(@node, now_ms)
       Hop::FFI.publish_prekey(@node)
@@ -92,6 +95,8 @@ module Hop
       begin
         res = Timeout.timeout(timeout) { q.pop } # [status, body], or CLOSED if #close woke us
         raise "endpoint is closed" if res == CLOSED
+        accepted = with_node { |n| Hop::FFI.accept_service_response(n, req_id) }
+        raise "service response acceptance failed" unless accepted
         res
       rescue Timeout::Error
         @mutex.synchronize { @pending.delete(req_id) }

data/lib/hop/ffi.rb

@@ -13,7 +13,7 @@ module Hop
     CH = Fiddle::TYPE_CHAR
     V  = Fiddle::TYPE_VOID
 
-    ABI_EXPECTED = 3
+    ABI_EXPECTED = 5
 
     def self.lib_path
       ext = case RbConfig::CONFIG["host_os"]
@@ -48,10 +48,12 @@ module Hop
     DRAIN_OUTGOING         = fn("hop_drain_outgoing", [P, P, P], V)
     SUBSCRIBE              = fn("hop_subscribe", [P, P], V)
     PUBLISH_PREKEY         = fn("hop_publish_prekey", [P], CH)
+    ACCEPT_INBOX           = fn("hop_accept_inbox", [P, P], CH)
     SEND_SERVICE_REQUEST   = fn("hop_send_service_request", [P, P, P, P, P, SZ, P], CH)
     SEND_SERVICE_RESPONSE  = fn("hop_send_service_response", [P, P, P, I, P, SZ], CH)
     POLL_SERVICE_REQUESTS  = fn("hop_poll_service_requests", [P, P, P], V)
     POLL_SERVICE_RESPONSES = fn("hop_poll_service_responses", [P, P, P], V)
+    ACCEPT_SERVICE_RESPONSE = fn("hop_accept_service_response", [P, P], CH)
     ADDRESS_TO_BASE58      = fn("hop_address_to_base58", [P, P, SZ], SZ)
     ADDRESS_FROM_BASE58    = fn("hop_address_from_base58", [P, P], CH)
     SIGN_REACH_RECORD      = fn("hop_sign_reach_record", [P, P, I, P, P], V)
@@ -69,6 +71,13 @@ module Hop
       raise "libhop ABI mismatch: wrapper expects #{ABI_EXPECTED}, library reports #{got}" if got != ABI_EXPECTED
     end
 
+    def self.require_32(value, name)
+      raise ArgumentError, "#{name} must be exactly 32 bytes, got #{value.bytesize}" unless value.bytesize == 32
+
+      value
+    end
+    private_class_method :require_32
+
     # ---- helpers: read C memory that is valid only during a call ----
     def self.read_bytes(ptr, len) = len.zero? ? "".b : Fiddle::Pointer.new(ptr)[0, len].b
     def self.read_cstr(ptr) = Fiddle::Pointer.new(ptr).to_s
@@ -82,11 +91,14 @@ module Hop
     def self.disconnected(node, link) = LINK_DOWN.call(node, link)
     def self.received(node, link, data) = BYTES_RECEIVED.call(node, link, data, data.bytesize)
     def self.subscribe(node, topic) = SUBSCRIBE.call(node, topic)
-    def self.cluster_join(node, secret) = CLUSTER_JOIN.call(node, secret)
+    def self.cluster_join(node, secret) = CLUSTER_JOIN.call(node, require_32(secret, "cluster secret"))
     def self.cluster_join_passphrase(node, pass) = CLUSTER_JOIN_PASSPHRASE.call(node, pass, pass.bytesize)
     def self.cluster_members(node) = CLUSTER_MEMBERS.call(node)
     def self.cluster_set_quorum(node, min) = CLUSTER_SET_QUORUM.call(node, min)
     def self.publish_prekey(node) = PUBLISH_PREKEY.call(node) != 0
+    def self.accept_inbox(node, inbox_id)
+      ACCEPT_INBOX.call(node, require_32(inbox_id, "inbox id")) != 0
+    end
 
     def self.address(node)
       out = Fiddle::Pointer.malloc(32, Fiddle::RUBY_FREE)
@@ -103,14 +115,19 @@ module Hop
 
     def self.send_service_request(node, dst, service, method, args)
       out = Fiddle::Pointer.malloc(32, Fiddle::RUBY_FREE)
-      ok = SEND_SERVICE_REQUEST.call(node, dst, service, method, args, args.bytesize, out) != 0
+      ok = SEND_SERVICE_REQUEST.call(node, require_32(dst, "destination"), service, method, args, args.bytesize, out) != 0
       raise "hop_send_service_request failed" unless ok
 
       out[0, 32].b
     end
 
     def self.send_service_response(node, to, for_request_id, status, body)
-      SEND_SERVICE_RESPONSE.call(node, to, for_request_id, status, body, body.bytesize) != 0
+      SEND_SERVICE_RESPONSE.call(node, require_32(to, "response destination"),
+                                 require_32(for_request_id, "request id"), status, body, body.bytesize) != 0
+    end
+
+    def self.accept_service_response(node, request_id)
+      ACCEPT_SERVICE_RESPONSE.call(node, require_32(request_id, "request id")) != 0
     end
 
     def self.take_service_requests(node)
@@ -124,8 +141,9 @@ module Hop
 
     def self.take_service_responses(node)
       out = []
-      sink = Closure.new(V, [P, P, P, I, P, SZ]) do |_ctx, frm, for_id, status, body, body_len|
+      sink = Closure.new(CH, [P, P, P, I, P, SZ]) do |_ctx, frm, for_id, status, body, body_len|
         out << [read_bytes(frm, 32), read_bytes(for_id, 32), status & 0xFFFF, read_bytes(body, body_len)]
+        0
       end
       POLL_SERVICE_RESPONSES.call(node, sink, nil)
       out
@@ -133,7 +151,7 @@ module Hop
 
     def self.to_b58(addr32)
       out = Fiddle::Pointer.malloc(64, Fiddle::RUBY_FREE)
-      n = ADDRESS_TO_BASE58.call(addr32, out, 64)
+      n = ADDRESS_TO_BASE58.call(require_32(addr32, "address"), out, 64)
       out[0, n]
     end
 

data/lib/hop/wss_bearer.rb

@@ -15,7 +15,13 @@ require "hop/discovery"
 module Hop
   module WssBearer
     GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
-    MAX_FRAME_BYTES = 1 << 20
+    MAX_MESSAGE_BYTES = 1 << 20
+    MAX_FRAME_BYTES = MAX_MESSAGE_BYTES
+    MAX_HEADER_BYTES = 16 << 10
+    MAX_PENDING_CONNECTIONS = 64
+    HANDSHAKE_WORKERS = 4
+    HANDSHAKE_TIMEOUT_S = 5.0
+    READ_TIMEOUT_S = 15.0
 
     @seq = 60_000
     @seq_mutex = Mutex.new
@@ -25,6 +31,8 @@ module Hop
 
     def self.encode_frame(payload, mask)
       n = payload.bytesize
+      raise ArgumentError, "WebSocket message exceeds 1 MiB" if n > MAX_MESSAGE_BYTES
+
       header = (+"\x82").b # FIN + binary opcode
       mb = mask ? 0x80 : 0
       if n < 126
@@ -49,44 +57,117 @@ module Hop
       out
     end
 
-    def self.read_exact(sock, n)
+    def self.monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+    def self.wait_io(sock, readable, deadline)
+      remaining = deadline - monotonic
+      raise IOError, "socket deadline exceeded" unless remaining.positive?
+
+      io = sock.respond_to?(:to_io) ? sock.to_io : sock
+      ready = readable ? IO.select([io], nil, nil, remaining) : IO.select(nil, [io], nil, remaining)
+      raise IOError, "socket deadline exceeded" unless ready
+    end
+
+    def self.read_some(sock, n, deadline)
+      return sock.read(n) unless sock.respond_to?(:read_nonblock)
+
+      loop do
+        result = sock.read_nonblock(n, exception: false)
+        case result
+        when :wait_readable then wait_io(sock, true, deadline)
+        when :wait_writable then wait_io(sock, false, deadline)
+        else return result
+        end
+      end
+    end
+
+    def self.write_all(sock, data, timeout = HANDSHAKE_TIMEOUT_S)
+      return sock.write(data) unless sock.respond_to?(:write_nonblock)
+
+      deadline = monotonic + timeout
+      offset = 0
+      while offset < data.bytesize
+        result = sock.write_nonblock(data.byteslice(offset..), exception: false)
+        case result
+        when :wait_readable then wait_io(sock, true, deadline)
+        when :wait_writable then wait_io(sock, false, deadline)
+        else offset += result
+        end
+      end
+      offset
+    end
+
+    def self.read_exact(sock, n, deadline: monotonic + READ_TIMEOUT_S)
       return "".b if n.zero?
 
-      data = sock.read(n)
-      raise EOFError, "closed" unless data && data.bytesize == n
+      data = +"".b
+      while data.bytesize < n
+        chunk = read_some(sock, n - data.bytesize, deadline)
+        raise EOFError, "closed" unless chunk
 
+        data << chunk
+      end
       data
     end
 
-    def self.read_frame(sock)
-      b0, b1 = read_exact(sock, 2).bytes
+    def self.read_frame_part(sock, remaining = MAX_MESSAGE_BYTES, deadline: monotonic + READ_TIMEOUT_S)
+      b0, b1 = read_exact(sock, 2, deadline: deadline).bytes
+      raise IOError, "WebSocket extensions are not supported" unless (b0 & 0x70).zero?
+
+      final = (b0 & 0x80) != 0
       opcode = b0 & 0x0F
       masked = (b1 & 0x80) != 0
       len = b1 & 0x7F
-      len = read_exact(sock, 2).unpack1("n") if len == 126
-      len = read_exact(sock, 8).unpack1("Q>") if len == 127
-      raise IOError, "WebSocket frame exceeds 1 MiB" if len > MAX_FRAME_BYTES
-      mask = masked ? read_exact(sock, 4) : nil
-      payload = read_exact(sock, len)
+      len = read_exact(sock, 2, deadline: deadline).unpack1("n") if len == 126
+      len = read_exact(sock, 8, deadline: deadline).unpack1("Q>") if len == 127
+      raise IOError, "WebSocket message exceeds 1 MiB" if len > remaining || len > MAX_MESSAGE_BYTES
+      raise IOError, "invalid WebSocket control frame" if opcode >= 0x8 && (!final || len > 125)
+
+      mask = masked ? read_exact(sock, 4, deadline: deadline) : nil
+      payload = read_exact(sock, len, deadline: deadline)
       payload = apply_mask(payload, mask) if mask
+      [final, opcode, payload]
+    end
+
+    def self.read_frame(sock)
+      _final, opcode, payload = read_frame_part(sock)
       [opcode, payload]
     end
 
+    def self.read_message(sock)
+      deadline = monotonic + READ_TIMEOUT_S
+      final, opcode, payload = read_frame_part(sock, deadline: deadline)
+      return [opcode, payload] if opcode >= 0x8
+      raise IOError, "expected a binary WebSocket message" unless opcode == 0x2
+      return [opcode, payload] if final
+
+      parts = [payload]
+      total = payload.bytesize
+      until final
+        final, continuation, payload = read_frame_part(sock, MAX_MESSAGE_BYTES - total, deadline: deadline)
+        raise IOError, "expected a WebSocket continuation frame" unless continuation.zero?
+
+        total += payload.bytesize
+        parts << payload
+      end
+      [opcode, parts.join]
+    end
+
     def self.run_link(endpoint, sock, role, mask)
       link = next_link
       send_fn = lambda do |buf|
-        sock.write(encode_frame(buf, mask))
+        write_all(sock, encode_frame(buf, mask), READ_TIMEOUT_S)
       rescue StandardError
         nil
       end
       endpoint.register_link(link, role, send_fn)
       loop do
-        opcode, payload = read_frame(sock)
+        opcode, payload = read_message(sock)
         break if opcode == 0x8
 
-        endpoint.deliver(link, payload) if [0x2, 0x0].include?(opcode)
+        endpoint.deliver(link, payload) if opcode == 0x2
       end
-    rescue EOFError, IOError, OpenSSL::SSL::SSLError, Errno::ECONNRESET
+    rescue EOFError, IOError, OpenSSL::SSL::SSLError, SystemCallError
       nil
     ensure
       endpoint.link_down(link)
@@ -97,74 +178,270 @@ module Hop
       end
     end
 
+    class Admission
+      def initialize(limit)
+        @limit = limit
+        @lock = Mutex.new
+        @sockets = {}
+      end
+
+      def acquire(sock)
+        @lock.synchronize do
+          return nil if @sockets.size >= @limit
+
+          lease = SocketLease.new(self, sock)
+          @sockets[lease] = sock
+          lease
+        end
+      end
+
+      def replace(lease, sock)
+        @lock.synchronize { @sockets[lease] = sock if @sockets.key?(lease) }
+      end
+
+      def release(lease)
+        @lock.synchronize { @sockets.delete(lease) }
+      end
+
+      def close_all
+        sockets = @lock.synchronize { @sockets.values.dup }
+        sockets.each { |sock| sock.close rescue nil }
+      end
+
+      def count = @lock.synchronize { @sockets.size }
+    end
+
+    class SocketLease
+      attr_reader :sock
+
+      def initialize(admission, sock)
+        @admission = admission
+        @sock = sock
+        @lock = Mutex.new
+        @released = false
+      end
+
+      def replace(sock)
+        @sock = sock
+        @admission.replace(self, sock)
+      end
+
+      def release
+        @lock.synchronize do
+          return if @released
+
+          @released = true
+          @admission.release(self)
+        end
+      end
+
+      def close = (@sock.close rescue nil)
+    end
+
+    def self.ssl_accept(raw, ssl_context)
+      sock = OpenSSL::SSL::SSLSocket.new(raw, ssl_context)
+      sock.sync_close = true
+      deadline = monotonic + HANDSHAKE_TIMEOUT_S
+      loop do
+        result = sock.accept_nonblock(exception: false)
+        case result
+        when :wait_readable then wait_io(sock, true, deadline)
+        when :wait_writable then wait_io(sock, false, deadline)
+        else return sock
+        end
+      end
+    rescue StandardError
+      sock&.close rescue nil
+      raise
+    end
+
+    def self.read_http_head(sock)
+      deadline = monotonic + HANDSHAKE_TIMEOUT_S
+      data = +"".b
+      until data.include?("\r\n\r\n")
+        room = MAX_HEADER_BYTES + 1 - data.bytesize
+        chunk = read_some(sock, [4096, room].min, deadline)
+        raise EOFError, "closed" unless chunk
+
+        data << chunk
+        raise IOError, "HTTP headers exceed 16 KiB" if data.bytesize > MAX_HEADER_BYTES
+      end
+      head, rest = data.split("\r\n\r\n", 2)
+      lines = head.split("\r\n")
+      request = lines.shift&.split(" ", 3)
+      raise IOError, "malformed HTTP request line" unless request&.size == 3
+
+      headers = {}
+      lines.each do |line|
+        key, value = line.split(":", 2)
+        headers[key.strip.downcase] = value.strip if value
+      end
+      [request[0], request[1], headers, rest.to_s.b]
+    end
+
     def self.serve(endpoint, port, ssl_context, public_url, ttl_secs = 3600)
       tcp = TCPServer.new(port)
-      ssl_server = OpenSSL::SSL::SSLServer.new(tcp, ssl_context)
-      # Let endpoint#close stop the listener so this accept loop exits instead of spinning on a closed
-      # socket (accept on a closed server raises immediately, which without the break is a busy loop).
-      endpoint.register_closer { ssl_server.close rescue nil }
-      Thread.new do
-        loop do
-          sock = begin
-            ssl_server.accept
-          rescue StandardError
-            break if tcp.closed?
+      tcp.listen(MAX_PENDING_CONNECTIONS)
+      pending = SizedQueue.new(MAX_PENDING_CONNECTIONS)
+      admission = Admission.new(MAX_PENDING_CONNECTIONS)
+      closing = false
+      close_lock = Mutex.new
 
-            next
+      close_server = lambda do
+        close_lock.synchronize do
+          next if closing
+
+          closing = true
+          tcp.close rescue nil
+          admission.close_all
+          pending.close
+        end
+      end
+      endpoint.register_closer(&close_server)
+
+      HANDSHAKE_WORKERS.times do |i|
+        Thread.new do
+          Thread.current.name = "hop-wss-handshake-#{i}" if Thread.current.respond_to?(:name=)
+          loop do
+            break if close_lock.synchronize { closing && pending.empty? }
+
+            lease = pending.pop
+            break unless lease
+
+            transferred = false
+            begin
+              sock = ssl_accept(lease.sock, ssl_context)
+              lease.replace(sock)
+              transferred = handle_conn(endpoint, sock, public_url, ttl_secs, lease)
+            rescue StandardError
+              nil
+            ensure
+              unless transferred
+                lease.close
+                lease.release
+              end
+            end
           end
-          Thread.new { handle_conn(endpoint, sock, public_url, ttl_secs) }
         end
       end
-      ssl_server
-    end
 
-    def self.handle_conn(endpoint, sock, public_url, ttl_secs)
-      request_line = sock.gets
-      return unless request_line
+      Thread.new do
+        loop do
+          raw = tcp.accept
+          lease = admission.acquire(raw)
+          unless lease
+            raw.close rescue nil
+            next
+          end
+          begin
+            pending.push(lease, true)
+          rescue ThreadError
+            lease.close
+            lease.release
+          end
+        rescue IOError, Errno::EBADF
+          break
+        rescue StandardError
+          next unless close_lock.synchronize { closing }
 
-      _method, path, = request_line.split
-      headers = {}
-      while (line = sock.gets) && line != "\r\n"
-        k, v = line.split(":", 2)
-        headers[k.strip.downcase] = v.strip if v
+          break
+        end
       end
+      tcp
+    end
 
+    def self.handle_conn(endpoint, sock, public_url, ttl_secs, lease = nil)
+      _method, path, headers, rest = read_http_head(sock)
       if path == "/.well-known/hop"
         body = Hop::Discovery.well_known_body(endpoint, public_url, ttl_secs)
-        sock.write("HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: #{body.bytesize}\r\nconnection: close\r\n\r\n#{body}")
-        sock.close
+        write_all(sock, "HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: #{body.bytesize}\r\nconnection: close\r\n\r\n#{body}")
+        false
       elsif path == "/_hop" && headers["upgrade"]&.downcase == "websocket"
-        sock.write("HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: #{accept_key(headers["sec-websocket-key"])}\r\n\r\n")
-        run_link(endpoint, sock, :acceptor, false)
+        key = headers["sec-websocket-key"] or raise IOError, "missing Sec-WebSocket-Key"
+        write_all(sock, "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: #{accept_key(key)}\r\n\r\n")
+        buffered = BufferedSocket.new(sock, rest)
+        if lease
+          Thread.new do
+            begin
+              run_link(endpoint, buffered, :acceptor, false)
+            ensure
+              lease.release
+            end
+          end
+          true
+        else
+          run_link(endpoint, buffered, :acceptor, false)
+          false
+        end
       else
-        sock.write("HTTP/1.1 404 Not Found\r\nconnection: close\r\n\r\n")
-        sock.close
+        write_all(sock, "HTTP/1.1 404 Not Found\r\nconnection: close\r\n\r\n")
+        false
       end
-    rescue StandardError
-      begin
-        sock.close
-      rescue StandardError
-        nil
+    end
+
+    class BufferedSocket
+      def initialize(sock, initial)
+        @sock = sock
+        @buffer = initial
       end
+
+      def read_nonblock(n, exception: true)
+        unless @buffer.empty?
+          chunk = @buffer.byteslice(0, n)
+          @buffer = @buffer.byteslice(chunk.bytesize..) || "".b
+          return chunk
+        end
+        @sock.read_nonblock(n, exception: exception)
+      end
+
+      def write_nonblock(data, exception: true) = @sock.write_nonblock(data, exception: exception)
+      def to_io = @sock.to_io
+      def close = @sock.close
     end
 
     def self.dial(endpoint, wss_url, insecure_tls: false)
       uri = URI.parse(wss_url)
       ctx = OpenSSL::SSL::SSLContext.new
       ctx.verify_mode = insecure_tls ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
-      sock = OpenSSL::SSL::SSLSocket.new(TCPSocket.new(uri.host, uri.port || 443), ctx)
+      raw = TCPSocket.new(uri.host, uri.port || 443, connect_timeout: HANDSHAKE_TIMEOUT_S)
+      sock = OpenSSL::SSL::SSLSocket.new(raw, ctx)
+      sock.sync_close = true
       sock.hostname = uri.host
-      sock.connect
+      deadline = monotonic + HANDSHAKE_TIMEOUT_S
+      loop do
+        result = sock.connect_nonblock(exception: false)
+        case result
+        when :wait_readable then wait_io(sock, true, deadline)
+        when :wait_writable then wait_io(sock, false, deadline)
+        else break
+        end
+      end
       key = Base64.strict_encode64(Random.bytes(16))
       path = uri.path.to_s.empty? ? "/_hop" : uri.path
-      sock.write("GET #{path} HTTP/1.1\r\nHost: #{uri.host}\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: #{key}\r\nSec-WebSocket-Version: 13\r\n\r\n")
-      status = sock.gets
+      write_all(sock, "GET #{path} HTTP/1.1\r\nHost: #{uri.host}\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: #{key}\r\nSec-WebSocket-Version: 13\r\n\r\n")
+      _version, status, _headers, rest = read_http_response(sock)
       raise "WS upgrade failed: #{status}" unless status&.include?("101")
 
-      nil while (line = sock.gets) && line != "\r\n" # drain response headers
       endpoint.register_closer { sock.close rescue nil } # so endpoint#close ends run_link's read loop
-      Thread.new { run_link(endpoint, sock, :dialer, true) }
+      Thread.new { run_link(endpoint, BufferedSocket.new(sock, rest), :dialer, true) }
       sock
     end
+
+    def self.read_http_response(sock)
+      deadline = monotonic + HANDSHAKE_TIMEOUT_S
+      data = +"".b
+      until data.include?("\r\n\r\n")
+        room = MAX_HEADER_BYTES + 1 - data.bytesize
+        chunk = read_some(sock, [4096, room].min, deadline)
+        raise EOFError, "closed" unless chunk
+
+        data << chunk
+        raise IOError, "HTTP headers exceed 16 KiB" if data.bytesize > MAX_HEADER_BYTES
+      end
+      head, rest = data.split("\r\n\r\n", 2)
+      lines = head.split("\r\n")
+      status = lines.shift.to_s
+      [status.split(" ", 2).first, status, lines, rest.to_s.b]
+    end
   end
 end

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: hop-endpoint
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Jason Waldrip
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-16 00:00:00.000000000 Z
+date: 2026-07-30 00:00:00.000000000 Z
 dependencies: []
 description: Receive Hop messages in Ruby with a hop.on / reply surface, over libhop
   via Fiddle. Your service becomes directly reachable on the mesh, no relay. Zero
   gems (stdlib only).
-email: 
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -31,7 +31,7 @@ licenses:
 - Apache-2.0
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -46,8 +46,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Embeddable Hop mesh endpoint for Ruby (Sinatra/Rails-shaped) over the libhop
   C ABI