mfp 0.1.0

data/lib/mfp/server/conn.rb

@@ -0,0 +1,362 @@
+# frozen_string_literal: true
+
+module Mfp
+  module Server
+    class Conn
+      attr_reader :id, :application, :hostname, :max_streams, :max_payload, :closed
+
+      def initialize(server, id, peer_socket, call_sign, settings)
+        @logger = settings.logger
+        @server = server
+        @sock = peer_socket
+        @call_sign = call_sign
+        @max_streams = settings.max_streams
+        @max_payload = settings.max_payload
+        @id = id
+        @first_frame_timeout = settings.first_frame_timeout_secs
+
+        @to_write = Async::Queue.new
+        @to_read = Async::Queue.new
+        @compression = Compressor.new(:identity)
+        @ping_handler = PingHandler.new(
+          idle_timeout: settings.idle_timeout_secs,
+          ping_timeout: settings.ping_timeout_secs,
+        )
+
+        @application = nil
+        @hostname = nil
+        @closed = false
+      end
+
+      def start(task)
+        @task = task.async do |t|
+          @write_task = t.async { handle_writes }
+          begin
+            status, err = t.with_timeout(@first_frame_timeout) { perform_handshake }
+          rescue Async::TimeoutError => e
+            @logger.error("Timeout waiting for full handshake", e)
+            status = :failed
+            err = e
+          rescue StandardError => e
+            @logger.error("Failed performing handshake", e)
+            status = :failed
+            err = e
+          end
+
+          if status == :failed
+            @logger.error("Failed completing handshake", err)
+            next
+          end
+
+          @server.connect(self)
+          @ping_handler.start(t)
+          t.async { handle_pings }
+
+          run_loop
+        ensure
+          close
+        end
+      end
+
+      def close
+        return if @closed
+
+        @logger.debug("Closing connection")
+
+        @closed = true
+
+        @ping_handler&.stop
+        @sock&.close
+        @server.disconnect(self)
+        @to_read.close
+        @task&.cancel
+      end
+
+      def recv = @to_read.dequeue
+
+      def send_stream(stream_id, msg, flags: 0)
+        raise ArgumentError, "msg must be a String or nil" unless msg.nil? || msg.is_a?(String)
+
+        send_conn_frame(Proto::Frame.new(
+          stream_id:,
+          kind: Proto::MessageKind::STREAM,
+          flags:,
+          length: msg&.bytesize || 0,
+          payload: msg,
+        ))
+      end
+
+      def send_control(stream_id, msg, flags: 0)
+        raise ArgumentError, "msg must be a String or nil" unless msg.nil? || msg.is_a?(String)
+
+        send_conn_frame(Proto::Frame.new(
+          stream_id:,
+          kind: Proto::MessageKind::CONTROL,
+          flags:,
+          length: msg&.bytesize || 0,
+          payload: msg,
+        ))
+      end
+
+      def send_error(stream_id, terminal:, code:, debug:)
+        debug = debug.to_s unless debug.nil?
+        msg = Proto::Error.new(code, terminal:, debug:)
+        send_conn_frame(msg.encode(stream_id))
+      end
+
+      private
+
+      def run_loop
+        @logger.debug("Client entering runloop")
+        loop do
+          begin
+            fr = read_frame
+          rescue StandardError => e
+            unless @closed
+              @logger.error("Failed reading frame", e)
+              @to_read.enqueue ConnectionEvent.new(CONNECTION_EVENT_CODE_BROKEN)
+              close
+            end
+            break
+          end
+          @ping_handler.notify_received
+          handle_frame(fr)
+        end
+      end
+
+      def failure(msg) = StandardError.new(msg)
+
+      def read_frame = Proto::Frame.read(@sock, @max_payload, @call_sign)
+
+      def perform_handshake
+        fr = read_frame
+        if fr.kind != Proto::MessageKind::HELLO
+          @logger.debug("Rejecting client: Invalid frame kind for handshake")
+          return [:failed, failure("invalid frame kind")]
+        end
+
+        hello = Proto::Hello.read(fr)
+        if [hello.version_major, hello.version_minor] != [1, 0]
+          @logger.debug("Rejecting client: Invalid version", vMaj: hello.version_major, vMin: hello.version_minor)
+          return [:failed, failure("invalid version")]
+        end
+
+        @application = hello.application
+        @hostname = hello.host
+
+        answer = Proto::HelloResponse.new(
+          capabilities: handle_caps(hello.capabilities),
+          max_streams: @max_streams,
+          max_payload: @max_payload,
+        )
+
+        begin
+          send_conn(answer)
+        rescue StandardError => e
+          @logger.error("Failed replying to hello", e)
+          terminate_error(Proto::ErrorKind::INTERNAL_ERROR)
+          return
+        end
+
+        case answer.capabilities
+        when Proto::Capability::COMPRESSION_BROTLI
+          @compression = Compressor.new(:brotli)
+        when Proto::Capability::COMPRESSION_GZIP
+          @compression = Compressor.new(:gzip)
+        end
+
+        [:ok, nil]
+      rescue Mfp::Error => e
+        [:failed, e]
+      end
+
+      def handle_writes
+        until @closed
+          msg = @to_write.dequeue
+          frm = msg.frame
+          frm.call_sign = @call_sign
+
+          begin
+            @sock.write(frm.encode)
+          rescue StandardError => e
+            msg.complete(e)
+            next
+          end
+
+          msg.complete(nil)
+        end
+      end
+
+      def send_conn(msg)
+        raise ConnectionClosedError if @closed
+
+        fr = msg.encode(0)
+        send_conn_frame(fr)
+      end
+
+      def send_conn_frame(fr)
+        raise ConnectionClosedError if @closed
+
+        @logger.debug("Sending frame", frame: fr.inspect)
+
+        fr.call_sign = @call_sign
+        if fr.kind == Proto::MessageKind::STREAM && fr.length.positive? && @compression.kind != :identity
+          fr.payload = @compression.compress(fr.payload)
+          fr.length = fr.payload.bytesize
+        end
+        out = OutgoingMessage.new(fr)
+        err = Async::Task.current.defer_cancel do
+          @to_write.enqueue out
+          out.wait
+        end
+        raise err if err
+      end
+
+      def handle_pings
+        until @closed
+          msg = @ping_handler.recv
+          break if msg.nil?
+
+          case msg[:kind]
+          when :request
+            begin
+              send_conn(Proto::Ping.new(ack: false, payload: msg[:cookie]))
+            rescue StandardError => e
+              @logger.error("Failed sending ping", e)
+              @to_read.enqueue(ConnectionEvent.new(code: CONNECTION_EVENT_CODE_BROKEN))
+              close
+              return
+            end
+
+          when :timeout
+            @logger.warn("Timed out waiting for ping acknowledgement. Dropping connection...")
+            @to_read.enqueue(ConnectionEvent.new(code: CONNECTION_EVENT_CODE_TIMED_OUT))
+            close
+            return
+          end
+        end
+      end
+
+      def handle_caps(r)
+        if r.anybits?(Proto::Capability::COMPRESSION_BROTLI)
+          Proto::Capability::COMPRESSION_BROTLI
+        elsif r.anybits?(Proto::Capability::COMPRESSION_GZIP)
+          Proto::Capability::COMPRESSION_GZIP
+        else
+          0
+        end
+      end
+
+      def handle_connection_error(fr)
+        err = nil
+        failed = false
+        begin
+          err = Proto::Error.read(fr)
+        rescue StandardError => e
+          @logger.error("Received connection-level error message from client, but decoding failed", e)
+          failed = true
+        end
+
+        unless failed
+          kvs = {
+            code: err.code,
+            debug_len: err.debug.respond_to?(:bytesize) ? err.debug.bytesize : 0,
+          }
+          kvs[:debug] = err.debug if !err.debug.nil? && err.debug.is_a?(String)
+
+          @logger.error("Received connection-level error message from client", **kvs)
+        end
+
+        @to_read.enqueue(ConnectionEvent.new(code: CONNECTION_EVENT_CODE_BROKEN))
+        close
+      end
+
+      def handle_stream_error(fr)
+        err = Proto::Error.read(fr)
+        @to_read.enqueue(ErrorEvent.new(
+          stream_id: fr.stream_id,
+          code: err.code,
+          terminal: err.terminal,
+          debug: err.debug,
+        ))
+      rescue StandardError => e
+        @logger.error("Failed handling stream error", e)
+        terminate_error(Proto::ErrorKind::PROTOCOL_ERROR)
+      end
+
+      def handle_ping(fr)
+        png = Proto::Ping.read(fr)
+        return @ping_handler.notify_pong(png.payload) if png.ack
+
+        send_conn(Proto::Ping.new(
+          ack: true,
+          payload: png.payload,
+        ))
+      end
+
+      def handle_frame(fr)
+        @logger.debug("Read frame", frame: fr.inspect)
+        case fr.kind
+        when Proto::MessageKind::HELLO, Proto::MessageKind::HELLO_RESPONSE, Proto::MessageKind::UNKNOWN
+          terminate_error(Proto::ErrorKind::PROTOCOL_ERROR)
+
+        when Proto::MessageKind::ERROR
+          return handle_connection_error(fr) if fr.stream_id.zero?
+
+          handle_stream_error(fr)
+
+        when Proto::MessageKind::CONTROL
+          @to_read.enqueue(ControlEvent.new(
+            stream_id: fr.stream_id,
+            payload: fr.payload,
+          ))
+
+        when Proto::MessageKind::PING
+          return terminate_error(Proto::ErrorKind::PROTOCOL_ERROR) unless fr.stream_id.zero?
+          return terminate_error(Proto::ErrorKind::PROTOCOL_ERROR) if fr.length != 8
+
+          begin
+            handle_ping(fr)
+          rescue StandardError => e
+            @logger.error("Failed handling ping", e)
+          end
+
+        when Proto::MessageKind::STREAM
+          return terminate_error(Proto::ErrorKind::PROTOCOL_ERROR) if fr.stream_id.zero?
+
+          if @compression.kind != :identity && fr.length.positive?
+            begin
+              out = @compression.decompress(fr.payload)
+              fr.payload = out
+              fr.length = out.bytesize
+            rescue StandardError => e
+              @logger.error("Failed decompressing stream", e)
+              terminate_error(Proto::ErrorKind::COMPRESSION_ERROR)
+              return
+            end
+          end
+
+          @to_read.enqueue(StreamEvent.new(
+            stream_id: fr.stream_id,
+            payload: fr.payload,
+          ))
+        end
+      end
+
+      def terminate_error(code)
+        @to_read.enqueue(ConnectionEvent.new(
+          code: CONNECTION_EVENT_CODE_BROKEN,
+        ))
+        begin
+          send_conn(Proto::Error.new(
+            code,
+            terminal: true,
+          ))
+        rescue StandardError
+          # noop
+        end
+        close
+      end
+    end
+  end
+end

data/lib/mfp/server/server.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Mfp
+  module Server
+    Settings = Data.define(
+      :max_streams,
+      :max_payload,
+      :idle_timeout_secs,
+      :ping_timeout_secs,
+      :first_frame_timeout_secs,
+      :logger,
+    )
+
+    class Server
+      DEFAULT_OPTIONS = {
+        max_streams: 0,
+        max_payload: 1 << 24,
+        idle_timeout_secs: 30,
+        ping_timeout_secs: 10,
+        cert: nil,
+        key: nil,
+        ca_certs: [],
+        client_auth: nil,
+        first_frame_timeout_secs: 5,
+        logger: Logrb.noop,
+      }.freeze
+
+      attr_reader :port
+
+      def initialize(host, port, call_sign, **opts)
+        raise ArgumentError, "call_sign must have 4 bytes" if call_sign.bytesize != 4
+
+        opts = DEFAULT_OPTIONS.merge(opts)
+        @client_id = 0
+        @clients = {}
+        @client_queue = Async::Queue.new
+        @call_sign = call_sign
+
+        @logger = opts[:logger]
+
+        @listener = if opts[:cert] && opts[:key]
+          @logger.debug("Starting TLS server", host:, port:)
+          ctx = Mfp.default_tls_context
+          ctx.cert = OpenSSL::X509::Certificate.new(opts[:cert])
+          ctx.key = OpenSSL::PKey.read(opts[:key])
+          store = OpenSSL::X509::Store.new
+          store.set_default_paths
+          opts[:ca_certs].each do |raw|
+            store.add_cert(OpenSSL::X509::Certificate.new(raw))
+          end
+          ctx.cert_store = store
+          ctx.verify_mode = opts[:client_auth] if opts[:client_auth]
+          IO::Endpoint.ssl(host, port, ssl_context: ctx)
+        else
+          @logger.debug("Starting plain server", host:, port:)
+          IO::Endpoint.tcp(host, port)
+        end
+
+        @settings = Settings.new(
+          opts[:max_streams],
+          opts[:max_payload],
+          opts[:idle_timeout_secs],
+          opts[:ping_timeout_secs],
+          opts[:first_frame_timeout_secs],
+          opts[:logger],
+        )
+
+        @sockets = @listener.bind
+        @port = @sockets.first.local_address.ip_port
+      end
+
+      def start(task)
+        return if @running
+
+        @running = true
+        @accept_tasks = @sockets.map do |sock|
+          task.async do |t|
+            loop do
+              peer = nil
+              begin
+                peer, = sock.accept
+                peer.accept if peer.respond_to?(:accept) && peer.is_a?(OpenSSL::SSL::SSLSocket)
+              rescue StandardError => e
+                @logger.debug("Error accepting connection", err: e.to_s)
+                peer&.close
+                next
+              end
+              client_addr = peer.remote_address.inspect_sockaddr
+              @logger.debug("Accepting connection", addr: client_addr)
+              id = @client_id
+              @client_id += 1
+              settings = Settings.new(**@settings.to_h, logger: @logger.with_fields(id:))
+              conn = Conn.new(self, id, peer, @call_sign, settings)
+              @logger.debug("Created client", addr: client_addr, id:)
+              @clients[id] = conn
+              @logger.debug("Starting client in background", id:)
+              conn.start(t)
+            end
+          end
+        end
+      end
+
+      def close
+        @accept_tasks&.each(&:stop)
+        @sockets.each(&:close)
+      end
+
+      def connect(client) = @client_queue.enqueue(client)
+
+      def disconnect(client)
+        @clients.delete(client.id)
+        @logger.debug("Disconnected client", id: client.id, connected_clients: @clients.length)
+      end
+
+      def accept = @client_queue.dequeue
+    end
+  end
+end

data/lib/mfp/server.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "server/server"
+require_relative "server/conn"

data/lib/mfp/tls_config.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Mfp
+  module_function
+
+  def default_tls_context
+    OpenSSL::SSL::SSLContext.new.tap do |v|
+      v.min_version = v.max_version = OpenSSL::SSL::TLS1_3_VERSION
+      v.ecdh_curves = "X25519:P-256:P-384"
+    end
+  end
+end

data/lib/mfp/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Mfp
+  VERSION = "0.1.0"
+end

data/lib/mfp.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "async"
+require "io/endpoint"
+require "io/endpoint/host_endpoint"
+require "io/endpoint/ssl_endpoint"
+require "brotli"
+require "zlib"
+require "openssl"
+require "logrb"
+
+require_relative "mfp/version"
+require_relative "mfp/enum"
+require_relative "mfp/tls_config"
+require_relative "mfp/error"
+require_relative "mfp/compressor"
+require_relative "mfp/outgoing_message"
+require_relative "mfp/resettable_timer"
+require_relative "mfp/ping_handler"
+require_relative "mfp/proto"
+require_relative "mfp/event"
+require_relative "mfp/server"
+require_relative "mfp/client"
+
+module Mfp
+  module_function
+
+  def listen(host, port, call_sign, task, **)
+    srv = Server::Server.new(host, port, call_sign, **)
+    srv.start(task)
+    srv
+  end
+
+  def dial(host, port, call_sign, task, **)
+    cli = Client.new(host, port, call_sign, **)
+    cli.start(task)
+    cli
+  end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: mfp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vito Sartori
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+- !ruby/object:Gem::Dependency
+  name: brotli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: io-endpoint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+- !ruby/object:Gem::Dependency
+  name: io-stream
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: logrb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: General-purpose framing protocol for organising data across multiplexed
+  streams
+email:
+- hey@vito.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".ruby-version"
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mfp.rb
+- lib/mfp/client.rb
+- lib/mfp/compressor.rb
+- lib/mfp/enum.rb
+- lib/mfp/error.rb
+- lib/mfp/event.rb
+- lib/mfp/outgoing_message.rb
+- lib/mfp/ping_handler.rb
+- lib/mfp/proto.rb
+- lib/mfp/proto/error.rb
+- lib/mfp/proto/frame.rb
+- lib/mfp/proto/hello.rb
+- lib/mfp/proto/hello_response.rb
+- lib/mfp/proto/ping.rb
+- lib/mfp/proto/protocol.rb
+- lib/mfp/proto/reader.rb
+- lib/mfp/proto/writer.rb
+- lib/mfp/resettable_timer.rb
+- lib/mfp/server.rb
+- lib/mfp/server/conn.rb
+- lib/mfp/server/server.rb
+- lib/mfp/tls_config.rb
+- lib/mfp/version.rb
+homepage: https://vito.io
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://vito.io
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: mfp stands for Multiplexed Framing Protocol
+test_files: []