netpump 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 298b321a2b63596d5247b8d8cd807722c5062249f8f2c9e1b44b30b030a528f3
+  data.tar.gz: c534a39e90383b0ac3896c8060d233dbd02c26c83563ed7d8c9d331b81c91370
+SHA512:
+  metadata.gz: 95a11534001077454e72c94f94c81a2e816b613f9ab643ebaaeb06bbcf3e40f7210799130457d0af56677d2c0e5ac73ff8701426f778551c837f5b0ef9c3c711
+  data.tar.gz: c0a4abe22639b9667cdfdf879f63a2c05e96c8ed3eac0d3376506b3d2e094724d5c18933ca9464ad099a87560545dbac91a55324ee82707f337d3eb2cf3a567c

data/CHANGELOG

@@ -0,0 +1,41 @@
+1.0.0
+
+* Add backpressure mechanism to keep memory usage bounded
+* Add websocket pool timeout
+* Add more unbind reasons
+* Add option to set the server URL, remove the server query param
+* Add direct client mode
+
+1.3.0
+
+* Run all servers in one event loop
+* Replace webrick with a simple static file server
+* Add websocket pool
+* Add extensive logging
+* Show connection count in browser
+* Drop SOCKS5 support
+* Drop web manifest
+* Drop websocket pinging
+
+1.2.0
+
+* Prevent screen from sleeping (@zakir8)
+* Send pings to keep websockets alive
+
+1.1.2
+
+* Add webrick as a runtime dependency
+
+1.1.1
+
+* Ignore interfaces with nil addresses
+
+1.1.0
+
+* Works on Windows
+* HTTPS proxy support
+
+1.0.0
+
+* First public release
+* SOCKS5 proxy support

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/bin/netpump

@@ -0,0 +1,114 @@
+#!/usr/bin/env -S ruby
+
+Process.setproctitle "netpump"
+$stdin.close
+if $PROGRAM_NAME.include?("/")
+  $VERBOSE = true
+  $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+else
+  $VERBOSE = nil
+end
+
+require "optparse"
+require "uri"
+require "netpump"
+
+copts = {}
+sopts = {}
+
+op = OptionParser.new do |op|
+  op.summary_width = 24
+
+  op.banner = "Usage: netpump [options]"
+  op.separator ""
+  op.separator "Options:"
+
+  Port = %r{\A[1-9][0-9]*\z} # Port zero is not supported.
+  op.accept(Port, nil) do |val|
+    port = Integer(val)
+    raise ArgumentError if port > 65_535
+    port
+  rescue ArgumentError
+    raise OptionParser::InvalidArgument, val
+  end
+
+  WSS = %r{\Awss?://.*\z}i
+  op.accept(WSS, nil) do |val|
+    URI(val)
+  rescue URI::InvalidURIError
+    raise OptionParser::InvalidArgument, val
+  end
+
+  op.on("-c", "--client MODE", ["direct", "browser"], "start netpump client (mode: direct, browser)") do |mode|
+    copts[:mode] = mode
+  end
+
+  op.on("--client-host HOST", String, "client host (default: 0.0.0.0)") do |host|
+    copts[:host] = host
+  end
+
+  op.on("--client-port PORT", Port, "client port (default: 8080)") do |port|
+    copts[:port] = port
+  end
+
+  op.on("--proxy-host HOST", String, "local proxy server host (default: 127.0.0.1)") do |host|
+    copts[:proxy_host] = host
+  end
+
+  op.on("--proxy-port PORT", Port, "local proxy server port (default: 3128)") do |port|
+    copts[:proxy_port] = port
+  end
+
+  op.on("--server-url URL", WSS, "netpump server url (example: wss://example.org)") do |url|
+    copts[:server_url] = url
+  end
+
+  op.on("-s", "--server", "start netpump server") do
+    sopts[:server] = true
+  end
+
+  op.on("--server-host HOST", String, "server host (default: 0.0.0.0)") do |host|
+    sopts[:host] = host
+  end
+
+  op.on("--server-port PORT", Port, "server port (default: 10000)") do |port|
+    sopts[:port] = port
+  end
+
+  op.on_tail("--version", "print version") do
+    version = File.expand_path("../VERSION", __dir__)
+    puts(File.read(version))
+    exit
+  end
+
+  op.on_tail("--help", "print this help") do
+    puts(op)
+    exit
+  end
+end
+
+begin
+  op.parse!
+rescue OptionParser::ParseError => e
+  op.abort(e)
+else
+  unless copts.key?(:mode) || sopts.key?(:server)
+    copts[:mode] = "direct"
+  end
+end
+
+EventMachine.error_handler { |e| log "[!] unexpected errback.", error: e }
+EventMachine.run do
+  trap(:INT) { puts; EventMachine.stop }
+  if sopts.delete(:server)
+    server = Netpump::Server.new(**sopts)
+    server.start
+  end
+  if copts[:mode]
+    client = Netpump::Client.new(**copts)
+    client.start
+  end
+rescue => e
+  log "[!] #{e.message}."
+  EventMachine.stop
+end

data/lib/eventmachine/websocket/client.rb

@@ -0,0 +1,100 @@
+require "securerandom"
+require "em-websocket"
+require "http_parser"
+
+module EventMachine::WebSocket
+  class Client < Connection
+    def post_init
+      url = @options.fetch(:url)
+      if url.scheme == "wss"
+        @secure = true
+        @tls_options[:sni_hostname] ||= url.host
+      end
+      super
+      @version = 13
+      @key = SecureRandom.base64(16)
+      @parser = Http::Parser.new
+      @parser.on_headers_complete = proc do
+        headers = @parser.headers
+        @parser = nil
+        accept = Digest::SHA1.base64digest(@key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
+        unless headers["Connection"]&.downcase == "upgrade" &&
+            headers["Upgrade"]&.downcase == "websocket" &&
+            headers["Sec-WebSocket-Accept"] == accept
+          raise HandshakeError, "Invalid server handshake"
+        end
+        debug [:handshake_completed]
+        @handler = Handler.klass_factory(@version).prepend(ClientFraming).new(self, @debug)
+        trigger_on_open(_handshake = nil)
+        :stop
+      end
+      send_handshake unless @secure
+    end
+
+    def ssl_handshake_completed
+      send_handshake
+    end
+
+    private
+
+    def dispatch(data)
+      @parser << data
+    rescue HTTP::Parser::Error => e
+      debug [:error, e]
+      trigger_on_error(e)
+      abort :handshake_error
+    end
+
+    def send_handshake
+      url = @options.fetch(:url)
+      send_data(
+        "GET /ws/rem/relay HTTP/1.1\r\n" \
+        "Host: #{url.host}\r\n" \
+        "Connection: Upgrade\r\n" \
+        "Upgrade: websocket\r\n" \
+        "Sec-WebSocket-Version: #{@version}\r\n" \
+        "Sec-WebSocket-Key: #{@key}\r\n\r\n"
+      )
+    end
+  end
+
+  module ClientFraming
+    module C
+      FIN = 0x80
+      MASKED = 0x80
+      FRAME_TYPES = Framing07::FRAME_TYPES
+    end
+    private_constant :C
+
+    def send_frame(frame_type, data)
+      head = String.new(capacity: 14)
+      head << (C::FIN | C::FRAME_TYPES[frame_type])
+      len = data.bytesize
+      case len
+      when 0..125
+        head << [len | C::MASKED].pack("C")
+      when 126..65535
+        head << [126 | C::MASKED, len].pack("Cn")
+      else
+        head << [127 | C::MASKED, len].pack("CQ>")
+      end
+      mask_size = 4
+      mask = SecureRandom.bytes(mask_size)
+      head << mask
+      dmask = mask * 2
+      dm = dmask.unpack1("Q")
+      dms = dmask.bytesize
+      q, r = len.divmod(dms)
+      q.times do |i|
+        b = i * dms
+        data[b, dms] = [data[b, dms].unpack1("Q") ^ dm].pack("Q")
+      end
+      r.times do |i|
+        b = q * dms + i
+        data.setbyte(b, data.getbyte(b) ^ dmask[i].ord)
+      end
+      @connection.send_data(head)
+      @connection.send_data(data)
+    end
+  end
+end

data/lib/eventmachine/websocket/server.rb

@@ -0,0 +1,43 @@
+module EventMachine::WebSocket::Server
+  def self.start(host, port, &block)
+    EventMachine::WebSocket.run(host: host, port: port, block: block) do |ws|
+      ws.onerror do |e|
+        if EventMachine::WebSocket::WebSocketError === e
+          log "[!] websocket error.", error: e
+        else
+          fail e
+        end
+      end
+      # WebSockets must not be closed because they are reused.
+      fail "inactivity timeout" unless ws.comm_inactivity_timeout.zero?
+
+      def ws.receive_data(data)
+        # The data can be nil on error.
+        return unless data
+        # Technically, we need to buffer the data until the first CRLF.
+        method, path, _httpv = data.split(" ", 3)
+        path, _qs = path.split("?", 2)
+        send_error = lambda do |status|
+          send_data("HTTP/1.1 #{status}\r\n\r\n#{status}")
+          close_connection_after_writing
+          log "[!] http client error.", method: method, path: path, status: status
+        end
+        if method != "GET"
+          send_error.call(405)
+        else
+          @options[:block].call(path, self) || send_error.call(404)
+        end
+        singleton_class.remove_method(__method__)
+        singleton_class.remove_method(:serve_file)
+        super if defined? @onopen
+      end
+
+      def ws.serve_file(path)
+        send_data("HTTP/1.1 200 OK\r\n\r\n")
+        # win: send/stream_file_data do not work on windows
+        send_data(path.read)
+        close_connection_after_writing
+      end
+    end
+  end
+end

data/lib/netpump/client.rb

@@ -0,0 +1,158 @@
+require "em-websocket"
+require "eventmachine"
+require "eventmachine/websocket/client"
+require "eventmachine/websocket/server"
+require "pathname"
+require "socket"
+require "uri"
+require "netpump/relay"
+
+module Netpump
+  class Client
+    def initialize(
+      mode: "direct",
+      host: "0.0.0.0",
+      port: "8080",
+      proxy_host: "127.0.0.1",
+      proxy_port: 3128,
+      server_url: "wss://weblink-ouux.onrender.com",
+      connection_inactivity_timeout: 30.0,
+      websocket_pool_size: 20,
+      websocket_pool_timeout: 60.0
+    )
+      @mode = mode
+      @host = host
+      @port = port
+      @proxy_host = proxy_host
+      @proxy_port = proxy_port
+      @server_url = URI(server_url)
+      @connection_inactivity_timeout = connection_inactivity_timeout
+      @websocket_pool = EventMachine::Queue.new
+      @websocket_pool_size = websocket_pool_size
+      @websocket_pool_timeout = websocket_pool_timeout
+      @control_ws = nil
+      @log = lambda { |msg, **ctx| log(msg, loc: true, **ctx) }
+      @ready = EventMachine::Completion.new
+    end
+
+    def start
+      @log.call "[+] netpump client is starting.", mode: @mode, host: @host, port: @port
+      case @mode
+      when "direct"
+        start_proxy_server
+        @ready.succeed
+      when "browser"
+        start_websocket_server
+        print_open_url
+      end
+      @ready
+    end
+
+    private
+
+    PUBLIC_DIR = Pathname(__dir__).parent.parent.join("public").freeze
+    private_constant :PUBLIC_DIR
+
+    def start_websocket_server
+      EventMachine::WebSocket::Server.start(@host, @port) do |path, ws|
+        case path
+        when "/"
+          ws.serve_file(PUBLIC_DIR.join("netpump.html"))
+          @log.call "[~] http request.", method: "GET", path: path, ip: ws.remote_ip
+        when "/favicon.svg"
+          ws.serve_file(PUBLIC_DIR.join("favicon.svg"))
+          @log.call "[~] http request.", method: "GET", path: path, ip: ws.remote_ip
+        when "/ws/loc/control"
+          next false if @control_ws
+          ws.onopen do |_handshake|
+            @log.call "[+] device is connected.", ip: ws.remote_ip
+            @control_ws = ws
+            @control_ws.send_text(@server_url.to_s)
+            proxy = start_proxy_server
+            @control_ws.onclose do
+              @control_ws = nil
+              @log.call "[-] device is disconnected.", sig: ws.signature
+              EventMachine.stop_server(proxy)
+              @log.call "[-] proxy server is stopped."
+            end
+            @ready.succeed
+          end
+        when "/ws/loc/relay"
+          next false unless @control_ws.remote_ip == ws.remote_ip
+          ws.onopen do |_handshake|
+            @log.call "[+] websocket is open.", ip: ws.remote_ip, sig: ws.signature
+            @websocket_pool << ws
+          end
+        else
+          next false
+        end
+        true
+      end
+    end
+
+    def print_open_url
+      ip = Socket.getifaddrs.find { |ifa| ifa.addr&.ipv4_private? } or raise(
+        "could not find an interface to listen on; " \
+        "make sure that you are connected to your device."
+      )
+      open_url = URI::HTTP.build(host: ip.addr.ip_address, port: @port)
+      @log.call "[~] waiting for device to connect.", url: open_url
+    end
+
+    def start_proxy_server
+      proxy = EventMachine.start_server(@proxy_host, @proxy_port, Relay, "loc") do |relay|
+        bind(relay)
+      end
+      @log.call "[+] proxy server is ready.", type: "https", host: @proxy_host, port: @proxy_port
+      proxy
+    end
+
+    def bind(relay)
+      if @websocket_pool.empty?
+        case @mode
+        when "direct"
+          host = @server_url.host
+          port = @server_url.port
+          begin
+            EventMachine.connect(host, port, EventMachine::WebSocket::Client, url: @server_url) do |ws|
+              ws.onopen do
+                @log.call "[+] websocket is open.", ip: ws.remote_ip, sig: ws.signature
+                @websocket_pool << ws
+              end
+            end
+          rescue EventMachine::ConnectionError => e
+            @log.call "[!] server connection error.", error: e
+            return relay.close("server connection error")
+          end
+        when "browser"
+          # Dogpile effect if batch size > 1.
+          @control_ws.send_text(_batch_size = "1")
+        end
+        @log.call "[~] websocket is requested.", waitcnt: @websocket_pool.num_waiting
+      end
+      timeout = EventMachine::Timer.new(@websocket_pool_timeout) do
+        relay.close("pool timeout")
+        raise "race condition" unless EventMachine.reactor_thread?
+        @websocket_pool.instance_variable_get(:@popq).shift || raise("popq")
+      end
+      @websocket_pool.pop do |ws|
+        timeout.cancel
+        if ws.state != :connected
+          # When the browser tab is closed or reloaded, all local websockets
+          # are closed, remaining dead in the pool until popped.
+          @log.call "[~] websocket is dead, retrying.", state: ws.state, sig: ws.signature
+          EventMachine.next_tick { bind(relay) }
+        else
+          relay.set_comm_inactivity_timeout(@connection_inactivity_timeout)
+          relay.bind(ws, ws.remote_ip).callback do
+            if @websocket_pool.size < @websocket_pool_size
+              @websocket_pool << ws
+            else
+              ws.close(1000, "purge")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/netpump/log.rb

@@ -0,0 +1,22 @@
+$log = $>
+$log.sync = true
+
+def log(msg, **context)
+  line = "%-35s" % msg
+  context.each do |k, v|
+    case v
+    when Exception
+      line << " #{k}=#{v.message.inspect}"
+      line << " backtrace=#{v.backtrace}" if !$VERBOSE.nil? && v.backtrace
+    when true
+      line << " #{k}"
+    when false, nil, ""
+      # skip
+    else
+      v = v.to_s
+      v = v.inspect if v.include?(" ")
+      line << " #{k}=#{v}"
+    end
+  end
+  $log.puts(line)
+end

data/lib/netpump/relay.rb

@@ -0,0 +1,126 @@
+module Netpump
+  class Relay < EventMachine::Connection
+    def initialize(
+      side,
+      connection_inactivity_timeout: 0.0,
+      backpressure_min_bytes: 2**23,
+      backpressure_max_bytes: 2**24,
+      backpressure_drain_seconds: 1.0
+    )
+      pause
+      @ws = nil
+      @completion = nil
+      @closed = false
+      @close_reason = nil
+      @unbind_sent = false
+      @unbind_recv = false
+      @connection_inactivity_timeout = connection_inactivity_timeout
+      @backpressure_min_bytes = backpressure_min_bytes
+      @backpressure_max_bytes = backpressure_max_bytes
+      @backpressure_drain_seconds = backpressure_drain_seconds
+      @remote_ip = nil
+      @sig = "-.#{signature}"
+      @log = lambda do |msg, **ctx|
+        log(msg, "#{side}": true, ip: @remote_ip, sig: @sig, **ctx)
+      end
+    end
+
+    def bind(ws, remote_ip)
+      @ws = ws
+      @sig = "#{ws.signature}.#{signature}"
+      @completion = EventMachine::Completion.new
+      @unbind_sent = false
+      @unbind_recv = false
+      @remote_ip = remote_ip
+      @connection_inactivity_timeout = comm_inactivity_timeout
+      if @closed
+        # If a connection is closed due to the pool timeout before being bound to
+        # a websocket, it is not added to the wait queue in the websocket pool,
+        # so this case should not happen under normal operation. However, it is
+        # still possible is the connection is closed due to any other reason.
+        @log.call "[!] bound closed before bind."
+        @completion.succeed
+        return @completion
+      end
+      @ws.onbinary do |data|
+        if @closed
+          @log.call "[~] data discard, bound closed.", connerror: error?, bytes: data.bytesize
+        else
+          send_data(data)
+        end
+      end
+      @ws.onmessage do |msg|
+        if msg == "unbind"
+          @unbind_recv = true
+          if @unbind_sent
+            @completion.succeed
+          else
+            close("unbind")
+          end
+        else
+          @log.call "[!] unexpected text on websocket.", msg: msg[0, 16].inspect
+        end
+      end
+      @ws.onclose do |close_info|
+        close("websocket closed") unless @closed
+        @completion.fail
+        @log.call "[-] websocket is closed.", **close_info.slice(:code, :reason)
+      end
+      resume
+      @log.call "[+] bind."
+      @completion
+    end
+
+    def receive_data(data)
+      @ws.send_binary(data)
+      check_backpressure
+    end
+
+    def close(reason)
+      fail "double close" if @closed
+      @close_reason = reason
+      close_connection_after_writing
+    end
+
+    def unbind(errno)
+      @closed = true
+      if @ws&.state == :connected
+        @ws.send_text("unbind")
+        @unbind_sent = true
+        @completion&.succeed if @unbind_recv
+      end
+      if errno.nil?
+        reason = @close_reason
+      elsif errno == Errno::ETIMEDOUT && @connection_inactivity_timeout > 0
+        reason = "inactive"
+      elsif errno.respond_to?(:exception)
+        reason = errno.exception.message
+        reason[0] = reason[0].downcase
+      else
+        # win: errno can be set to :unknown on windows
+        reason = errno.to_s
+      end
+      @log.call "[-] unbind.", reason: reason
+    end
+
+    private
+
+    def check_backpressure
+      outbound_bytes = @ws.get_outbound_data_size
+      if outbound_bytes >= @backpressure_max_bytes && !paused?
+        pause
+        @log.call "[~] paused.", outbytes: outbound_bytes
+      end
+      if outbound_bytes <= @backpressure_min_bytes && paused?
+        resume
+        @log.call "[~] resumed.", outbytes: outbound_bytes
+      end
+      if paused?
+        EventMachine::Timer.new(@backpressure_drain_seconds) do
+          check_backpressure
+        end
+      end
+    end
+  end
+  private_constant :Relay
+end

data/lib/netpump/server.rb

@@ -0,0 +1,60 @@
+require "em-websocket"
+require "eventmachine-proxy"
+require "eventmachine/websocket/server"
+require "socket"
+require "netpump/relay"
+
+module Netpump
+  class Server
+    def initialize(host: "0.0.0.0", port: 10000, proxy_host: "127.0.0.1", proxy_port: 0)
+      @host = host
+      @port = port
+      @proxy_host = proxy_host
+      @proxy_port = proxy_port
+      @log = lambda { |msg, **ctx| log(msg, rem: true, **ctx) }
+    end
+
+    def start
+      @log.call "[+] netpump server is starting.", host: @host, port: @port
+      start_websocket_server
+      proxy = EventMachine.start_server(
+        @proxy_host, @proxy_port, EventMachine::Protocols::CONNECT
+      ) do |c|
+        fail "inactivity timeout" unless c.comm_inactivity_timeout.zero?
+      end
+      @proxy_port, @proxy_host = Socket.unpack_sockaddr_in(EventMachine.get_sockname(proxy))
+    end
+
+    private
+
+    def start_websocket_server
+      EventMachine::WebSocket::Server.start(@host, @port) do |path, ws|
+        case path
+        when "/", "/healthcheck"
+          @log.call "[~] http request.", method: "GET", path: path, ip: ws.remote_ip
+          ws.send_healthcheck_response
+        when "/ws/rem/relay"
+          ws.onopen do |handshake|
+            xff = handshake.headers_downcased["x-forwarded-for"]&.split(",", 2)&.first
+            ip = xff || ws.remote_ip
+            @log.call "[+] websocket is open.", ip: ip, sig: ws.signature
+            bind(ws, ip)
+          end
+        else
+          return false
+        end
+        true
+      end
+    end
+
+    def bind(ws, ip)
+      EventMachine.connect(@proxy_host, @proxy_port, Relay, "rem") do |relay|
+        fail "inactivity timeout" unless relay.comm_inactivity_timeout.zero?
+        relay.bind(ws, ip).callback { bind(ws, ip) }
+      end
+    rescue RuntimeError => e
+      @log.call "[!] proxy connection error.", error: e
+      ws.close(4000, "proxy connection error")
+    end
+  end
+end

data/lib/netpump.rb

@@ -0,0 +1,6 @@
+module Netpump
+end
+
+require "netpump/log"
+require "netpump/client"
+require "netpump/server"

data/public/favicon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" width="16" height="16"><style>@media (prefers-color-scheme:dark){path{stroke:#fff!important}}</style><path d="M5.072 5.73v6.054h5.856V5.73" style="stroke:#540b0b;stroke-width:2.91;fill:none"/></svg>

data/public/netpump.html

@@ -0,0 +1,191 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>netpump</title>
+    <link rel="icon" href="favicon.svg" type="image/svg+xml" />
+    <style>
+      html,
+      body {
+        height: 100%;
+        background-color: #540b0b;
+        font-family: arial, sans-serif;
+      }
+      body {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        text-align: center;
+        color: white;
+      }
+      dd {
+        margin: 0;
+      }
+      input[type="checkbox"] {
+        margin-right: 0.5em;
+      }
+      header {
+        margin: 1em 0;
+      }
+      header h1 {
+        margin: 0;
+        font-size: 1.5em;
+      }
+      header svg {
+        width: 4em;
+      }
+    </style>
+  </head>
+  <body>
+    <header>
+      <svg role="img" viewBox="0 0 16 16">
+        <path
+          d="M5.072 5.73v6.054h5.856V5.73"
+          style="stroke: #fff; stroke-width: 2.91; fill: none"
+        />
+      </svg>
+      <h1>netpump</h1>
+    </header>
+    <div class="settings">
+      <label
+        ><input type="checkbox" id="nosleep" />Prevent screen from
+        sleeping</label
+      >
+    </div>
+    <dl class="stats">
+      <dt>Connections</dt>
+      <dd id="connectionCount">0</dd>
+    </dl>
+    <script>
+      function createRelayWebSocketPair(clientAddr, serverAddr) {
+        // client websocket.
+        var client;
+        // Connect to the server first, so that when we
+        // connect to the client the whole chain is complete.
+        var server = new WebSocket(serverAddr + "/ws/rem/relay");
+        // Log server errors.
+        server.onerror = function (event) {
+          console.error("[!] server/error", event);
+        };
+        // When the server closes its websocket, close the corresponding
+        // client websocket too.
+        server.onclose = function (event) {
+          console.log("[-] server/close", {
+            code: event.code,
+            reason: event.reason,
+            wasClean: event.wasClean,
+          });
+          if (client?.readyState === WebSocket.OPEN) {
+            client.close(
+              1000,
+              `bound close: ${event.code} ${event.reason}`.trimEnd(),
+            );
+          }
+        };
+        server.onopen = function () {
+          // Connect to the client to relay data.
+          client = new WebSocket(clientAddr + "/ws/loc/relay");
+          // Log relay errors.
+          client.onerror = function (event) {
+            console.error("[!] client/error", event);
+          };
+          // When the client websocket is closed, close the corresponding
+          // server websocket.
+          client.onclose = function (event) {
+            if (client.cleanOpen) {
+              connections--;
+              connectionCount.textContent = connections;
+            }
+            console.log("[-] client/close", {
+              code: event.code,
+              reason: event.reason,
+              wasClean: event.wasClean,
+            });
+            if (server.readyState === WebSocket.OPEN) {
+              server.close(
+                1000,
+                `bound close: ${event.code} ${event.reason}`.trimEnd(),
+              );
+            }
+          };
+          // Splice client and server websockets.
+          client.onopen = function () {
+            connections++;
+            connectionCount.textContent = connections;
+            client.cleanOpen = true;
+            client.onmessage = function (msg) {
+              server.send(msg.data);
+            };
+            server.onmessage = function (msg) {
+              client.send(msg.data);
+            };
+          };
+        };
+      }
+      // Netpump client.
+      var clientAddr = "ws://" + location.host;
+      // Netpump server.
+      var serverAddr;
+      // Establish a client control websocket to receive commands.
+      var control = new WebSocket(clientAddr + "/ws/loc/control");
+      // Total number of client connections.
+      var connections = 0;
+      // Log control websocket errors.
+      control.onerror = function (event) {
+        console.error("[!] control/error", event);
+      };
+      // Log control websocket closure.
+      control.onclose = function (event) {
+        console.log("[-] control/close", {
+          code: event.code,
+          reason: event.reason,
+        });
+      };
+      // Add more connections on demand.
+      control.onmessage = function (msg) {
+        serverAddr = msg.data;
+        control.onmessage = function (msg) {
+          var connectionBatchSize = Number.parseInt(msg.data);
+          console.log("[~] control/batch", { count: connectionBatchSize });
+          for (var i = 0; i < connectionBatchSize; i++) {
+            createRelayWebSocketPair(clientAddr, serverAddr);
+          }
+        };
+      };
+    </script>
+    <script
+      src="https://cdnjs.cloudflare.com/ajax/libs/nosleep/0.12.0/NoSleep.min.js"
+      type="text/javascript"
+      crossorigin="anonymous"
+    ></script>
+    <script>
+      var noSleep = new NoSleep();
+      var noSleepCheckbox = document.getElementById("nosleep");
+
+      document.addEventListener(
+        "visibilitychange",
+        function resetNoSleep(event) {
+          if (document.visibilityState === "visible") {
+            noSleep.disable();
+            noSleep = new NoSleep();
+            noSleepCheckbox.checked = false;
+          }
+        },
+      );
+
+      noSleepCheckbox.addEventListener("click", function toggleNoSleep(event) {
+        if (noSleep.isEnabled) {
+          noSleep.disable();
+        } else {
+          try {
+            noSleep.enable();
+          } catch (error) {
+            event.preventDefault();
+          }
+        }
+      });
+    </script>
+  </body>
+</html>

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: netpump
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- soylent
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: eventmachine-proxy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+executables:
+- netpump
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG
+- VERSION
+- bin/netpump
+- lib/eventmachine/websocket/client.rb
+- lib/eventmachine/websocket/server.rb
+- lib/netpump.rb
+- lib/netpump/client.rb
+- lib/netpump/log.rb
+- lib/netpump/relay.rb
+- lib/netpump/server.rb
+- public/favicon.svg
+- public/netpump.html
+homepage: https://netpump.org
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Tiny websocket proxy tunnel
+test_files: []