src/lib/fidl/llcpp/tests/dispatcher/server_test.cc

// Copyright 2021 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 <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
#include <lib/fidl/cpp/wire/connect_service.h>
#include <lib/fidl/cpp/wire/server.h>
#include <lib/fidl/cpp/wire/wire_messaging.h>
#include <lib/sync/completion.h>

#include <mutex>
#include <thread>
#include <vector>

#include <zxtest/zxtest.h>

#include "lsan_disabler.h"

//
// Mock FIDL protocol and its |WireServer| definition.
//

namespace fidl_test {
namespace {
class TestProtocol {
 public:
  TestProtocol() = delete;

  using Transport = fidl::internal::ChannelTransport;
  using WeakEventSender = fidl::internal::WireWeakEventSender<fidl_test::TestProtocol>;
};
}  // namespace
}  // namespace fidl_test

template <>
struct ::fidl::IsProtocol<fidl_test::TestProtocol> : public std::true_type {};

template <>
class ::fidl::internal::WireWeakEventSender<fidl_test::TestProtocol> {
 public:
  explicit WireWeakEventSender(std::weak_ptr<fidl::internal::AsyncServerBinding>&& binding) {}
};

template <>
class ::fidl::WireServer<fidl_test::TestProtocol>
    : public ::fidl::internal::IncomingMessageDispatcher {
 public:
  WireServer() = default;
  ~WireServer() override = default;

  using _EnclosingProtocol = fidl_test::TestProtocol;
  using _Transport = fidl::internal::ChannelTransport;

 private:
  void dispatch_message(::fidl::IncomingHeaderAndMessage&& msg, ::fidl::Transaction* txn,
                        internal::MessageStorageViewBase* storage_view) final {
    std::move(msg).CloseHandles();
    txn->InternalError(::fidl::UnbindInfo::UnknownOrdinal(), ::fidl::ErrorOrigin::kReceive);
  }
};

namespace {

class TestServer : public fidl::WireServer<fidl_test::TestProtocol> {};

//
// Tests covering the error behavior of |BindServer|.
//

TEST(BindServerTestCase, DispatcherWasShutDown) {
  auto endpoints = fidl::Endpoints<fidl_test::TestProtocol>::Create();
  async::Loop loop(&kAsyncLoopConfigNoAttachToCurrentThread);
  ASSERT_OK(loop.StartThread());

  loop.Shutdown();

  ASSERT_DEATH(([&] {
    fidl_testing::RunWithLsanDisabled([&] {
      fidl::BindServer(loop.dispatcher(), std::move(endpoints.server),
                       std::make_unique<TestServer>());
    });
  }));
}

TEST(BindServerTestCase, InsufficientChannelRights) {
  async::Loop loop(&kAsyncLoopConfigNoAttachToCurrentThread);
  auto [client_end, server_end] = fidl::Endpoints<fidl_test::TestProtocol>::Create();

  zx::channel server_channel_reduced_rights;
  ASSERT_OK(server_end.channel().replace(ZX_RIGHT_NONE, &server_channel_reduced_rights));
  server_end.channel() = std::move(server_channel_reduced_rights);

  sync_completion_t unbound;
  fidl::OnUnboundFn<TestServer> on_unbound = [&](TestServer*, fidl::UnbindInfo info,
                                                 fidl::ServerEnd<fidl_test::TestProtocol>) {
    EXPECT_EQ(info.reason(), fidl::Reason::kDispatcherError);
    EXPECT_EQ(info.status(), ZX_ERR_ACCESS_DENIED);
    sync_completion_signal(&unbound);
  };
  fidl::BindServer(loop.dispatcher(), std::move(server_end), std::make_unique<TestServer>(),
                   std::move(on_unbound));

  ASSERT_OK(loop.RunUntilIdle());
  ASSERT_OK(sync_completion_wait(&unbound, ZX_TIME_INFINITE));
  ASSERT_OK(client_end.channel().wait_one(ZX_CHANNEL_PEER_CLOSED, zx::time::infinite(), nullptr));
}

TEST(BindServerTestCase, PeerAlreadyClosed) {
  async::Loop loop(&kAsyncLoopConfigNoAttachToCurrentThread);
  ASSERT_OK(loop.StartThread());

  zx::result endpoints = fidl::CreateEndpoints<fidl_test::TestProtocol>();
  ASSERT_OK(endpoints.status_value());

  endpoints->client.reset();

  sync_completion_t unbound;
  fidl::OnUnboundFn<TestServer> on_unbound = [&](TestServer*, fidl::UnbindInfo info,
                                                 fidl::ServerEnd<fidl_test::TestProtocol>) {
    EXPECT_EQ(info.reason(), fidl::Reason::kPeerClosedWhileReading);
    EXPECT_EQ(info.status(), ZX_ERR_PEER_CLOSED);
    sync_completion_signal(&unbound);
  };
  fidl::BindServer(loop.dispatcher(), std::move(endpoints->server), std::make_unique<TestServer>(),
                   std::move(on_unbound));

  ASSERT_OK(loop.RunUntilIdle());
  ASSERT_OK(sync_completion_wait(&unbound, ZX_TIME_INFINITE));
}

// Test the behavior of |fidl::internal::[Try]Dispatch| in case of a message
// with an error.
TEST(TryDispatchTestCase, MessageStatusNotOk) {
  class MockTransaction : public fidl::Transaction {
   public:
    bool errored() const { return errored_; }

   private:
    std::unique_ptr<Transaction> TakeOwnership() final { ZX_PANIC("Not used"); }
    zx_status_t Reply(fidl::OutgoingMessage* message, fidl::WriteOptions) final {
      ZX_PANIC("Not used");
    }
    void Close(zx_status_t epitaph) final { ZX_PANIC("Not used"); }
    void InternalError(fidl::UnbindInfo error, fidl::ErrorOrigin origin) final {
      EXPECT_FALSE(errored_);
      EXPECT_EQ(fidl::ErrorOrigin::kReceive, origin);
      EXPECT_EQ(fidl::Reason::kTransportError, error.reason());
      EXPECT_STATUS(ZX_ERR_BAD_HANDLE, error.status());
      errored_ = true;
    }

    bool errored_ = false;
  };

  {
    auto msg =
        fidl::IncomingHeaderAndMessage::Create(fidl::Status::TransportError(ZX_ERR_BAD_HANDLE));
    MockTransaction txn;
    fidl::DispatchResult result =
        fidl::internal::TryDispatch(nullptr, msg, nullptr, &txn, nullptr, nullptr);
    EXPECT_EQ(fidl::DispatchResult::kFound, result);
    EXPECT_TRUE(txn.errored());
  }

  {
    auto msg =
        fidl::IncomingHeaderAndMessage::Create(fidl::Status::TransportError(ZX_ERR_BAD_HANDLE));
    MockTransaction txn;
    fidl::internal::Dispatch(
        nullptr, msg, nullptr, &txn, nullptr, nullptr,
        &::fidl::internal::UnknownMethodHandlerEntry::kClosedProtocolHandlerEntry);
    EXPECT_TRUE(txn.errored());
  }
}

}  // namespace