| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <fidl/llcpptest.flexible.test/cpp/wire.h> |
| #include <fidl/llcpptest.flexible.test/cpp/wire_test_base.h> |
| #include <lib/async-loop/cpp/loop.h> |
| #include <lib/async-loop/default.h> |
| #include <lib/async/wait.h> |
| #include <lib/fidl/cpp/wire/outgoing_message.h> |
| #include <lib/zx/event.h> |
| #include <zircon/fidl.h> |
| #include <zircon/status.h> |
| #include <zircon/types.h> |
| |
| #include <gtest/gtest.h> |
| |
| namespace test = ::llcpptest_flexible_test; |
| |
| // These tests verify that the messaging APIs allocate a bespoke amount of memory |
| // depending on the shapes of types in the methods in the protocol, but also |
| // anticipate future bytes/handles size additions to flexible types, and allocate |
| // the transport maximum in those cases. |
| namespace { |
| |
| // The only difference between StrictUnboundedXUnion and StrictBoundedXUnion is that |
| // StrictBoundedXUnion limits the vector payload length to 200 bytes. Therefore, by observing that |
| // sizeof(fidl::WireResult<test::ReceiveStrictEnvelope::GetUnboundedXUnion>) is less than 200, we |
| // can guarantee that the response storage is not inlined. Rather, it is allocated on the heap. |
| static_assert(sizeof(fidl::WireResult<test::ReceiveStrictEnvelope::GetUnboundedXUnion>) < 200, |
| "Result of GetUnboundedXUnion should be stored as a pointer to heap allocation"); |
| |
| // GetBoundedXUnion should be inlined, because it is smaller than 512, but bigger than 200, making |
| // the entire ResultOf object bigger than 200. The assertion triggers when the ResultOf object size |
| // falls below 200, at which point we know it is physically incapable of holding a GetBoundedXUnion |
| // inline, so probably used heap allocation. Here we are trying to test this without plumbing extra |
| // flags which themselves need to be tested. |
| static_assert(sizeof(fidl::WireResult<test::ReceiveStrictEnvelope::GetBoundedXUnion>) > 200, |
| "Result of GetBoundedXUnion should be inlined"); |
| |
| // Implement a special server that returns xunion/tables with unknown ordinals. |
| // This is impossible to do when using the bindings normally. Here we use a normal server to |
| // set a tag in the response xunion corresponding to the FIDL call, and intercept and rewrite |
| // the xunion to an unknown ordinal using a special fidl::Transaction implementation. |
| class RewriteTransaction : public fidl::Transaction { |
| public: |
| std::unique_ptr<Transaction> TakeOwnership() override { |
| ADD_FAILURE() << "Never called"; |
| return {}; |
| } |
| |
| void Close(zx_status_t epitaph) override { |
| ADD_FAILURE() << "Transaction::Close called with epitaph " << epitaph; |
| } |
| |
| zx_status_t Reply(fidl::OutgoingMessage* indicator_msg, |
| fidl::WriteOptions write_options) override { |
| EXPECT_NE(txid_, 0u); |
| auto indicator_msg_bytes = indicator_msg->CopyBytes(); |
| |
| unsigned char real_msg_bytes[ZX_CHANNEL_MAX_MSG_BYTES] = {}; |
| zx_handle_t real_msg_handles[ZX_CHANNEL_MAX_MSG_HANDLES] = {}; |
| fidl_channel_handle_metadata_t real_msg_handle_metadata[ZX_CHANNEL_MAX_MSG_HANDLES] = {}; |
| // Copy from original header to get magic, flags, and ordinals. |
| EXPECT_GE(indicator_msg_bytes.size(), sizeof(fidl_message_header_t)); |
| memcpy(real_msg_bytes, indicator_msg_bytes.data(), sizeof(fidl_message_header_t)); |
| fidl_message_header_t* header = reinterpret_cast<fidl_message_header_t*>(real_msg_bytes); |
| header->txid = txid_; |
| zx_channel_iovec_t iovec = { |
| .buffer = real_msg_bytes, |
| .capacity = 0, |
| }; |
| uint32_t num_handles = 0; |
| |
| EXPECT_GE(indicator_msg_bytes.size(), |
| sizeof(fidl::internal::TransactionalResponse< |
| test::ReceiveFlexibleEnvelope::GetUnknownXUnionMoreHandles>)); |
| // Determine if |indicator_msg| has a xunion or a table, by inspecting the first few bytes. |
| auto maybe_vector = reinterpret_cast<const fidl_vector_t*>(indicator_msg_bytes.data() + |
| sizeof(fidl_message_header_t)); |
| if ((maybe_vector->count == 1 || maybe_vector->count == 2) && |
| reinterpret_cast<uintptr_t>(maybe_vector->data) == FIDL_ALLOC_PRESENT) { |
| // Table |
| // Manually craft the actual response which has an unknown ordinal |
| auto real_response = |
| reinterpret_cast<fidl_table_t*>(&real_msg_bytes[sizeof(fidl_message_header_t)]); |
| real_response->envelopes.data = reinterpret_cast<void*>(FIDL_ALLOC_PRESENT); |
| |
| if (maybe_vector->count == 1) { |
| // The |want_more_than_30_bytes_at_ordinal_3| field was set. |
| // Create a message with more bytes than expected |
| constexpr uint32_t kUnknownBytes = 5000; |
| constexpr uint32_t kUnknownHandles = 0; |
| real_response->envelopes.count = 3; |
| const auto envelope_header_offset = |
| sizeof(fidl_message_header_t) + sizeof(fidl_table_t) + sizeof(fidl_envelope_t) * 2; |
| const auto envelope_payload_offset = envelope_header_offset + sizeof(fidl_envelope_t); |
| auto envelope = reinterpret_cast<fidl_envelope_t*>(&real_msg_bytes[envelope_header_offset]); |
| *envelope = fidl_envelope_t{ |
| .num_bytes = kUnknownBytes, |
| .num_handles = kUnknownHandles, |
| }; |
| iovec.capacity = envelope_payload_offset + kUnknownBytes; |
| num_handles = kUnknownHandles; |
| memset(&real_msg_bytes[envelope_payload_offset], 0xAA, kUnknownBytes); |
| } else { |
| // The |want_more_than_4_handles_at_ordinal_4| field was set. |
| // Create a message with more handles than expected |
| constexpr uint32_t kUnknownBytes = 16; |
| constexpr uint32_t kUnknownHandles = ZX_CHANNEL_MAX_MSG_HANDLES; |
| for (uint32_t i = 0; i < kUnknownHandles; i++) { |
| EXPECT_EQ(zx_event_create(0, &real_msg_handles[i]), ZX_OK); |
| } |
| real_response->envelopes.count = 4; |
| const auto envelope_header_offset = |
| sizeof(fidl_message_header_t) + sizeof(fidl_table_t) + sizeof(fidl_envelope_t) * 3; |
| const auto envelope_payload_offset = envelope_header_offset + sizeof(fidl_envelope_t); |
| auto envelope = reinterpret_cast<fidl_envelope_t*>(&real_msg_bytes[envelope_header_offset]); |
| *envelope = fidl_envelope_t{ |
| .num_bytes = kUnknownBytes, |
| .num_handles = kUnknownHandles, |
| }; |
| iovec.capacity = envelope_payload_offset + kUnknownBytes; |
| num_handles = kUnknownHandles; |
| memset(&real_msg_bytes[envelope_payload_offset], 0xBB, kUnknownBytes); |
| } |
| } else { |
| // Manually craft the actual response which has an unknown ordinal |
| constexpr uint32_t kBadOrdinal = 0x8badf00d; |
| static_assert(kBadOrdinal != |
| static_cast<uint32_t>(test::wire::FlexibleXUnion::Tag::kWantMoreThan30Bytes)); |
| static_assert(kBadOrdinal != |
| static_cast<uint32_t>(test::wire::FlexibleXUnion::Tag::kWantMoreThan4Handles)); |
| auto real_response = |
| reinterpret_cast<fidl_union_t*>(&real_msg_bytes[sizeof(fidl_message_header_t)]); |
| real_response->tag = kBadOrdinal; |
| |
| auto indicator_response = reinterpret_cast<const fidl::internal::TransactionalResponse< |
| test::ReceiveFlexibleEnvelope::GetUnknownXUnionMoreHandles>*>(indicator_msg_bytes.data()); |
| switch (indicator_response->body.xu.Which()) { |
| case test::wire::FlexibleXUnion::Tag::kWantMoreThan30Bytes: { |
| // Create a message with more bytes than expected |
| constexpr uint32_t kUnknownBytes = 5000; |
| constexpr uint32_t kUnknownHandles = 0; |
| real_response->envelope = fidl_envelope_t{ |
| .num_bytes = kUnknownBytes, |
| .num_handles = kUnknownHandles, |
| }; |
| iovec.capacity = sizeof(fidl_message_header_t) + sizeof(fidl_union_t) + kUnknownBytes; |
| num_handles = kUnknownHandles; |
| memset(&real_msg_bytes[sizeof(fidl_message_header_t) + sizeof(fidl_union_t)], 0xAA, |
| kUnknownBytes); |
| break; |
| } |
| case test::wire::FlexibleXUnion::Tag::kWantMoreThan4Handles: { |
| // Create a message with more handles than expected |
| constexpr uint32_t kUnknownBytes = 16; |
| constexpr uint32_t kUnknownHandles = ZX_CHANNEL_MAX_MSG_HANDLES; |
| for (uint32_t i = 0; i < kUnknownHandles; i++) { |
| EXPECT_EQ(zx_event_create(0, &real_msg_handles[i]), ZX_OK); |
| } |
| real_response->envelope = fidl_envelope_t{ |
| .num_bytes = kUnknownBytes, |
| .num_handles = kUnknownHandles, |
| }; |
| iovec.capacity = sizeof(fidl_message_header_t) + sizeof(fidl_union_t) + kUnknownBytes; |
| num_handles = kUnknownHandles; |
| memset(&real_msg_bytes[sizeof(fidl_message_header_t) + sizeof(fidl_union_t)], 0xBB, |
| kUnknownBytes); |
| break; |
| } |
| default: |
| ADD_FAILURE() << "Cannot reach here"; |
| } |
| } |
| zx_handle_disposition_t handle_dispositions[ZX_CHANNEL_MAX_MSG_HANDLES]; |
| for (uint32_t i = 0; i < num_handles; i++) { |
| handle_dispositions[i] = { |
| .operation = ZX_HANDLE_OP_MOVE, |
| .handle = real_msg_handles[i], |
| .type = real_msg_handle_metadata[i].obj_type, |
| .rights = real_msg_handle_metadata[i].rights, |
| .result = ZX_OK, |
| }; |
| } |
| EXPECT_EQ( |
| channel_->write_etc(0, iovec.buffer, iovec.capacity, handle_dispositions, num_handles), |
| ZX_OK); |
| return ZX_OK; |
| } |
| |
| RewriteTransaction(zx_txid_t txid, zx::unowned_channel channel) |
| : txid_(txid), channel_(std::move(channel)) {} |
| |
| private: |
| zx_txid_t txid_; |
| zx::unowned_channel channel_; |
| }; |
| |
| class Server : fidl::WireServer<test::ReceiveFlexibleEnvelope>, private async_wait_t { |
| public: |
| void GetUnknownXUnionMoreBytes(GetUnknownXUnionMoreBytesCompleter::Sync& completer) override { |
| test::wire::FlexibleXUnion xunion; |
| fidl::Array<uint8_t, 30> array = {}; |
| completer.Reply(test::wire::FlexibleXUnion::WithWantMoreThan30Bytes( |
| fidl::ObjectView<fidl::Array<uint8_t, 30>>::FromExternal(&array))); |
| } |
| |
| void GetUnknownXUnionMoreHandles(GetUnknownXUnionMoreHandlesCompleter::Sync& completer) override { |
| test::wire::FlexibleXUnion xunion; |
| fidl::Array<zx::handle, 4> array = {}; |
| completer.Reply(test::wire::FlexibleXUnion::WithWantMoreThan4Handles( |
| fidl::ObjectView<fidl::Array<zx::handle, 4>>::FromExternal(&array))); |
| } |
| |
| void GetUnknownTableMoreBytes(GetUnknownTableMoreBytesCompleter::Sync& completer) override { |
| fidl::Arena allocator; |
| auto flexible_table = test::wire::FlexibleTable::Builder(allocator) |
| .want_more_than_30_bytes_at_ordinal_3({}) |
| .Build(); |
| completer.Reply(flexible_table); |
| } |
| |
| void GetUnknownTableMoreHandles(GetUnknownTableMoreHandlesCompleter::Sync& completer) override { |
| fidl::Arena allocator; |
| auto flexible_table = test::wire::FlexibleTable::Builder(allocator) |
| .want_more_than_4_handles_at_ordinal_4({}) |
| .Build(); |
| completer.Reply(flexible_table); |
| } |
| |
| Server(async_dispatcher_t* dispatcher, fidl::ServerEnd<test::ReceiveFlexibleEnvelope> channel) |
| : async_wait_t({ |
| .state = ASYNC_STATE_INIT, |
| .handler = &MessageHandler, |
| .object = channel.TakeChannel().release(), |
| .trigger = ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED, |
| .options = 0, |
| }), |
| dispatcher_(dispatcher) { |
| async_begin_wait(dispatcher_, this); |
| } |
| |
| ~Server() override { |
| async_cancel_wait(dispatcher_, this); |
| zx_handle_close(async_wait_t::object); |
| } |
| |
| void HandleMessage(async_dispatcher_t* dispatcher, zx_status_t status, |
| const zx_packet_signal_t* signal) { |
| if (status != ZX_OK) { |
| return; |
| } |
| if (signal->observed & ZX_CHANNEL_READABLE) { |
| for (uint64_t i = 0; i < signal->count; i++) { |
| fidl::IncomingHeaderAndMessage msg = |
| fidl::MessageRead(zx::unowned_channel(async_wait_t::object), |
| fidl::ChannelMessageStorageView{ |
| .bytes = fidl::BufferSpan(bytes_->data(), bytes_->size()), |
| .handles = handles_->data(), |
| .handle_metadata = handle_metadata_->data(), |
| .handle_capacity = static_cast<uint32_t>(handles_->size()), |
| }); |
| if (!msg.ok()) { |
| return; |
| } |
| |
| auto hdr = msg.header(); |
| RewriteTransaction txn(hdr->txid, zx::unowned_channel(async_wait_t::object)); |
| fidl::WireDispatch<test::ReceiveFlexibleEnvelope>(this, std::move(msg), &txn); |
| } |
| |
| // Will only get here if every single message was handled synchronously and successfully. |
| async_begin_wait(dispatcher_, this); |
| } else { |
| ASSERT_TRUE(signal->observed & ZX_CHANNEL_PEER_CLOSED); |
| } |
| } |
| |
| // Implement the function required by |async_wait_t|. |
| static void MessageHandler(async_dispatcher_t* dispatcher, async_wait_t* wait, zx_status_t status, |
| const zx_packet_signal_t* signal) { |
| static_cast<Server*>(wait)->HandleMessage(dispatcher, status, signal); |
| } |
| |
| private: |
| async_dispatcher_t* dispatcher_; |
| std::unique_ptr<std::array<uint8_t, ZX_CHANNEL_MAX_MSG_BYTES>> bytes_ = |
| std::make_unique<std::array<uint8_t, ZX_CHANNEL_MAX_MSG_BYTES>>(); |
| std::unique_ptr<std::array<zx_handle_t, ZX_CHANNEL_MAX_MSG_HANDLES>> handles_ = |
| std::make_unique<std::array<zx_handle_t, ZX_CHANNEL_MAX_MSG_HANDLES>>(); |
| std::unique_ptr<std::array<fidl_channel_handle_metadata_t, ZX_CHANNEL_MAX_MSG_HANDLES>> |
| handle_metadata_ = std::make_unique< |
| std::array<fidl_channel_handle_metadata_t, ZX_CHANNEL_MAX_MSG_HANDLES>>(); |
| }; |
| |
| class FlexibleEnvelopeTest : public ::testing::Test { |
| protected: |
| void SetUp() override { |
| loop_ = std::make_unique<async::Loop>(&kAsyncLoopConfigAttachToCurrentThread); |
| ASSERT_EQ(loop_->StartThread("test_llcpp_flexible_envelope_server"), ZX_OK); |
| zx::result server_end = fidl::CreateEndpoints(&client_end_); |
| ASSERT_EQ(server_end.status_value(), ZX_OK); |
| server_ = std::make_unique<Server>(loop_->dispatcher(), std::move(*server_end)); |
| } |
| |
| void TearDown() override { |
| loop_->Quit(); |
| loop_->JoinThreads(); |
| } |
| |
| fidl::WireSyncClient<test::ReceiveFlexibleEnvelope> TakeClient() { |
| EXPECT_TRUE(client_end_.is_valid()); |
| return fidl::WireSyncClient<test::ReceiveFlexibleEnvelope>(std::move(client_end_)); |
| } |
| |
| private: |
| std::unique_ptr<async::Loop> loop_; |
| std::unique_ptr<Server> server_; |
| fidl::ClientEnd<test::ReceiveFlexibleEnvelope> client_end_; |
| }; |
| |
| static_assert(fidl::internal::ClampedMessageSize< |
| fidl::internal::TransactionalResponse< |
| test::ReceiveFlexibleEnvelope::GetUnknownXUnionMoreBytes>, |
| fidl::MessageDirection::kReceiving>() == ZX_CHANNEL_MAX_MSG_BYTES, |
| "Cannot assume any limit on byte size apart from the channel limit"); |
| |
| TEST_F(FlexibleEnvelopeTest, ReceiveUnknownVariantWithMoreBytes) { |
| auto client = TakeClient(); |
| auto result = client->GetUnknownXUnionMoreBytes(); |
| EXPECT_TRUE(result.ok()); |
| ASSERT_EQ(result.status(), ZX_OK) << zx_status_get_string(result.status()); |
| ASSERT_TRUE(result.value().xu.IsUnknown()); |
| } |
| |
| static_assert(fidl::internal::ClampedHandleCount< |
| fidl::internal::TransactionalResponse< |
| test::ReceiveFlexibleEnvelope::GetUnknownXUnionMoreHandles>, |
| fidl::MessageDirection::kReceiving>() == ZX_CHANNEL_MAX_MSG_HANDLES, |
| "Cannot assume any limit on handle count apart from the channel limit"); |
| |
| TEST_F(FlexibleEnvelopeTest, ReceiveUnknownVariantWithMoreHandles) { |
| auto client = TakeClient(); |
| auto result = client->GetUnknownXUnionMoreHandles(); |
| EXPECT_TRUE(result.ok()); |
| ASSERT_EQ(result.status(), ZX_OK) << zx_status_get_string(result.status()); |
| ASSERT_TRUE(result.value().xu.IsUnknown()); |
| } |
| |
| static_assert( |
| fidl::internal::ClampedMessageSize<fidl::internal::TransactionalResponse< |
| test::ReceiveFlexibleEnvelope::GetUnknownTableMoreBytes>, |
| fidl::MessageDirection::kReceiving>() == |
| ZX_CHANNEL_MAX_MSG_BYTES, |
| "Cannot assume any limit on byte size apart from the channel limit"); |
| |
| TEST_F(FlexibleEnvelopeTest, ReceiveUnknownTableFieldWithMoreBytes) { |
| auto client = TakeClient(); |
| auto result = client->GetUnknownTableMoreBytes(); |
| EXPECT_TRUE(result.ok()); |
| ASSERT_EQ(result.status(), ZX_OK) << zx_status_get_string(result.status()); |
| EXPECT_FALSE(result.value().t.has_want_more_than_30_bytes_at_ordinal_3()); |
| EXPECT_FALSE(result.value().t.has_want_more_than_4_handles_at_ordinal_4()); |
| } |
| |
| static_assert(fidl::internal::ClampedHandleCount< |
| fidl::internal::TransactionalResponse< |
| test::ReceiveFlexibleEnvelope::GetUnknownTableMoreHandles>, |
| fidl::MessageDirection::kReceiving>() == ZX_CHANNEL_MAX_MSG_HANDLES, |
| "Cannot assume any limit on handle count apart from the channel limit"); |
| |
| TEST_F(FlexibleEnvelopeTest, ReceiveUnknownTableFieldWithMoreHandles) { |
| auto client = TakeClient(); |
| auto result = client->GetUnknownTableMoreHandles(); |
| EXPECT_TRUE(result.ok()); |
| ASSERT_EQ(result.status(), ZX_OK) << zx_status_get_string(result.status()); |
| EXPECT_FALSE(result.value().t.has_want_more_than_30_bytes_at_ordinal_3()); |
| EXPECT_FALSE(result.value().t.has_want_more_than_4_handles_at_ordinal_4()); |
| } |
| |
| // Test receiving an event with a flexible envelope that's larger than the types |
| // described by the FIDL schema. |
| class FlexibleEnvelopeEventTest : public ::testing::Test { |
| public: |
| void SetUp() final { |
| auto endpoints = fidl::Endpoints<test::ReceiveFlexibleEnvelope>::Create(); |
| client_end_ = std::move(endpoints.client); |
| server_end_ = std::move(endpoints.server); |
| } |
| |
| const fidl::ClientEnd<test::ReceiveFlexibleEnvelope>& client_end() const { return client_end_; } |
| const fidl::ServerEnd<test::ReceiveFlexibleEnvelope>& server_end() const { return server_end_; } |
| |
| static constexpr uint32_t kBadOrdinal = 0x8badf00d; |
| static_assert(kBadOrdinal != |
| static_cast<uint32_t>(test::wire::FlexibleXUnion::Tag::kWantMoreThan30Bytes)); |
| static_assert(kBadOrdinal != |
| static_cast<uint32_t>(test::wire::FlexibleXUnion::Tag::kWantMoreThan4Handles)); |
| |
| private: |
| fidl::ClientEnd<test::ReceiveFlexibleEnvelope> client_end_; |
| fidl::ServerEnd<test::ReceiveFlexibleEnvelope> server_end_; |
| }; |
| |
| struct MessageStorage { |
| template <typename FidlType> |
| void Init() { |
| FidlType value; |
| static_assert(fidl::IsFidlTransactionalMessage<FidlType>::value); |
| memcpy(bytes_, static_cast<void*>(&value), sizeof(value)); |
| } |
| |
| template <typename T> |
| T* Build() { |
| T* ptr = reinterpret_cast<T*>(&bytes_[num_bytes_]); |
| num_bytes_ += FIDL_ALIGN(sizeof(T)); |
| return ptr; |
| } |
| |
| void AddGarbage(uint32_t count) { |
| memset(&bytes_[num_bytes_], 0xAA, count); |
| num_bytes_ += FIDL_ALIGN(count); |
| } |
| |
| void AddHandles(uint32_t count) { |
| for (uint32_t i = 0; i < count; i++) { |
| zx::event e; |
| ASSERT_EQ(zx::event::create(0, &e), ZX_OK); |
| handles_[num_handles_] = e.release(); |
| num_handles_++; |
| } |
| } |
| |
| zx_status_t Write(const zx::channel& channel) { |
| return channel.write(0, bytes_, num_bytes_, handles_, num_handles_); |
| } |
| |
| private: |
| uint8_t bytes_[ZX_CHANNEL_MAX_MSG_BYTES] = {}; |
| zx_handle_t handles_[ZX_CHANNEL_MAX_MSG_HANDLES] = {}; |
| uint32_t num_bytes_ = sizeof(fidl_message_header_t); |
| uint32_t num_handles_ = 0; |
| }; |
| |
| static_assert( |
| fidl::internal::ClampedMessageSize< |
| fidl::internal::TransactionalEvent<test::ReceiveFlexibleEnvelope::OnUnknownXUnionMoreBytes>, |
| fidl::MessageDirection::kReceiving>() == ZX_CHANNEL_MAX_MSG_BYTES, |
| "Cannot assume any limit on byte size apart from the channel limit"); |
| |
| TEST_F(FlexibleEnvelopeEventTest, ReceiveUnknownXUnionFieldWithMoreBytes) { |
| MessageStorage storage; |
| storage.Init<fidl::internal::TransactionalEvent< |
| test::ReceiveFlexibleEnvelope::OnUnknownXUnionMoreBytes>>(); |
| |
| // Manually craft a xunion response with an unknown ordinal that is larger |
| // than expected. |
| auto* real_response = storage.Build<fidl_union_t>(); |
| real_response->tag = kBadOrdinal; |
| constexpr uint32_t kUnknownBytes = 5000; |
| constexpr uint32_t kUnknownHandles = 0; |
| real_response->envelope = fidl_envelope_t{ |
| .num_bytes = kUnknownBytes, |
| .num_handles = kUnknownHandles, |
| }; |
| storage.AddGarbage(kUnknownBytes); |
| |
| ASSERT_EQ(ZX_OK, storage.Write(server_end().channel())); |
| |
| class EventHandler |
| : public fidl::testing::WireSyncEventHandlerTestBase<test::ReceiveFlexibleEnvelope> { |
| public: |
| void NotImplemented_(const std::string& name) final { ADD_FAILURE() << "Unexpected " << name; } |
| |
| void OnUnknownXUnionMoreBytes( |
| fidl::WireEvent<test::ReceiveFlexibleEnvelope::OnUnknownXUnionMoreBytes>* event) final { |
| EXPECT_FALSE(event->is_want_more_than_30_bytes()); |
| EXPECT_FALSE(event->is_want_more_than_4_handles()); |
| EXPECT_TRUE(event->IsUnknown()); |
| called = true; |
| } |
| |
| bool called = false; |
| }; |
| EventHandler event_handler; |
| fidl::Status status = event_handler.HandleOneEvent(client_end()); |
| EXPECT_TRUE(status.ok()) << status; |
| EXPECT_TRUE(event_handler.called); |
| } |
| |
| static_assert(fidl::internal::ClampedHandleCount< |
| fidl::internal::TransactionalEvent< |
| test::ReceiveFlexibleEnvelope::OnUnknownXUnionMoreHandles>, |
| fidl::MessageDirection::kReceiving>() == ZX_CHANNEL_MAX_MSG_HANDLES, |
| "Cannot assume any limit on handle count apart from the channel limit"); |
| |
| TEST_F(FlexibleEnvelopeEventTest, ReceiveUnknownXUnionFieldWithMoreHandles) { |
| MessageStorage storage; |
| storage.Init<fidl::internal::TransactionalEvent< |
| test::ReceiveFlexibleEnvelope::OnUnknownXUnionMoreHandles>>(); |
| |
| // Manually craft a xunion response with an unknown ordinal has more handles |
| // than expected. |
| auto* real_response = storage.Build<fidl_union_t>(); |
| real_response->tag = kBadOrdinal; |
| constexpr uint32_t kUnknownBytes = 16; |
| constexpr uint32_t kUnknownHandles = ZX_CHANNEL_MAX_MSG_HANDLES; |
| real_response->envelope = fidl_envelope_t{ |
| .num_bytes = kUnknownBytes, |
| .num_handles = kUnknownHandles, |
| }; |
| storage.AddGarbage(kUnknownBytes); |
| storage.AddHandles(kUnknownHandles); |
| |
| ASSERT_EQ(ZX_OK, storage.Write(server_end().channel())); |
| |
| class EventHandler |
| : public fidl::testing::WireSyncEventHandlerTestBase<test::ReceiveFlexibleEnvelope> { |
| public: |
| void NotImplemented_(const std::string& name) final { ADD_FAILURE() << "Unexpected " << name; } |
| |
| void OnUnknownXUnionMoreHandles( |
| fidl::WireEvent<test::ReceiveFlexibleEnvelope::OnUnknownXUnionMoreHandles>* event) final { |
| EXPECT_FALSE(event->is_want_more_than_30_bytes()); |
| EXPECT_FALSE(event->is_want_more_than_4_handles()); |
| EXPECT_TRUE(event->IsUnknown()); |
| called = true; |
| } |
| |
| bool called = false; |
| }; |
| EventHandler event_handler; |
| fidl::Status status = event_handler.HandleOneEvent(client_end()); |
| EXPECT_TRUE(status.ok()) << status; |
| EXPECT_TRUE(event_handler.called); |
| } |
| |
| static_assert( |
| fidl::internal::ClampedMessageSize< |
| fidl::internal::TransactionalEvent<test::ReceiveFlexibleEnvelope::OnUnknownTableMoreBytes>, |
| fidl::MessageDirection::kReceiving>() == ZX_CHANNEL_MAX_MSG_BYTES, |
| "Cannot assume any limit on byte size apart from the channel limit"); |
| |
| TEST_F(FlexibleEnvelopeEventTest, ReceiveUnknownTableFieldWithMoreBytes) { |
| MessageStorage storage; |
| storage.Init< |
| fidl::internal::TransactionalEvent<test::ReceiveFlexibleEnvelope::OnUnknownTableMoreBytes>>(); |
| |
| // Manually craft a table response with an unknown ordinal that is larger |
| // than expected. |
| auto* real_response = storage.Build<fidl_table_t>(); |
| real_response->envelopes.count = 4; |
| auto* envelopes = storage.Build<fidl_envelope_t[4]>(); |
| real_response->envelopes.data = reinterpret_cast<void*>(FIDL_ALLOC_PRESENT); // NOLINT |
| (*envelopes)[0] = fidl_envelope_t{}; |
| (*envelopes)[1] = fidl_envelope_t{}; |
| (*envelopes)[2] = fidl_envelope_t{}; |
| constexpr uint32_t kUnknownBytes = 5000; |
| constexpr uint32_t kUnknownHandles = 0; |
| (*envelopes)[3] = fidl_envelope_t{ |
| .num_bytes = kUnknownBytes, |
| .num_handles = kUnknownHandles, |
| }; |
| storage.AddGarbage(kUnknownBytes); |
| |
| ASSERT_EQ(ZX_OK, storage.Write(server_end().channel())); |
| |
| class EventHandler |
| : public fidl::testing::WireSyncEventHandlerTestBase<test::ReceiveFlexibleEnvelope> { |
| public: |
| void NotImplemented_(const std::string& name) final { ADD_FAILURE() << "Unexpected " << name; } |
| |
| void OnUnknownTableMoreBytes( |
| fidl::WireEvent<test::ReceiveFlexibleEnvelope::OnUnknownTableMoreBytes>* event) final { |
| EXPECT_FALSE(event->has_want_more_than_30_bytes_at_ordinal_3()); |
| EXPECT_FALSE(event->has_want_more_than_4_handles_at_ordinal_4()); |
| EXPECT_TRUE(event->HasUnknownData()); |
| called = true; |
| } |
| |
| bool called = false; |
| }; |
| EventHandler event_handler; |
| fidl::Status status = event_handler.HandleOneEvent(client_end()); |
| EXPECT_TRUE(status.ok()) << status; |
| EXPECT_TRUE(event_handler.called); |
| } |
| |
| static_assert(fidl::internal::ClampedMessageSize< |
| fidl::internal::TransactionalEvent< |
| test::ReceiveFlexibleEnvelope::OnUnknownTableMoreHandles>, |
| fidl::MessageDirection::kReceiving>() == ZX_CHANNEL_MAX_MSG_BYTES, |
| "Cannot assume any limit on handle count apart from the channel limit"); |
| |
| TEST_F(FlexibleEnvelopeEventTest, ReceiveUnknownTableFieldWithMoreHandles) { |
| MessageStorage storage; |
| storage.Init<fidl::internal::TransactionalEvent< |
| test::ReceiveFlexibleEnvelope::OnUnknownTableMoreHandles>>(); |
| |
| // Manually craft a table response with an unknown ordinal that has more |
| // handles than expected. |
| auto* real_response = storage.Build<fidl_table_t>(); |
| real_response->envelopes.count = 4; |
| auto* envelopes = storage.Build<fidl_envelope_t[4]>(); |
| real_response->envelopes.data = reinterpret_cast<void*>(FIDL_ALLOC_PRESENT); // NOLINT |
| (*envelopes)[0] = fidl_envelope_t{}; |
| (*envelopes)[1] = fidl_envelope_t{}; |
| (*envelopes)[2] = fidl_envelope_t{}; |
| constexpr uint32_t kUnknownBytes = 16; |
| constexpr uint32_t kUnknownHandles = ZX_CHANNEL_MAX_MSG_HANDLES; |
| (*envelopes)[3] = fidl_envelope_t{ |
| .num_bytes = kUnknownBytes, |
| .num_handles = kUnknownHandles, |
| }; |
| storage.AddGarbage(kUnknownBytes); |
| storage.AddHandles(kUnknownHandles); |
| |
| ASSERT_EQ(ZX_OK, storage.Write(server_end().channel())); |
| |
| class EventHandler |
| : public fidl::testing::WireSyncEventHandlerTestBase<test::ReceiveFlexibleEnvelope> { |
| public: |
| void NotImplemented_(const std::string& name) final { ADD_FAILURE() << "Unexpected " << name; } |
| |
| void OnUnknownTableMoreHandles( |
| fidl::WireEvent<test::ReceiveFlexibleEnvelope::OnUnknownTableMoreHandles>* event) final { |
| EXPECT_FALSE(event->has_want_more_than_30_bytes_at_ordinal_3()); |
| EXPECT_FALSE(event->has_want_more_than_4_handles_at_ordinal_4()); |
| EXPECT_TRUE(event->HasUnknownData()); |
| called = true; |
| } |
| |
| bool called = false; |
| }; |
| EventHandler event_handler; |
| fidl::Status status = event_handler.HandleOneEvent(client_end()); |
| EXPECT_TRUE(status.ok()) << status; |
| EXPECT_TRUE(event_handler.called); |
| } |
| |
| } // namespace |
