From 217b8e5171e6303d841e9a333774857fcb803f97 Mon Sep 17 00:00:00 2001 From: Vaxry Date: Tue, 17 Nov 2026 23:26:46 +0100 Subject: [PATCH 1/4] wire: reject embedded NUL before C-string callbacks --- include/hyprwire/core/types/MessageMagic.hpp | 6 +- src/core/wireObject/IWireObject.cpp | 90 +++++++-- tests/unit/IWireObjectMatrix.cpp | 192 +++++++++++++++++++ 3 files changed, 272 insertions(+), 16 deletions(-) diff --git a/include/hyprwire/core/types/MessageMagic.hpp b/include/hyprwire/core/types/MessageMagic.hpp index 3555928..c5b3f71 100644 --- a/include/hyprwire/core/types/MessageMagic.hpp +++ b/include/hyprwire/core/types/MessageMagic.hpp @@ -27,6 +27,10 @@ namespace Hyprwire { /* [magic : 1B][len : VLQ][data : len B] + + VARCHAR protocol method arguments must be NUL-free, including array elements. + Empty strings are allowed. Callbacks receive NUL-terminated C strings; + the terminator is not part of the payload or its length. */ HW_MESSAGE_MAGIC_TYPE_VARCHAR = 0x20, @@ -56,4 +60,4 @@ namespace Hyprwire { */ HW_MESSAGE_MAGIC_TYPE_FD = 0x40, }; -}; \ No newline at end of file +}; diff --git a/src/core/wireObject/IWireObject.cpp b/src/core/wireObject/IWireObject.cpp index 264b831..a6d6e5e 100644 --- a/src/core/wireObject/IWireObject.cpp +++ b/src/core/wireObject/IWireObject.cpp @@ -12,6 +12,7 @@ #include #include +#include #include #include #include @@ -44,6 +45,29 @@ namespace { } } +static std::pair parseArgumentLength(const std::span& data) { + if (data.empty()) + return {0, 0}; + + // encodeVarInt emits at most four bytes. Bound the parser before checking termination. + const auto [length, bytes] = g_messageParser->parseVarInt(data.first(std::min(data.size(), size_t{4}))); + if (!bytes || (data[bytes - 1] & 0x80)) + return {0, 0}; + + return {length, bytes}; +} + +static size_t validatedStringLength(const std::span& data) { + const auto [length, bytes] = parseArgumentLength(data); + if (!bytes || length > data.size() - bytes) + return 0; + + if (std::ranges::contains(data.subspan(bytes, length), uint8_t{0})) + return 0; + + return bytes + length; +} + IWireObject::~IWireObject() = default; uint32_t IWireObject::call(uint32_t id, ...) { @@ -254,11 +278,6 @@ void IWireObject::called(uint32_t id, const std::span& data, cons const auto& method = METHODS.at(id); - if (m_listeners.size() <= id || m_listeners.at(id) == nullptr) { - destroyIfNeeded(this, method); - return; - } - std::vector params; if (!method.returnsType.empty()) @@ -276,6 +295,13 @@ void IWireObject::called(uint32_t id, const std::span& data, cons std::vector ffiTypes = {&ffi_type_pointer}; size_t dataI = 0; for (size_t i = 0; i < params.size(); ++i) { + if (dataI >= data.size()) { + const auto MSG = std::format("method {} param idx {} is truncated", id, i); + Debug::log(ERR, "core protocol error: {}", MSG); + error(m_id, MSG); + return; + } + const auto PARAM = sc(params.at(i)); const auto WIRE_PARAM = sc(data[dataI]); @@ -299,11 +325,25 @@ void IWireObject::called(uint32_t id, const std::span& data, cons case HW_MESSAGE_MAGIC_TYPE_OBJECT: case HW_MESSAGE_MAGIC_TYPE_SEQ: dataI += 5; break; case HW_MESSAGE_MAGIC_TYPE_VARCHAR: { - auto [a, b] = g_messageParser->parseVarInt(std::span{&data[dataI + 1], data.size() - dataI}); - dataI += a + b + 1; + const auto length = validatedStringLength(data.subspan(dataI + 1)); + if (!length) { + const auto MSG = std::format("method {} param idx {} is not a complete NUL-free VARCHAR", id, i); + Debug::log(ERR, "core protocol error: {}", MSG); + error(m_id, MSG); + return; + } + + dataI += length + 1; break; } case HW_MESSAGE_MAGIC_TYPE_ARRAY: { + if (data.size() - dataI < 3) { + const auto MSG = std::format("failed demarshaling array message"); + Debug::log(ERR, "core protocol error: {}", MSG); + error(m_id, MSG); + return; + } + const auto arrType = sc(params.at(++i)); const auto wireType = sc(data[dataI + 1]); @@ -315,8 +355,15 @@ void IWireObject::called(uint32_t id, const std::span& data, cons return; } - auto [arrLen, lenLen] = g_messageParser->parseVarInt(std::span{&data[dataI + 2], data.size() - i}); - size_t arrMessageLen = 2 + lenLen; + const auto [arrLen, lenLen] = parseArgumentLength(data.subspan(dataI + 2)); + if (!lenLen) { + const auto MSG = std::format("failed demarshaling array message"); + Debug::log(ERR, "core protocol error: {}", MSG); + error(m_id, MSG); + return; + } + + size_t arrMessageLen = 2 + lenLen; if (arrLen > 10000) { // raise protocol error @@ -339,14 +386,15 @@ void IWireObject::called(uint32_t id, const std::span& data, cons } case HW_MESSAGE_MAGIC_TYPE_VARCHAR: { for (size_t j = 0; j < arrLen; ++j) { - if (dataI + arrMessageLen > data.size()) { - const auto MSG = std::format("failed demarshaling array message"); + const auto length = validatedStringLength(data.subspan(dataI + arrMessageLen)); + if (!length) { + const auto MSG = std::format("method {} param idx {} array element {} is not a complete NUL-free VARCHAR", id, i, j); Debug::log(ERR, "core protocol error: {}", MSG); error(m_id, MSG); return; } - auto [strLen, strlenLen] = g_messageParser->parseVarInt(std::span{&data[dataI + arrMessageLen], data.size() - dataI - arrMessageLen}); - arrMessageLen += strLen + strlenLen; + + arrMessageLen += length; } break; } @@ -373,6 +421,18 @@ void IWireObject::called(uint32_t id, const std::span& data, cons } } + if (dataI >= data.size() || data[dataI] != HW_MESSAGE_MAGIC_END) { + const auto MSG = std::format("method {} has missing end marker or unexpected arguments", id); + Debug::log(ERR, "core protocol error: {}", MSG); + error(m_id, MSG); + return; + } + + if (m_listeners.size() <= id || m_listeners.at(id) == nullptr) { + destroyIfNeeded(this, method); + return; + } + ffi_cif cif; if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, ffiTypes.size(), &ffi_type_void, ffiTypes.data())) { Debug::log(ERR, "core protocol error: ffi failed"); @@ -449,7 +509,7 @@ void IWireObject::called(uint32_t id, const std::span& data, cons } case HW_MESSAGE_MAGIC_TYPE_ARRAY: { const auto arrType = sc(data[i + 1]); - auto [arrLen, lenLen] = g_messageParser->parseVarInt(std::span{&data[i + 2], data.size() - i}); + auto [arrLen, lenLen] = g_messageParser->parseVarInt(data.subspan(i + 2)); size_t arrMessageLen = 2 + lenLen; switch (arrType) { @@ -488,7 +548,7 @@ void IWireObject::called(uint32_t id, const std::span& data, cons otherBuffers.emplace_back(dataPtr); for (size_t j = 0; j < arrLen; ++j) { - auto [strLen, strlenLen] = g_messageParser->parseVarInt(std::span{&data[i + arrMessageLen], data.size() - i}); + auto [strLen, strlenLen] = g_messageParser->parseVarInt(data.subspan(i + arrMessageLen)); auto& str = strings.emplace_back(makeShared(std::string_view{rc(&data[i + arrMessageLen + strlenLen]), strLen})); dataPtr[j] = str->c_str(); arrMessageLen += strlenLen + strLen; diff --git a/tests/unit/IWireObjectMatrix.cpp b/tests/unit/IWireObjectMatrix.cpp index e14ae21..e61ba98 100644 --- a/tests/unit/IWireObjectMatrix.cpp +++ b/tests/unit/IWireObjectMatrix.cpp @@ -10,7 +10,9 @@ #include #include #include +#include #include +#include using namespace Hyprwire; @@ -101,6 +103,44 @@ namespace { ++g_destructorListenerCalls; } + struct SStringListenerState { + size_t calls = 0; + std::vector values; + }; + + void onString(IObject* object, const char* value) { + auto* state = static_cast(object->getData()); + ++state->calls; + state->values = {value}; + } + + void onStringArray(IObject* object, const char** values, uint32_t count) { + auto* state = static_cast(object->getData()); + ++state->calls; + state->values.clear(); + for (size_t i = 0; i < count; ++i) + state->values.emplace_back(values[i]); + } + + std::vector makeStringArguments(bool array, const std::vector& values) { + CMessageParser parser; + std::vector data; + if (array) { + data = {HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR}; + data.append_range(parser.encodeVarInt(values.size())); + } + + for (const auto& value : values) { + if (!array) + data.emplace_back(HW_MESSAGE_MAGIC_TYPE_VARCHAR); + data.append_range(parser.encodeVarInt(value.size())); + data.append_range(value); + } + + data.emplace_back(HW_MESSAGE_MAGIC_END); + return data; + } + } // namespace TEST(IWireObjectMatrix, CallRejectsInvalidMethodIndex) { @@ -288,3 +328,155 @@ TEST(IWireObjectMatrix, CalledMarksDestroyedForDestructorWithListener) { EXPECT_EQ(g_destructorListenerCalls, 1); EXPECT_TRUE(obj->m_destroyed); } + +TEST(IWireObjectMatrix, CalledRejectsEmbeddedNulStringsBeforeCallbackOrDestruction) { + const std::vector invalidStrings = { + std::string{"\0abc", 4}, + std::string{"a\0bc", 4}, + std::string{"abc\0", 4}, + }; + + for (const bool array : {false, true}) { + for (const bool withListener : {false, true}) { + for (const auto& value : invalidStrings) { + // Also reject a bad array element after a valid one. + for (size_t validPrefix = 0; validPrefix <= static_cast(array); ++validPrefix) { + SCOPED_TRACE(::testing::Message() << "array=" << array << " listener=" << withListener << " prefix=" << validPrefix + << " value=" << ::testing::PrintToString(value)); + SStringListenerState state; + auto obj = makeObject(); + obj->setData(&state); + obj->m_methodsIn = { + SMethod{.idx = 0, + .params = + array ? std::vector{HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR} : std::vector{HW_MESSAGE_MAGIC_TYPE_VARCHAR}, + .isDestructor = true}, + }; + if (withListener) + obj->listen(0, array ? fnToVoid(&onStringArray) : fnToVoid(&onString)); + + std::vector values(validPrefix, "valid"); + values.emplace_back(value); + const auto data = makeStringArguments(array, values); + obj->called(0, data, {}); + + EXPECT_NE(obj->m_lastErrorMsg.find("NUL-free VARCHAR"), std::string::npos); + EXPECT_EQ(state.calls, 0u); + EXPECT_FALSE(obj->m_destroyed); + } + } + } + } +} + +TEST(IWireObjectMatrix, CalledAcceptsEmptyAndNormalStrings) { + for (const bool withListener : {false, true}) { + for (const auto& value : {std::string{}, std::string{"hello"}, std::string(128, 'x')}) { + SCOPED_TRACE(::testing::Message() << "listener=" << withListener << " length=" << value.size()); + SStringListenerState state; + auto obj = makeObject(); + obj->setData(&state); + obj->m_methodsIn = { + SMethod{.idx = 0, .params = {HW_MESSAGE_MAGIC_TYPE_VARCHAR}, .isDestructor = true}, + }; + if (withListener) + obj->listen(0, fnToVoid(&onString)); + + const auto data = makeStringArguments(false, {value}); + obj->called(0, data, {}); + + EXPECT_TRUE(obj->m_lastErrorMsg.empty()); + EXPECT_EQ(state.calls, withListener ? 1u : 0u); + if (withListener) { + EXPECT_EQ(state.values, std::vector{value}); + } + EXPECT_TRUE(obj->m_destroyed); + } + } +} + +TEST(IWireObjectMatrix, CalledAcceptsEmptyAndNormalStringArrays) { + const std::vector> cases = { + {}, + {""}, + {"hello"}, + {"", "hello", "", std::string(128, 'x')}, + }; + + for (const bool withListener : {false, true}) { + for (const auto& values : cases) { + SCOPED_TRACE(::testing::Message() << "listener=" << withListener << " values=" << ::testing::PrintToString(values)); + SStringListenerState state; + auto obj = makeObject(); + obj->setData(&state); + obj->m_methodsIn = { + SMethod{.idx = 0, .params = {HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR}, .isDestructor = true}, + }; + if (withListener) + obj->listen(0, fnToVoid(&onStringArray)); + + const auto data = makeStringArguments(true, values); + obj->called(0, data, {}); + + EXPECT_TRUE(obj->m_lastErrorMsg.empty()); + EXPECT_EQ(state.calls, withListener ? 1u : 0u); + if (withListener) { + EXPECT_EQ(state.values, values); + } + EXPECT_TRUE(obj->m_destroyed); + } + } +} + +TEST(IWireObjectMatrix, CalledRejectsMalformedStringArgumentsBeforeCallbackOrDestruction) { + struct SCase { + bool array = false; + std::vector data; + }; + + const std::vector cases = { + {false, {}}, + {false, {HW_MESSAGE_MAGIC_TYPE_VARCHAR}}, + {false, {HW_MESSAGE_MAGIC_TYPE_VARCHAR, 0x80}}, + {false, {HW_MESSAGE_MAGIC_TYPE_VARCHAR, 0x80, 0x80, 0x80, 0x80, 0}}, + {false, {HW_MESSAGE_MAGIC_TYPE_VARCHAR, 3, 'a', 'b'}}, + {false, {HW_MESSAGE_MAGIC_TYPE_VARCHAR, 0}}, + {false, {HW_MESSAGE_MAGIC_TYPE_VARCHAR, 1, 'a'}}, + {false, {HW_MESSAGE_MAGIC_TYPE_VARCHAR, 0, HW_MESSAGE_MAGIC_TYPE_VARCHAR, 1, 0, HW_MESSAGE_MAGIC_END}}, + {true, {HW_MESSAGE_MAGIC_TYPE_ARRAY}}, + {true, {HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR}}, + {true, {HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR, 0x80}}, + {true, {HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR, 0x80, 0x80, 0x80, 0x80, 0}}, + {true, {HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR, 1}}, + {true, {HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR, 1, 0x80}}, + {true, {HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR, 1, 0x80, 0x80, 0x80, 0x80, 0}}, + {true, {HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR, 1, 2, 'a'}}, + {true, {HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR, 2, 1, 'a'}}, + {true, {HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR, 2, 1, 'a', 0x80}}, + {true, {HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR, 2, 1, 'a', 2, 'b'}}, + {true, {HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR, 0}}, + {true, {HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR, 1, 1, 'a'}}, + }; + + for (const bool withListener : {false, true}) { + for (const auto& [array, data] : cases) { + SCOPED_TRACE(::testing::Message() << "listener=" << withListener << " data=" << ::testing::PrintToString(data)); + SStringListenerState state; + auto obj = makeObject(); + obj->setData(&state); + obj->m_methodsIn = { + SMethod{.idx = 0, + .params = array ? std::vector{HW_MESSAGE_MAGIC_TYPE_ARRAY, HW_MESSAGE_MAGIC_TYPE_VARCHAR} : std::vector{HW_MESSAGE_MAGIC_TYPE_VARCHAR}, + .isDestructor = true}, + }; + if (withListener) + obj->listen(0, array ? fnToVoid(&onStringArray) : fnToVoid(&onString)); + + obj->called(0, data, {}); + + EXPECT_FALSE(obj->m_lastErrorMsg.empty()); + EXPECT_EQ(state.calls, 0u); + EXPECT_FALSE(obj->m_destroyed); + } + } +} From e27c5f6ba26c530313d08af00726c893ec403ed3 Mon Sep 17 00:00:00 2001 From: Vaxry Date: Tue, 17 Nov 2026 23:26:46 +0100 Subject: [PATCH 2/4] server: expose captured peer credentials --- include/hyprwire/core/ServerSocket.hpp | 18 ++++++- src/core/server/ServerClient.cpp | 50 ++++++++++-------- src/core/server/ServerClient.hpp | 44 +++++++++------- tests/unit/PeerCredentials.cpp | 72 ++++++++++++++++++++++++++ 4 files changed, 141 insertions(+), 43 deletions(-) create mode 100644 tests/unit/PeerCredentials.cpp diff --git a/include/hyprwire/core/ServerSocket.hpp b/include/hyprwire/core/ServerSocket.hpp index 5d7ee17..f920552 100644 --- a/include/hyprwire/core/ServerSocket.hpp +++ b/include/hyprwire/core/ServerSocket.hpp @@ -2,18 +2,34 @@ #include #include +#include #include +#include namespace Hyprwire { class IProtocolServerImplementation; class IObject; + struct SPeerCredentials { + pid_t pid = -1; + uid_t uid = static_cast(-1); + gid_t gid = static_cast(-1); + }; + class IServerClient { public: virtual ~IServerClient(); virtual int getPID() = 0; + /* + Socket peer credentials captured when the client is added, before the + new-client handler or handshake. Empty if they could not be obtained. + These remain a snapshot, not the current credentials of a process or + an attestation of the original sender behind a forwarded socket. + */ + virtual std::optional getPeerCredentials() const = 0; + /* Set a protocol filter. If the function returns false, the protocol will not be exposed in the handshake, and will not @@ -75,4 +91,4 @@ namespace Hyprwire { protected: IServerSocket() = default; }; -}; \ No newline at end of file +}; diff --git a/src/core/server/ServerClient.cpp b/src/core/server/ServerClient.cpp index 219a51c..eb5cc28 100644 --- a/src/core/server/ServerClient.cpp +++ b/src/core/server/ServerClient.cpp @@ -11,7 +11,6 @@ #include #include -#include #include #include @@ -27,6 +26,7 @@ using namespace Hyprwire; CServerClient::CServerClient(int fd) : m_fd(fd) { m_fd.setFlags(O_CLOEXEC); + readPeerCredentials(); } CServerClient::~CServerClient() { @@ -41,44 +41,46 @@ void CServerClient::dispatchFirstPoll() { if (m_firstPollDone) return; - auto x = Hyprutils::Utils::CScopeGuard([this] { - if (!m_server) { - TRACE(Debug::log(TRACE, "[{}] dispatchFirstPoll: no server?", m_fd.get())); - return; - } - - if (m_server->m_newClientHandler) - m_server->m_newClientHandler(m_self.lock()); + m_firstPollDone = true; - setupExposedProtocols(); - }); + if (!m_server) { + TRACE(Debug::log(TRACE, "[{}] dispatchFirstPoll: no server?", m_fd.get())); + return; + } - m_firstPollDone = true; + if (m_server->m_newClientHandler) + m_server->m_newClientHandler(m_self.lock()); - // get peer's pid + setupExposedProtocols(); +} +void CServerClient::readPeerCredentials() { #if defined(__FreeBSD__) - struct xucred cred; + struct xucred cred = {}; #elif defined(__OpenBSD__) - struct sockpeercred cred; + struct sockpeercred cred = {}; #else - ucred cred; + ucred cred = {}; #endif socklen_t len = sizeof(cred); #if defined(__FreeBSD__) - if (getsockopt(m_fd.get(), SOL_SOCKET, LOCAL_PEERCRED, &cred, &len) == -1) { + const auto RESULT = getsockopt(m_fd.get(), SOL_LOCAL, LOCAL_PEERCRED, &cred, &len); #else - if (getsockopt(m_fd.get(), SOL_SOCKET, SO_PEERCRED, &cred, &len) == -1) { + const auto RESULT = getsockopt(m_fd.get(), SOL_SOCKET, SO_PEERCRED, &cred, &len); #endif - TRACE(Debug::log(TRACE, "dispatchFirstPoll: failed to get pid")); + if (RESULT == -1 || len != sizeof(cred)) { + TRACE(Debug::log(TRACE, "[{}] failed to get peer credentials", m_fd.get())); return; } #if defined(__FreeBSD__) - m_pid = cred.cr_pid; + if (cred.cr_version != XUCRED_VERSION || cred.cr_ngroups < 1) + return; + + m_peerCredentials = SPeerCredentials{.pid = cred.cr_pid, .uid = cred.cr_uid, .gid = cred.cr_groups[0]}; #else - m_pid = cred.pid; + m_peerCredentials = SPeerCredentials{.pid = cred.pid, .uid = cred.uid, .gid = cred.gid}; #endif } @@ -233,7 +235,11 @@ void CServerClient::onGeneric(const CGenericProtocolMessage& msg) { } int CServerClient::getPID() { - return m_pid; + return m_peerCredentials ? m_peerCredentials->pid : -1; +} + +std::optional CServerClient::getPeerCredentials() const { + return m_peerCredentials; } void CServerClient::setProtocolFilter(std::function&& fn) { diff --git a/src/core/server/ServerClient.hpp b/src/core/server/ServerClient.hpp index 322df7f..6ef9522 100644 --- a/src/core/server/ServerClient.hpp +++ b/src/core/server/ServerClient.hpp @@ -17,33 +17,37 @@ namespace Hyprwire { CServerClient(int fd); virtual ~CServerClient(); - virtual int getPID() override; - virtual void setProtocolFilter(std::function&& fn) override; + virtual int getPID() override; + virtual std::optional getPeerCredentials() const override; + virtual void setProtocolFilter(std::function&& fn) override; - void sendMessage(const IMessage& message); - SP createObject(const std::string& protocol, const std::string& object, uint32_t version, uint32_t seq); - void destroyObject(uint32_t id); - void onBind(SP obj); - void onGeneric(const CGenericProtocolMessage& msg); - void dispatchFirstPoll(); - void setupExposedProtocols(); + void sendMessage(const IMessage& message); + SP createObject(const std::string& protocol, const std::string& object, uint32_t version, uint32_t seq); + void destroyObject(uint32_t id); + void onBind(SP obj); + void onGeneric(const CGenericProtocolMessage& msg); + void dispatchFirstPoll(); + void setupExposedProtocols(); - Hyprutils::OS::CFileDescriptor m_fd; + Hyprutils::OS::CFileDescriptor m_fd; - int m_pid = -1; - bool m_firstPollDone = false; + bool m_firstPollDone = false; - uint32_t m_version = 0, m_maxId = 1; - bool m_error = false; + uint32_t m_version = 0, m_maxId = 1; + bool m_error = false; - uint32_t m_scheduledRoundtripSeq = 0; + uint32_t m_scheduledRoundtripSeq = 0; - std::vector> m_objects; + std::vector> m_objects; - WP m_server; - WP m_self; + WP m_server; + WP m_self; - std::function m_protocolFilter; - std::vector m_exposedProtocols; + std::function m_protocolFilter; + std::vector m_exposedProtocols; + + private: + void readPeerCredentials(); + std::optional m_peerCredentials; }; }; diff --git a/tests/unit/PeerCredentials.cpp b/tests/unit/PeerCredentials.cpp new file mode 100644 index 0000000..375ef3c --- /dev/null +++ b/tests/unit/PeerCredentials.cpp @@ -0,0 +1,72 @@ +#include + +#include +#include + +#include "core/server/ServerClient.hpp" + +#include +#include + +using namespace Hyprwire; +using namespace Hyprutils::OS; + +TEST(PeerCredentials, CapturedBeforeHandshakeAndNewClientHandler) { + int fds[2] = {-1, -1}; + ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0); + CFileDescriptor serverFD{fds[0]}, peerFD{fds[1]}; + + auto server = IServerSocket::open(); + ASSERT_NE(server, nullptr); + + bool notified = false; + server->setNewClientHandler([&](auto client) { + const auto CREDENTIALS = client->getPeerCredentials(); + ASSERT_TRUE(CREDENTIALS.has_value()); + EXPECT_EQ(CREDENTIALS->pid, getpid()); + EXPECT_EQ(CREDENTIALS->uid, geteuid()); + EXPECT_EQ(CREDENTIALS->gid, getegid()); + notified = true; + }); + + auto client = server->addClient(serverFD.take()); + ASSERT_NE(client, nullptr); + const auto CREDENTIALS = client->getPeerCredentials(); + ASSERT_TRUE(CREDENTIALS.has_value()); + EXPECT_EQ(CREDENTIALS->pid, getpid()); + EXPECT_EQ(CREDENTIALS->uid, geteuid()); + EXPECT_EQ(CREDENTIALS->gid, getegid()); + EXPECT_EQ(client->getPID(), CREDENTIALS->pid); + EXPECT_FALSE(notified); + + auto peer = IClientSocket::open(peerFD.take()); + ASSERT_NE(peer, nullptr); + ASSERT_TRUE(server->dispatchEvents(false)); + EXPECT_TRUE(notified); +} + +TEST(PeerCredentials, SnapshotSurvivesDescriptorClosure) { + int fds[2] = {-1, -1}; + ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0); + CFileDescriptor peerFD{fds[1]}; + CServerClient client{fds[0]}; + + client.m_fd.reset(); + + const auto CREDENTIALS = client.getPeerCredentials(); + ASSERT_TRUE(CREDENTIALS.has_value()); + EXPECT_EQ(CREDENTIALS->pid, getpid()); + EXPECT_EQ(CREDENTIALS->uid, geteuid()); + EXPECT_EQ(CREDENTIALS->gid, getegid()); + EXPECT_EQ(client.getPID(), CREDENTIALS->pid); +} + +TEST(PeerCredentials, MissingCredentialsRemainUnknown) { + int fds[2] = {-1, -1}; + ASSERT_EQ(pipe(fds), 0); + CFileDescriptor writer{fds[1]}; + CServerClient client{fds[0]}; + + EXPECT_FALSE(client.getPeerCredentials().has_value()); + EXPECT_EQ(client.getPID(), -1); +} From 9d73127f14fb9c31eabf075bd52fd3d28f48aac5 Mon Sep 17 00:00:00 2001 From: Vaxry Date: Tue, 17 Nov 2026 23:50:36 +0100 Subject: [PATCH 3/4] server: notify client disconnection after teardown --- include/hyprwire/core/ServerSocket.hpp | 9 ++ src/core/server/ServerClient.cpp | 38 ++++- src/core/server/ServerClient.hpp | 5 + src/core/server/ServerObject.cpp | 12 +- src/core/server/ServerSocket.cpp | 86 +++++++--- src/core/server/ServerSocket.hpp | 1 + tests/unit/ServerClientLifecycle.cpp | 214 +++++++++++++++++++++++++ 7 files changed, 332 insertions(+), 33 deletions(-) create mode 100644 tests/unit/ServerClientLifecycle.cpp diff --git a/include/hyprwire/core/ServerSocket.hpp b/include/hyprwire/core/ServerSocket.hpp index f920552..503f771 100644 --- a/include/hyprwire/core/ServerSocket.hpp +++ b/include/hyprwire/core/ServerSocket.hpp @@ -37,6 +37,15 @@ namespace Hyprwire { */ virtual void setProtocolFilter(std::function&& fn) = 0; + /* + Called once after the socket is closed and wire objects are torn down, + even if the application retains this client. Runs during dispatch, + explicit removal, or server destruction, not on the polling thread. + Replaces the previous handler; an empty handler clears it. Installing + a handler on an already disconnected client calls it immediately. + */ + virtual void setDisconnectHandler(std::function&& fn) = 0; + protected: IServerClient() = default; }; diff --git a/src/core/server/ServerClient.cpp b/src/core/server/ServerClient.cpp index eb5cc28..b134128 100644 --- a/src/core/server/ServerClient.cpp +++ b/src/core/server/ServerClient.cpp @@ -16,6 +16,7 @@ #include #include +#include #if defined(__FreeBSD__) #include @@ -31,10 +32,29 @@ CServerClient::CServerClient(int fd) : m_fd(fd) { CServerClient::~CServerClient() { TRACE(Debug::log(TRACE, "[{}] destroying client", m_fd.get())); + disconnect(); +} - for (const auto& o : m_objects) { +void CServerClient::disconnect() { + if (m_disconnecting || m_disconnected) + return; + + m_disconnecting = true; + m_error = true; + m_fd.reset(); + + auto objects = std::exchange(m_objects, {}); + + for (const auto& o : objects) { + o->m_destroyed = true; o->sendDestroyIfNeeded(); } + + m_disconnected = true; + m_disconnecting = false; + auto handler = std::exchange(m_disconnectHandler, {}); + if (handler) + handler(); } void CServerClient::dispatchFirstPoll() { @@ -51,6 +71,9 @@ void CServerClient::dispatchFirstPoll() { if (m_server->m_newClientHandler) m_server->m_newClientHandler(m_self.lock()); + if (m_error) + return; + setupExposedProtocols(); } @@ -131,6 +154,9 @@ void CServerClient::sendMessage(const IMessage& message) { } SP CServerClient::createObject(const std::string& protocol, const std::string& object, uint32_t version, uint32_t seq) { + if (m_error || !m_server) + return nullptr; + auto obj = makeShared(m_self.lock()); obj->m_id = m_maxId++; obj->m_self = obj; @@ -246,6 +272,16 @@ void CServerClient::setProtocolFilter(std::function&& fn m_protocolFilter = std::move(fn); } +void CServerClient::setDisconnectHandler(std::function&& fn) { + if (m_disconnected) { + if (fn) + fn(); + return; + } + + m_disconnectHandler = std::move(fn); +} + void CServerClient::setupExposedProtocols() { for (const auto& i : m_server->m_impls) { const auto NAME = i->protocol()->specName(); diff --git a/src/core/server/ServerClient.hpp b/src/core/server/ServerClient.hpp index 6ef9522..4f5e200 100644 --- a/src/core/server/ServerClient.hpp +++ b/src/core/server/ServerClient.hpp @@ -20,7 +20,9 @@ namespace Hyprwire { virtual int getPID() override; virtual std::optional getPeerCredentials() const override; virtual void setProtocolFilter(std::function&& fn) override; + virtual void setDisconnectHandler(std::function&& fn) override; + void disconnect(); void sendMessage(const IMessage& message); SP createObject(const std::string& protocol, const std::string& object, uint32_t version, uint32_t seq); void destroyObject(uint32_t id); @@ -49,5 +51,8 @@ namespace Hyprwire { private: void readPeerCredentials(); std::optional m_peerCredentials; + std::function m_disconnectHandler; + bool m_disconnecting = false; + bool m_disconnected = false; }; }; diff --git a/src/core/server/ServerObject.cpp b/src/core/server/ServerObject.cpp index e167a78..26a3dd7 100644 --- a/src/core/server/ServerObject.cpp +++ b/src/core/server/ServerObject.cpp @@ -12,6 +12,7 @@ #include #include #include +#include #include using namespace Hyprwire; @@ -21,7 +22,7 @@ CServerObject::CServerObject(SP client) : m_client(client) { } CServerObject::~CServerObject() { - TRACE(Debug::log(TRACE, "[{}] destroying object {}", m_client->m_fd.get(), m_id)); + TRACE(Debug::log(TRACE, "[{}] destroying object {}", m_client ? m_client->m_fd.get() : -1, m_id)); } const std::vector& CServerObject::methodsOut() { @@ -70,11 +71,8 @@ void CServerObject::sendDestroyIfNeeded() { if (!m_onDestroy) return; - TRACE(Debug::log(TRACE, "[{}] object {}: calling onDestroy from sendDestroyIfNeeded", m_client->m_fd.get(), m_id)); + TRACE(Debug::log(TRACE, "[{}] object {}: calling onDestroy from sendDestroyIfNeeded", m_client ? m_client->m_fd.get() : -1, m_id)); - m_onDestroy(); - - // remove onDestroy: this object is already dead, - // and we don't want to call it twice - m_onDestroy = nullptr; + auto handler = std::exchange(m_onDestroy, {}); + handler(); } diff --git a/src/core/server/ServerSocket.cpp b/src/core/server/ServerSocket.cpp index faf0b24..4f489d7 100644 --- a/src/core/server/ServerSocket.cpp +++ b/src/core/server/ServerSocket.cpp @@ -17,7 +17,9 @@ #include #include +#include #include +#include #include using namespace Hyprwire; @@ -59,6 +61,8 @@ CServerSocket::CServerSocket() { } CServerSocket::~CServerSocket() { + m_destroying = true; + if (m_pollThread.joinable()) { m_threadCanPoll = false; m_pollEvent = false; @@ -69,6 +73,11 @@ CServerSocket::~CServerSocket() { m_fd.reset(); + auto clients = std::exchange(m_clients, {}); + for (const auto& client : clients) { + client->disconnect(); + } + if (!m_path.empty()) { std::error_code ec; std::filesystem::remove(m_path, ec); @@ -151,6 +160,7 @@ bool CServerSocket::dispatchPending() { } bool CServerSocket::dispatchEvents(bool block) { + const auto SELF = m_self.lock(); m_pollmtx.lock(); @@ -207,6 +217,11 @@ void CServerSocket::clearWakeupFd() { } SP CServerSocket::createClient(int fd) { + if (m_destroying) { + CFileDescriptor closed{fd}; + return nullptr; + } + auto x = makeShared(fd); if (x->m_fd.isClosed() || !x->m_fd.isValid()) return nullptr; @@ -219,7 +234,8 @@ SP CServerSocket::createClient(int fd) { } SP CServerSocket::addClient(int fd) { - auto x = createClient(fd); + std::lock_guard lock(m_pollmtx); + auto x = createClient(fd); recheckPollFds(); @@ -230,12 +246,18 @@ SP CServerSocket::addClient(int fd) { } bool CServerSocket::removeClient(int fd) { - auto r = std::erase_if(m_clients, [&fd](const auto& c) { return c->m_fd.get() == fd; }); + const auto SELF = m_self.lock(); + std::lock_guard lock(m_pollmtx); + const auto it = std::ranges::find_if(m_clients, [fd](const auto& client) { return client->m_fd.get() == fd; }); + if (it == m_clients.end()) + return false; - if (r > 0) - recheckPollFds(); + auto client = *it; + m_clients.erase(it); + recheckPollFds(); + client->disconnect(); - return r > 0; + return true; } size_t CServerSocket::internalFds() { @@ -295,36 +317,48 @@ bool CServerSocket::dispatchNewConnections() { } bool CServerSocket::dispatchExistingConnections() { - bool hadAny = false; - bool needsPollRecheck = false; + struct SReadyClient { + SP client; + short events = 0; + }; - for (size_t i = internalFds(); i < m_pollfds.size(); ++i) { - if (!(m_pollfds.at(i).revents & POLLIN)) - continue; + std::vector ready; + bool needsPollRecheck = false; - dispatchClient(m_clients.at(i - internalFds())); + // Request handlers may add or remove clients, invalidating the live poll list. + for (size_t i = internalFds(); i < m_pollfds.size(); ++i) { + const auto& client = m_clients.at(i - internalFds()); + const auto events = m_pollfds.at(i).revents; + if (client->m_error || (events & (POLLIN | POLLHUP | POLLERR | POLLNVAL))) + ready.push_back({client, events}); + } - hadAny = true; + for (const auto& [client, events] : ready) { + if (!client->m_error && (events & POLLIN)) + dispatchClient(client); - if (m_pollfds.at(i).revents & POLLHUP) { - m_clients.at(i - internalFds())->m_error = true; - needsPollRecheck = true; - TRACE(Debug::log(TRACE, "[{} @ {:.3f}] Dropping client (hangup)", m_clients.at(i - internalFds())->m_fd.get(), steadyMillis())); - continue; - } + if (events & (POLLHUP | POLLERR | POLLNVAL)) + client->m_error = true; - if (m_clients.at(i - internalFds())->m_error) { - needsPollRecheck = true; - TRACE(Debug::log(TRACE, "[{} @ {:.3f}] Dropping client (protocol error)", m_clients.at(i - internalFds())->m_fd.get(), steadyMillis())); - } + needsPollRecheck |= client->m_error; } if (needsPollRecheck) { - std::erase_if(m_clients, [](const auto& c) { return c->m_error; }); + std::vector> disconnected; + std::erase_if(m_clients, [&](const auto& client) { + if (!client->m_error) + return false; + disconnected.emplace_back(client); + return true; + }); recheckPollFds(); + + for (const auto& client : disconnected) { + client->disconnect(); + } } - return hadAny; + return !ready.empty(); } void CServerSocket::dispatchClient(SP client) { @@ -336,8 +370,10 @@ void CServerSocket::dispatchClient(SP client) { return; } - if (data.data.empty()) // this should NOT happen + if (data.data.empty()) { + client->m_error = true; return; + } const auto RET = g_messageParser->handleMessage(data, client); diff --git a/src/core/server/ServerSocket.hpp b/src/core/server/ServerSocket.hpp index acec196..4e9aa80 100644 --- a/src/core/server/ServerSocket.hpp +++ b/src/core/server/ServerSocket.hpp @@ -65,5 +65,6 @@ namespace Hyprwire { private: SP createClient(int fd); + bool m_destroying = false; }; }; diff --git a/tests/unit/ServerClientLifecycle.cpp b/tests/unit/ServerClientLifecycle.cpp new file mode 100644 index 0000000..ba3b27a --- /dev/null +++ b/tests/unit/ServerClientLifecycle.cpp @@ -0,0 +1,214 @@ +#include + +#include +#include + +#include "core/server/ServerClient.hpp" +#include "core/server/ServerObject.hpp" +#include "core/server/ServerSocket.hpp" + +#include +#include + +using namespace Hyprwire; +using namespace Hyprutils::Memory; +using namespace Hyprutils::OS; + +class CServerClientLifecycleTest : public testing::Test { + protected: + void SetUp() override { + int fds[2] = {-1, -1}; + ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0); + CFileDescriptor serverFD{fds[0]}; + m_peer = CFileDescriptor{fds[1]}; + m_serverFD = serverFD.get(); + + m_server = IServerSocket::open(); + ASSERT_NE(m_server, nullptr); + m_client = m_server->addClient(serverFD.take()); + ASSERT_NE(m_client, nullptr); + m_client->setDisconnectHandler([this] { + ++m_disconnections; + EXPECT_FALSE(reinterpretPointerCast(m_client)->m_fd.isValid()); + m_events.emplace_back("client"); + }); + } + + void TearDown() override { + m_server.reset(); + m_client.reset(); + } + + void pollFailure(short events) { + auto server = reinterpretPointerCast(m_server); + server->m_pollfds.at(server->internalFds()).revents = events; + EXPECT_TRUE(server->dispatchExistingConnections()); + EXPECT_EQ(m_disconnections, 1); + EXPECT_TRUE(server->m_clients.empty()); + } + + int m_serverFD = -1; + int m_disconnections = 0; + std::vector m_events; + CFileDescriptor m_peer; + CSharedPointer m_server; + CSharedPointer m_client; +}; + +TEST_F(CServerClientLifecycleTest, ExplicitRemovalClosesRetainedClientExactlyOnce) { + ASSERT_TRUE(m_server->removeClient(m_serverFD)); + EXPECT_EQ(m_disconnections, 1); + EXPECT_EQ(m_client->getPID(), getpid()); + + char byte = 0; + EXPECT_EQ(recv(m_peer.get(), &byte, 1, MSG_DONTWAIT), 0); + EXPECT_FALSE(m_server->removeClient(m_serverFD)); + EXPECT_TRUE(m_server->dispatchEvents(false)); + m_client.reset(); + m_server.reset(); + EXPECT_EQ(m_disconnections, 1); +} + +TEST_F(CServerClientLifecycleTest, PeerClosureNotifiesWithoutDroppingClientReference) { + m_peer.reset(); + ASSERT_TRUE(m_server->dispatchEvents(false)); + EXPECT_EQ(m_disconnections, 1); + ASSERT_TRUE(m_server->dispatchEvents(false)); + EXPECT_EQ(m_disconnections, 1); +} + +TEST_F(CServerClientLifecycleTest, PeerWriteShutdownNotifiesOnEof) { + ASSERT_EQ(shutdown(m_peer.get(), SHUT_WR), 0); + ASSERT_TRUE(m_server->dispatchEvents(false)); + EXPECT_EQ(m_disconnections, 1); +} + +TEST_F(CServerClientLifecycleTest, MalformedMessageNotifiesExactlyOnce) { + const uint8_t bytes[] = {0xFF, 0}; + ASSERT_EQ(write(m_peer.get(), bytes, sizeof(bytes)), sc(sizeof(bytes))); + ASSERT_TRUE(m_server->dispatchEvents(false)); + EXPECT_EQ(m_disconnections, 1); + ASSERT_TRUE(m_server->dispatchEvents(false)); + EXPECT_EQ(m_disconnections, 1); +} + +TEST_F(CServerClientLifecycleTest, HangupWithoutReadableDataNotifies) { + pollFailure(POLLHUP); +} + +TEST_F(CServerClientLifecycleTest, PollErrorNotifies) { + pollFailure(POLLERR); +} + +TEST_F(CServerClientLifecycleTest, InvalidDescriptorNotifies) { + pollFailure(POLLNVAL); +} + +TEST_F(CServerClientLifecycleTest, ServerDestructionNotifiesRetainedClient) { + m_server.reset(); + EXPECT_EQ(m_disconnections, 1); + m_client.reset(); + EXPECT_EQ(m_disconnections, 1); +} + +TEST_F(CServerClientLifecycleTest, WireObjectsAreTornDownBeforeNotification) { + auto client = reinterpretPointerCast(m_client); + auto object = makeShared(client); + object->m_self = object; + client->m_objects.emplace_back(object); + object->setOnDestroy([this] { + m_events.emplace_back("object"); + EXPECT_FALSE(m_server->removeClient(m_serverFD)); + }); + + ASSERT_TRUE(m_server->removeClient(m_serverFD)); + EXPECT_EQ(m_events, (std::vector{"object", "client"})); + EXPECT_TRUE(object->m_destroyed); + object.reset(); + EXPECT_EQ(m_events.size(), 2u); +} + +TEST_F(CServerClientLifecycleTest, DisconnectHandlerCanRemoveAnotherClient) { + int fds[2] = {-1, -1}; + ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0); + CFileDescriptor serverFD{fds[0]}, peer{fds[1]}; + auto other = m_server->addClient(serverFD.take()); + ASSERT_NE(other, nullptr); + other->setDisconnectHandler([this] { m_events.emplace_back("other"); }); + m_client->setDisconnectHandler([this, fd = fds[0]] { + m_events.emplace_back("first"); + EXPECT_TRUE(m_server->removeClient(fd)); + EXPECT_FALSE(m_server->removeClient(m_serverFD)); + }); + + m_peer.reset(); + ASSERT_TRUE(m_server->dispatchEvents(false)); + EXPECT_EQ(m_events, (std::vector{"first", "other"})); +} + +TEST_F(CServerClientLifecycleTest, NewClientHandlerCanRejectTheClient) { + m_server->setNewClientHandler([this](auto) { EXPECT_TRUE(m_server->removeClient(m_serverFD)); }); + auto peer = IClientSocket::open(m_peer.take()); + ASSERT_NE(peer, nullptr); + + ASSERT_TRUE(m_server->dispatchEvents(false)); + EXPECT_EQ(m_disconnections, 1); + EXPECT_FALSE(peer->dispatchEvents(false)); +} + +TEST_F(CServerClientLifecycleTest, LateHandlerIsInvokedImmediately) { + ASSERT_TRUE(m_server->removeClient(m_serverFD)); + EXPECT_EQ(m_disconnections, 1); + m_client->setDisconnectHandler([this] { m_events.emplace_back("late"); }); + EXPECT_EQ(m_events, (std::vector{"client", "late"})); + m_client.reset(); + EXPECT_EQ(m_events.size(), 2u); +} + +TEST_F(CServerClientLifecycleTest, HandlerRegisteredDuringTeardownWaitsForObjects) { + auto client = reinterpretPointerCast(m_client); + auto first = makeShared(client); + auto second = makeShared(client); + client->m_objects = {first, second}; + first->setOnDestroy([&] { + client->disconnect(); + client->setDisconnectHandler([this] { m_events.emplace_back("replacement"); }); + EXPECT_TRUE(m_events.empty()); + }); + second->setOnDestroy([this] { m_events.emplace_back("object"); }); + + ASSERT_TRUE(m_server->removeClient(m_serverFD)); + EXPECT_EQ(m_events, (std::vector{"object", "replacement"})); +} + +TEST_F(CServerClientLifecycleTest, HandlerCanBeCleared) { + m_client->setDisconnectHandler({}); + ASSERT_TRUE(m_server->removeClient(m_serverFD)); + EXPECT_EQ(m_disconnections, 0); +} + +TEST_F(CServerClientLifecycleTest, RemovalHandlerCanReleaseServer) { + m_client->setDisconnectHandler([this] { m_server.reset(); }); + ASSERT_TRUE(m_server->removeClient(m_serverFD)); + EXPECT_EQ(m_server, nullptr); +} + +TEST_F(CServerClientLifecycleTest, DispatchHandlerCanReleaseServer) { + m_client->setDisconnectHandler([this] { m_server.reset(); }); + m_peer.reset(); + ASSERT_TRUE(m_server->dispatchEvents(false)); + EXPECT_EQ(m_server, nullptr); +} + +TEST_F(CServerClientLifecycleTest, ServerDestructionRejectsAndClosesReentrantAddition) { + int fds[2] = {-1, -1}; + ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0); + CFileDescriptor serverFD{fds[0]}, peer{fds[1]}; + CSharedPointer added; + m_client->setDisconnectHandler([&, server = m_server.get()] { added = server->addClient(serverFD.take()); }); + + m_server.reset(); + EXPECT_EQ(added, nullptr); + char byte = 0; + EXPECT_EQ(recv(peer.get(), &byte, 1, MSG_DONTWAIT), 0); +} From 46de98718062a0153b81810bf42e002cdeec065b Mon Sep 17 00:00:00 2001 From: Vaxry Date: Tue, 17 Nov 2026 23:50:36 +0100 Subject: [PATCH 4/4] client: bind protocols without waiting for replies --- include/hyprwire/core/ClientSocket.hpp | 14 +- src/core/client/ClientSocket.cpp | 122 ++++++-- src/core/client/ClientSocket.hpp | 11 +- src/core/message/MessageParser.cpp | 2 +- tests/unit/IntegrationCore.cpp | 390 ++++++++++++++++++++++++- 5 files changed, 507 insertions(+), 32 deletions(-) diff --git a/include/hyprwire/core/ClientSocket.hpp b/include/hyprwire/core/ClientSocket.hpp index b7e369f..dc13b67 100644 --- a/include/hyprwire/core/ClientSocket.hpp +++ b/include/hyprwire/core/ClientSocket.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include namespace Hyprwire { class IProtocolClientImplementation; @@ -46,6 +47,17 @@ namespace Hyprwire { */ virtual Hyprutils::Memory::CSharedPointer bindProtocol(const Hyprutils::Memory::CSharedPointer& spec, uint32_t version) = 0; + /* + Bind without waiting for the server's binding reply. Writes may still block under backpressure. + A non-empty completion is called exactly once, with a confirmed object or nullptr on failure. + Validation failures may complete inline; pending binds complete during dispatch or socket teardown. + Success runs before subsequent events, allowing the completion to attach object listeners. + Completions may bind again or release the socket. Releasing its last reference cancels remaining + binds with nullptr, after any active dispatch finishes. Keep callback captures alive until completion. + */ + virtual void bindProtocolAsync(const Hyprutils::Memory::CSharedPointer& spec, uint32_t version, + std::function)>&& completion) = 0; + /* Get an object from an id */ @@ -69,4 +81,4 @@ namespace Hyprwire { protected: IClientSocket() = default; }; -}; \ No newline at end of file +}; diff --git a/src/core/client/ClientSocket.cpp b/src/core/client/ClientSocket.cpp index b9d9ae3..b2fd927 100644 --- a/src/core/client/ClientSocket.cpp +++ b/src/core/client/ClientSocket.cpp @@ -25,6 +25,7 @@ #include #include +#include #include using namespace Hyprwire; @@ -55,6 +56,10 @@ SP IClientSocket::open(const int fd) { return sock; } +CClientSocket::~CClientSocket() { + disconnectOnError(); +} + bool CClientSocket::attempt(const std::string& path) { m_fd = CFileDescriptor{socket(AF_UNIX, SOCK_STREAM, 0)}; sockaddr_un serverAddress = {.sun_family = AF_UNIX}; @@ -116,12 +121,18 @@ void CClientSocket::resetHandshakeTimeoutForTests() { // bool CClientSocket::dispatchEvents(bool block) { + const auto self = m_self.lock(); + CScopeGuard onError([this] { + if (m_error) + disconnectOnError(); + }); if (m_error) return false; collectOrphanedObjects(); + int ret = 0; if (!m_handshakeDone) { const auto elapsed = std::chrono::steady_clock::now() - m_handshakeBegin; const auto maxMs = g_handshakeMax; @@ -133,7 +144,7 @@ bool CClientSocket::dispatchEvents(bool block) { } const auto timeout = block ? std::chrono::duration_cast(maxMs - elapsed).count() : 0; - int ret = Syscalls::poll(m_pollfds.data(), m_pollfds.size(), static_cast(timeout)); + ret = Syscalls::poll(m_pollfds.data(), m_pollfds.size(), static_cast(timeout)); if (block && !ret) { Debug::log(ERR, "handshake error: timed out"); disconnectOnError(); @@ -142,11 +153,23 @@ bool CClientSocket::dispatchEvents(bool block) { } if (m_handshakeDone) - Syscalls::poll(m_pollfds.data(), m_pollfds.size(), block ? -1 : 0); + ret = Syscalls::poll(m_pollfds.data(), m_pollfds.size(), block ? -1 : 0); + + if (ret < 0) { + if (errno == EINTR) + return !m_error; + disconnectOnError(); + return false; + } - if (!(m_pollfds[0].revents & POLLIN)) { + const auto revents = m_pollfds[0].revents; + if (!(revents & POLLIN)) { + if (revents & (POLLHUP | POLLERR | POLLNVAL)) { + disconnectOnError(); + return false; + } collectOrphanedObjects(); - return !(m_pollfds[0].revents & POLLHUP); + return !m_error; } // dispatch @@ -159,10 +182,12 @@ bool CClientSocket::dispatchEvents(bool block) { return false; } - if (data.data.empty()) + if (data.data.empty()) { + disconnectOnError(); return false; + } - const auto RET = g_messageParser->handleMessage(data, m_self.lock()); + const auto RET = g_messageParser->handleMessage(data, self); if (RET != MESSAGE_PARSED_OK) { Debug::log(ERR, "fatal: failed to handle message on wire"); @@ -170,6 +195,14 @@ bool CClientSocket::dispatchEvents(bool block) { return false; } + if (m_error) + return false; + + if (revents & (POLLHUP | POLLERR | POLLNVAL)) { + disconnectOnError(); + return false; + } + std::erase_if(m_pendingOutgoing, [this](auto& msg) { auto obj = objectForSeq(msg.m_dependsOnSeq); if (!obj) @@ -256,6 +289,7 @@ void CClientSocket::serverSpecs(const std::vector& s) { } bool CClientSocket::waitForHandshake() { + const auto self = m_self.lock(); m_handshakeBegin = std::chrono::steady_clock::now(); while (!m_error && !m_handshakeDone) { @@ -279,25 +313,71 @@ SP CClientSocket::getSpec(const std::string& name) { } void CClientSocket::onSeq(uint32_t seq, uint32_t id) { - for (const auto& c : m_objects) { - if (c->m_seq == seq) { - c->m_id = id; - return; - } + if (m_error) + return; + + auto object = reinterpretPointerCast(objectForSeq(seq)); + if (!object) { + Debug::log(WARN, "[{} @ {:.3f}] -> No object for sequence {} (Would be id {}).!", m_fd.get(), steadyMillis(), seq, id); + return; } - Debug::log(WARN, "[{} @ {:.3f}] -> No object for sequence {} (Would be id {}).!", m_fd.get(), steadyMillis(), seq, id); + if (!id) { + Debug::log(ERR, "invalid object id for sequence {}", seq); + disconnectOnError(); + return; + } + + object->m_id = id; + // Detach before calling user code: it can bind again or disconnect the socket. + auto completion = m_pendingBinds.extract(seq); + if (!completion.empty() && completion.mapped()) + completion.mapped()(object); } SP CClientSocket::bindProtocol(const SP& spec, uint32_t version) { + const auto self = m_self.lock(); + auto object = beginBindProtocol(spec, version); + if (!object) + return nullptr; + + waitForObject(object); + return !m_error && object->m_id ? object : nullptr; +} + +void CClientSocket::bindProtocolAsync(const SP& spec, uint32_t version, std::function)>&& completion) { + const auto self = m_self.lock(); + auto object = beginBindProtocol(spec, version); + if (!object) { + if (completion) + completion(nullptr); + return; + } + + m_pendingBinds.emplace(object->m_seq, std::move(completion)); +} + +SP CClientSocket::beginBindProtocol(const SP& spec, uint32_t version) { + if (m_error || !spec) { + disconnectOnError(); + return nullptr; + } + if (version > spec->specVer()) { Debug::log(ERR, "version {} is larger than current spec ver of {}", version, spec->specVer()); disconnectOnError(); return nullptr; } + const auto objects = spec->objects(); + if (objects.empty() || !objects.front()) { + Debug::log(ERR, "protocol spec has no binding object"); + disconnectOnError(); + return nullptr; + } + auto object = makeShared(m_self.lock()); - object->m_spec = spec->objects().front(); + object->m_spec = objects.front(); object->m_seq = ++m_seq; object->m_version = version; object->m_self = object; @@ -307,8 +387,6 @@ SP CClientSocket::bindProtocol(const SP& spec, uint32_t auto bindMessage = CBindProtocolMessage(spec->specName(), object->m_seq, version); sendMessage(bindMessage); - waitForObject(object); - return object; } @@ -341,9 +419,11 @@ SP CClientSocket::makeObject(const std::string& protocolName, con } void CClientSocket::waitForObject(SP x) { + const auto self = m_self.lock(); m_waitingOnObject = x; while (!x->m_id && !m_error) { - dispatchEvents(true); + if (!dispatchEvents(true)) + break; } m_waitingOnObject.reset(); } @@ -405,11 +485,19 @@ SP CClientSocket::objectForSeq(uint32_t seq) { } void CClientSocket::disconnectOnError() { - m_error = true; + const auto self = m_self.lock(); + m_error = true; m_fd.reset(); + + auto pending = std::exchange(m_pendingBinds, {}); + for (auto& [seq, completion] : pending) { + if (completion) + completion(nullptr); + } } void CClientSocket::roundtrip() { + const auto self = m_self.lock(); if (m_error) return; diff --git a/src/core/client/ClientSocket.hpp b/src/core/client/ClientSocket.hpp index 5a70179..1357f12 100644 --- a/src/core/client/ClientSocket.hpp +++ b/src/core/client/ClientSocket.hpp @@ -7,6 +7,7 @@ #include "../wireObject/IWireObject.hpp" #include +#include #include #include @@ -17,8 +18,8 @@ namespace Hyprwire { class CClientSocket : public IClientSocket { public: - CClientSocket() = default; - virtual ~CClientSocket() = default; + CClientSocket() = default; + virtual ~CClientSocket(); bool attempt(const std::string& path); bool attemptFromFd(const int fd); @@ -29,6 +30,7 @@ namespace Hyprwire { virtual bool waitForHandshake(); virtual SP getSpec(const std::string& name); virtual SP bindProtocol(const SP& spec, uint32_t version); + virtual void bindProtocolAsync(const SP& spec, uint32_t version, std::function)>&& completion); virtual SP objectForId(uint32_t id); virtual SP objectForSeq(uint32_t seq); virtual void roundtrip(); @@ -70,5 +72,10 @@ namespace Hyprwire { uint32_t m_lastAckdRoundtripSeq = 0; uint32_t m_lastSentRoundtripSeq = 0; + + private: + SP beginBindProtocol(const SP& spec, uint32_t version); + + std::unordered_map)>> m_pendingBinds; }; }; diff --git a/src/core/message/MessageParser.cpp b/src/core/message/MessageParser.cpp index 054af75..7cd56aa 100644 --- a/src/core/message/MessageParser.cpp +++ b/src/core/message/MessageParser.cpp @@ -45,7 +45,7 @@ eMessageParsingResult CMessageParser::handleMessage(SSocketRawParsedMessage& dat eMessageParsingResult CMessageParser::handleMessage(SSocketRawParsedMessage& data, SP client) { size_t needle = 0; - while (needle < data.data.size()) { + while (needle < data.data.size() && !client->m_error) { auto ret = parseSingleMessage(data, needle, client); if (ret == 0) return MESSAGE_PARSED_ERROR; diff --git a/tests/unit/IntegrationCore.cpp b/tests/unit/IntegrationCore.cpp index f8d2157..e5cd226 100644 --- a/tests/unit/IntegrationCore.cpp +++ b/tests/unit/IntegrationCore.cpp @@ -3,7 +3,15 @@ #include #include +#include "core/wireObject/IWireObject.hpp" +#include "core/message/messages/FatalProtocolError.hpp" +#include "core/message/messages/NewObject.hpp" +#include "helpers/Syscalls.hpp" +#include + #include +#include +#include #include #include #include @@ -21,9 +29,6 @@ using namespace Hyprutils::Memory; namespace { - template - using SP = CSharedPointer; - template void* fnToVoid(Fn fn) { static_assert(std::is_pointer_v); @@ -155,7 +160,7 @@ namespace { class CIntegrationHarness { public: - CIntegrationHarness() { + explicit CIntegrationHarness(bool manualPump = false, bool notifyOnBind = false) : m_manualPump(manualPump), m_notifyOnBind(notifyOnBind) { int fds[2] = {-1, -1}; if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) != 0) throw std::runtime_error("socketpair failed"); @@ -170,6 +175,7 @@ namespace { m_server->addImplementation(std::move(m_serverImpl)); m_serverClient = m_server->addClient(fds[0]); + m_serverFD = fds[0]; if (!m_serverClient) throw std::runtime_error("server addClient failed"); @@ -179,6 +185,9 @@ namespace { m_client->addImplementation(std::move(m_clientImpl)); + if (m_manualPump) + return; + m_pumpThread = std::thread([this] { while (!m_stopPump) { if (m_server) @@ -192,9 +201,17 @@ namespace { m_stopPump = true; if (m_pumpThread.joinable()) m_pumpThread.join(); + m_client.reset(); } bool waitForHandshake() { + if (m_manualPump) { + for (size_t i = 0; i < 4 && !m_client->isHandshakeDone(); ++i) { + if (!m_server->dispatchEvents(false) || !m_client->dispatchEvents(false)) + return false; + } + return m_client->isHandshakeDone(); + } return m_client->waitForHandshake(); } @@ -203,15 +220,15 @@ namespace { if (!manager) return nullptr; + attachManagerClientListener(manager); + return manager; + } + + void attachManagerClientListener(const SP& manager) { manager->setData(this); manager->listen(0, fnToVoid(&CIntegrationHarness::onManagerNotify)); - - { - std::scoped_lock lock(m_stateMutex); - m_managerClientObject = manager; - } - - return manager; + std::scoped_lock lock(m_stateMutex); + m_managerClientObject = manager; } bool pumpClientUntil(const std::function& pred, std::chrono::milliseconds timeout = std::chrono::milliseconds(1500)) { @@ -246,6 +263,22 @@ namespace { return m_client->dispatchEvents(false); } + bool dispatchServer() { + return m_server->dispatchEvents(false); + } + + int serverFD() { + return m_serverFD; + } + + SP serverClient() { + return m_serverClient; + } + + void releaseClient() { + m_client.reset(); + } + int clientFD() { return m_client->extractLoopFD(); } @@ -362,11 +395,16 @@ namespace { obj->listen(1, fnToVoid(&CIntegrationHarness::onManagerMakeChild)); obj->listen(2, fnToVoid(&CIntegrationHarness::onManagerSendFd)); obj->listen(3, fnToVoid(&CIntegrationHarness::onManagerSendArray)); + if (m_notifyOnBind) + obj->call(0, "bound"); } private: std::atomic m_stopPump = false; std::thread m_pumpThread; + bool m_manualPump = false; + bool m_notifyOnBind = false; + int m_serverFD = -1; SP m_protocolSpec; SP m_serverImpl; @@ -501,3 +539,333 @@ TEST(IntegrationCore, MalformedMessageDisconnectsClient) { EXPECT_TRUE(disconnected); } + +TEST(IntegrationCore, AsyncBindReturnsBeforeReplyAndReceivesImmediateEvents) { + int completions = 0; + SP manager, child; + CIntegrationHarness harness(true, true); + ASSERT_TRUE(harness.waitForHandshake()); + + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++completions; + ASSERT_NE(object, nullptr); + manager = object; + harness.attachManagerClientListener(manager); + manager->call(0, "hello"); + + const auto childSeq = manager->call(1); + child = harness.childClientObjectForSeq(childSeq); + ASSERT_NE(child, nullptr); + harness.attachChildClientListener(child); + child->call(0, 41u); + }); + + // There is no server thread: waiting for the binding reply here would hang. + EXPECT_EQ(completions, 0); + EXPECT_EQ(manager, nullptr); + ASSERT_TRUE(harness.dispatchClient()); + EXPECT_EQ(completions, 0); + ASSERT_TRUE(harness.dispatchServer()); + EXPECT_EQ(completions, 0); + ASSERT_TRUE(harness.dispatchClient()); + EXPECT_EQ(completions, 1); + EXPECT_EQ(harness.clientNotifications(), (std::vector{"bound"})); + + // The callback's requests and the child's deferred request are usable normally. + for (size_t i = 0; i < 2; ++i) { + ASSERT_TRUE(harness.dispatchServer()); + ASSERT_TRUE(harness.dispatchClient()); + } + EXPECT_EQ(harness.serverPings(), (std::vector{"hello"})); + EXPECT_EQ(harness.clientNotifications(), (std::vector{"bound", "pong"})); + EXPECT_EQ(harness.childPingValue(), 41u); + EXPECT_EQ(harness.childNotifyValue(), 42u); + EXPECT_EQ(completions, 1); +} + +TEST(IntegrationCore, AsyncBindMatchesSequencesAndAllowsReentrantBinds) { + std::array completions = {}; + std::array, 3> objects; + CIntegrationHarness harness(true); + ASSERT_TRUE(harness.waitForHandshake()); + + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++completions[0]; + objects[0] = object; + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP nested) { + ++completions[2]; + objects[2] = nested; + }); + }); + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++completions[1]; + objects[1] = object; + }); + + // Reply out of order, then duplicate a reply. Completion must follow the sequence. + auto replies = CNewObjectMessage(2, 102).m_data; + replies.append_range(CNewObjectMessage(1, 101).m_data); + replies.append_range(CNewObjectMessage(1, 101).m_data); + ASSERT_EQ(write(harness.serverFD(), replies.data(), replies.size()), static_cast(replies.size())); + ASSERT_TRUE(harness.dispatchClient()); + EXPECT_EQ(completions, (std::array{1, 1, 0})); + EXPECT_EQ(objects[0], harness.client()->objectForId(101)); + EXPECT_EQ(objects[1], harness.client()->objectForId(102)); + + replies = CNewObjectMessage(3, 103).m_data; + ASSERT_EQ(write(harness.serverFD(), replies.data(), replies.size()), static_cast(replies.size())); + ASSERT_TRUE(harness.dispatchClient()); + EXPECT_EQ(completions, (std::array{1, 1, 1})); + EXPECT_EQ(objects[2], harness.client()->objectForId(103)); +} + +TEST(IntegrationCore, AsyncBindRejectionFailsAllPendingOnce) { + int completions = 0, nestedCompletions = 0; + CIntegrationHarness harness(true); + harness.serverClient()->setProtocolFilter([](std::string_view) { return false; }); + ASSERT_TRUE(harness.waitForHandshake()); + + for (size_t i = 0; i < 2; ++i) { + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++completions; + EXPECT_EQ(object, nullptr); + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP nested) { + ++nestedCompletions; + EXPECT_EQ(nested, nullptr); + }); + }); + } + EXPECT_EQ(completions, 0); + harness.dispatchServer(); + EXPECT_FALSE(harness.dispatchClient()); + EXPECT_EQ(completions, 2); + EXPECT_EQ(nestedCompletions, 2); + EXPECT_EQ(harness.clientFD(), -1); + EXPECT_FALSE(harness.dispatchClient()); + EXPECT_EQ(completions, 2); +} + +TEST(IntegrationCore, AsyncBindPeerEofFailsPendingAndSyncBindReturnsNull) { + int completions = 0; + CIntegrationHarness harness(true); + ASSERT_TRUE(harness.waitForHandshake()); + for (size_t i = 0; i < 2; ++i) { + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++completions; + EXPECT_EQ(object, nullptr); + }); + } + ASSERT_EQ(shutdown(harness.serverFD(), SHUT_WR), 0); + EXPECT_EQ(harness.client()->bindProtocol(harness.protocolSpec(), 1), nullptr); + EXPECT_EQ(completions, 2); + EXPECT_EQ(harness.clientFD(), -1); + EXPECT_FALSE(harness.dispatchClient()); + EXPECT_EQ(completions, 2); +} + +TEST(IntegrationCore, AsyncBindStopsParsingAfterFatalOrMalformedReply) { + const std::vector> errors = { + CFatalErrorMessage(0, 1, "rejected").m_data, + {0xFF, HW_MESSAGE_MAGIC_END}, + CNewObjectMessage(1, 0).m_data, + }; + for (const auto& error : errors) { + int completions = 0; + CIntegrationHarness harness(true); + ASSERT_TRUE(harness.waitForHandshake()); + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++completions; + EXPECT_EQ(object, nullptr); + }); + + auto replies = error; + replies.append_range(CNewObjectMessage(1, 101).m_data); + ASSERT_EQ(write(harness.serverFD(), replies.data(), replies.size()), static_cast(replies.size())); + EXPECT_FALSE(harness.dispatchClient()); + EXPECT_EQ(completions, 1); + EXPECT_EQ(harness.client()->objectForId(101), nullptr); + EXPECT_FALSE(harness.dispatchClient()); + EXPECT_EQ(completions, 1); + } +} + +TEST(IntegrationCore, AsyncBindHangupAfterReplyFailsRemainingBinds) { + int completed = 0, cancelled = 0; + CIntegrationHarness harness(true); + ASSERT_TRUE(harness.waitForHandshake()); + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++completed; + EXPECT_NE(object, nullptr); + }); + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++cancelled; + EXPECT_EQ(object, nullptr); + }); + const auto reply = CNewObjectMessage(1, 101).m_data; + ASSERT_EQ(write(harness.serverFD(), reply.data(), reply.size()), static_cast(reply.size())); + ASSERT_EQ(shutdown(harness.serverFD(), SHUT_RDWR), 0); + EXPECT_FALSE(harness.dispatchClient()); + EXPECT_EQ(completed, 1); + EXPECT_EQ(cancelled, 1); +} + +TEST(IntegrationCore, AsyncBindPollAndReceiveFailuresDrainPending) { + const std::vector failures = { + {.poll = + [](pollfd* fds, nfds_t, int) { + fds[0].revents = POLLHUP; + return 1; + }}, + {.poll = + [](pollfd* fds, nfds_t, int) { + fds[0].revents = POLLERR; + return 1; + }}, + {.poll = + [](pollfd* fds, nfds_t, int) { + fds[0].revents = POLLNVAL; + return 1; + }}, + {.poll = + [](pollfd*, nfds_t, int) { + errno = EIO; + return -1; + }}, + {.poll = + [](pollfd* fds, nfds_t, int) { + fds[0].revents = POLLIN; + return 1; + }, + .recvmsg = [](int, msghdr*, int) -> ssize_t { + errno = EIO; + return -1; + }}, + }; + for (const auto& failure : failures) { + int completions = 0; + CIntegrationHarness harness(true); + ASSERT_TRUE(harness.waitForHandshake()); + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++completions; + EXPECT_EQ(object, nullptr); + }); + + Hyprutils::Utils::CScopeGuard resetHooks([] { Syscalls::resetHooks(); }); + Syscalls::setHooks(failure); + EXPECT_FALSE(harness.dispatchClient()); + EXPECT_EQ(completions, 1); + EXPECT_EQ(harness.clientFD(), -1); + EXPECT_FALSE(harness.dispatchClient()); + EXPECT_EQ(completions, 1); + } +} + +TEST(IntegrationCore, AsyncBindHandshakeTimeoutDrainsPending) { + int completions = 0; + CIntegrationHarness harness(true); + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++completions; + EXPECT_EQ(object, nullptr); + }); + Hyprutils::Utils::CScopeGuard resetHooks([] { Syscalls::resetHooks(); }); + Syscalls::setHooks({.poll = [](pollfd*, nfds_t, int) { return 0; }}); + EXPECT_FALSE(harness.client()->waitForHandshake()); + EXPECT_EQ(completions, 1); +} + +TEST(IntegrationCore, AsyncBindValidationCanCompleteInline) { + for (size_t invalid = 0; invalid < 3; ++invalid) { + int completions = 0; + CIntegrationHarness harness(true); + ASSERT_TRUE(harness.waitForHandshake()); + // Null spec, excessive version, and a discovery-only spec without object definitions. + auto spec = invalid == 0 ? SP{} : invalid == 1 ? harness.protocolSpec() : harness.client()->getSpec("integration_protocol"); + harness.client()->bindProtocolAsync(spec, invalid == 1 ? 2 : 1, [&](SP object) { + ++completions; + EXPECT_EQ(object, nullptr); + }); + EXPECT_EQ(completions, 1); + EXPECT_FALSE(harness.dispatchClient()); + EXPECT_EQ(completions, 1); + } +} + +TEST(IntegrationCore, AsyncBindDestructionCancelsRemainingCompletions) { + int completions = 0; + CIntegrationHarness harness(true); + ASSERT_TRUE(harness.waitForHandshake()); + for (size_t i = 0; i < 2; ++i) { + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++completions; + EXPECT_EQ(object, nullptr); + }); + } + EXPECT_EQ(completions, 0); + harness.releaseClient(); + EXPECT_EQ(completions, 2); +} + +TEST(IntegrationCore, AsyncBindCompletionCanReleaseSocketAndCancelReentrantBind) { + int completions = 0, cancelled = 0; + CIntegrationHarness harness(true); + ASSERT_TRUE(harness.waitForHandshake()); + WP weak = harness.client(); + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++completions; + ASSERT_NE(object, nullptr); + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP pending) { + ++cancelled; + EXPECT_EQ(pending, nullptr); + }); + harness.releaseClient(); + EXPECT_FALSE(weak.expired()); + }); + ASSERT_TRUE(harness.dispatchServer()); + EXPECT_TRUE(harness.dispatchClient()); + EXPECT_TRUE(weak.expired()); + EXPECT_EQ(completions, 1); + EXPECT_EQ(cancelled, 1); +} + +TEST(IntegrationCore, AsyncBindCallbackErrorStopsLaterEventsAndCompletions) { + int completed = 0, cancelled = 0; + CIntegrationHarness harness(true, true); + ASSERT_TRUE(harness.waitForHandshake()); + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++completed; + ASSERT_NE(object, nullptr); + harness.attachManagerClientListener(object); + reinterpretPointerCast(object)->errd(); + }); + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++cancelled; + EXPECT_EQ(object, nullptr); + }); + ASSERT_TRUE(harness.dispatchServer()); + EXPECT_FALSE(harness.dispatchClient()); + EXPECT_EQ(completed, 1); + EXPECT_EQ(cancelled, 1); + EXPECT_TRUE(harness.clientNotifications().empty()); + EXPECT_EQ(harness.clientFD(), -1); + EXPECT_FALSE(harness.dispatchClient()); + EXPECT_EQ(cancelled, 1); +} + +TEST(IntegrationCore, AsyncBindExistingClientErrorDrainsOnNextDispatch) { + int cancelled = 0; + SP manager; + CIntegrationHarness harness(true); + ASSERT_TRUE(harness.waitForHandshake()); + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { manager = object; }); + ASSERT_TRUE(harness.dispatchServer()); + ASSERT_TRUE(harness.dispatchClient()); + ASSERT_NE(manager, nullptr); + harness.client()->bindProtocolAsync(harness.protocolSpec(), 1, [&](SP object) { + ++cancelled; + EXPECT_EQ(object, nullptr); + }); + reinterpretPointerCast(manager)->errd(); + EXPECT_FALSE(harness.dispatchClient()); + EXPECT_EQ(cancelled, 1); + EXPECT_EQ(harness.clientFD(), -1); +}