From 43374c0a44477bb51b28d43a7d74faa9e0c15552 Mon Sep 17 00:00:00 2001 From: Jonghyun Kim Date: Wed, 21 Oct 2026 10:42:04 -0700 Subject: [PATCH 1/8] feat(remote_device_bridge): add ITransport, TCP and WebSocket transports Sessions talk to the bridge through ITransport, which sends and receives complete wire frames. TcpTransport frames them over one TCP connection (TcpSocket owns the POSIX socket, timeouts and buffer sizes); WebSocketTransport carries exactly one frame per RFC 6455 binary message (no TLS; terminate wss:// in a proxy). parse_remote() and connect_transport() turn --remote= or ws://host:port[/path] into a connected transport. The TCP seam has no test file of its own, so it ships with the WebSocket transport and its tests. Signed-off-by: Jonghyun Kim --- src/plugins/remote_device_bridge/AGENTS.md | 3 +- .../session/CMakeLists.txt | 10 + .../inc/remote_plugin_session/tcp_socket.hpp | 93 ++++ .../inc/remote_plugin_session/transport.hpp | 48 ++ .../websocket_transport.hpp | 81 +++ .../session/tcp_socket.cpp | 473 ++++++++++++++++++ .../session/websocket_transport.cpp | 459 +++++++++++++++++ .../remote_device_bridge/CMakeLists.txt | 1 + .../test_websocket_transport.cpp | 279 +++++++++++ 9 files changed, 1446 insertions(+), 1 deletion(-) create mode 100644 src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_socket.hpp create mode 100644 src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp create mode 100644 src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp create mode 100644 src/plugins/remote_device_bridge/session/tcp_socket.cpp create mode 100644 src/plugins/remote_device_bridge/session/websocket_transport.cpp create mode 100644 tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp diff --git a/src/plugins/remote_device_bridge/AGENTS.md b/src/plugins/remote_device_bridge/AGENTS.md index 12e70cd249..91b80a347b 100644 --- a/src/plugins/remote_device_bridge/AGENTS.md +++ b/src/plugins/remote_device_bridge/AGENTS.md @@ -7,7 +7,8 @@ SPDX-License-Identifier: Apache-2.0 **CRITICAL:** Complete the mandatory `AGENTS.md` preflight in [`../../../AGENTS.md`](../../../AGENTS.md) before editing here. -- `session/protocol_frame.*`, `session/protocol_payloads.*` and the `Reader`/`Writer` in `session/protocol_io.hpp` are the only serialization points. Every frame is encoded and decoded there and nowhere else; changing the wire format means changing them and their codec tests together. +- `session/protocol_frame.*`, `session/protocol_payloads.*` and the `Reader`/`Writer` in `session/protocol_io.hpp` are the only serialization points. Every frame is encoded and decoded there and nowhere else; changing the wire format means changing them and their codec tests together. Sessions hold an `ITransport` (`session/inc/remote_plugin_session/transport.hpp`) and only call `send/receive/shutdown` on complete frames; TCP framing lives in `TcpTransport`. - Wire format v1 (`kProtocolVersion` = 1, the only version number): 24-byte header `RPS0` magic, type u8, version u8, channel u16, seq u32, payload size u32, `t_send` i64; frame types 1..13 with no gaps; the hand byte is 0 = left, 1 = right in every payload; PING has no payload and PONG carries the PING's header `t_send` and the client's receive time. Any change to a header, payload or type number bumps `kProtocolVersion`; `decode_header` rejects other versions before reading the type, so old senders and bridges fail with a readable reason instead of mis-decoding. - A frame's `t_send` is its send time for clock exchange: call `stamp_header` where the frame is written to the transport, never when it is queued. +- WebSocket is a second transport, not a second protocol: `WebSocketTransport` carries exactly one wire frame per binary message (no TLS; terminate `wss://` in a proxy). Clients pick it with `--remote=ws://host:port[/path]` via `parse_remote`/`connect_transport`; the bridge serves it on a separate `--ws-listen` port sharing the fork-per-client loop and `--max-clients`. Never sniff the protocol on the TCP port. The server-side HTTP upgrade runs in the first `receive()` so the accept loop never blocks on a client. - Never add `OpenXR::openxr_loader`, `Teleop::plugin_utils` or DeviceIO session libraries to `Teleop::remote_plugin_session`: a plugin that talks to a bridge through this library must run without an OpenXR runtime. diff --git a/src/plugins/remote_device_bridge/session/CMakeLists.txt b/src/plugins/remote_device_bridge/session/CMakeLists.txt index c2f76d671f..1d1b60f67e 100644 --- a/src/plugins/remote_device_bridge/session/CMakeLists.txt +++ b/src/plugins/remote_device_bridge/session/CMakeLists.txt @@ -1,12 +1,19 @@ # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 +find_package(Threads REQUIRED) + add_library(remote_plugin_session STATIC protocol_frame.cpp protocol_payloads.cpp protocol_io.hpp inc/remote_plugin_session/protocol_frame.hpp inc/remote_plugin_session/protocol_payloads.hpp + tcp_socket.cpp + inc/remote_plugin_session/tcp_socket.hpp + inc/remote_plugin_session/transport.hpp + websocket_transport.cpp + inc/remote_plugin_session/websocket_transport.hpp ) target_include_directories(remote_plugin_session @@ -17,6 +24,9 @@ target_include_directories(remote_plugin_session target_link_libraries(remote_plugin_session PUBLIC pusherio::pusherio + PRIVATE + log_bridge::log_bridge_core + Threads::Threads ) add_library(Teleop::remote_plugin_session ALIAS remote_plugin_session) diff --git a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_socket.hpp b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_socket.hpp new file mode 100644 index 0000000000..cb5e000a33 --- /dev/null +++ b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_socket.hpp @@ -0,0 +1,93 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "transport.hpp" + +#include +#include +#include +#include +#include +#include + +namespace remote_plugin_session +{ + +struct Endpoint +{ + std::string host; + uint16_t port = 0; +}; + +//! Parses "host[:port]"; a missing port falls back to default_port. Throws std::invalid_argument. +Endpoint parse_endpoint(const std::string& text, uint16_t default_port); + +//! Minimal RAII wrapper over a blocking POSIX TCP socket (IPv4/IPv6 via getaddrinfo). +class TcpSocket +{ +public: + enum class RecvResult + { + Ok, + Timeout, + Closed, + }; + + TcpSocket() = default; + explicit TcpSocket(int fd); + ~TcpSocket(); + + TcpSocket(TcpSocket&& other) noexcept; + TcpSocket& operator=(TcpSocket&& other) noexcept; + TcpSocket(const TcpSocket&) = delete; + TcpSocket& operator=(const TcpSocket&) = delete; + + //! Throws std::runtime_error when no address connects within the timeout. + static TcpSocket connect(const Endpoint& endpoint, std::chrono::milliseconds timeout); + //! Throws std::runtime_error when bind/listen fails. Port 0 picks an ephemeral port. + static TcpSocket listen(const Endpoint& endpoint, int backlog); + //! Returns an invalid socket when the timeout expires; throws on a hard error. + TcpSocket accept(std::chrono::milliseconds timeout); + + bool valid() const; + int fd() const; + uint16_t local_port() const; + //! Numeric "host:port" of the connected peer; "?" when unavailable. + std::string peer_name() const; + + //! False when the peer closed or the send stalled past the socket send timeout. + bool send_all(const uint8_t* data, size_t size); + //! Timeout applies to the wait for the first byte; a stall mid-message reports Closed. + RecvResult recv_all(uint8_t* data, size_t size, std::chrono::milliseconds timeout); + + //! Unblocks recv/send on other threads; the descriptor stays open until close(). + void shutdown(); + void close(); + +private: + int m_fd = -1; +}; + +//! ITransport over one TCP stream; messages are delimited by the wire header's payload_size. +class TcpTransport final : public ITransport +{ +public: + explicit TcpTransport(TcpSocket socket); + + //! One transport per connection accepted on `listener`; null when the poll expires. `peer`, when given, + //! receives the client's numeric host:port. + static std::unique_ptr accept(TcpSocket& listener, + std::chrono::milliseconds poll, + std::string* peer = nullptr); + + bool send(const uint8_t* frame, size_t size) override; + ReceiveResult receive(std::vector& frame, std::chrono::milliseconds timeout) override; + void shutdown() override; + +private: + TcpSocket m_socket; +}; + +} // namespace remote_plugin_session diff --git a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp new file mode 100644 index 0000000000..c8402c285f --- /dev/null +++ b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp @@ -0,0 +1,48 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include +#include +#include +#include + +namespace remote_plugin_session +{ + +enum class ReceiveResult +{ + Ok, + Timeout, + Closed, + Malformed, +}; + +/*! + * @brief Message transport between a RemotePluginSession and the bridge. + * + * A frame is one complete wire message (24-byte header + payload) as built by + * wire::encode_frame. send() and receive() may run concurrently on two + * threads; shutdown() unblocks both. Framing (TCP is a stream) lives in the + * implementation, not in the callers. + */ +class ITransport +{ +public: + virtual ~ITransport() = default; + + //! False once the peer is gone or a send stalled past the transport's timeout. + virtual bool send(const uint8_t* frame, size_t size) = 0; + //! Timeout covers the wait for the first byte; Ok means `frame` holds exactly one complete message. + virtual ReceiveResult receive(std::vector& frame, std::chrono::milliseconds timeout) = 0; + virtual void shutdown() = 0; + //! Server side: finishes the transport's own handshake so send() works without waiting for a frame. Ok at once + //! when there is none (TCP). + virtual ReceiveResult wait_ready(std::chrono::milliseconds /*timeout*/) + { + return ReceiveResult::Ok; + } +}; + +} // namespace remote_plugin_session diff --git a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp new file mode 100644 index 0000000000..84376e2a88 --- /dev/null +++ b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp @@ -0,0 +1,81 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "tcp_socket.hpp" +#include "transport.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace remote_plugin_session +{ + +//! Where a client connects: plain "host[:port]" (TCP) or "ws://host[:port][/path]" (WebSocket). +struct RemoteAddress +{ + Endpoint endpoint; + bool websocket = false; + std::string path = "/"; +}; + +//! Throws std::invalid_argument; wss:// is refused (terminate TLS in a proxy in front of the bridge). +RemoteAddress parse_remote(const std::string& text, uint16_t default_port); +//! Connects (and for ws:// completes the upgrade) within `timeout`; throws std::runtime_error. +std::unique_ptr connect_transport(const RemoteAddress& remote, + std::chrono::milliseconds timeout = std::chrono::milliseconds{ 3000 }); + +/*! + * @brief RFC 6455 transport: each wire frame travels as one binary WebSocket message. No TLS, no extensions. + * + * The server role answers the HTTP upgrade inside its first receive(), so an accept loop never waits on a + * slow client; send() fails until the upgrade is done. Incoming fragments are reassembled, pings answered. + */ +class WebSocketTransport final : public ITransport +{ +public: + enum class Role + { + Client, + Server, + }; + + //! Server: no I/O. Client: sends the upgrade for `host`/`path` and throws std::runtime_error unless 101. + WebSocketTransport(TcpSocket socket, + Role role, + const std::string& host = "", + const std::string& path = "/", + std::chrono::milliseconds timeout = std::chrono::milliseconds{ 3000 }); + + //! Like TcpTransport::accept; the upgrade happens on the first receive(). + static std::unique_ptr accept(TcpSocket& listener, + std::chrono::milliseconds poll, + std::string* peer = nullptr); + + bool send(const uint8_t* frame, size_t size) override; + ReceiveResult receive(std::vector& frame, std::chrono::milliseconds timeout) override; + void shutdown() override; + //! Server: answers the HTTP upgrade if receive() has not yet. + ReceiveResult wait_ready(std::chrono::milliseconds timeout) override; + +private: + bool send_message(uint8_t opcode, const uint8_t* data, size_t size); + ReceiveResult accept_upgrade(std::chrono::milliseconds timeout); + + TcpSocket m_socket; + Role m_role; + std::atomic m_open{ false }; + std::mutex m_send_mutex; // receive() answers pings and closes concurrently with send() + std::vector m_send_buffer; + std::mt19937 m_mask_rng; +}; + +} // namespace remote_plugin_session diff --git a/src/plugins/remote_device_bridge/session/tcp_socket.cpp b/src/plugins/remote_device_bridge/session/tcp_socket.cpp new file mode 100644 index 0000000000..1b404c4619 --- /dev/null +++ b/src/plugins/remote_device_bridge/session/tcp_socket.cpp @@ -0,0 +1,473 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +#include "inc/remote_plugin_session/tcp_socket.hpp" + +#include "inc/remote_plugin_session/wire_codec.hpp" + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace remote_plugin_session +{ + +namespace +{ + +// A send may stall as long as the peer timeout tolerates silence; liveness is decided by the receive side. +constexpr std::chrono::milliseconds kSendTimeout{ 3000 }; +constexpr std::chrono::milliseconds kMidMessageStall{ 3000 }; +// Best effort: the kernel clamps to its rmem/wmem maximum; the effective sizes are logged once. +constexpr int kSocketBufferBytes = 4 * 1024 * 1024; + +std::string errno_string(const char* what) +{ + return std::string(what) + ": " + std::strerror(errno); +} + +void set_blocking(int fd, bool blocking) +{ + const int flags = fcntl(fd, F_GETFL, 0); + if (flags < 0) + { + throw std::runtime_error(errno_string("fcntl(F_GETFL)")); + } + const int updated = blocking ? (flags & ~O_NONBLOCK) : (flags | O_NONBLOCK); + if (fcntl(fd, F_SETFL, updated) < 0) + { + throw std::runtime_error(errno_string("fcntl(F_SETFL)")); + } +} + +void configure_stream(int fd) +{ + const int one = 1; + setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one)); + timeval send_timeout{}; + send_timeout.tv_sec = static_cast(kSendTimeout.count() / 1000); + send_timeout.tv_usec = static_cast((kSendTimeout.count() % 1000) * 1000); + setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &send_timeout, sizeof(send_timeout)); + + int snd = kSocketBufferBytes; + int rcv = kSocketBufferBytes; + setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &snd, sizeof(snd)); + setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rcv, sizeof(rcv)); + static std::atomic logged{ false }; + socklen_t len = sizeof(snd); + if (!logged.exchange(true) && getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &snd, &len) == 0 && + getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rcv, &len) == 0) + { + isaaccapture::Logger::get("isaaccapture.plugins.remote_device_bridge.TcpSocket") + ->info("[tcp] socket buffers: SO_SNDBUF={} SO_RCVBUF={} (requested {})", snd, rcv, kSocketBufferBytes); + } +} + +int poll_fd(int fd, short events, std::chrono::milliseconds timeout) +{ + pollfd pfd{}; + pfd.fd = fd; + pfd.events = events; + while (true) + { + const int result = ::poll(&pfd, 1, timeout.count() < 0 ? -1 : static_cast(timeout.count())); + if (result < 0 && errno == EINTR) + { + continue; + } + return result; + } +} + +struct AddrInfoList +{ + addrinfo* head = nullptr; + ~AddrInfoList() + { + if (head) + { + freeaddrinfo(head); + } + } +}; + +AddrInfoList resolve(const Endpoint& endpoint, bool passive) +{ + addrinfo hints{}; + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = passive ? (AI_PASSIVE | AI_NUMERICSERV) : AI_NUMERICSERV; + AddrInfoList list; + const std::string service = std::to_string(endpoint.port); + const int rc = + getaddrinfo(endpoint.host.empty() ? nullptr : endpoint.host.c_str(), service.c_str(), &hints, &list.head); + if (rc != 0) + { + throw std::runtime_error("getaddrinfo(" + endpoint.host + "): " + gai_strerror(rc)); + } + return list; +} + +//! Non-blocking connect with a deadline; on failure `last_error` says why and the caller tries the next address. +bool try_connect(TcpSocket& socket, const addrinfo& ai, std::chrono::milliseconds timeout, std::string& last_error) +{ + set_blocking(socket.fd(), false); + const int rc = ::connect(socket.fd(), ai.ai_addr, ai.ai_addrlen); + if (rc < 0 && errno != EINPROGRESS) + { + last_error = errno_string("connect"); + return false; + } + if (rc < 0) + { + const int ready = poll_fd(socket.fd(), POLLOUT, timeout); + if (ready <= 0) + { + last_error = ready == 0 ? "connect timed out" : errno_string("poll"); + return false; + } + int so_error = 0; + socklen_t len = sizeof(so_error); + if (getsockopt(socket.fd(), SOL_SOCKET, SO_ERROR, &so_error, &len) < 0 || so_error != 0) + { + last_error = std::string("connect: ") + std::strerror(so_error != 0 ? so_error : errno); + return false; + } + } + set_blocking(socket.fd(), true); + configure_stream(socket.fd()); + return true; +} + +bool try_listen(TcpSocket& socket, const addrinfo& ai, int backlog, std::string& last_error) +{ + const int one = 1; + setsockopt(socket.fd(), SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); + if (::bind(socket.fd(), ai.ai_addr, ai.ai_addrlen) < 0) + { + last_error = errno_string("bind"); + return false; + } + if (::listen(socket.fd(), backlog) < 0) + { + last_error = errno_string("listen"); + return false; + } + return true; +} + +//! Runs `attempt` on a fresh socket for each resolved address; the first success wins. `what` names the caller. +template +TcpSocket for_each_address(const Endpoint& endpoint, bool passive, const char* what, Attempt attempt) +{ + const AddrInfoList addresses = resolve(endpoint, passive); + std::string last_error = "no addresses"; + + for (const addrinfo* ai = addresses.head; ai != nullptr; ai = ai->ai_next) + { + TcpSocket socket(::socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol)); + if (!socket.valid()) + { + last_error = errno_string("socket"); + continue; + } + if (attempt(socket, *ai, last_error)) + { + return socket; + } + } + + throw std::runtime_error(std::string("TcpSocket::") + what + "(" + endpoint.host + ":" + + std::to_string(endpoint.port) + ") failed: " + last_error); +} + +} // namespace + +Endpoint parse_endpoint(const std::string& text, uint16_t default_port) +{ + Endpoint endpoint; + endpoint.port = default_port; + const size_t colon = text.rfind(':'); + if (colon == std::string::npos) + { + endpoint.host = text; + } + else + { + endpoint.host = text.substr(0, colon); + const std::string port_text = text.substr(colon + 1); + try + { + const unsigned long port = std::stoul(port_text); + if (port_text.empty() || port == 0 || port > 65535) + { + throw std::out_of_range("port"); + } + endpoint.port = static_cast(port); + } + catch (const std::exception&) + { + throw std::invalid_argument("invalid port in endpoint '" + text + "'"); + } + } + if (endpoint.host.empty()) + { + throw std::invalid_argument("missing host in endpoint '" + text + "'"); + } + return endpoint; +} + +TcpSocket::TcpSocket(int fd) : m_fd(fd) +{ +} + +TcpSocket::~TcpSocket() +{ + close(); +} + +TcpSocket::TcpSocket(TcpSocket&& other) noexcept : m_fd(std::exchange(other.m_fd, -1)) +{ +} + +TcpSocket& TcpSocket::operator=(TcpSocket&& other) noexcept +{ + if (this != &other) + { + close(); + m_fd = std::exchange(other.m_fd, -1); + } + return *this; +} + +TcpSocket TcpSocket::connect(const Endpoint& endpoint, std::chrono::milliseconds timeout) +{ + return for_each_address(endpoint, false, "connect", + [timeout](TcpSocket& socket, const addrinfo& ai, std::string& last_error) + { return try_connect(socket, ai, timeout, last_error); }); +} + +TcpSocket TcpSocket::listen(const Endpoint& endpoint, int backlog) +{ + return for_each_address(endpoint, true, "listen", + [backlog](TcpSocket& socket, const addrinfo& ai, std::string& last_error) + { return try_listen(socket, ai, backlog, last_error); }); +} + +TcpSocket TcpSocket::accept(std::chrono::milliseconds timeout) +{ + const int ready = poll_fd(m_fd, POLLIN, timeout); + if (ready == 0) + { + return TcpSocket(); + } + if (ready < 0) + { + throw std::runtime_error(errno_string("poll(accept)")); + } + const int fd = ::accept(m_fd, nullptr, nullptr); + if (fd < 0) + { + if (errno == EAGAIN || errno == EWOULDBLOCK || errno == ECONNABORTED || errno == EINTR) + { + return TcpSocket(); + } + throw std::runtime_error(errno_string("accept")); + } + TcpSocket client(fd); + configure_stream(fd); + return client; +} + +bool TcpSocket::valid() const +{ + return m_fd >= 0; +} + +int TcpSocket::fd() const +{ + return m_fd; +} + +uint16_t TcpSocket::local_port() const +{ + sockaddr_storage addr{}; + socklen_t len = sizeof(addr); + if (getsockname(m_fd, reinterpret_cast(&addr), &len) < 0) + { + throw std::runtime_error(errno_string("getsockname")); + } + if (addr.ss_family == AF_INET) + { + return ntohs(reinterpret_cast(&addr)->sin_port); + } + if (addr.ss_family == AF_INET6) + { + return ntohs(reinterpret_cast(&addr)->sin6_port); + } + throw std::runtime_error("getsockname: unsupported address family"); +} + +std::string TcpSocket::peer_name() const +{ + sockaddr_storage addr{}; + socklen_t len = sizeof(addr); + char host[NI_MAXHOST]; + char service[NI_MAXSERV]; + if (getpeername(m_fd, reinterpret_cast(&addr), &len) < 0 || + getnameinfo(reinterpret_cast(&addr), len, host, sizeof(host), service, sizeof(service), + NI_NUMERICHOST | NI_NUMERICSERV) != 0) + { + return "?"; + } + return std::string(host) + ":" + service; +} + +bool TcpSocket::send_all(const uint8_t* data, size_t size) +{ + size_t sent = 0; + while (sent < size) + { + const ssize_t n = ::send(m_fd, data + sent, size - sent, MSG_NOSIGNAL); + if (n < 0) + { + if (errno == EINTR) + { + continue; + } + return false; + } + if (n == 0) + { + return false; + } + sent += static_cast(n); + } + return true; +} + +TcpSocket::RecvResult TcpSocket::recv_all(uint8_t* data, size_t size, std::chrono::milliseconds timeout) +{ + size_t received = 0; + while (received < size) + { + const int ready = poll_fd(m_fd, POLLIN, received == 0 ? timeout : kMidMessageStall); + if (ready == 0) + { + return received == 0 ? RecvResult::Timeout : RecvResult::Closed; + } + if (ready < 0) + { + return RecvResult::Closed; + } + const ssize_t n = ::recv(m_fd, data + received, size - received, 0); + if (n < 0) + { + if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) + { + continue; + } + return RecvResult::Closed; + } + if (n == 0) + { + return RecvResult::Closed; + } + received += static_cast(n); + } + return RecvResult::Ok; +} + +void TcpSocket::shutdown() +{ + if (m_fd >= 0) + { + ::shutdown(m_fd, SHUT_RDWR); + } +} + +void TcpSocket::close() +{ + if (m_fd >= 0) + { + ::close(m_fd); + m_fd = -1; + } +} + +TcpTransport::TcpTransport(TcpSocket socket) : m_socket(std::move(socket)) +{ +} + +bool TcpTransport::send(const uint8_t* frame, size_t size) +{ + return m_socket.send_all(frame, size); +} + +ReceiveResult TcpTransport::receive(std::vector& frame, std::chrono::milliseconds timeout) +{ + frame.resize(wire::kHeaderSize); + switch (m_socket.recv_all(frame.data(), wire::kHeaderSize, timeout)) + { + case TcpSocket::RecvResult::Timeout: + return ReceiveResult::Timeout; + case TcpSocket::RecvResult::Closed: + return ReceiveResult::Closed; + case TcpSocket::RecvResult::Ok: + break; + } + + uint32_t payload_size = 0; + try + { + payload_size = wire::decode_header(frame.data()).payload_size; + } + catch (const wire::DecodeError&) + { + return ReceiveResult::Malformed; + } + if (payload_size == 0) + { + return ReceiveResult::Ok; + } + frame.resize(wire::kHeaderSize + payload_size); + // A header without its payload within the stall window is a broken peer, not a quiet one. + return m_socket.recv_all(frame.data() + wire::kHeaderSize, payload_size, kMidMessageStall) == + TcpSocket::RecvResult::Ok ? + ReceiveResult::Ok : + ReceiveResult::Closed; +} + +void TcpTransport::shutdown() +{ + m_socket.shutdown(); +} + +std::unique_ptr TcpTransport::accept(TcpSocket& listener, std::chrono::milliseconds poll, std::string* peer) +{ + TcpSocket client = listener.accept(poll); + if (!client.valid()) + { + return nullptr; + } + if (peer != nullptr) + { + *peer = client.peer_name(); + } + return std::make_unique(std::move(client)); +} + +} // namespace remote_plugin_session diff --git a/src/plugins/remote_device_bridge/session/websocket_transport.cpp b/src/plugins/remote_device_bridge/session/websocket_transport.cpp new file mode 100644 index 0000000000..fc5787d9f5 --- /dev/null +++ b/src/plugins/remote_device_bridge/session/websocket_transport.cpp @@ -0,0 +1,459 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +#include "inc/remote_plugin_session/websocket_transport.hpp" + +#include "inc/remote_plugin_session/wire_codec.hpp" + +#include +#include +#include +#include +#include +#include + +namespace remote_plugin_session +{ + +namespace +{ + +constexpr std::chrono::milliseconds kStall{ 3000 }; // matches TcpTransport's mid-message stall +constexpr size_t kMaxHttpHead = 8192; +constexpr uint64_t kMaxMessage = wire::kHeaderSize + wire::kMaxPayloadSize; +constexpr char kAcceptGuid[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; + +constexpr uint8_t kContinuation = 0x0; +constexpr uint8_t kBinary = 0x2; +constexpr uint8_t kClose = 0x8; +constexpr uint8_t kPing = 0x9; +constexpr uint8_t kPong = 0xA; + +std::array sha1(const std::string& text) +{ + std::array h{ 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 }; + std::vector msg(text.begin(), text.end()); + const uint64_t bits = static_cast(msg.size()) * 8; + msg.push_back(0x80); + while (msg.size() % 64 != 56) + { + msg.push_back(0); + } + for (int i = 7; i >= 0; --i) + { + msg.push_back(static_cast(bits >> (i * 8))); + } + const auto rotl = [](uint32_t v, int n) { return (v << n) | (v >> (32 - n)); }; + for (size_t chunk = 0; chunk < msg.size(); chunk += 64) + { + std::array w{}; + for (size_t i = 0; i < 16; ++i) + { + const uint8_t* p = &msg[chunk + 4 * i]; + w[i] = (uint32_t{ p[0] } << 24) | (uint32_t{ p[1] } << 16) | (uint32_t{ p[2] } << 8) | p[3]; + } + for (size_t i = 16; i < 80; ++i) + { + w[i] = rotl(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1); + } + uint32_t a = h[0], b = h[1], c = h[2], d = h[3], e = h[4]; + for (size_t i = 0; i < 80; ++i) + { + const uint32_t f = i < 20 ? (b & c) | (~b & d) : + (i < 40 || i >= 60) ? b ^ c ^ d : + (b & c) | (b & d) | (c & d); + const uint32_t k = i < 20 ? 0x5A827999 : i < 40 ? 0x6ED9EBA1 : i < 60 ? 0x8F1BBCDC : 0xCA62C1D6; + const uint32_t t = rotl(a, 5) + f + e + k + w[i]; + e = d; + d = c; + c = rotl(b, 30); + b = a; + a = t; + } + h[0] += a; + h[1] += b; + h[2] += c; + h[3] += d; + h[4] += e; + } + std::array digest{}; + for (size_t i = 0; i < digest.size(); ++i) + { + digest[i] = static_cast(h[i / 4] >> (24 - 8 * (i % 4))); + } + return digest; +} + +std::string base64(const uint8_t* data, size_t size) +{ + static constexpr char kAlphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + std::string out; + for (size_t i = 0; i < size; i += 3) + { + uint32_t n = uint32_t{ data[i] } << 16; + n |= i + 1 < size ? uint32_t{ data[i + 1] } << 8 : 0; + n |= i + 2 < size ? data[i + 2] : 0; + out += kAlphabet[(n >> 18) & 63]; + out += kAlphabet[(n >> 12) & 63]; + out += i + 1 < size ? kAlphabet[(n >> 6) & 63] : '='; + out += i + 2 < size ? kAlphabet[n & 63] : '='; + } + return out; +} + +std::string accept_key(const std::string& key) +{ + const std::array digest = sha1(key + kAcceptGuid); + return base64(digest.data(), digest.size()); +} + +std::string lower(std::string text) +{ + std::transform(text.begin(), text.end(), text.begin(), [](unsigned char c) { return std::tolower(c); }); + return text; +} + +struct HttpHead +{ + std::string start_line; + std::map headers; //!< lowercase names, trimmed values +}; + +//! Reads up to the blank line one byte at a time so no WebSocket bytes that follow are consumed. +ReceiveResult read_http_head(TcpSocket& socket, std::chrono::milliseconds timeout, HttpHead& head) +{ + std::string text; + while (text.size() < 4 || text.compare(text.size() - 4, 4, "\r\n\r\n") != 0) + { + if (text.size() >= kMaxHttpHead) + { + return ReceiveResult::Malformed; + } + uint8_t byte = 0; + const TcpSocket::RecvResult result = socket.recv_all(&byte, 1, text.empty() ? timeout : kStall); + if (result != TcpSocket::RecvResult::Ok) + { + return result == TcpSocket::RecvResult::Timeout && text.empty() ? ReceiveResult::Timeout : + ReceiveResult::Closed; + } + text.push_back(static_cast(byte)); + } + size_t begin = text.find("\r\n"); + head.start_line = text.substr(0, begin); + for (begin += 2; begin < text.size() - 2;) + { + const size_t end = text.find("\r\n", begin); + const std::string line = text.substr(begin, end - begin); + begin = end + 2; + const size_t colon = line.find(':'); + if (colon == std::string::npos) + { + return ReceiveResult::Malformed; + } + const size_t value = line.find_first_not_of(" \t", colon + 1); + head.headers[lower(line.substr(0, colon))] = + value == std::string::npos ? "" : line.substr(value, line.find_last_not_of(" \t") + 1 - value); + } + return ReceiveResult::Ok; +} + +std::string header(const HttpHead& head, const std::string& name) +{ + const auto it = head.headers.find(name); + return it == head.headers.end() ? "" : it->second; +} + +} // namespace + +RemoteAddress parse_remote(const std::string& text, uint16_t default_port) +{ + const std::string scheme = "ws://"; + if (text.rfind("wss://", 0) == 0) + { + throw std::invalid_argument("wss:// is not supported ('" + text + "'); terminate TLS in a proxy, use ws://"); + } + RemoteAddress remote; + if (text.rfind(scheme, 0) != 0) + { + remote.endpoint = parse_endpoint(text, default_port); + return remote; + } + remote.websocket = true; + std::string authority = text.substr(scheme.size()); + const size_t slash = authority.find('/'); + if (slash != std::string::npos) + { + remote.path = authority.substr(slash); + authority.resize(slash); + } + remote.endpoint = parse_endpoint(authority, default_port); + return remote; +} + +std::unique_ptr connect_transport(const RemoteAddress& remote, std::chrono::milliseconds timeout) +{ + TcpSocket socket = TcpSocket::connect(remote.endpoint, timeout); + if (!remote.websocket) + { + return std::make_unique(std::move(socket)); + } + return std::make_unique(std::move(socket), WebSocketTransport::Role::Client, + remote.endpoint.host + ":" + std::to_string(remote.endpoint.port), + remote.path, timeout); +} + +WebSocketTransport::WebSocketTransport( + TcpSocket socket, Role role, const std::string& host, const std::string& path, std::chrono::milliseconds timeout) + : m_socket(std::move(socket)), m_role(role), m_mask_rng(std::random_device{}()) +{ + if (role == Role::Server) + { + return; + } + std::array nonce{}; + std::generate(nonce.begin(), nonce.end(), [this] { return static_cast(m_mask_rng()); }); + const std::string key = base64(nonce.data(), nonce.size()); + const std::string request = "GET " + path + " HTTP/1.1\r\nHost: " + host + + "\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: " + key + + "\r\nSec-WebSocket-Version: 13\r\n\r\n"; + HttpHead response; + if (!m_socket.send_all(reinterpret_cast(request.data()), request.size()) || + read_http_head(m_socket, timeout, response) != ReceiveResult::Ok) + { + throw std::runtime_error("WebSocket upgrade to " + host + path + ": no HTTP response"); + } + if (response.start_line.rfind("HTTP/1.1 101", 0) != 0) + { + throw std::runtime_error("WebSocket upgrade to " + host + path + " refused: " + response.start_line); + } + if (header(response, "sec-websocket-accept") != accept_key(key)) + { + throw std::runtime_error("WebSocket upgrade to " + host + path + ": wrong Sec-WebSocket-Accept"); + } + m_open = true; +} + +std::unique_ptr WebSocketTransport::accept(TcpSocket& listener, + std::chrono::milliseconds poll, + std::string* peer) +{ + TcpSocket client = listener.accept(poll); + if (!client.valid()) + { + return nullptr; + } + if (peer != nullptr) + { + *peer = client.peer_name(); + } + return std::make_unique(std::move(client), Role::Server); +} + +ReceiveResult WebSocketTransport::accept_upgrade(std::chrono::milliseconds timeout) +{ + HttpHead request; + const ReceiveResult result = read_http_head(m_socket, timeout, request); + if (result == ReceiveResult::Timeout || result == ReceiveResult::Closed) + { + return result; + } + const std::string key = header(request, "sec-websocket-key"); + if (result != ReceiveResult::Ok || request.start_line.rfind("GET ", 0) != 0 || + lower(header(request, "upgrade")).find("websocket") == std::string::npos || + lower(header(request, "connection")).find("upgrade") == std::string::npos || + header(request, "sec-websocket-version") != "13" || key.empty()) + { + static const std::string kBadRequest = "HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\n\r\n"; + m_socket.send_all(reinterpret_cast(kBadRequest.data()), kBadRequest.size()); + m_socket.shutdown(); + return ReceiveResult::Malformed; + } + const std::string response = + "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: " + + accept_key(key) + "\r\n\r\n"; + if (!m_socket.send_all(reinterpret_cast(response.data()), response.size())) + { + return ReceiveResult::Closed; + } + m_open = true; + return ReceiveResult::Ok; +} + +bool WebSocketTransport::send(const uint8_t* frame, size_t size) +{ + return m_open.load() && send_message(kBinary, frame, size); +} + +bool WebSocketTransport::send_message(uint8_t opcode, const uint8_t* data, size_t size) +{ + std::lock_guard lock(m_send_mutex); + std::vector& out = m_send_buffer; + out.assign(1, static_cast(0x80 | opcode)); // FIN: never fragmented on send + const uint8_t mask_bit = m_role == Role::Client ? 0x80 : 0x00; + if (size < 126) + { + out.push_back(static_cast(mask_bit | size)); + } + else + { + const int length_bytes = size <= 0xFFFF ? 2 : 8; + out.push_back(static_cast(mask_bit | (length_bytes == 2 ? 126 : 127))); + for (int i = length_bytes - 1; i >= 0; --i) + { + out.push_back(static_cast(static_cast(size) >> (8 * i))); + } + } + const size_t payload_at = out.size() + (mask_bit ? 4 : 0); + if (mask_bit) + { + const uint32_t key = m_mask_rng(); + out.insert(out.end(), { static_cast(key >> 24), static_cast(key >> 16), + static_cast(key >> 8), static_cast(key) }); + } + out.insert(out.end(), data, data + size); + if (mask_bit) + { + for (size_t i = 0; i < size; ++i) + { + out[payload_at + i] ^= out[payload_at - 4 + i % 4]; + } + } + return m_socket.send_all(out.data(), out.size()); +} + +ReceiveResult WebSocketTransport::receive(std::vector& frame, std::chrono::milliseconds timeout) +{ + const auto deadline = std::chrono::steady_clock::now() + timeout; + if (!m_open.load()) + { + const ReceiveResult upgraded = accept_upgrade(timeout); + if (upgraded != ReceiveResult::Ok) + { + return upgraded; + } + } + frame.clear(); + bool in_message = false; + while (true) + { + // The caller's timeout covers the wait for a message to start (pings included); inside one, a stall is a drop. + const auto remaining = timeout.count() < 0 ? timeout : + std::max(std::chrono::milliseconds{ 0 }, + std::chrono::duration_cast( + deadline - std::chrono::steady_clock::now())); + uint8_t head[2]; + const TcpSocket::RecvResult first = m_socket.recv_all(head, sizeof(head), in_message ? kStall : remaining); + if (first != TcpSocket::RecvResult::Ok) + { + return first == TcpSocket::RecvResult::Timeout && !in_message ? ReceiveResult::Timeout : + ReceiveResult::Closed; + } + const bool fin = (head[0] & 0x80) != 0; + const uint8_t opcode = head[0] & 0x0F; + const bool masked = (head[1] & 0x80) != 0; + const bool control = (opcode & 0x08) != 0; + uint64_t length = head[1] & 0x7F; + // RSV bits need an extension we never negotiate; clients must mask and servers must not. + if ((head[0] & 0x70) != 0 || masked != (m_role == Role::Server)) + { + return ReceiveResult::Closed; + } + if (length >= 126) + { + std::array ext{}; + const size_t ext_size = length == 126 ? 2 : 8; + if (m_socket.recv_all(ext.data(), ext_size, kStall) != TcpSocket::RecvResult::Ok) + { + return ReceiveResult::Closed; + } + length = 0; + for (size_t i = 0; i < ext_size; ++i) + { + length = (length << 8) | ext[i]; + } + } + std::array mask{}; + if (masked && m_socket.recv_all(mask.data(), mask.size(), kStall) != TcpSocket::RecvResult::Ok) + { + return ReceiveResult::Closed; + } + + std::vector control_payload; + uint8_t* dest = nullptr; + if (control) + { + if (!fin || length > 125) + { + return ReceiveResult::Closed; + } + control_payload.resize(length); + dest = control_payload.data(); + } + else + { + if (opcode != (in_message ? kContinuation : kBinary)) + { + return ReceiveResult::Closed; // text frames, unknown opcodes, broken fragmentation + } + if (length > kMaxMessage - frame.size()) + { + return ReceiveResult::Malformed; + } + const size_t offset = frame.size(); + frame.resize(offset + length); + dest = frame.data() + offset; + } + if (length > 0 && m_socket.recv_all(dest, length, kStall) != TcpSocket::RecvResult::Ok) + { + return ReceiveResult::Closed; + } + for (size_t i = 0; masked && i < length; ++i) + { + dest[i] ^= mask[i % 4]; + } + + if (opcode == kPing) + { + send_message(kPong, control_payload.data(), control_payload.size()); + continue; + } + if (opcode == kPong) + { + continue; + } + if (control) + { + // Close (and the reserved control opcodes): echo the status code, then report the peer gone. + send_message(kClose, control_payload.data(), std::min(control_payload.size(), 2)); + return ReceiveResult::Closed; + } + in_message = !fin; + if (in_message) + { + continue; + } + try + { + return frame.size() >= wire::kHeaderSize && + frame.size() == wire::kHeaderSize + wire::decode_header(frame.data()).payload_size ? + ReceiveResult::Ok : + ReceiveResult::Malformed; + } + catch (const wire::DecodeError&) + { + return ReceiveResult::Malformed; + } + } +} + +void WebSocketTransport::shutdown() +{ + m_socket.shutdown(); +} + +ReceiveResult WebSocketTransport::wait_ready(std::chrono::milliseconds timeout) +{ + return m_open.load() ? ReceiveResult::Ok : accept_upgrade(timeout); +} + +} // namespace remote_plugin_session diff --git a/tests/cpp/plugins/remote_device_bridge/CMakeLists.txt b/tests/cpp/plugins/remote_device_bridge/CMakeLists.txt index fcac49524b..344a77f9e6 100644 --- a/tests/cpp/plugins/remote_device_bridge/CMakeLists.txt +++ b/tests/cpp/plugins/remote_device_bridge/CMakeLists.txt @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 add_executable(remote_plugin_session_tests + test_websocket_transport.cpp test_wire_codec.cpp ) diff --git a/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp b/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp new file mode 100644 index 0000000000..6db6d8f67c --- /dev/null +++ b/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp @@ -0,0 +1,279 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +using namespace remote_plugin_session; +using Role = WebSocketTransport::Role; + +namespace +{ + +constexpr std::chrono::milliseconds kWait{ 2000 }; +constexpr std::chrono::milliseconds kShort{ 300 }; + +std::pair socket_pair() +{ + int fds[2]; + REQUIRE(socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == 0); + return { TcpSocket(fds[0]), TcpSocket(fds[1]) }; +} + +//! A wire frame whose WebSocket message (header + payload) is exactly `message_size` bytes. +std::vector frame_of_size(size_t message_size) +{ + std::vector payload(message_size - wire::kHeaderSize); + for (size_t i = 0; i < payload.size(); ++i) + { + payload[i] = static_cast(i * 31 + 7); + } + return wire::encode_frame(wire::FrameType::SchemaSample, 3, payload); +} + +//! Hand-built client frame (masked, length < 65536) for driving the server role directly. +std::vector raw_frame(uint8_t opcode, bool fin, const std::vector& payload, bool masked = true) +{ + std::vector out{ static_cast((fin ? 0x80 : 0) | opcode) }; + const uint8_t mask_bit = masked ? 0x80 : 0; + if (payload.size() < 126) + { + out.push_back(static_cast(mask_bit | payload.size())); + } + else + { + out.insert(out.end(), { static_cast(mask_bit | 126), static_cast(payload.size() >> 8), + static_cast(payload.size()) }); + } + const uint8_t key[4] = { 0x12, 0x34, 0x56, 0x78 }; + if (masked) + { + out.insert(out.end(), key, key + 4); + } + for (size_t i = 0; i < payload.size(); ++i) + { + out.push_back(masked ? payload[i] ^ key[i % 4] : payload[i]); + } + return out; +} + +void raw_send(TcpSocket& socket, const std::string& text) +{ + REQUIRE(socket.send_all(reinterpret_cast(text.data()), text.size())); +} + +void raw_send(TcpSocket& socket, const std::vector& bytes) +{ + REQUIRE(socket.send_all(bytes.data(), bytes.size())); +} + +std::vector raw_recv(TcpSocket& socket, size_t size) +{ + std::vector bytes(size); + REQUIRE(socket.recv_all(bytes.data(), size, kWait) == TcpSocket::RecvResult::Ok); + return bytes; +} + +//! Reads the server's HTTP response head byte by byte. +std::string raw_recv_head(TcpSocket& socket) +{ + std::string text; + while (text.size() < 4 || text.compare(text.size() - 4, 4, "\r\n\r\n") != 0) + { + text.push_back(static_cast(raw_recv(socket, 1)[0])); + } + return text; +} + +// RFC 6455 section 1.3 sample handshake. +const std::string kSampleUpgrade = + "GET /chat HTTP/1.1\r\nHost: server.example.com\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n" + "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://example.com\r\nSec-WebSocket-Version: 13\r\n\r\n"; + +//! A server transport upgraded by a raw client using the RFC sample key. +std::unique_ptr upgraded_server(TcpSocket server_end, TcpSocket& raw_client) +{ + auto server = std::make_unique(std::move(server_end), Role::Server); + raw_send(raw_client, kSampleUpgrade); + std::vector frame; + REQUIRE(server->receive(frame, kShort) == ReceiveResult::Timeout); + const std::string response = raw_recv_head(raw_client); + REQUIRE(response.rfind("HTTP/1.1 101", 0) == 0); + REQUIRE(response.find("Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n") != std::string::npos); + return server; +} + +struct Connected +{ + std::unique_ptr client; + std::unique_ptr server; +}; + +Connected connected_pair() +{ + auto [client_end, server_end] = socket_pair(); + Connected pair; + pair.server = std::make_unique(std::move(server_end), Role::Server); + std::thread client( + [&] { pair.client = std::make_unique(std::move(client_end), Role::Client, "h:1", "/x"); }); + std::vector frame; + REQUIRE(pair.server->receive(frame, kShort) == ReceiveResult::Timeout); + client.join(); + REQUIRE(pair.client); + return pair; +} + +} // namespace + +TEST_CASE("parse_remote selects TCP or WebSocket", "[remote_device_bridge][unit]") +{ + const RemoteAddress tcp = parse_remote("10.0.0.2:5000", 47500); + REQUIRE_FALSE(tcp.websocket); + REQUIRE(tcp.endpoint.host == "10.0.0.2"); + REQUIRE(tcp.endpoint.port == 5000); + + const RemoteAddress ws = parse_remote("ws://bridge.local:8080/teleop", 47500); + REQUIRE(ws.websocket); + REQUIRE(ws.endpoint.host == "bridge.local"); + REQUIRE(ws.endpoint.port == 8080); + REQUIRE(ws.path == "/teleop"); + + const RemoteAddress bare = parse_remote("ws://bridge.local", 47500); + REQUIRE(bare.endpoint.port == 47500); + REQUIRE(bare.path == "/"); + + REQUIRE_THROWS_AS(parse_remote("wss://bridge.local", 47500), std::invalid_argument); + REQUIRE_THROWS_AS(parse_remote("ws:///teleop", 47500), std::invalid_argument); +} + +TEST_CASE("WebSocketTransport round-trips frames of every length class", "[remote_device_bridge][unit]") +{ + // 7-bit, 16-bit and 64-bit WebSocket lengths, both directions (client frames are masked). + const size_t message_size = GENERATE(size_t{ 25 }, 125, 126, 65535, 65536, 1024 * 1024); + Connected pair = connected_pair(); + const std::vector sent = frame_of_size(message_size); + + for (auto [from, to] : + { std::pair{ pair.client.get(), pair.server.get() }, std::pair{ pair.server.get(), pair.client.get() } }) + { + bool send_ok = false; + std::thread sender([&, from = from] { send_ok = from->send(sent.data(), sent.size()); }); + std::vector received; + REQUIRE(to->receive(received, kWait) == ReceiveResult::Ok); + sender.join(); + REQUIRE(send_ok); + REQUIRE(received == sent); + } +} + +TEST_CASE("WebSocketTransport server role handles control frames and fragments", "[remote_device_bridge][unit]") +{ + auto [raw, server_end] = socket_pair(); + auto server = upgraded_server(std::move(server_end), raw); + std::vector frame; + + SECTION("ping is answered with a pong carrying the same payload") + { + raw_send(raw, raw_frame(0x9, true, { 'h', 'i' })); + REQUIRE(server->receive(frame, kShort) == ReceiveResult::Timeout); + REQUIRE(raw_recv(raw, 4) == std::vector{ 0x8A, 0x02, 'h', 'i' }); + } + SECTION("a fragmented message with an interleaved ping is reassembled") + { + const std::vector sent = frame_of_size(300); + raw_send(raw, raw_frame(0x2, false, { sent.begin(), sent.begin() + 100 })); + raw_send(raw, raw_frame(0x9, true, {})); + raw_send(raw, raw_frame(0x0, true, { sent.begin() + 100, sent.end() })); + REQUIRE(server->receive(frame, kWait) == ReceiveResult::Ok); + REQUIRE(frame == sent); + REQUIRE(raw_recv(raw, 2) == std::vector{ 0x8A, 0x00 }); + } + SECTION("peer close is echoed and reported as closed") + { + raw_send(raw, raw_frame(0x8, true, { 0x03, 0xE8 })); + REQUIRE(server->receive(frame, kWait) == ReceiveResult::Closed); + REQUIRE(raw_recv(raw, 4) == std::vector{ 0x88, 0x02, 0x03, 0xE8 }); + } + SECTION("an unmasked client frame closes the connection") + { + raw_send(raw, raw_frame(0x2, true, frame_of_size(24), false)); + REQUIRE(server->receive(frame, kWait) == ReceiveResult::Closed); + } + SECTION("text frames are refused") + { + raw_send(raw, raw_frame(0x1, true, { 'x' })); + REQUIRE(server->receive(frame, kWait) == ReceiveResult::Closed); + } + SECTION("a message that is not exactly one wire frame is malformed") + { + raw_send(raw, raw_frame(0x2, true, { 0x01 })); + REQUIRE(server->receive(frame, kWait) == ReceiveResult::Malformed); + } + SECTION("TCP EOF is reported as closed") + { + raw.shutdown(); + REQUIRE(server->receive(frame, kWait) == ReceiveResult::Closed); + } +} + +TEST_CASE("WebSocketTransport rejects bad handshakes", "[remote_device_bridge][unit]") +{ + auto [peer, own_end] = socket_pair(); + SECTION("server answers garbage with 400 and refuses to send") + { + WebSocketTransport server(std::move(own_end), Role::Server); + raw_send(peer, "hello there\r\n\r\n"); + std::vector frame; + REQUIRE(server.receive(frame, kWait) == ReceiveResult::Malformed); + REQUIRE(raw_recv_head(peer).rfind("HTTP/1.1 400", 0) == 0); + const std::vector sent = frame_of_size(24); + REQUIRE_FALSE(server.send(sent.data(), sent.size())); + } + SECTION("client throws on a non-101 response") + { + raw_send(peer, "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"); + REQUIRE_THROWS_AS(WebSocketTransport(std::move(own_end), Role::Client, "h:1", "/"), std::runtime_error); + } + SECTION("client throws on a wrong Sec-WebSocket-Accept") + { + raw_send(peer, + "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n" + "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n\r\n"); + REQUIRE_THROWS_AS(WebSocketTransport(std::move(own_end), Role::Client, "h:1", "/"), std::runtime_error); + } +} + +TEST_CASE("connect_transport speaks ws:// to a listening WebSocketTransport", "[remote_device_bridge][unit]") +{ + TcpSocket listener = TcpSocket::listen(Endpoint{ "127.0.0.1", 0 }, 1); + const RemoteAddress remote = parse_remote("ws://127.0.0.1:" + std::to_string(listener.local_port()) + "/t", 1); + std::unique_ptr client; + std::thread connector([&] { client = connect_transport(remote, kWait); }); + std::unique_ptr server; + while (!server) + { + server = WebSocketTransport::accept(listener, kShort); + } + std::vector frame; + REQUIRE(server->receive(frame, kShort) == ReceiveResult::Timeout); + connector.join(); + REQUIRE(client); + + const std::vector sent = frame_of_size(200); + REQUIRE(client->send(sent.data(), sent.size())); + REQUIRE(server->receive(frame, kWait) == ReceiveResult::Ok); + REQUIRE(frame == sent); + client->shutdown(); + REQUIRE(server->receive(frame, kWait) == ReceiveResult::Closed); +} From 89d8f84e4837e89cd0b146b8fda4f256b6840a16 Mon Sep 17 00:00:00 2001 From: Jonghyun Kim Date: Fri, 30 Oct 2026 10:29:37 -0700 Subject: [PATCH 2/8] rebase onto pr00 review pr01's codec became remote_plugin_protocol (protocol_frame.hpp / protocol_payloads.hpp): the transports include protocol_frame.hpp and use protocol::kHeaderSize, protocol::decode_header and protocol::DecodeError through a namespace alias. The session CMake and AGENTS.md conflicts are resolved onto the split file names. Co-Authored-By: Claude Opus 5.5 Signed-off-by: Jonghyun Kim --- .../inc/remote_plugin_session/transport.hpp | 2 +- .../remote_device_bridge/session/tcp_socket.cpp | 16 +++++++++------- .../session/websocket_transport.cpp | 12 +++++++----- .../test_websocket_transport.cpp | 7 ++++--- 4 files changed, 21 insertions(+), 16 deletions(-) diff --git a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp index c8402c285f..a40f2091e5 100644 --- a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp +++ b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp @@ -23,7 +23,7 @@ enum class ReceiveResult * @brief Message transport between a RemotePluginSession and the bridge. * * A frame is one complete wire message (24-byte header + payload) as built by - * wire::encode_frame. send() and receive() may run concurrently on two + * protocol::encode_frame. send() and receive() may run concurrently on two * threads; shutdown() unblocks both. Framing (TCP is a stream) lives in the * implementation, not in the callers. */ diff --git a/src/plugins/remote_device_bridge/session/tcp_socket.cpp b/src/plugins/remote_device_bridge/session/tcp_socket.cpp index 1b404c4619..8689aaaeba 100644 --- a/src/plugins/remote_device_bridge/session/tcp_socket.cpp +++ b/src/plugins/remote_device_bridge/session/tcp_socket.cpp @@ -3,7 +3,7 @@ #include "inc/remote_plugin_session/tcp_socket.hpp" -#include "inc/remote_plugin_session/wire_codec.hpp" +#include "inc/remote_plugin_session/protocol_frame.hpp" #include #include @@ -25,6 +25,8 @@ namespace remote_plugin_session { +namespace protocol = remote_plugin_protocol; + namespace { @@ -419,8 +421,8 @@ bool TcpTransport::send(const uint8_t* frame, size_t size) ReceiveResult TcpTransport::receive(std::vector& frame, std::chrono::milliseconds timeout) { - frame.resize(wire::kHeaderSize); - switch (m_socket.recv_all(frame.data(), wire::kHeaderSize, timeout)) + frame.resize(protocol::kHeaderSize); + switch (m_socket.recv_all(frame.data(), protocol::kHeaderSize, timeout)) { case TcpSocket::RecvResult::Timeout: return ReceiveResult::Timeout; @@ -433,9 +435,9 @@ ReceiveResult TcpTransport::receive(std::vector& frame, std::chrono::mi uint32_t payload_size = 0; try { - payload_size = wire::decode_header(frame.data()).payload_size; + payload_size = protocol::decode_header(frame).payload_size; } - catch (const wire::DecodeError&) + catch (const protocol::DecodeError&) { return ReceiveResult::Malformed; } @@ -443,9 +445,9 @@ ReceiveResult TcpTransport::receive(std::vector& frame, std::chrono::mi { return ReceiveResult::Ok; } - frame.resize(wire::kHeaderSize + payload_size); + frame.resize(protocol::kHeaderSize + payload_size); // A header without its payload within the stall window is a broken peer, not a quiet one. - return m_socket.recv_all(frame.data() + wire::kHeaderSize, payload_size, kMidMessageStall) == + return m_socket.recv_all(frame.data() + protocol::kHeaderSize, payload_size, kMidMessageStall) == TcpSocket::RecvResult::Ok ? ReceiveResult::Ok : ReceiveResult::Closed; diff --git a/src/plugins/remote_device_bridge/session/websocket_transport.cpp b/src/plugins/remote_device_bridge/session/websocket_transport.cpp index fc5787d9f5..0bf356ae20 100644 --- a/src/plugins/remote_device_bridge/session/websocket_transport.cpp +++ b/src/plugins/remote_device_bridge/session/websocket_transport.cpp @@ -3,7 +3,7 @@ #include "inc/remote_plugin_session/websocket_transport.hpp" -#include "inc/remote_plugin_session/wire_codec.hpp" +#include "inc/remote_plugin_session/protocol_frame.hpp" #include #include @@ -15,12 +15,14 @@ namespace remote_plugin_session { +namespace protocol = remote_plugin_protocol; + namespace { constexpr std::chrono::milliseconds kStall{ 3000 }; // matches TcpTransport's mid-message stall constexpr size_t kMaxHttpHead = 8192; -constexpr uint64_t kMaxMessage = wire::kHeaderSize + wire::kMaxPayloadSize; +constexpr uint64_t kMaxMessage = protocol::kHeaderSize + protocol::kMaxPayloadSize; constexpr char kAcceptGuid[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; constexpr uint8_t kContinuation = 0x0; @@ -434,12 +436,12 @@ ReceiveResult WebSocketTransport::receive(std::vector& frame, std::chro } try { - return frame.size() >= wire::kHeaderSize && - frame.size() == wire::kHeaderSize + wire::decode_header(frame.data()).payload_size ? + return frame.size() >= protocol::kHeaderSize && + frame.size() == protocol::kHeaderSize + protocol::decode_header(frame).payload_size ? ReceiveResult::Ok : ReceiveResult::Malformed; } - catch (const wire::DecodeError&) + catch (const protocol::DecodeError&) { return ReceiveResult::Malformed; } diff --git a/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp b/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp index 6db6d8f67c..1f4a88beee 100644 --- a/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp +++ b/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp @@ -3,8 +3,8 @@ #include #include +#include #include -#include #include #include @@ -16,6 +16,7 @@ #include using namespace remote_plugin_session; +namespace protocol = remote_plugin_protocol; using Role = WebSocketTransport::Role; namespace @@ -34,12 +35,12 @@ std::pair socket_pair() //! A wire frame whose WebSocket message (header + payload) is exactly `message_size` bytes. std::vector frame_of_size(size_t message_size) { - std::vector payload(message_size - wire::kHeaderSize); + std::vector payload(message_size - protocol::kHeaderSize); for (size_t i = 0; i < payload.size(); ++i) { payload[i] = static_cast(i * 31 + 7); } - return wire::encode_frame(wire::FrameType::SchemaSample, 3, payload); + return protocol::encode_frame(protocol::FrameType::SchemaSample, 3, payload); } //! Hand-built client frame (masked, length < 65536) for driving the server role directly. From 3c917e7de9c51044e2daf8062baa19d02dbe7742 Mon Sep 17 00:00:00 2001 From: Jonghyun Kim Date: Fri, 30 Oct 2026 10:39:44 -0700 Subject: [PATCH 3/8] review round 1 (pr03) Applied the fact-checked (VERIFIED) findings on code this branch adds: - TcpSocket: setsockopt failures (TCP_NODELAY, SO_SNDTIMEO, SO_REUSEADDR) throw with errno; connect/listen attempts throw their reason instead of bool + out-param, including a failed socket(); addrinfo is held by a unique_ptr; parse_endpoint accepts [v6]:port and bare v6 hosts and rejects trailing garbage ("80x"); EAGAIN branches that a blocking socket cannot hit are gone; the once-per-process buffer-size log is dropped (and with it the log_bridge link). - TcpTransport moves to tcp_transport.{hpp,cpp}; parse_remote and connect_transport move to remote_address.{hpp,cpp}; RemoteAddress carries std::optional ws_path instead of bool + path. - accept() reports the peer through TcpSocket::accept, so the two transports' accept functions no longer copy each other. - One kMidMessageStall and one kConnectTimeout in transport.hpp. - WebSocket: named header-bit constants; protocol violations (unmasked client frame, RSV bits, oversized control frame, text/unknown opcodes) are Malformed, not Closed; the client upgrade error says what failed; the Host value is named host_header. - Threads is linked by the test that spawns them, not the library. - Tests: TcpTransport::receive cases, invalid/IPv6 endpoint cases, wait_ready drives the server handshake, kHeaderSize instead of 24. Co-Authored-By: Claude Opus 5.5 Signed-off-by: Jonghyun Kim --- .../session/CMakeLists.txt | 9 +- .../remote_plugin_session/remote_address.hpp | 31 +++ .../inc/remote_plugin_session/tcp_socket.hpp | 31 +-- .../remote_plugin_session/tcp_transport.hpp | 39 +++ .../inc/remote_plugin_session/transport.hpp | 9 +- .../websocket_transport.hpp | 21 +- .../session/remote_address.cpp | 51 ++++ .../session/tcp_socket.cpp | 228 +++++++----------- .../session/tcp_transport.cpp | 69 ++++++ .../session/websocket_transport.cpp | 120 ++++----- .../remote_device_bridge/CMakeLists.txt | 3 + .../test_websocket_transport.cpp | 92 +++++-- 12 files changed, 422 insertions(+), 281 deletions(-) create mode 100644 src/plugins/remote_device_bridge/session/inc/remote_plugin_session/remote_address.hpp create mode 100644 src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_transport.hpp create mode 100644 src/plugins/remote_device_bridge/session/remote_address.cpp create mode 100644 src/plugins/remote_device_bridge/session/tcp_transport.cpp diff --git a/src/plugins/remote_device_bridge/session/CMakeLists.txt b/src/plugins/remote_device_bridge/session/CMakeLists.txt index 1d1b60f67e..4a6542aab2 100644 --- a/src/plugins/remote_device_bridge/session/CMakeLists.txt +++ b/src/plugins/remote_device_bridge/session/CMakeLists.txt @@ -1,16 +1,18 @@ # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 -find_package(Threads REQUIRED) - add_library(remote_plugin_session STATIC protocol_frame.cpp protocol_payloads.cpp protocol_io.hpp inc/remote_plugin_session/protocol_frame.hpp inc/remote_plugin_session/protocol_payloads.hpp + remote_address.cpp + inc/remote_plugin_session/remote_address.hpp tcp_socket.cpp inc/remote_plugin_session/tcp_socket.hpp + tcp_transport.cpp + inc/remote_plugin_session/tcp_transport.hpp inc/remote_plugin_session/transport.hpp websocket_transport.cpp inc/remote_plugin_session/websocket_transport.hpp @@ -24,9 +26,6 @@ target_include_directories(remote_plugin_session target_link_libraries(remote_plugin_session PUBLIC pusherio::pusherio - PRIVATE - log_bridge::log_bridge_core - Threads::Threads ) add_library(Teleop::remote_plugin_session ALIAS remote_plugin_session) diff --git a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/remote_address.hpp b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/remote_address.hpp new file mode 100644 index 0000000000..8ccb131d51 --- /dev/null +++ b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/remote_address.hpp @@ -0,0 +1,31 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "tcp_socket.hpp" +#include "transport.hpp" + +#include +#include +#include +#include +#include + +namespace remote_plugin_session +{ + +//! Where a client connects: plain "host[:port]" (TCP) or "ws://host[:port][/path]" (WebSocket). +struct RemoteAddress +{ + Endpoint endpoint; + std::optional ws_path; //!< set for ws:// +}; + +//! Throws std::invalid_argument; wss:// is refused (terminate TLS in a proxy in front of the bridge). +RemoteAddress parse_remote(const std::string& text, uint16_t default_port); +//! Connects (and for ws:// completes the upgrade) within `timeout`; throws std::runtime_error. +std::unique_ptr connect_transport(const RemoteAddress& remote, + std::chrono::milliseconds timeout = kConnectTimeout); + +} // namespace remote_plugin_session diff --git a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_socket.hpp b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_socket.hpp index cb5e000a33..bc25009f16 100644 --- a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_socket.hpp +++ b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_socket.hpp @@ -3,12 +3,9 @@ #pragma once -#include "transport.hpp" - #include #include #include -#include #include #include @@ -21,7 +18,8 @@ struct Endpoint uint16_t port = 0; }; -//! Parses "host[:port]"; a missing port falls back to default_port. Throws std::invalid_argument. +//! Parses "host[:port]" or "[v6-host][:port]"; a missing port falls back to default_port. Throws +//! std::invalid_argument. Endpoint parse_endpoint(const std::string& text, uint16_t default_port); //! Minimal RAII wrapper over a blocking POSIX TCP socket (IPv4/IPv6 via getaddrinfo). @@ -48,8 +46,9 @@ class TcpSocket static TcpSocket connect(const Endpoint& endpoint, std::chrono::milliseconds timeout); //! Throws std::runtime_error when bind/listen fails. Port 0 picks an ephemeral port. static TcpSocket listen(const Endpoint& endpoint, int backlog); - //! Returns an invalid socket when the timeout expires; throws on a hard error. - TcpSocket accept(std::chrono::milliseconds timeout); + //! Returns an invalid socket when the timeout expires; throws on a hard error. `peer`, when given, receives + //! the client's numeric host:port. + TcpSocket accept(std::chrono::milliseconds timeout, std::string* peer = nullptr); bool valid() const; int fd() const; @@ -70,24 +69,4 @@ class TcpSocket int m_fd = -1; }; -//! ITransport over one TCP stream; messages are delimited by the wire header's payload_size. -class TcpTransport final : public ITransport -{ -public: - explicit TcpTransport(TcpSocket socket); - - //! One transport per connection accepted on `listener`; null when the poll expires. `peer`, when given, - //! receives the client's numeric host:port. - static std::unique_ptr accept(TcpSocket& listener, - std::chrono::milliseconds poll, - std::string* peer = nullptr); - - bool send(const uint8_t* frame, size_t size) override; - ReceiveResult receive(std::vector& frame, std::chrono::milliseconds timeout) override; - void shutdown() override; - -private: - TcpSocket m_socket; -}; - } // namespace remote_plugin_session diff --git a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_transport.hpp b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_transport.hpp new file mode 100644 index 0000000000..4f90fe411d --- /dev/null +++ b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_transport.hpp @@ -0,0 +1,39 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include "tcp_socket.hpp" +#include "transport.hpp" + +#include +#include +#include +#include +#include +#include + +namespace remote_plugin_session +{ + +//! ITransport over one TCP stream; messages are delimited by the wire header's payload_size. +class TcpTransport final : public ITransport +{ +public: + explicit TcpTransport(TcpSocket socket); + + //! One transport per connection accepted on `listener`; null when the poll expires. `peer`, when given, + //! receives the client's numeric host:port. + static std::unique_ptr accept(TcpSocket& listener, + std::chrono::milliseconds poll, + std::string* peer = nullptr); + + bool send(const uint8_t* frame, size_t size) override; + ReceiveResult receive(std::vector& frame, std::chrono::milliseconds timeout) override; + void shutdown() override; + +private: + TcpSocket m_socket; +}; + +} // namespace remote_plugin_session diff --git a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp index a40f2091e5..1b147427e4 100644 --- a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp +++ b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp @@ -11,6 +11,11 @@ namespace remote_plugin_session { +//! Default connect/upgrade timeout for client transports. +constexpr std::chrono::milliseconds kConnectTimeout{ 3000 }; +//! A frame that has started arriving must finish within this window, or the peer counts as gone. +constexpr std::chrono::milliseconds kMidMessageStall{ 3000 }; + enum class ReceiveResult { Ok, @@ -22,8 +27,8 @@ enum class ReceiveResult /*! * @brief Message transport between a RemotePluginSession and the bridge. * - * A frame is one complete wire message (24-byte header + payload) as built by - * protocol::encode_frame. send() and receive() may run concurrently on two + * A frame is one complete wire message (protocol kHeaderSize header + payload) + * as built by protocol::encode_frame. send() and receive() may run concurrently on two * threads; shutdown() unblocks both. Framing (TCP is a stream) lives in the * implementation, not in the callers. */ diff --git a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp index 84376e2a88..c5b9bd9944 100644 --- a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp +++ b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp @@ -19,20 +19,6 @@ namespace remote_plugin_session { -//! Where a client connects: plain "host[:port]" (TCP) or "ws://host[:port][/path]" (WebSocket). -struct RemoteAddress -{ - Endpoint endpoint; - bool websocket = false; - std::string path = "/"; -}; - -//! Throws std::invalid_argument; wss:// is refused (terminate TLS in a proxy in front of the bridge). -RemoteAddress parse_remote(const std::string& text, uint16_t default_port); -//! Connects (and for ws:// completes the upgrade) within `timeout`; throws std::runtime_error. -std::unique_ptr connect_transport(const RemoteAddress& remote, - std::chrono::milliseconds timeout = std::chrono::milliseconds{ 3000 }); - /*! * @brief RFC 6455 transport: each wire frame travels as one binary WebSocket message. No TLS, no extensions. * @@ -48,12 +34,13 @@ class WebSocketTransport final : public ITransport Server, }; - //! Server: no I/O. Client: sends the upgrade for `host`/`path` and throws std::runtime_error unless 101. + //! Server: no I/O. Client: sends the upgrade for `path` with `host_header` ("host:port") and throws + //! std::runtime_error unless 101. WebSocketTransport(TcpSocket socket, Role role, - const std::string& host = "", + const std::string& host_header = "", const std::string& path = "/", - std::chrono::milliseconds timeout = std::chrono::milliseconds{ 3000 }); + std::chrono::milliseconds timeout = kConnectTimeout); //! Like TcpTransport::accept; the upgrade happens on the first receive(). static std::unique_ptr accept(TcpSocket& listener, diff --git a/src/plugins/remote_device_bridge/session/remote_address.cpp b/src/plugins/remote_device_bridge/session/remote_address.cpp new file mode 100644 index 0000000000..8c306dc40c --- /dev/null +++ b/src/plugins/remote_device_bridge/session/remote_address.cpp @@ -0,0 +1,51 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +#include "inc/remote_plugin_session/remote_address.hpp" + +#include "inc/remote_plugin_session/tcp_transport.hpp" +#include "inc/remote_plugin_session/websocket_transport.hpp" + +#include +#include + +namespace remote_plugin_session +{ + +RemoteAddress parse_remote(const std::string& text, uint16_t default_port) +{ + const std::string scheme = "ws://"; + if (text.rfind("wss://", 0) == 0) + { + throw std::invalid_argument("wss:// is not supported ('" + text + "'); terminate TLS in a proxy, use ws://"); + } + RemoteAddress remote; + if (text.rfind(scheme, 0) != 0) + { + remote.endpoint = parse_endpoint(text, default_port); + return remote; + } + std::string authority = text.substr(scheme.size()); + const size_t slash = authority.find('/'); + remote.ws_path = slash == std::string::npos ? "/" : authority.substr(slash); + if (slash != std::string::npos) + { + authority.resize(slash); + } + remote.endpoint = parse_endpoint(authority, default_port); + return remote; +} + +std::unique_ptr connect_transport(const RemoteAddress& remote, std::chrono::milliseconds timeout) +{ + TcpSocket socket = TcpSocket::connect(remote.endpoint, timeout); + if (!remote.ws_path) + { + return std::make_unique(std::move(socket)); + } + return std::make_unique(std::move(socket), WebSocketTransport::Role::Client, + remote.endpoint.host + ":" + std::to_string(remote.endpoint.port), + *remote.ws_path, timeout); +} + +} // namespace remote_plugin_session diff --git a/src/plugins/remote_device_bridge/session/tcp_socket.cpp b/src/plugins/remote_device_bridge/session/tcp_socket.cpp index 8689aaaeba..f70d38999c 100644 --- a/src/plugins/remote_device_bridge/session/tcp_socket.cpp +++ b/src/plugins/remote_device_bridge/session/tcp_socket.cpp @@ -3,19 +3,18 @@ #include "inc/remote_plugin_session/tcp_socket.hpp" -#include "inc/remote_plugin_session/protocol_frame.hpp" +#include "inc/remote_plugin_session/transport.hpp" #include -#include #include #include -#include #include -#include +#include #include #include #include +#include #include #include #include @@ -25,15 +24,12 @@ namespace remote_plugin_session { -namespace protocol = remote_plugin_protocol; - namespace { // A send may stall as long as the peer timeout tolerates silence; liveness is decided by the receive side. constexpr std::chrono::milliseconds kSendTimeout{ 3000 }; -constexpr std::chrono::milliseconds kMidMessageStall{ 3000 }; -// Best effort: the kernel clamps to its rmem/wmem maximum; the effective sizes are logged once. +// Best effort: the kernel clamps to its rmem/wmem maximum. constexpr int kSocketBufferBytes = 4 * 1024 * 1024; std::string errno_string(const char* what) @@ -55,27 +51,25 @@ void set_blocking(int fd, bool blocking) } } +template +void set_option(int fd, int level, int name, const T& value, const char* what) +{ + if (setsockopt(fd, level, name, &value, sizeof(value)) < 0) + { + throw std::runtime_error(errno_string(what)); + } +} + void configure_stream(int fd) { - const int one = 1; - setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one)); + set_option(fd, IPPROTO_TCP, TCP_NODELAY, 1, "setsockopt(TCP_NODELAY)"); timeval send_timeout{}; send_timeout.tv_sec = static_cast(kSendTimeout.count() / 1000); send_timeout.tv_usec = static_cast((kSendTimeout.count() % 1000) * 1000); - setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &send_timeout, sizeof(send_timeout)); - - int snd = kSocketBufferBytes; - int rcv = kSocketBufferBytes; - setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &snd, sizeof(snd)); - setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rcv, sizeof(rcv)); - static std::atomic logged{ false }; - socklen_t len = sizeof(snd); - if (!logged.exchange(true) && getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &snd, &len) == 0 && - getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rcv, &len) == 0) - { - isaaccapture::Logger::get("isaaccapture.plugins.remote_device_bridge.TcpSocket") - ->info("[tcp] socket buffers: SO_SNDBUF={} SO_RCVBUF={} (requested {})", snd, rcv, kSocketBufferBytes); - } + set_option(fd, SOL_SOCKET, SO_SNDTIMEO, send_timeout, "setsockopt(SO_SNDTIMEO)"); + // Buffer sizes are a hint the kernel may clamp; a refusal is not an error. + setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &kSocketBufferBytes, sizeof(kSocketBufferBytes)); + setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &kSocketBufferBytes, sizeof(kSocketBufferBytes)); } int poll_fd(int fd, short events, std::chrono::milliseconds timeout) @@ -94,17 +88,7 @@ int poll_fd(int fd, short events, std::chrono::milliseconds timeout) } } -struct AddrInfoList -{ - addrinfo* head = nullptr; - ~AddrInfoList() - { - if (head) - { - freeaddrinfo(head); - } - } -}; +using AddrInfoList = std::unique_ptr; AddrInfoList resolve(const Endpoint& endpoint, bool passive) { @@ -112,83 +96,81 @@ AddrInfoList resolve(const Endpoint& endpoint, bool passive) hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = passive ? (AI_PASSIVE | AI_NUMERICSERV) : AI_NUMERICSERV; - AddrInfoList list; + addrinfo* head = nullptr; const std::string service = std::to_string(endpoint.port); - const int rc = - getaddrinfo(endpoint.host.empty() ? nullptr : endpoint.host.c_str(), service.c_str(), &hints, &list.head); + const int rc = getaddrinfo(endpoint.host.empty() ? nullptr : endpoint.host.c_str(), service.c_str(), &hints, &head); if (rc != 0) { throw std::runtime_error("getaddrinfo(" + endpoint.host + "): " + gai_strerror(rc)); } - return list; + return AddrInfoList(head, &freeaddrinfo); } -//! Non-blocking connect with a deadline; on failure `last_error` says why and the caller tries the next address. -bool try_connect(TcpSocket& socket, const addrinfo& ai, std::chrono::milliseconds timeout, std::string& last_error) +//! Non-blocking connect with a deadline. Throws std::runtime_error with the reason. +void try_connect(TcpSocket& socket, const addrinfo& ai, std::chrono::milliseconds timeout) { set_blocking(socket.fd(), false); const int rc = ::connect(socket.fd(), ai.ai_addr, ai.ai_addrlen); if (rc < 0 && errno != EINPROGRESS) { - last_error = errno_string("connect"); - return false; + throw std::runtime_error(errno_string("connect")); } if (rc < 0) { const int ready = poll_fd(socket.fd(), POLLOUT, timeout); if (ready <= 0) { - last_error = ready == 0 ? "connect timed out" : errno_string("poll"); - return false; + throw std::runtime_error(ready == 0 ? "connect timed out" : errno_string("poll")); } int so_error = 0; socklen_t len = sizeof(so_error); if (getsockopt(socket.fd(), SOL_SOCKET, SO_ERROR, &so_error, &len) < 0 || so_error != 0) { - last_error = std::string("connect: ") + std::strerror(so_error != 0 ? so_error : errno); - return false; + throw std::runtime_error(std::string("connect: ") + std::strerror(so_error != 0 ? so_error : errno)); } } set_blocking(socket.fd(), true); configure_stream(socket.fd()); - return true; } -bool try_listen(TcpSocket& socket, const addrinfo& ai, int backlog, std::string& last_error) +//! Throws std::runtime_error with the reason. +void try_listen(TcpSocket& socket, const addrinfo& ai, int backlog) { - const int one = 1; - setsockopt(socket.fd(), SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); + set_option(socket.fd(), SOL_SOCKET, SO_REUSEADDR, 1, "setsockopt(SO_REUSEADDR)"); if (::bind(socket.fd(), ai.ai_addr, ai.ai_addrlen) < 0) { - last_error = errno_string("bind"); - return false; + throw std::runtime_error(errno_string("bind")); } if (::listen(socket.fd(), backlog) < 0) { - last_error = errno_string("listen"); - return false; + throw std::runtime_error(errno_string("listen")); } - return true; } -//! Runs `attempt` on a fresh socket for each resolved address; the first success wins. `what` names the caller. +//! Runs `attempt` on a fresh socket for each resolved address; the first that does not throw wins. `what` names +//! the caller. template TcpSocket for_each_address(const Endpoint& endpoint, bool passive, const char* what, Attempt attempt) { const AddrInfoList addresses = resolve(endpoint, passive); std::string last_error = "no addresses"; - for (const addrinfo* ai = addresses.head; ai != nullptr; ai = ai->ai_next) + for (const addrinfo* ai = addresses.get(); ai != nullptr; ai = ai->ai_next) { - TcpSocket socket(::socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol)); - if (!socket.valid()) + try { - last_error = errno_string("socket"); - continue; + const int fd = ::socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); + if (fd < 0) + { + throw std::runtime_error(errno_string("socket")); + } + TcpSocket socket(fd); + attempt(socket, *ai); + return socket; } - if (attempt(socket, *ai, last_error)) + catch (const std::runtime_error& e) { - return socket; + last_error = e.what(); } } @@ -202,28 +184,48 @@ Endpoint parse_endpoint(const std::string& text, uint16_t default_port) { Endpoint endpoint; endpoint.port = default_port; - const size_t colon = text.rfind(':'); - if (colon == std::string::npos) + std::string port_text; + bool has_port = false; + if (!text.empty() && text.front() == '[') { - endpoint.host = text; + // "[v6-address]" or "[v6-address]:port" + const size_t close = text.find(']'); + if (close == std::string::npos || (close + 1 < text.size() && text[close + 1] != ':')) + { + throw std::invalid_argument("invalid bracketed host in endpoint '" + text + "'"); + } + endpoint.host = text.substr(1, close - 1); + has_port = close + 1 < text.size(); + port_text = has_port ? text.substr(close + 2) : ""; + } + else if (std::count(text.begin(), text.end(), ':') > 1) + { + endpoint.host = text; // bare IPv6 address, no port } else { + const size_t colon = text.find(':'); endpoint.host = text.substr(0, colon); - const std::string port_text = text.substr(colon + 1); + has_port = colon != std::string::npos; + port_text = has_port ? text.substr(colon + 1) : ""; + } + if (has_port) + { + unsigned long port = 0; + size_t parsed = 0; try { - const unsigned long port = std::stoul(port_text); - if (port_text.empty() || port == 0 || port > 65535) - { - throw std::out_of_range("port"); - } - endpoint.port = static_cast(port); + port = std::stoul(port_text, &parsed); } catch (const std::exception&) + { + parsed = 0; + } + if (parsed == 0 || parsed != port_text.size() || port == 0 || port > 65535) { throw std::invalid_argument("invalid port in endpoint '" + text + "'"); } + endpoint.port = static_cast(port); } if (endpoint.host.empty()) { @@ -258,18 +260,16 @@ TcpSocket& TcpSocket::operator=(TcpSocket&& other) noexcept TcpSocket TcpSocket::connect(const Endpoint& endpoint, std::chrono::milliseconds timeout) { return for_each_address(endpoint, false, "connect", - [timeout](TcpSocket& socket, const addrinfo& ai, std::string& last_error) - { return try_connect(socket, ai, timeout, last_error); }); + [timeout](TcpSocket& socket, const addrinfo& ai) { try_connect(socket, ai, timeout); }); } TcpSocket TcpSocket::listen(const Endpoint& endpoint, int backlog) { return for_each_address(endpoint, true, "listen", - [backlog](TcpSocket& socket, const addrinfo& ai, std::string& last_error) - { return try_listen(socket, ai, backlog, last_error); }); + [backlog](TcpSocket& socket, const addrinfo& ai) { try_listen(socket, ai, backlog); }); } -TcpSocket TcpSocket::accept(std::chrono::milliseconds timeout) +TcpSocket TcpSocket::accept(std::chrono::milliseconds timeout, std::string* peer) { const int ready = poll_fd(m_fd, POLLIN, timeout); if (ready == 0) @@ -283,7 +283,7 @@ TcpSocket TcpSocket::accept(std::chrono::milliseconds timeout) const int fd = ::accept(m_fd, nullptr, nullptr); if (fd < 0) { - if (errno == EAGAIN || errno == EWOULDBLOCK || errno == ECONNABORTED || errno == EINTR) + if (errno == ECONNABORTED || errno == EINTR) { return TcpSocket(); } @@ -291,6 +291,10 @@ TcpSocket TcpSocket::accept(std::chrono::milliseconds timeout) } TcpSocket client(fd); configure_stream(fd); + if (peer != nullptr) + { + *peer = client.peer_name(); + } return client; } @@ -378,7 +382,7 @@ TcpSocket::RecvResult TcpSocket::recv_all(uint8_t* data, size_t size, std::chron const ssize_t n = ::recv(m_fd, data + received, size - received, 0); if (n < 0) { - if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) + if (errno == EINTR) { continue; } @@ -410,66 +414,4 @@ void TcpSocket::close() } } -TcpTransport::TcpTransport(TcpSocket socket) : m_socket(std::move(socket)) -{ -} - -bool TcpTransport::send(const uint8_t* frame, size_t size) -{ - return m_socket.send_all(frame, size); -} - -ReceiveResult TcpTransport::receive(std::vector& frame, std::chrono::milliseconds timeout) -{ - frame.resize(protocol::kHeaderSize); - switch (m_socket.recv_all(frame.data(), protocol::kHeaderSize, timeout)) - { - case TcpSocket::RecvResult::Timeout: - return ReceiveResult::Timeout; - case TcpSocket::RecvResult::Closed: - return ReceiveResult::Closed; - case TcpSocket::RecvResult::Ok: - break; - } - - uint32_t payload_size = 0; - try - { - payload_size = protocol::decode_header(frame).payload_size; - } - catch (const protocol::DecodeError&) - { - return ReceiveResult::Malformed; - } - if (payload_size == 0) - { - return ReceiveResult::Ok; - } - frame.resize(protocol::kHeaderSize + payload_size); - // A header without its payload within the stall window is a broken peer, not a quiet one. - return m_socket.recv_all(frame.data() + protocol::kHeaderSize, payload_size, kMidMessageStall) == - TcpSocket::RecvResult::Ok ? - ReceiveResult::Ok : - ReceiveResult::Closed; -} - -void TcpTransport::shutdown() -{ - m_socket.shutdown(); -} - -std::unique_ptr TcpTransport::accept(TcpSocket& listener, std::chrono::milliseconds poll, std::string* peer) -{ - TcpSocket client = listener.accept(poll); - if (!client.valid()) - { - return nullptr; - } - if (peer != nullptr) - { - *peer = client.peer_name(); - } - return std::make_unique(std::move(client)); -} - } // namespace remote_plugin_session diff --git a/src/plugins/remote_device_bridge/session/tcp_transport.cpp b/src/plugins/remote_device_bridge/session/tcp_transport.cpp new file mode 100644 index 0000000000..d6500f3d74 --- /dev/null +++ b/src/plugins/remote_device_bridge/session/tcp_transport.cpp @@ -0,0 +1,69 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +#include "inc/remote_plugin_session/tcp_transport.hpp" + +#include "inc/remote_plugin_session/protocol_frame.hpp" + +#include + +namespace remote_plugin_session +{ + +namespace protocol = remote_plugin_protocol; + +TcpTransport::TcpTransport(TcpSocket socket) : m_socket(std::move(socket)) +{ +} + +bool TcpTransport::send(const uint8_t* frame, size_t size) +{ + return m_socket.send_all(frame, size); +} + +ReceiveResult TcpTransport::receive(std::vector& frame, std::chrono::milliseconds timeout) +{ + frame.resize(protocol::kHeaderSize); + switch (m_socket.recv_all(frame.data(), protocol::kHeaderSize, timeout)) + { + case TcpSocket::RecvResult::Timeout: + return ReceiveResult::Timeout; + case TcpSocket::RecvResult::Closed: + return ReceiveResult::Closed; + case TcpSocket::RecvResult::Ok: + break; + } + + uint32_t payload_size = 0; + try + { + payload_size = protocol::decode_header(frame).payload_size; + } + catch (const protocol::DecodeError&) + { + return ReceiveResult::Malformed; + } + if (payload_size == 0) + { + return ReceiveResult::Ok; + } + frame.resize(protocol::kHeaderSize + payload_size); + // A header without its payload within the stall window is a broken peer, not a quiet one. + return m_socket.recv_all(frame.data() + protocol::kHeaderSize, payload_size, kMidMessageStall) == + TcpSocket::RecvResult::Ok ? + ReceiveResult::Ok : + ReceiveResult::Closed; +} + +void TcpTransport::shutdown() +{ + m_socket.shutdown(); +} + +std::unique_ptr TcpTransport::accept(TcpSocket& listener, std::chrono::milliseconds poll, std::string* peer) +{ + TcpSocket client = listener.accept(poll, peer); + return client.valid() ? std::make_unique(std::move(client)) : nullptr; +} + +} // namespace remote_plugin_session diff --git a/src/plugins/remote_device_bridge/session/websocket_transport.cpp b/src/plugins/remote_device_bridge/session/websocket_transport.cpp index 0bf356ae20..d3228164ca 100644 --- a/src/plugins/remote_device_bridge/session/websocket_transport.cpp +++ b/src/plugins/remote_device_bridge/session/websocket_transport.cpp @@ -20,11 +20,17 @@ namespace protocol = remote_plugin_protocol; namespace { -constexpr std::chrono::milliseconds kStall{ 3000 }; // matches TcpTransport's mid-message stall constexpr size_t kMaxHttpHead = 8192; constexpr uint64_t kMaxMessage = protocol::kHeaderSize + protocol::kMaxPayloadSize; constexpr char kAcceptGuid[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; +constexpr uint8_t kFinBit = 0x80; +constexpr uint8_t kRsvBits = 0x70; +constexpr uint8_t kOpcodeMask = 0x0F; +constexpr uint8_t kControlBit = 0x08; +constexpr uint8_t kMaskBit = 0x80; +constexpr uint8_t kLengthMask = 0x7F; + constexpr uint8_t kContinuation = 0x0; constexpr uint8_t kBinary = 0x2; constexpr uint8_t kClose = 0x8; @@ -132,7 +138,7 @@ ReceiveResult read_http_head(TcpSocket& socket, std::chrono::milliseconds timeou return ReceiveResult::Malformed; } uint8_t byte = 0; - const TcpSocket::RecvResult result = socket.recv_all(&byte, 1, text.empty() ? timeout : kStall); + const TcpSocket::RecvResult result = socket.recv_all(&byte, 1, text.empty() ? timeout : kMidMessageStall); if (result != TcpSocket::RecvResult::Ok) { return result == TcpSocket::RecvResult::Timeout && text.empty() ? ReceiveResult::Timeout : @@ -167,45 +173,11 @@ std::string header(const HttpHead& head, const std::string& name) } // namespace -RemoteAddress parse_remote(const std::string& text, uint16_t default_port) -{ - const std::string scheme = "ws://"; - if (text.rfind("wss://", 0) == 0) - { - throw std::invalid_argument("wss:// is not supported ('" + text + "'); terminate TLS in a proxy, use ws://"); - } - RemoteAddress remote; - if (text.rfind(scheme, 0) != 0) - { - remote.endpoint = parse_endpoint(text, default_port); - return remote; - } - remote.websocket = true; - std::string authority = text.substr(scheme.size()); - const size_t slash = authority.find('/'); - if (slash != std::string::npos) - { - remote.path = authority.substr(slash); - authority.resize(slash); - } - remote.endpoint = parse_endpoint(authority, default_port); - return remote; -} - -std::unique_ptr connect_transport(const RemoteAddress& remote, std::chrono::milliseconds timeout) -{ - TcpSocket socket = TcpSocket::connect(remote.endpoint, timeout); - if (!remote.websocket) - { - return std::make_unique(std::move(socket)); - } - return std::make_unique(std::move(socket), WebSocketTransport::Role::Client, - remote.endpoint.host + ":" + std::to_string(remote.endpoint.port), - remote.path, timeout); -} - -WebSocketTransport::WebSocketTransport( - TcpSocket socket, Role role, const std::string& host, const std::string& path, std::chrono::milliseconds timeout) +WebSocketTransport::WebSocketTransport(TcpSocket socket, + Role role, + const std::string& host_header, + const std::string& path, + std::chrono::milliseconds timeout) : m_socket(std::move(socket)), m_role(role), m_mask_rng(std::random_device{}()) { if (role == Role::Server) @@ -215,22 +187,33 @@ WebSocketTransport::WebSocketTransport( std::array nonce{}; std::generate(nonce.begin(), nonce.end(), [this] { return static_cast(m_mask_rng()); }); const std::string key = base64(nonce.data(), nonce.size()); - const std::string request = "GET " + path + " HTTP/1.1\r\nHost: " + host + + const std::string request = "GET " + path + " HTTP/1.1\r\nHost: " + host_header + "\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: " + key + "\r\nSec-WebSocket-Version: 13\r\n\r\n"; + const std::string target = host_header + path; + if (!m_socket.send_all(reinterpret_cast(request.data()), request.size())) + { + throw std::runtime_error("WebSocket upgrade to " + target + ": sending the request failed"); + } HttpHead response; - if (!m_socket.send_all(reinterpret_cast(request.data()), request.size()) || - read_http_head(m_socket, timeout, response) != ReceiveResult::Ok) + switch (read_http_head(m_socket, timeout, response)) { - throw std::runtime_error("WebSocket upgrade to " + host + path + ": no HTTP response"); + case ReceiveResult::Ok: + break; + case ReceiveResult::Timeout: + throw std::runtime_error("WebSocket upgrade to " + target + ": no HTTP response within the timeout"); + case ReceiveResult::Closed: + throw std::runtime_error("WebSocket upgrade to " + target + ": connection closed before the response"); + case ReceiveResult::Malformed: + throw std::runtime_error("WebSocket upgrade to " + target + ": malformed HTTP response"); } if (response.start_line.rfind("HTTP/1.1 101", 0) != 0) { - throw std::runtime_error("WebSocket upgrade to " + host + path + " refused: " + response.start_line); + throw std::runtime_error("WebSocket upgrade to " + target + " refused: " + response.start_line); } if (header(response, "sec-websocket-accept") != accept_key(key)) { - throw std::runtime_error("WebSocket upgrade to " + host + path + ": wrong Sec-WebSocket-Accept"); + throw std::runtime_error("WebSocket upgrade to " + target + ": wrong Sec-WebSocket-Accept"); } m_open = true; } @@ -239,16 +222,8 @@ std::unique_ptr WebSocketTransport::accept(TcpSocket& listener, std::chrono::milliseconds poll, std::string* peer) { - TcpSocket client = listener.accept(poll); - if (!client.valid()) - { - return nullptr; - } - if (peer != nullptr) - { - *peer = client.peer_name(); - } - return std::make_unique(std::move(client), Role::Server); + TcpSocket client = listener.accept(poll, peer); + return client.valid() ? std::make_unique(std::move(client), Role::Server) : nullptr; } ReceiveResult WebSocketTransport::accept_upgrade(std::chrono::milliseconds timeout) @@ -290,8 +265,8 @@ bool WebSocketTransport::send_message(uint8_t opcode, const uint8_t* data, size_ { std::lock_guard lock(m_send_mutex); std::vector& out = m_send_buffer; - out.assign(1, static_cast(0x80 | opcode)); // FIN: never fragmented on send - const uint8_t mask_bit = m_role == Role::Client ? 0x80 : 0x00; + out.assign(1, static_cast(kFinBit | opcode)); // never fragmented on send + const uint8_t mask_bit = m_role == Role::Client ? kMaskBit : 0x00; if (size < 126) { out.push_back(static_cast(mask_bit | size)); @@ -344,27 +319,28 @@ ReceiveResult WebSocketTransport::receive(std::vector& frame, std::chro std::chrono::duration_cast( deadline - std::chrono::steady_clock::now())); uint8_t head[2]; - const TcpSocket::RecvResult first = m_socket.recv_all(head, sizeof(head), in_message ? kStall : remaining); + const TcpSocket::RecvResult first = + m_socket.recv_all(head, sizeof(head), in_message ? kMidMessageStall : remaining); if (first != TcpSocket::RecvResult::Ok) { return first == TcpSocket::RecvResult::Timeout && !in_message ? ReceiveResult::Timeout : ReceiveResult::Closed; } - const bool fin = (head[0] & 0x80) != 0; - const uint8_t opcode = head[0] & 0x0F; - const bool masked = (head[1] & 0x80) != 0; - const bool control = (opcode & 0x08) != 0; - uint64_t length = head[1] & 0x7F; + const bool fin = (head[0] & kFinBit) != 0; + const uint8_t opcode = head[0] & kOpcodeMask; + const bool masked = (head[1] & kMaskBit) != 0; + const bool control = (opcode & kControlBit) != 0; + uint64_t length = head[1] & kLengthMask; // RSV bits need an extension we never negotiate; clients must mask and servers must not. - if ((head[0] & 0x70) != 0 || masked != (m_role == Role::Server)) + if ((head[0] & kRsvBits) != 0 || masked != (m_role == Role::Server)) { - return ReceiveResult::Closed; + return ReceiveResult::Malformed; } if (length >= 126) { std::array ext{}; const size_t ext_size = length == 126 ? 2 : 8; - if (m_socket.recv_all(ext.data(), ext_size, kStall) != TcpSocket::RecvResult::Ok) + if (m_socket.recv_all(ext.data(), ext_size, kMidMessageStall) != TcpSocket::RecvResult::Ok) { return ReceiveResult::Closed; } @@ -375,7 +351,7 @@ ReceiveResult WebSocketTransport::receive(std::vector& frame, std::chro } } std::array mask{}; - if (masked && m_socket.recv_all(mask.data(), mask.size(), kStall) != TcpSocket::RecvResult::Ok) + if (masked && m_socket.recv_all(mask.data(), mask.size(), kMidMessageStall) != TcpSocket::RecvResult::Ok) { return ReceiveResult::Closed; } @@ -386,7 +362,7 @@ ReceiveResult WebSocketTransport::receive(std::vector& frame, std::chro { if (!fin || length > 125) { - return ReceiveResult::Closed; + return ReceiveResult::Malformed; } control_payload.resize(length); dest = control_payload.data(); @@ -395,7 +371,7 @@ ReceiveResult WebSocketTransport::receive(std::vector& frame, std::chro { if (opcode != (in_message ? kContinuation : kBinary)) { - return ReceiveResult::Closed; // text frames, unknown opcodes, broken fragmentation + return ReceiveResult::Malformed; // text frames, unknown opcodes, broken fragmentation } if (length > kMaxMessage - frame.size()) { @@ -405,7 +381,7 @@ ReceiveResult WebSocketTransport::receive(std::vector& frame, std::chro frame.resize(offset + length); dest = frame.data() + offset; } - if (length > 0 && m_socket.recv_all(dest, length, kStall) != TcpSocket::RecvResult::Ok) + if (length > 0 && m_socket.recv_all(dest, length, kMidMessageStall) != TcpSocket::RecvResult::Ok) { return ReceiveResult::Closed; } diff --git a/tests/cpp/plugins/remote_device_bridge/CMakeLists.txt b/tests/cpp/plugins/remote_device_bridge/CMakeLists.txt index 344a77f9e6..8cd8ef95b7 100644 --- a/tests/cpp/plugins/remote_device_bridge/CMakeLists.txt +++ b/tests/cpp/plugins/remote_device_bridge/CMakeLists.txt @@ -1,6 +1,8 @@ # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 +find_package(Threads REQUIRED) + add_executable(remote_plugin_session_tests test_websocket_transport.cpp test_wire_codec.cpp @@ -8,6 +10,7 @@ add_executable(remote_plugin_session_tests target_link_libraries(remote_plugin_session_tests PRIVATE Teleop::remote_plugin_session + Threads::Threads Catch2::Catch2WithMain ) diff --git a/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp b/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp index 1f4a88beee..48f9774ee4 100644 --- a/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp +++ b/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp @@ -4,6 +4,8 @@ #include #include #include +#include +#include #include #include @@ -107,8 +109,7 @@ std::unique_ptr upgraded_server(TcpSocket server_end, TcpSoc { auto server = std::make_unique(std::move(server_end), Role::Server); raw_send(raw_client, kSampleUpgrade); - std::vector frame; - REQUIRE(server->receive(frame, kShort) == ReceiveResult::Timeout); + REQUIRE(server->wait_ready(kWait) == ReceiveResult::Ok); const std::string response = raw_recv_head(raw_client); REQUIRE(response.rfind("HTTP/1.1 101", 0) == 0); REQUIRE(response.find("Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n") != std::string::npos); @@ -128,8 +129,7 @@ Connected connected_pair() pair.server = std::make_unique(std::move(server_end), Role::Server); std::thread client( [&] { pair.client = std::make_unique(std::move(client_end), Role::Client, "h:1", "/x"); }); - std::vector frame; - REQUIRE(pair.server->receive(frame, kShort) == ReceiveResult::Timeout); + REQUIRE(pair.server->wait_ready(kWait) == ReceiveResult::Ok); client.join(); REQUIRE(pair.client); return pair; @@ -140,24 +140,40 @@ Connected connected_pair() TEST_CASE("parse_remote selects TCP or WebSocket", "[remote_device_bridge][unit]") { const RemoteAddress tcp = parse_remote("10.0.0.2:5000", 47500); - REQUIRE_FALSE(tcp.websocket); + REQUIRE_FALSE(tcp.ws_path); REQUIRE(tcp.endpoint.host == "10.0.0.2"); REQUIRE(tcp.endpoint.port == 5000); const RemoteAddress ws = parse_remote("ws://bridge.local:8080/teleop", 47500); - REQUIRE(ws.websocket); + REQUIRE(ws.ws_path); REQUIRE(ws.endpoint.host == "bridge.local"); REQUIRE(ws.endpoint.port == 8080); - REQUIRE(ws.path == "/teleop"); + REQUIRE(*ws.ws_path == "/teleop"); const RemoteAddress bare = parse_remote("ws://bridge.local", 47500); REQUIRE(bare.endpoint.port == 47500); - REQUIRE(bare.path == "/"); + REQUIRE(*bare.ws_path == "/"); REQUIRE_THROWS_AS(parse_remote("wss://bridge.local", 47500), std::invalid_argument); REQUIRE_THROWS_AS(parse_remote("ws:///teleop", 47500), std::invalid_argument); } +TEST_CASE("parse_endpoint validates ports and accepts IPv6 hosts", "[remote_device_bridge][unit]") +{ + for (const char* bad : { "host:", "host:0", "host:70000", "host:80x", "[::1", "[::1]x" }) + { + INFO(bad); + REQUIRE_THROWS_AS(parse_endpoint(bad, 47500), std::invalid_argument); + } + const Endpoint bracketed = parse_endpoint("[::1]:8080", 47500); + REQUIRE(bracketed.host == "::1"); + REQUIRE(bracketed.port == 8080); + const Endpoint bare_v6 = parse_endpoint("fe80::1", 47500); + REQUIRE(bare_v6.host == "fe80::1"); + REQUIRE(bare_v6.port == 47500); + REQUIRE(parse_endpoint("[::1]", 47500).port == 47500); +} + TEST_CASE("WebSocketTransport round-trips frames of every length class", "[remote_device_bridge][unit]") { // 7-bit, 16-bit and 64-bit WebSocket lengths, both directions (client frames are masked). @@ -206,15 +222,15 @@ TEST_CASE("WebSocketTransport server role handles control frames and fragments", REQUIRE(server->receive(frame, kWait) == ReceiveResult::Closed); REQUIRE(raw_recv(raw, 4) == std::vector{ 0x88, 0x02, 0x03, 0xE8 }); } - SECTION("an unmasked client frame closes the connection") + SECTION("an unmasked client frame is malformed") { - raw_send(raw, raw_frame(0x2, true, frame_of_size(24), false)); - REQUIRE(server->receive(frame, kWait) == ReceiveResult::Closed); + raw_send(raw, raw_frame(0x2, true, frame_of_size(protocol::kHeaderSize), false)); + REQUIRE(server->receive(frame, kWait) == ReceiveResult::Malformed); } - SECTION("text frames are refused") + SECTION("text frames are malformed") { raw_send(raw, raw_frame(0x1, true, { 'x' })); - REQUIRE(server->receive(frame, kWait) == ReceiveResult::Closed); + REQUIRE(server->receive(frame, kWait) == ReceiveResult::Malformed); } SECTION("a message that is not exactly one wire frame is malformed") { @@ -238,7 +254,7 @@ TEST_CASE("WebSocketTransport rejects bad handshakes", "[remote_device_bridge][u std::vector frame; REQUIRE(server.receive(frame, kWait) == ReceiveResult::Malformed); REQUIRE(raw_recv_head(peer).rfind("HTTP/1.1 400", 0) == 0); - const std::vector sent = frame_of_size(24); + const std::vector sent = frame_of_size(protocol::kHeaderSize); REQUIRE_FALSE(server.send(sent.data(), sent.size())); } SECTION("client throws on a non-101 response") @@ -266,10 +282,10 @@ TEST_CASE("connect_transport speaks ws:// to a listening WebSocketTransport", "[ { server = WebSocketTransport::accept(listener, kShort); } - std::vector frame; - REQUIRE(server->receive(frame, kShort) == ReceiveResult::Timeout); + REQUIRE(server->wait_ready(kWait) == ReceiveResult::Ok); connector.join(); REQUIRE(client); + std::vector frame; const std::vector sent = frame_of_size(200); REQUIRE(client->send(sent.data(), sent.size())); @@ -278,3 +294,47 @@ TEST_CASE("connect_transport speaks ws:// to a listening WebSocketTransport", "[ client->shutdown(); REQUIRE(server->receive(frame, kWait) == ReceiveResult::Closed); } + +TEST_CASE("TcpTransport delimits frames by the header and reports broken peers", "[remote_device_bridge][unit]") +{ + auto [peer, transport_end] = socket_pair(); + TcpTransport transport(std::move(transport_end)); + std::vector frame; + + SECTION("a header-only frame arrives on its own") + { + const std::vector sent = protocol::encode_frame(protocol::FrameType::Heartbeat, 0, {}); + raw_send(peer, sent); + REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Ok); + REQUIRE(frame == sent); + } + SECTION("a frame with a payload arrives whole") + { + const std::vector sent = frame_of_size(protocol::kHeaderSize + 100); + raw_send(peer, sent); + REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Ok); + REQUIRE(frame == sent); + } + SECTION("nothing within the timeout") + { + REQUIRE(transport.receive(frame, kShort) == ReceiveResult::Timeout); + } + SECTION("a bad magic is malformed") + { + std::vector sent = protocol::encode_frame(protocol::FrameType::Heartbeat, 0, {}); + sent[0] ^= 0xFF; + raw_send(peer, sent); + REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Malformed); + } + SECTION("a header whose payload never arrives counts as closed") + { + const std::vector sent = frame_of_size(protocol::kHeaderSize + 100); + raw_send(peer, std::vector(sent.begin(), sent.begin() + protocol::kHeaderSize)); + REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Closed); + } + SECTION("peer EOF is closed") + { + peer.shutdown(); + REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Closed); + } +} From 3fd995d3ef403ac41aa2b283ab925d2bcd8b6b4d Mon Sep 17 00:00:00 2001 From: Jonghyun Kim Date: Fri, 30 Oct 2026 10:46:11 -0700 Subject: [PATCH 4/8] review round 2 (pr03) Applied the fact-checked (VERIFIED) findings on code this branch adds: - TcpSocket::recv_all returns ReceiveResult (its Ok/Timeout/Closed subset), so TcpTransport no longer maps one enum onto the other; peer_name() is private; a failed connect/listen reports every address's error. - parse_endpoint moves to remote_address.hpp with parse_remote, and parses the port with std::from_chars; the Host header brackets IPv6 hosts. - WebSocketTransport: an explicit server constructor and a client connect() factory replace the role flag plus client-only defaults. - One accept_transport helper instead of two copies of accept. - WebSocket: reserved control opcodes are Malformed; starts_with instead of rfind(..., 0). - TcpTransport::receive drops a check recv_all already covers; kSendTimeout says why it is independent of the other 3 s constants. - Tests: oversized and reserved-opcode WebSocket cases. Co-Authored-By: Claude Opus 5.5 Signed-off-by: Jonghyun Kim --- .../remote_plugin_session/remote_address.hpp | 4 + .../inc/remote_plugin_session/tcp_socket.hpp | 32 ++++---- .../websocket_transport.hpp | 28 ++++--- .../session/remote_address.cpp | 71 +++++++++++++++-- .../session/tcp_socket.cpp | 76 +++---------------- .../session/tcp_transport.cpp | 20 ++--- .../session/websocket_transport.cpp | 66 +++++++++------- .../test_websocket_transport.cpp | 33 +++++--- 8 files changed, 183 insertions(+), 147 deletions(-) diff --git a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/remote_address.hpp b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/remote_address.hpp index 8ccb131d51..a02ddbd54d 100644 --- a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/remote_address.hpp +++ b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/remote_address.hpp @@ -15,6 +15,10 @@ namespace remote_plugin_session { +//! Parses "host[:port]" or "[v6-host][:port]"; a missing port falls back to default_port. Throws +//! std::invalid_argument. +Endpoint parse_endpoint(const std::string& text, uint16_t default_port); + //! Where a client connects: plain "host[:port]" (TCP) or "ws://host[:port][/path]" (WebSocket). struct RemoteAddress { diff --git a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_socket.hpp b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_socket.hpp index bc25009f16..d3c5cc3074 100644 --- a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_socket.hpp +++ b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/tcp_socket.hpp @@ -3,10 +3,14 @@ #pragma once +#include "transport.hpp" + #include #include #include +#include #include +#include #include namespace remote_plugin_session @@ -18,21 +22,10 @@ struct Endpoint uint16_t port = 0; }; -//! Parses "host[:port]" or "[v6-host][:port]"; a missing port falls back to default_port. Throws -//! std::invalid_argument. -Endpoint parse_endpoint(const std::string& text, uint16_t default_port); - //! Minimal RAII wrapper over a blocking POSIX TCP socket (IPv4/IPv6 via getaddrinfo). class TcpSocket { public: - enum class RecvResult - { - Ok, - Timeout, - Closed, - }; - TcpSocket() = default; explicit TcpSocket(int fd); ~TcpSocket(); @@ -53,20 +46,31 @@ class TcpSocket bool valid() const; int fd() const; uint16_t local_port() const; - //! Numeric "host:port" of the connected peer; "?" when unavailable. - std::string peer_name() const; //! False when the peer closed or the send stalled past the socket send timeout. bool send_all(const uint8_t* data, size_t size); //! Timeout applies to the wait for the first byte; a stall mid-message reports Closed. - RecvResult recv_all(uint8_t* data, size_t size, std::chrono::milliseconds timeout); + //! Ok, Timeout or Closed. + ReceiveResult recv_all(uint8_t* data, size_t size, std::chrono::milliseconds timeout); //! Unblocks recv/send on other threads; the descriptor stays open until close(). void shutdown(); void close(); private: + //! Numeric "host:port" of the connected peer; "?" when unavailable. + std::string peer_name() const; + int m_fd = -1; }; +//! Accepts one connection on `listener` and wraps it in `Transport`; null when the poll expires. `peer`, when +//! given, receives the client's numeric host:port. +template +std::unique_ptr accept_transport(TcpSocket& listener, std::chrono::milliseconds poll, std::string* peer) +{ + TcpSocket client = listener.accept(poll, peer); + return client.valid() ? std::make_unique(std::move(client)) : nullptr; +} + } // namespace remote_plugin_session diff --git a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp index c5b9bd9944..c90e24005e 100644 --- a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp +++ b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp @@ -28,19 +28,15 @@ namespace remote_plugin_session class WebSocketTransport final : public ITransport { public: - enum class Role - { - Client, - Server, - }; + //! Server role over an accepted socket; no I/O until the first receive() or wait_ready(). + explicit WebSocketTransport(TcpSocket socket); - //! Server: no I/O. Client: sends the upgrade for `path` with `host_header` ("host:port") and throws - //! std::runtime_error unless 101. - WebSocketTransport(TcpSocket socket, - Role role, - const std::string& host_header = "", - const std::string& path = "/", - std::chrono::milliseconds timeout = kConnectTimeout); + //! Client role: sends the upgrade for `path` with `host_header` ("host:port") and throws + //! std::runtime_error unless the server answers 101. + static std::unique_ptr connect(TcpSocket socket, + const std::string& host_header, + const std::string& path, + std::chrono::milliseconds timeout = kConnectTimeout); //! Like TcpTransport::accept; the upgrade happens on the first receive(). static std::unique_ptr accept(TcpSocket& listener, @@ -54,6 +50,14 @@ class WebSocketTransport final : public ITransport ReceiveResult wait_ready(std::chrono::milliseconds timeout) override; private: + enum class Role + { + Client, + Server, + }; + + WebSocketTransport(TcpSocket socket, Role role); + void client_upgrade(const std::string& host_header, const std::string& path, std::chrono::milliseconds timeout); bool send_message(uint8_t opcode, const uint8_t* data, size_t size); ReceiveResult accept_upgrade(std::chrono::milliseconds timeout); diff --git a/src/plugins/remote_device_bridge/session/remote_address.cpp b/src/plugins/remote_device_bridge/session/remote_address.cpp index 8c306dc40c..b468a4d055 100644 --- a/src/plugins/remote_device_bridge/session/remote_address.cpp +++ b/src/plugins/remote_device_bridge/session/remote_address.cpp @@ -6,21 +6,84 @@ #include "inc/remote_plugin_session/tcp_transport.hpp" #include "inc/remote_plugin_session/websocket_transport.hpp" +#include +#include #include +#include +#include #include namespace remote_plugin_session { +namespace +{ + +//! HTTP Host value: IPv6 literals need brackets before the port. +std::string host_header(const Endpoint& endpoint) +{ + const bool v6 = endpoint.host.find(':') != std::string::npos; + return (v6 ? "[" + endpoint.host + "]" : endpoint.host) + ":" + std::to_string(endpoint.port); +} + +} // namespace + +Endpoint parse_endpoint(const std::string& text, uint16_t default_port) +{ + Endpoint endpoint; + endpoint.port = default_port; + std::string port_text; + bool has_port = false; + if (!text.empty() && text.front() == '[') + { + // "[v6-address]" or "[v6-address]:port" + const size_t close = text.find(']'); + if (close == std::string::npos || (close + 1 < text.size() && text[close + 1] != ':')) + { + throw std::invalid_argument("invalid bracketed host in endpoint '" + text + "'"); + } + endpoint.host = text.substr(1, close - 1); + has_port = close + 1 < text.size(); + port_text = has_port ? text.substr(close + 2) : ""; + } + else if (std::count(text.begin(), text.end(), ':') > 1) + { + endpoint.host = text; // bare IPv6 address, no port + } + else + { + const size_t colon = text.find(':'); + endpoint.host = text.substr(0, colon); + has_port = colon != std::string::npos; + port_text = has_port ? text.substr(colon + 1) : ""; + } + if (has_port) + { + unsigned long port = 0; + const char* end = port_text.data() + port_text.size(); + const auto [stop, error] = std::from_chars(port_text.data(), end, port); + if (error != std::errc{} || stop != end || port == 0 || port > 65535) + { + throw std::invalid_argument("invalid port in endpoint '" + text + "'"); + } + endpoint.port = static_cast(port); + } + if (endpoint.host.empty()) + { + throw std::invalid_argument("missing host in endpoint '" + text + "'"); + } + return endpoint; +} + RemoteAddress parse_remote(const std::string& text, uint16_t default_port) { const std::string scheme = "ws://"; - if (text.rfind("wss://", 0) == 0) + if (text.starts_with("wss://")) { throw std::invalid_argument("wss:// is not supported ('" + text + "'); terminate TLS in a proxy, use ws://"); } RemoteAddress remote; - if (text.rfind(scheme, 0) != 0) + if (!text.starts_with(scheme)) { remote.endpoint = parse_endpoint(text, default_port); return remote; @@ -43,9 +106,7 @@ std::unique_ptr connect_transport(const RemoteAddress& remote, std:: { return std::make_unique(std::move(socket)); } - return std::make_unique(std::move(socket), WebSocketTransport::Role::Client, - remote.endpoint.host + ":" + std::to_string(remote.endpoint.port), - *remote.ws_path, timeout); + return WebSocketTransport::connect(std::move(socket), host_header(remote.endpoint), *remote.ws_path, timeout); } } // namespace remote_plugin_session diff --git a/src/plugins/remote_device_bridge/session/tcp_socket.cpp b/src/plugins/remote_device_bridge/session/tcp_socket.cpp index f70d38999c..d8dc7cdf0f 100644 --- a/src/plugins/remote_device_bridge/session/tcp_socket.cpp +++ b/src/plugins/remote_device_bridge/session/tcp_socket.cpp @@ -10,7 +10,6 @@ #include #include -#include #include #include #include @@ -27,7 +26,8 @@ namespace remote_plugin_session namespace { -// A send may stall as long as the peer timeout tolerates silence; liveness is decided by the receive side. +// A send may stall as long as the peer timeout tolerates silence; liveness is decided by the receive side. It +// is independent of kConnectTimeout and kMidMessageStall, which only share its value. constexpr std::chrono::milliseconds kSendTimeout{ 3000 }; // Best effort: the kernel clamps to its rmem/wmem maximum. constexpr int kSocketBufferBytes = 4 * 1024 * 1024; @@ -153,7 +153,7 @@ template TcpSocket for_each_address(const Endpoint& endpoint, bool passive, const char* what, Attempt attempt) { const AddrInfoList addresses = resolve(endpoint, passive); - std::string last_error = "no addresses"; + std::string errors; for (const addrinfo* ai = addresses.get(); ai != nullptr; ai = ai->ai_next) { @@ -170,70 +170,16 @@ TcpSocket for_each_address(const Endpoint& endpoint, bool passive, const char* w } catch (const std::runtime_error& e) { - last_error = e.what(); + errors += errors.empty() ? e.what() : std::string("; ") + e.what(); } } throw std::runtime_error(std::string("TcpSocket::") + what + "(" + endpoint.host + ":" + - std::to_string(endpoint.port) + ") failed: " + last_error); + std::to_string(endpoint.port) + ") failed: " + (errors.empty() ? "no addresses" : errors)); } } // namespace -Endpoint parse_endpoint(const std::string& text, uint16_t default_port) -{ - Endpoint endpoint; - endpoint.port = default_port; - std::string port_text; - bool has_port = false; - if (!text.empty() && text.front() == '[') - { - // "[v6-address]" or "[v6-address]:port" - const size_t close = text.find(']'); - if (close == std::string::npos || (close + 1 < text.size() && text[close + 1] != ':')) - { - throw std::invalid_argument("invalid bracketed host in endpoint '" + text + "'"); - } - endpoint.host = text.substr(1, close - 1); - has_port = close + 1 < text.size(); - port_text = has_port ? text.substr(close + 2) : ""; - } - else if (std::count(text.begin(), text.end(), ':') > 1) - { - endpoint.host = text; // bare IPv6 address, no port - } - else - { - const size_t colon = text.find(':'); - endpoint.host = text.substr(0, colon); - has_port = colon != std::string::npos; - port_text = has_port ? text.substr(colon + 1) : ""; - } - if (has_port) - { - unsigned long port = 0; - size_t parsed = 0; - try - { - port = std::stoul(port_text, &parsed); - } - catch (const std::exception&) - { - parsed = 0; - } - if (parsed == 0 || parsed != port_text.size() || port == 0 || port > 65535) - { - throw std::invalid_argument("invalid port in endpoint '" + text + "'"); - } - endpoint.port = static_cast(port); - } - if (endpoint.host.empty()) - { - throw std::invalid_argument("missing host in endpoint '" + text + "'"); - } - return endpoint; -} - TcpSocket::TcpSocket(int fd) : m_fd(fd) { } @@ -365,7 +311,7 @@ bool TcpSocket::send_all(const uint8_t* data, size_t size) return true; } -TcpSocket::RecvResult TcpSocket::recv_all(uint8_t* data, size_t size, std::chrono::milliseconds timeout) +ReceiveResult TcpSocket::recv_all(uint8_t* data, size_t size, std::chrono::milliseconds timeout) { size_t received = 0; while (received < size) @@ -373,11 +319,11 @@ TcpSocket::RecvResult TcpSocket::recv_all(uint8_t* data, size_t size, std::chron const int ready = poll_fd(m_fd, POLLIN, received == 0 ? timeout : kMidMessageStall); if (ready == 0) { - return received == 0 ? RecvResult::Timeout : RecvResult::Closed; + return received == 0 ? ReceiveResult::Timeout : ReceiveResult::Closed; } if (ready < 0) { - return RecvResult::Closed; + return ReceiveResult::Closed; } const ssize_t n = ::recv(m_fd, data + received, size - received, 0); if (n < 0) @@ -386,15 +332,15 @@ TcpSocket::RecvResult TcpSocket::recv_all(uint8_t* data, size_t size, std::chron { continue; } - return RecvResult::Closed; + return ReceiveResult::Closed; } if (n == 0) { - return RecvResult::Closed; + return ReceiveResult::Closed; } received += static_cast(n); } - return RecvResult::Ok; + return ReceiveResult::Ok; } void TcpSocket::shutdown() diff --git a/src/plugins/remote_device_bridge/session/tcp_transport.cpp b/src/plugins/remote_device_bridge/session/tcp_transport.cpp index d6500f3d74..c86418fb9a 100644 --- a/src/plugins/remote_device_bridge/session/tcp_transport.cpp +++ b/src/plugins/remote_device_bridge/session/tcp_transport.cpp @@ -24,14 +24,10 @@ bool TcpTransport::send(const uint8_t* frame, size_t size) ReceiveResult TcpTransport::receive(std::vector& frame, std::chrono::milliseconds timeout) { frame.resize(protocol::kHeaderSize); - switch (m_socket.recv_all(frame.data(), protocol::kHeaderSize, timeout)) + if (const ReceiveResult header = m_socket.recv_all(frame.data(), protocol::kHeaderSize, timeout); + header != ReceiveResult::Ok) { - case TcpSocket::RecvResult::Timeout: - return ReceiveResult::Timeout; - case TcpSocket::RecvResult::Closed: - return ReceiveResult::Closed; - case TcpSocket::RecvResult::Ok: - break; + return header; } uint32_t payload_size = 0; @@ -43,14 +39,9 @@ ReceiveResult TcpTransport::receive(std::vector& frame, std::chrono::mi { return ReceiveResult::Malformed; } - if (payload_size == 0) - { - return ReceiveResult::Ok; - } frame.resize(protocol::kHeaderSize + payload_size); // A header without its payload within the stall window is a broken peer, not a quiet one. - return m_socket.recv_all(frame.data() + protocol::kHeaderSize, payload_size, kMidMessageStall) == - TcpSocket::RecvResult::Ok ? + return m_socket.recv_all(frame.data() + protocol::kHeaderSize, payload_size, kMidMessageStall) == ReceiveResult::Ok ? ReceiveResult::Ok : ReceiveResult::Closed; } @@ -62,8 +53,7 @@ void TcpTransport::shutdown() std::unique_ptr TcpTransport::accept(TcpSocket& listener, std::chrono::milliseconds poll, std::string* peer) { - TcpSocket client = listener.accept(poll, peer); - return client.valid() ? std::make_unique(std::move(client)) : nullptr; + return accept_transport(listener, poll, peer); } } // namespace remote_plugin_session diff --git a/src/plugins/remote_device_bridge/session/websocket_transport.cpp b/src/plugins/remote_device_bridge/session/websocket_transport.cpp index d3228164ca..9baa48d598 100644 --- a/src/plugins/remote_device_bridge/session/websocket_transport.cpp +++ b/src/plugins/remote_device_bridge/session/websocket_transport.cpp @@ -138,11 +138,10 @@ ReceiveResult read_http_head(TcpSocket& socket, std::chrono::milliseconds timeou return ReceiveResult::Malformed; } uint8_t byte = 0; - const TcpSocket::RecvResult result = socket.recv_all(&byte, 1, text.empty() ? timeout : kMidMessageStall); - if (result != TcpSocket::RecvResult::Ok) + const ReceiveResult result = socket.recv_all(&byte, 1, text.empty() ? timeout : kMidMessageStall); + if (result != ReceiveResult::Ok) { - return result == TcpSocket::RecvResult::Timeout && text.empty() ? ReceiveResult::Timeout : - ReceiveResult::Closed; + return result == ReceiveResult::Timeout && text.empty() ? ReceiveResult::Timeout : ReceiveResult::Closed; } text.push_back(static_cast(byte)); } @@ -173,17 +172,29 @@ std::string header(const HttpHead& head, const std::string& name) } // namespace -WebSocketTransport::WebSocketTransport(TcpSocket socket, - Role role, - const std::string& host_header, - const std::string& path, - std::chrono::milliseconds timeout) +WebSocketTransport::WebSocketTransport(TcpSocket socket, Role role) : m_socket(std::move(socket)), m_role(role), m_mask_rng(std::random_device{}()) { - if (role == Role::Server) - { - return; - } +} + +WebSocketTransport::WebSocketTransport(TcpSocket socket) : WebSocketTransport(std::move(socket), Role::Server) +{ +} + +std::unique_ptr WebSocketTransport::connect(TcpSocket socket, + const std::string& host_header, + const std::string& path, + std::chrono::milliseconds timeout) +{ + std::unique_ptr transport(new WebSocketTransport(std::move(socket), Role::Client)); + transport->client_upgrade(host_header, path, timeout); + return transport; +} + +void WebSocketTransport::client_upgrade(const std::string& host_header, + const std::string& path, + std::chrono::milliseconds timeout) +{ std::array nonce{}; std::generate(nonce.begin(), nonce.end(), [this] { return static_cast(m_mask_rng()); }); const std::string key = base64(nonce.data(), nonce.size()); @@ -207,7 +218,7 @@ WebSocketTransport::WebSocketTransport(TcpSocket socket, case ReceiveResult::Malformed: throw std::runtime_error("WebSocket upgrade to " + target + ": malformed HTTP response"); } - if (response.start_line.rfind("HTTP/1.1 101", 0) != 0) + if (!response.start_line.starts_with("HTTP/1.1 101")) { throw std::runtime_error("WebSocket upgrade to " + target + " refused: " + response.start_line); } @@ -222,8 +233,7 @@ std::unique_ptr WebSocketTransport::accept(TcpSocket& listener, std::chrono::milliseconds poll, std::string* peer) { - TcpSocket client = listener.accept(poll, peer); - return client.valid() ? std::make_unique(std::move(client), Role::Server) : nullptr; + return accept_transport(listener, poll, peer); } ReceiveResult WebSocketTransport::accept_upgrade(std::chrono::milliseconds timeout) @@ -235,7 +245,7 @@ ReceiveResult WebSocketTransport::accept_upgrade(std::chrono::milliseconds timeo return result; } const std::string key = header(request, "sec-websocket-key"); - if (result != ReceiveResult::Ok || request.start_line.rfind("GET ", 0) != 0 || + if (result != ReceiveResult::Ok || !request.start_line.starts_with("GET ") || lower(header(request, "upgrade")).find("websocket") == std::string::npos || lower(header(request, "connection")).find("upgrade") == std::string::npos || header(request, "sec-websocket-version") != "13" || key.empty()) @@ -319,12 +329,10 @@ ReceiveResult WebSocketTransport::receive(std::vector& frame, std::chro std::chrono::duration_cast( deadline - std::chrono::steady_clock::now())); uint8_t head[2]; - const TcpSocket::RecvResult first = - m_socket.recv_all(head, sizeof(head), in_message ? kMidMessageStall : remaining); - if (first != TcpSocket::RecvResult::Ok) + const ReceiveResult first = m_socket.recv_all(head, sizeof(head), in_message ? kMidMessageStall : remaining); + if (first != ReceiveResult::Ok) { - return first == TcpSocket::RecvResult::Timeout && !in_message ? ReceiveResult::Timeout : - ReceiveResult::Closed; + return first == ReceiveResult::Timeout && !in_message ? ReceiveResult::Timeout : ReceiveResult::Closed; } const bool fin = (head[0] & kFinBit) != 0; const uint8_t opcode = head[0] & kOpcodeMask; @@ -340,7 +348,7 @@ ReceiveResult WebSocketTransport::receive(std::vector& frame, std::chro { std::array ext{}; const size_t ext_size = length == 126 ? 2 : 8; - if (m_socket.recv_all(ext.data(), ext_size, kMidMessageStall) != TcpSocket::RecvResult::Ok) + if (m_socket.recv_all(ext.data(), ext_size, kMidMessageStall) != ReceiveResult::Ok) { return ReceiveResult::Closed; } @@ -351,7 +359,7 @@ ReceiveResult WebSocketTransport::receive(std::vector& frame, std::chro } } std::array mask{}; - if (masked && m_socket.recv_all(mask.data(), mask.size(), kMidMessageStall) != TcpSocket::RecvResult::Ok) + if (masked && m_socket.recv_all(mask.data(), mask.size(), kMidMessageStall) != ReceiveResult::Ok) { return ReceiveResult::Closed; } @@ -381,7 +389,7 @@ ReceiveResult WebSocketTransport::receive(std::vector& frame, std::chro frame.resize(offset + length); dest = frame.data() + offset; } - if (length > 0 && m_socket.recv_all(dest, length, kMidMessageStall) != TcpSocket::RecvResult::Ok) + if (length > 0 && m_socket.recv_all(dest, length, kMidMessageStall) != ReceiveResult::Ok) { return ReceiveResult::Closed; } @@ -399,12 +407,16 @@ ReceiveResult WebSocketTransport::receive(std::vector& frame, std::chro { continue; } - if (control) + if (opcode == kClose) { - // Close (and the reserved control opcodes): echo the status code, then report the peer gone. + // Echo the status code, then report the peer gone. send_message(kClose, control_payload.data(), std::min(control_payload.size(), 2)); return ReceiveResult::Closed; } + if (control) + { + return ReceiveResult::Malformed; // reserved control opcode + } in_message = !fin; if (in_message) { diff --git a/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp b/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp index 48f9774ee4..e6b76fe8ed 100644 --- a/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp +++ b/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp @@ -19,7 +19,6 @@ using namespace remote_plugin_session; namespace protocol = remote_plugin_protocol; -using Role = WebSocketTransport::Role; namespace { @@ -84,7 +83,7 @@ void raw_send(TcpSocket& socket, const std::vector& bytes) std::vector raw_recv(TcpSocket& socket, size_t size) { std::vector bytes(size); - REQUIRE(socket.recv_all(bytes.data(), size, kWait) == TcpSocket::RecvResult::Ok); + REQUIRE(socket.recv_all(bytes.data(), size, kWait) == ReceiveResult::Ok); return bytes; } @@ -107,7 +106,7 @@ const std::string kSampleUpgrade = //! A server transport upgraded by a raw client using the RFC sample key. std::unique_ptr upgraded_server(TcpSocket server_end, TcpSocket& raw_client) { - auto server = std::make_unique(std::move(server_end), Role::Server); + auto server = std::make_unique(std::move(server_end)); raw_send(raw_client, kSampleUpgrade); REQUIRE(server->wait_ready(kWait) == ReceiveResult::Ok); const std::string response = raw_recv_head(raw_client); @@ -126,9 +125,8 @@ Connected connected_pair() { auto [client_end, server_end] = socket_pair(); Connected pair; - pair.server = std::make_unique(std::move(server_end), Role::Server); - std::thread client( - [&] { pair.client = std::make_unique(std::move(client_end), Role::Client, "h:1", "/x"); }); + pair.server = std::make_unique(std::move(server_end)); + std::thread client([&] { pair.client = WebSocketTransport::connect(std::move(client_end), "h:1", "/x"); }); REQUIRE(pair.server->wait_ready(kWait) == ReceiveResult::Ok); client.join(); REQUIRE(pair.client); @@ -232,6 +230,23 @@ TEST_CASE("WebSocketTransport server role handles control frames and fragments", raw_send(raw, raw_frame(0x1, true, { 'x' })); REQUIRE(server->receive(frame, kWait) == ReceiveResult::Malformed); } + SECTION("a message larger than a wire frame can be is malformed") + { + std::vector head{ 0x82, 0x80 | 127 }; // FIN + binary, masked, 64-bit length + const uint64_t length = protocol::kHeaderSize + protocol::kMaxPayloadSize + 1; + for (int i = 7; i >= 0; --i) + { + head.push_back(static_cast(length >> (8 * i))); + } + head.insert(head.end(), { 0x12, 0x34, 0x56, 0x78 }); + raw_send(raw, head); + REQUIRE(server->receive(frame, kWait) == ReceiveResult::Malformed); + } + SECTION("a reserved control opcode is malformed") + { + raw_send(raw, raw_frame(0xB, true, {})); + REQUIRE(server->receive(frame, kWait) == ReceiveResult::Malformed); + } SECTION("a message that is not exactly one wire frame is malformed") { raw_send(raw, raw_frame(0x2, true, { 0x01 })); @@ -249,7 +264,7 @@ TEST_CASE("WebSocketTransport rejects bad handshakes", "[remote_device_bridge][u auto [peer, own_end] = socket_pair(); SECTION("server answers garbage with 400 and refuses to send") { - WebSocketTransport server(std::move(own_end), Role::Server); + WebSocketTransport server(std::move(own_end)); raw_send(peer, "hello there\r\n\r\n"); std::vector frame; REQUIRE(server.receive(frame, kWait) == ReceiveResult::Malformed); @@ -260,14 +275,14 @@ TEST_CASE("WebSocketTransport rejects bad handshakes", "[remote_device_bridge][u SECTION("client throws on a non-101 response") { raw_send(peer, "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"); - REQUIRE_THROWS_AS(WebSocketTransport(std::move(own_end), Role::Client, "h:1", "/"), std::runtime_error); + REQUIRE_THROWS_AS(WebSocketTransport::connect(std::move(own_end), "h:1", "/"), std::runtime_error); } SECTION("client throws on a wrong Sec-WebSocket-Accept") { raw_send(peer, "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n" "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n\r\n"); - REQUIRE_THROWS_AS(WebSocketTransport(std::move(own_end), Role::Client, "h:1", "/"), std::runtime_error); + REQUIRE_THROWS_AS(WebSocketTransport::connect(std::move(own_end), "h:1", "/"), std::runtime_error); } } From 937ec7921d10ee485ac782d696494d504143f560 Mon Sep 17 00:00:00 2001 From: Jonghyun Kim Date: Fri, 30 Oct 2026 10:52:54 -0700 Subject: [PATCH 5/8] review round 3 (pr03) Applied the fact-checked (VERIFIED) findings on code this branch adds: - WebSocketTransport's client role is a constructor that performs the upgrade and throws, instead of a connect() factory plus a second step. - A failed PONG send in receive() reports Closed instead of being ignored. - send_all drops a check for a zero-byte send() of a non-empty buffer. - parse_remote/parse_endpoint and TcpTransport tests move to test_remote_address.cpp and test_tcp_transport.cpp. Co-Authored-By: Claude Opus 5.5 Signed-off-by: Jonghyun Kim --- .../websocket_transport.hpp | 8 +- .../session/remote_address.cpp | 3 +- .../session/tcp_socket.cpp | 4 - .../session/websocket_transport.cpp | 18 ++-- .../remote_device_bridge/CMakeLists.txt | 2 + .../test_remote_address.cpp | 46 ++++++++++ .../test_tcp_transport.cpp | 86 ++++++++++++++++++ .../test_websocket_transport.cpp | 88 +------------------ 8 files changed, 153 insertions(+), 102 deletions(-) create mode 100644 tests/cpp/plugins/remote_device_bridge/test_remote_address.cpp create mode 100644 tests/cpp/plugins/remote_device_bridge/test_tcp_transport.cpp diff --git a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp index c90e24005e..0aa8925d3a 100644 --- a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp +++ b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/websocket_transport.hpp @@ -33,10 +33,10 @@ class WebSocketTransport final : public ITransport //! Client role: sends the upgrade for `path` with `host_header` ("host:port") and throws //! std::runtime_error unless the server answers 101. - static std::unique_ptr connect(TcpSocket socket, - const std::string& host_header, - const std::string& path, - std::chrono::milliseconds timeout = kConnectTimeout); + WebSocketTransport(TcpSocket socket, + const std::string& host_header, + const std::string& path, + std::chrono::milliseconds timeout = kConnectTimeout); //! Like TcpTransport::accept; the upgrade happens on the first receive(). static std::unique_ptr accept(TcpSocket& listener, diff --git a/src/plugins/remote_device_bridge/session/remote_address.cpp b/src/plugins/remote_device_bridge/session/remote_address.cpp index b468a4d055..aefc49e827 100644 --- a/src/plugins/remote_device_bridge/session/remote_address.cpp +++ b/src/plugins/remote_device_bridge/session/remote_address.cpp @@ -106,7 +106,8 @@ std::unique_ptr connect_transport(const RemoteAddress& remote, std:: { return std::make_unique(std::move(socket)); } - return WebSocketTransport::connect(std::move(socket), host_header(remote.endpoint), *remote.ws_path, timeout); + return std::make_unique( + std::move(socket), host_header(remote.endpoint), *remote.ws_path, timeout); } } // namespace remote_plugin_session diff --git a/src/plugins/remote_device_bridge/session/tcp_socket.cpp b/src/plugins/remote_device_bridge/session/tcp_socket.cpp index d8dc7cdf0f..16e5c2a780 100644 --- a/src/plugins/remote_device_bridge/session/tcp_socket.cpp +++ b/src/plugins/remote_device_bridge/session/tcp_socket.cpp @@ -302,10 +302,6 @@ bool TcpSocket::send_all(const uint8_t* data, size_t size) } return false; } - if (n == 0) - { - return false; - } sent += static_cast(n); } return true; diff --git a/src/plugins/remote_device_bridge/session/websocket_transport.cpp b/src/plugins/remote_device_bridge/session/websocket_transport.cpp index 9baa48d598..e88ec14b0f 100644 --- a/src/plugins/remote_device_bridge/session/websocket_transport.cpp +++ b/src/plugins/remote_device_bridge/session/websocket_transport.cpp @@ -181,14 +181,13 @@ WebSocketTransport::WebSocketTransport(TcpSocket socket) : WebSocketTransport(st { } -std::unique_ptr WebSocketTransport::connect(TcpSocket socket, - const std::string& host_header, - const std::string& path, - std::chrono::milliseconds timeout) +WebSocketTransport::WebSocketTransport(TcpSocket socket, + const std::string& host_header, + const std::string& path, + std::chrono::milliseconds timeout) + : WebSocketTransport(std::move(socket), Role::Client) { - std::unique_ptr transport(new WebSocketTransport(std::move(socket), Role::Client)); - transport->client_upgrade(host_header, path, timeout); - return transport; + client_upgrade(host_header, path, timeout); } void WebSocketTransport::client_upgrade(const std::string& host_header, @@ -400,7 +399,10 @@ ReceiveResult WebSocketTransport::receive(std::vector& frame, std::chro if (opcode == kPing) { - send_message(kPong, control_payload.data(), control_payload.size()); + if (!send_message(kPong, control_payload.data(), control_payload.size())) + { + return ReceiveResult::Closed; + } continue; } if (opcode == kPong) diff --git a/tests/cpp/plugins/remote_device_bridge/CMakeLists.txt b/tests/cpp/plugins/remote_device_bridge/CMakeLists.txt index 8cd8ef95b7..a513b47b05 100644 --- a/tests/cpp/plugins/remote_device_bridge/CMakeLists.txt +++ b/tests/cpp/plugins/remote_device_bridge/CMakeLists.txt @@ -4,6 +4,8 @@ find_package(Threads REQUIRED) add_executable(remote_plugin_session_tests + test_remote_address.cpp + test_tcp_transport.cpp test_websocket_transport.cpp test_wire_codec.cpp ) diff --git a/tests/cpp/plugins/remote_device_bridge/test_remote_address.cpp b/tests/cpp/plugins/remote_device_bridge/test_remote_address.cpp new file mode 100644 index 0000000000..e6be1f3ad1 --- /dev/null +++ b/tests/cpp/plugins/remote_device_bridge/test_remote_address.cpp @@ -0,0 +1,46 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +#include +#include + +#include + +using namespace remote_plugin_session; + +TEST_CASE("parse_remote selects TCP or WebSocket", "[remote_device_bridge][unit]") +{ + const RemoteAddress tcp = parse_remote("10.0.0.2:5000", 47500); + REQUIRE_FALSE(tcp.ws_path); + REQUIRE(tcp.endpoint.host == "10.0.0.2"); + REQUIRE(tcp.endpoint.port == 5000); + + const RemoteAddress ws = parse_remote("ws://bridge.local:8080/teleop", 47500); + REQUIRE(ws.ws_path); + REQUIRE(ws.endpoint.host == "bridge.local"); + REQUIRE(ws.endpoint.port == 8080); + REQUIRE(*ws.ws_path == "/teleop"); + + const RemoteAddress bare = parse_remote("ws://bridge.local", 47500); + REQUIRE(bare.endpoint.port == 47500); + REQUIRE(*bare.ws_path == "/"); + + REQUIRE_THROWS_AS(parse_remote("wss://bridge.local", 47500), std::invalid_argument); + REQUIRE_THROWS_AS(parse_remote("ws:///teleop", 47500), std::invalid_argument); +} + +TEST_CASE("parse_endpoint validates ports and accepts IPv6 hosts", "[remote_device_bridge][unit]") +{ + for (const char* bad : { "host:", "host:0", "host:70000", "host:80x", "[::1", "[::1]x" }) + { + INFO(bad); + REQUIRE_THROWS_AS(parse_endpoint(bad, 47500), std::invalid_argument); + } + const Endpoint bracketed = parse_endpoint("[::1]:8080", 47500); + REQUIRE(bracketed.host == "::1"); + REQUIRE(bracketed.port == 8080); + const Endpoint bare_v6 = parse_endpoint("fe80::1", 47500); + REQUIRE(bare_v6.host == "fe80::1"); + REQUIRE(bare_v6.port == 47500); + REQUIRE(parse_endpoint("[::1]", 47500).port == 47500); +} diff --git a/tests/cpp/plugins/remote_device_bridge/test_tcp_transport.cpp b/tests/cpp/plugins/remote_device_bridge/test_tcp_transport.cpp new file mode 100644 index 0000000000..58adea524b --- /dev/null +++ b/tests/cpp/plugins/remote_device_bridge/test_tcp_transport.cpp @@ -0,0 +1,86 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include +#include + +#include +#include +#include +#include + +using namespace remote_plugin_session; +namespace protocol = remote_plugin_protocol; + +namespace +{ + +constexpr std::chrono::milliseconds kWait{ 2000 }; +constexpr std::chrono::milliseconds kShort{ 300 }; + +std::pair socket_pair() +{ + int fds[2]; + REQUIRE(socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == 0); + return { TcpSocket(fds[0]), TcpSocket(fds[1]) }; +} + +//! A wire frame of exactly `message_size` bytes. +std::vector frame_of_size(size_t message_size) +{ + return protocol::encode_frame( + protocol::FrameType::SchemaSample, 3, std::vector(message_size - protocol::kHeaderSize, 0x5A)); +} + +void raw_send(TcpSocket& socket, const std::vector& bytes) +{ + REQUIRE(socket.send_all(bytes.data(), bytes.size())); +} + +} // namespace + +TEST_CASE("TcpTransport delimits frames by the header and reports broken peers", "[remote_device_bridge][unit]") +{ + auto [peer, transport_end] = socket_pair(); + TcpTransport transport(std::move(transport_end)); + std::vector frame; + + SECTION("a header-only frame arrives on its own") + { + const std::vector sent = protocol::encode_frame(protocol::FrameType::Heartbeat, 0, {}); + raw_send(peer, sent); + REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Ok); + REQUIRE(frame == sent); + } + SECTION("a frame with a payload arrives whole") + { + const std::vector sent = frame_of_size(protocol::kHeaderSize + 100); + raw_send(peer, sent); + REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Ok); + REQUIRE(frame == sent); + } + SECTION("nothing within the timeout") + { + REQUIRE(transport.receive(frame, kShort) == ReceiveResult::Timeout); + } + SECTION("a bad magic is malformed") + { + std::vector sent = protocol::encode_frame(protocol::FrameType::Heartbeat, 0, {}); + sent[0] ^= 0xFF; + raw_send(peer, sent); + REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Malformed); + } + SECTION("a header whose payload never arrives counts as closed") + { + const std::vector sent = frame_of_size(protocol::kHeaderSize + 100); + raw_send(peer, std::vector(sent.begin(), sent.begin() + protocol::kHeaderSize)); + REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Closed); + } + SECTION("peer EOF is closed") + { + peer.shutdown(); + REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Closed); + } +} diff --git a/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp b/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp index e6b76fe8ed..08f37da2ad 100644 --- a/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp +++ b/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp @@ -5,7 +5,6 @@ #include #include #include -#include #include #include @@ -126,7 +125,7 @@ Connected connected_pair() auto [client_end, server_end] = socket_pair(); Connected pair; pair.server = std::make_unique(std::move(server_end)); - std::thread client([&] { pair.client = WebSocketTransport::connect(std::move(client_end), "h:1", "/x"); }); + std::thread client([&] { pair.client = std::make_unique(std::move(client_end), "h:1", "/x"); }); REQUIRE(pair.server->wait_ready(kWait) == ReceiveResult::Ok); client.join(); REQUIRE(pair.client); @@ -135,43 +134,6 @@ Connected connected_pair() } // namespace -TEST_CASE("parse_remote selects TCP or WebSocket", "[remote_device_bridge][unit]") -{ - const RemoteAddress tcp = parse_remote("10.0.0.2:5000", 47500); - REQUIRE_FALSE(tcp.ws_path); - REQUIRE(tcp.endpoint.host == "10.0.0.2"); - REQUIRE(tcp.endpoint.port == 5000); - - const RemoteAddress ws = parse_remote("ws://bridge.local:8080/teleop", 47500); - REQUIRE(ws.ws_path); - REQUIRE(ws.endpoint.host == "bridge.local"); - REQUIRE(ws.endpoint.port == 8080); - REQUIRE(*ws.ws_path == "/teleop"); - - const RemoteAddress bare = parse_remote("ws://bridge.local", 47500); - REQUIRE(bare.endpoint.port == 47500); - REQUIRE(*bare.ws_path == "/"); - - REQUIRE_THROWS_AS(parse_remote("wss://bridge.local", 47500), std::invalid_argument); - REQUIRE_THROWS_AS(parse_remote("ws:///teleop", 47500), std::invalid_argument); -} - -TEST_CASE("parse_endpoint validates ports and accepts IPv6 hosts", "[remote_device_bridge][unit]") -{ - for (const char* bad : { "host:", "host:0", "host:70000", "host:80x", "[::1", "[::1]x" }) - { - INFO(bad); - REQUIRE_THROWS_AS(parse_endpoint(bad, 47500), std::invalid_argument); - } - const Endpoint bracketed = parse_endpoint("[::1]:8080", 47500); - REQUIRE(bracketed.host == "::1"); - REQUIRE(bracketed.port == 8080); - const Endpoint bare_v6 = parse_endpoint("fe80::1", 47500); - REQUIRE(bare_v6.host == "fe80::1"); - REQUIRE(bare_v6.port == 47500); - REQUIRE(parse_endpoint("[::1]", 47500).port == 47500); -} - TEST_CASE("WebSocketTransport round-trips frames of every length class", "[remote_device_bridge][unit]") { // 7-bit, 16-bit and 64-bit WebSocket lengths, both directions (client frames are masked). @@ -275,14 +237,14 @@ TEST_CASE("WebSocketTransport rejects bad handshakes", "[remote_device_bridge][u SECTION("client throws on a non-101 response") { raw_send(peer, "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"); - REQUIRE_THROWS_AS(WebSocketTransport::connect(std::move(own_end), "h:1", "/"), std::runtime_error); + REQUIRE_THROWS_AS(WebSocketTransport(std::move(own_end), "h:1", "/"), std::runtime_error); } SECTION("client throws on a wrong Sec-WebSocket-Accept") { raw_send(peer, "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n" "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n\r\n"); - REQUIRE_THROWS_AS(WebSocketTransport::connect(std::move(own_end), "h:1", "/"), std::runtime_error); + REQUIRE_THROWS_AS(WebSocketTransport(std::move(own_end), "h:1", "/"), std::runtime_error); } } @@ -309,47 +271,3 @@ TEST_CASE("connect_transport speaks ws:// to a listening WebSocketTransport", "[ client->shutdown(); REQUIRE(server->receive(frame, kWait) == ReceiveResult::Closed); } - -TEST_CASE("TcpTransport delimits frames by the header and reports broken peers", "[remote_device_bridge][unit]") -{ - auto [peer, transport_end] = socket_pair(); - TcpTransport transport(std::move(transport_end)); - std::vector frame; - - SECTION("a header-only frame arrives on its own") - { - const std::vector sent = protocol::encode_frame(protocol::FrameType::Heartbeat, 0, {}); - raw_send(peer, sent); - REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Ok); - REQUIRE(frame == sent); - } - SECTION("a frame with a payload arrives whole") - { - const std::vector sent = frame_of_size(protocol::kHeaderSize + 100); - raw_send(peer, sent); - REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Ok); - REQUIRE(frame == sent); - } - SECTION("nothing within the timeout") - { - REQUIRE(transport.receive(frame, kShort) == ReceiveResult::Timeout); - } - SECTION("a bad magic is malformed") - { - std::vector sent = protocol::encode_frame(protocol::FrameType::Heartbeat, 0, {}); - sent[0] ^= 0xFF; - raw_send(peer, sent); - REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Malformed); - } - SECTION("a header whose payload never arrives counts as closed") - { - const std::vector sent = frame_of_size(protocol::kHeaderSize + 100); - raw_send(peer, std::vector(sent.begin(), sent.begin() + protocol::kHeaderSize)); - REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Closed); - } - SECTION("peer EOF is closed") - { - peer.shutdown(); - REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Closed); - } -} From 60c25ba32c696942a97967bed210ffc617a363d6 Mon Sep 17 00:00:00 2001 From: Jonghyun Kim Date: Wed, 18 Nov 2026 14:34:02 -0800 Subject: [PATCH 6/8] docs(remote_device_bridge): describe WebSocket selection without flags that do not exist yet Co-Authored-By: Claude Opus 5.5 Signed-off-by: Jonghyun Kim --- src/plugins/remote_device_bridge/AGENTS.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plugins/remote_device_bridge/AGENTS.md b/src/plugins/remote_device_bridge/AGENTS.md index 91b80a347b..70b309a38d 100644 --- a/src/plugins/remote_device_bridge/AGENTS.md +++ b/src/plugins/remote_device_bridge/AGENTS.md @@ -10,5 +10,5 @@ SPDX-License-Identifier: Apache-2.0 - `session/protocol_frame.*`, `session/protocol_payloads.*` and the `Reader`/`Writer` in `session/protocol_io.hpp` are the only serialization points. Every frame is encoded and decoded there and nowhere else; changing the wire format means changing them and their codec tests together. Sessions hold an `ITransport` (`session/inc/remote_plugin_session/transport.hpp`) and only call `send/receive/shutdown` on complete frames; TCP framing lives in `TcpTransport`. - Wire format v1 (`kProtocolVersion` = 1, the only version number): 24-byte header `RPS0` magic, type u8, version u8, channel u16, seq u32, payload size u32, `t_send` i64; frame types 1..13 with no gaps; the hand byte is 0 = left, 1 = right in every payload; PING has no payload and PONG carries the PING's header `t_send` and the client's receive time. Any change to a header, payload or type number bumps `kProtocolVersion`; `decode_header` rejects other versions before reading the type, so old senders and bridges fail with a readable reason instead of mis-decoding. - A frame's `t_send` is its send time for clock exchange: call `stamp_header` where the frame is written to the transport, never when it is queued. -- WebSocket is a second transport, not a second protocol: `WebSocketTransport` carries exactly one wire frame per binary message (no TLS; terminate `wss://` in a proxy). Clients pick it with `--remote=ws://host:port[/path]` via `parse_remote`/`connect_transport`; the bridge serves it on a separate `--ws-listen` port sharing the fork-per-client loop and `--max-clients`. Never sniff the protocol on the TCP port. The server-side HTTP upgrade runs in the first `receive()` so the accept loop never blocks on a client. +- WebSocket is a second transport, not a second protocol: `WebSocketTransport` carries exactly one wire frame per binary message (no TLS; terminate `wss://` in a proxy). Clients pick it with a `ws://host:port[/path]` address via `parse_remote`/`connect_transport`. A server serves it on its own port; never sniff the protocol on the TCP port. The server-side HTTP upgrade runs in the first `receive()` so an accept loop never blocks on a client. - Never add `OpenXR::openxr_loader`, `Teleop::plugin_utils` or DeviceIO session libraries to `Teleop::remote_plugin_session`: a plugin that talks to a bridge through this library must run without an OpenXR runtime. From 02cde691719591ba50420487b30572b7fd5ad5da Mon Sep 17 00:00:00 2001 From: Jonghyun Kim Date: Wed, 18 Nov 2026 15:22:08 -0800 Subject: [PATCH 7/8] build(remote_device_bridge): skip on Windows with the socket code, option text names the transports (pr03) Co-Authored-By: Claude Opus 5.5 Signed-off-by: Jonghyun Kim --- CMakeLists.txt | 2 +- src/plugins/remote_device_bridge/CMakeLists.txt | 5 +++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index afc7ca3ee9..d61f8f704e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -71,7 +71,7 @@ option(BUILD_PLUGIN_NOITOM_MOCAP "Build Noitom mocap plugin (downloads MocapApi option(BUILD_PLUGIN_OGLO "Build OGLO tactile glove plugin (BLE, Linux only; fetches SimpleBLE + nlohmann/json)" OFF) option(BUILD_PLUGIN_WUJI_GLOVE "Build Wuji glove plugin (requires the wuji_sdk C SDK)" OFF) option(BUILD_PLUGIN_SHARPA_AVATAR "Build Sharpa AvatarExo Glove plugin (Linux; skips if the Avatar SDK is missing)" OFF) -option(BUILD_PLUGIN_REMOTE_DEVICE_BRIDGE "Build the remote device bridge wire codec library (Teleop::remote_plugin_session)" ON) +option(BUILD_PLUGIN_REMOTE_DEVICE_BRIDGE "Build the remote device bridge wire codec and TCP/WebSocket transports (Teleop::remote_plugin_session; POSIX sockets, skipped on Windows)" ON) option(BUILD_EXAMPLES "Build examples" ON) option(BUILD_EXAMPLE_TELEOP_ROS2 "Build only the teleop_ros2 ROS 2 reference integration (e.g. for Docker)" OFF) option(BUILD_TESTING "Build unit tests" ON) diff --git a/src/plugins/remote_device_bridge/CMakeLists.txt b/src/plugins/remote_device_bridge/CMakeLists.txt index f7c312b75a..daf8c7aa38 100644 --- a/src/plugins/remote_device_bridge/CMakeLists.txt +++ b/src/plugins/remote_device_bridge/CMakeLists.txt @@ -1,4 +1,9 @@ # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 +# The transports use POSIX sockets. +if(WIN32) + return() +endif() + add_subdirectory(session) From 7849930e734a1a4b2fc9dd924817ee252c92f427 Mon Sep 17 00:00:00 2001 From: Jonghyun Kim Date: Wed, 18 Nov 2026 15:28:09 -0800 Subject: [PATCH 8/8] feat(remote_device_bridge): transports frame by size only, so a version mismatch reaches the decoder (pr03) TcpTransport and WebSocketTransport cut frames with frame_payload_size. A frame from a peer on another protocol version is delivered and split_frame rejects it naming both versions, instead of the receiver seeing a bare Malformed. Co-Authored-By: Claude Opus 5.5 Signed-off-by: Jonghyun Kim --- .../session/inc/remote_plugin_session/transport.hpp | 4 +++- .../remote_device_bridge/session/tcp_transport.cpp | 2 +- .../session/websocket_transport.cpp | 2 +- .../remote_device_bridge/test_tcp_transport.cpp | 11 +++++++++++ .../remote_device_bridge/test_websocket_transport.cpp | 8 ++++++++ 5 files changed, 24 insertions(+), 3 deletions(-) diff --git a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp index 1b147427e4..fd8b4cf498 100644 --- a/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp +++ b/src/plugins/remote_device_bridge/session/inc/remote_plugin_session/transport.hpp @@ -30,7 +30,9 @@ enum class ReceiveResult * A frame is one complete wire message (protocol kHeaderSize header + payload) * as built by protocol::encode_frame. send() and receive() may run concurrently on two * threads; shutdown() unblocks both. Framing (TCP is a stream) lives in the - * implementation, not in the callers. + * implementation, not in the callers. Framing checks only magic and size + * (protocol::frame_payload_size): version and type are the decoder's, so a peer + * on another protocol version is reported by split_frame with a readable reason. */ class ITransport { diff --git a/src/plugins/remote_device_bridge/session/tcp_transport.cpp b/src/plugins/remote_device_bridge/session/tcp_transport.cpp index c86418fb9a..13772fb958 100644 --- a/src/plugins/remote_device_bridge/session/tcp_transport.cpp +++ b/src/plugins/remote_device_bridge/session/tcp_transport.cpp @@ -33,7 +33,7 @@ ReceiveResult TcpTransport::receive(std::vector& frame, std::chrono::mi uint32_t payload_size = 0; try { - payload_size = protocol::decode_header(frame).payload_size; + payload_size = protocol::frame_payload_size(frame); } catch (const protocol::DecodeError&) { diff --git a/src/plugins/remote_device_bridge/session/websocket_transport.cpp b/src/plugins/remote_device_bridge/session/websocket_transport.cpp index e88ec14b0f..50e860a3d3 100644 --- a/src/plugins/remote_device_bridge/session/websocket_transport.cpp +++ b/src/plugins/remote_device_bridge/session/websocket_transport.cpp @@ -427,7 +427,7 @@ ReceiveResult WebSocketTransport::receive(std::vector& frame, std::chro try { return frame.size() >= protocol::kHeaderSize && - frame.size() == protocol::kHeaderSize + protocol::decode_header(frame).payload_size ? + frame.size() == protocol::kHeaderSize + protocol::frame_payload_size(frame) ? ReceiveResult::Ok : ReceiveResult::Malformed; } diff --git a/tests/cpp/plugins/remote_device_bridge/test_tcp_transport.cpp b/tests/cpp/plugins/remote_device_bridge/test_tcp_transport.cpp index 58adea524b..d6c2a53b72 100644 --- a/tests/cpp/plugins/remote_device_bridge/test_tcp_transport.cpp +++ b/tests/cpp/plugins/remote_device_bridge/test_tcp_transport.cpp @@ -2,6 +2,7 @@ // SPDX-License-Identifier: Apache-2.0 #include +#include #include #include #include @@ -72,6 +73,16 @@ TEST_CASE("TcpTransport delimits frames by the header and reports broken peers", raw_send(peer, sent); REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Malformed); } + SECTION("a frame of another protocol version is delivered; the decoder names the version") + { + std::vector sent = frame_of_size(protocol::kHeaderSize + 8); + sent[protocol::kVersionOffset] = 0; + raw_send(peer, sent); + REQUIRE(transport.receive(frame, kWait) == ReceiveResult::Ok); + REQUIRE(frame == sent); + REQUIRE_THROWS_WITH( + protocol::split_frame(frame), Catch::Matchers::ContainsSubstring("peer speaks protocol version 0")); + } SECTION("a header whose payload never arrives counts as closed") { const std::vector sent = frame_of_size(protocol::kHeaderSize + 100); diff --git a/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp b/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp index 08f37da2ad..c8ddb3e225 100644 --- a/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp +++ b/tests/cpp/plugins/remote_device_bridge/test_websocket_transport.cpp @@ -214,6 +214,14 @@ TEST_CASE("WebSocketTransport server role handles control frames and fragments", raw_send(raw, raw_frame(0x2, true, { 0x01 })); REQUIRE(server->receive(frame, kWait) == ReceiveResult::Malformed); } + SECTION("a frame of another protocol version is delivered; the decoder names the version") + { + std::vector sent = frame_of_size(protocol::kHeaderSize + 8); + sent[protocol::kVersionOffset] = 0; + raw_send(raw, raw_frame(0x2, true, sent)); + REQUIRE(server->receive(frame, kWait) == ReceiveResult::Ok); + REQUIRE(frame == sent); + } SECTION("TCP EOF is reported as closed") { raw.shutdown();