// 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/fidl/internal.h>
#include <lib/fidl/llcpp/internal/debug_thread_checker.h>
#include <lib/fidl/llcpp/internal/transport_channel.h>
#include <lib/fidl/llcpp/message.h>
#include <lib/fidl/llcpp/message_storage.h>
#include <lib/fidl/trace.h>
#include <zircon/syscalls.h>

#include <cstring>

namespace fidl {
namespace internal {

namespace {

zx_status_t channel_write(fidl_handle_t handle, WriteOptions write_options, const void* data,
                          uint32_t data_count, const fidl_handle_t* handles,
                          const void* handle_metadata, uint32_t handles_count) {
  zx_handle_disposition_t hds[ZX_CHANNEL_MAX_MSG_HANDLES];
  const fidl_channel_handle_metadata_t* metadata =
      static_cast<const fidl_channel_handle_metadata_t*>(handle_metadata);
  for (uint32_t i = 0; i < handles_count; i++) {
    hds[i] = zx_handle_disposition_t{
        .operation = ZX_HANDLE_OP_MOVE,
        .handle = handles[i],
        .type = metadata[i].obj_type,
        .rights = metadata[i].rights,
        .result = ZX_OK,
    };
  }
  return zx_channel_write_etc(handle, ZX_CHANNEL_WRITE_USE_IOVEC, data, data_count,
                              reinterpret_cast<zx_handle_disposition_t*>(hds), handles_count);
}

zx_status_t channel_read(fidl_handle_t handle, const ReadOptions& read_options, void* data,
                         uint32_t data_capacity, fidl_handle_t* handles, void* handle_metadata,
                         uint32_t handles_capacity, uint32_t* out_data_actual_count,
                         uint32_t* out_handles_actual_count) {
  uint32_t options = 0;
  if (read_options.discardable) {
    options |= ZX_CHANNEL_READ_MAY_DISCARD;
  }

  *out_data_actual_count = 0;
  *out_handles_actual_count = 0;
  zx_handle_info_t his[ZX_CHANNEL_MAX_MSG_HANDLES];
  zx_status_t status =
      zx_channel_read_etc(handle, options, data, his, data_capacity, handles_capacity,
                          out_data_actual_count, out_handles_actual_count);
  fidl_channel_handle_metadata_t* metadata =
      static_cast<fidl_channel_handle_metadata_t*>(handle_metadata);
  for (uint32_t i = 0; i < *out_handles_actual_count; i++) {
    handles[i] = his[i].handle;
    metadata[i] = fidl_channel_handle_metadata_t{
        .obj_type = his[i].type,
        .rights = his[i].rights,
    };
  }
  return status;
}

zx_status_t channel_call(fidl_handle_t handle, CallOptions call_options,
                         const CallMethodArgs& cargs, uint32_t* out_data_actual_count,
                         uint32_t* out_handles_actual_count) {
  ZX_DEBUG_ASSERT(cargs.out_rd_data == nullptr);
  ZX_DEBUG_ASSERT(cargs.rd_data != nullptr);

  zx_handle_disposition_t hds[ZX_CHANNEL_MAX_MSG_HANDLES];
  const fidl_channel_handle_metadata_t* wr_metadata =
      reinterpret_cast<const fidl_channel_handle_metadata_t*>(cargs.wr_handle_metadata);
  for (uint32_t i = 0; i < cargs.wr_handles_count; i++) {
    hds[i] = zx_handle_disposition_t{
        .operation = ZX_HANDLE_OP_MOVE,
        .handle = cargs.wr_handles[i],
        .type = wr_metadata[i].obj_type,
        .rights = wr_metadata[i].rights,
        .result = ZX_OK,
    };
  }
  zx_handle_info_t his[ZX_CHANNEL_MAX_MSG_HANDLES];
  zx_channel_call_etc_args_t args = {
      .wr_bytes = cargs.wr_data,
      .wr_handles = hds,
      .rd_bytes = cargs.rd_data,
      .rd_handles = his,
      .wr_num_bytes = cargs.wr_data_count,
      .wr_num_handles = cargs.wr_handles_count,
      .rd_num_bytes = cargs.rd_data_capacity,
      .rd_num_handles = cargs.rd_handles_capacity,
  };
  zx_status_t status =
      zx_channel_call_etc(handle, ZX_CHANNEL_WRITE_USE_IOVEC, call_options.deadline, &args,
                          out_data_actual_count, out_handles_actual_count);
  fidl_channel_handle_metadata_t* rd_metadata =
      reinterpret_cast<fidl_channel_handle_metadata_t*>(cargs.rd_handle_metadata);
  for (uint32_t i = 0; i < *out_handles_actual_count; i++) {
    cargs.rd_handles[i] = his[i].handle;
    rd_metadata[i] = fidl_channel_handle_metadata_t{
        .obj_type = his[i].type,
        .rights = his[i].rights,
    };
  }
  return status;
}

zx_status_t channel_create_waiter(fidl_handle_t handle, async_dispatcher_t* dispatcher,
                                  TransportWaitSuccessHandler success_handler,
                                  TransportWaitFailureHandler failure_handler,
                                  AnyTransportWaiter& any_transport_waiter) {
  any_transport_waiter.emplace<ChannelWaiter>(handle, dispatcher, std::move(success_handler),
                                              std::move(failure_handler));
  return ZX_OK;
}

void channel_create_thread_checker(async_dispatcher_t* dispatcher, ThreadingPolicy threading_policy,
                                   AnyThreadChecker& any_thread_checker) {
  any_thread_checker.emplace<ZirconThreadChecker>(threading_policy);
}

void channel_close(fidl_handle_t handle) { zx_handle_close(handle); }
void channel_close_many(const fidl_handle_t* handles, size_t num_handles) {
  zx_handle_close_many(handles, num_handles);
}

}  // namespace

const TransportVTable ChannelTransport::VTable = {
    .type = FIDL_TRANSPORT_TYPE_CHANNEL,
    .encoding_configuration = &ChannelTransport::EncodingConfiguration,
    .write = channel_write,
    .read = channel_read,
    .call = channel_call,
    .create_waiter = channel_create_waiter,
    .create_thread_checker = channel_create_thread_checker,
};

void ChannelWaiter::HandleWaitFinished(async_dispatcher_t* dispatcher, zx_status_t status,
                                       const zx_packet_signal_t* signal) {
  if (status != ZX_OK) {
    return failure_handler_(fidl::UnbindInfo::DispatcherError(status));
  }
  if (!(signal->observed & ZX_CHANNEL_READABLE)) {
    ZX_ASSERT(signal->observed & ZX_CHANNEL_PEER_CLOSED);
    return failure_handler_(fidl::UnbindInfo::PeerClosed(ZX_ERR_PEER_CLOSED));
  }

  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT InlineMessageBuffer<ZX_CHANNEL_MAX_MSG_BYTES> bytes;
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT zx_handle_t handles[ZX_CHANNEL_MAX_MSG_HANDLES];
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT fidl_channel_handle_metadata_t
      handle_metadata[ZX_CHANNEL_MAX_MSG_HANDLES];
  fidl_trace(WillLLCPPAsyncChannelRead);
  IncomingMessage msg = fidl::MessageRead(zx::unowned_channel(async_wait_t::object), bytes.view(),
                                          handles, handle_metadata, ZX_CHANNEL_MAX_MSG_HANDLES);
  if (!msg.ok()) {
    return failure_handler_(fidl::UnbindInfo{msg});
  }
  fidl_trace(DidLLCPPAsyncChannelRead, nullptr /* type */, bytes.data(), msg.byte_actual(),
             msg.handle_actual());
  return success_handler_(msg, IncomingTransportContext());
}

namespace {

zx_status_t channel_encode_process_handle(HandleAttributes attr, uint32_t metadata_index,
                                          void* out_metadata_array, const char** out_error) {
  reinterpret_cast<fidl_channel_handle_metadata_t*>(out_metadata_array)[metadata_index] = {
      .obj_type = attr.obj_type, .rights = attr.rights};
  return ZX_OK;
}
zx_status_t channel_decode_process_handle(fidl_handle_t* handle, HandleAttributes attr,
                                          uint32_t metadata_index, const void* metadata_array,
                                          const char** error) {
  fidl_channel_handle_metadata_t v =
      reinterpret_cast<const fidl_channel_handle_metadata_t*>(metadata_array)[metadata_index];
  return FidlEnsureHandleRights(handle, v.obj_type, v.rights, attr.obj_type, attr.rights, error);
}

}  // namespace

const CodingConfig ChannelTransport::EncodingConfiguration = {
    .max_iovecs_write = ZX_CHANNEL_MAX_MSG_IOVECS,
    .handle_metadata_stride = sizeof(fidl_channel_handle_metadata_t),
    .encode_process_handle = channel_encode_process_handle,
    .decode_process_handle = channel_decode_process_handle,
    .close = channel_close,
    .close_many = channel_close_many,
};

}  // namespace internal
}  // namespace fidl