src/connectivity/network/tun/network-tun/tun_device.cc - fuchsia - Git at Google

 // Copyright 2020 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 "tun_device.h"

 #include <lib/async-loop/default.h>
 #include <lib/async/cpp/task.h>
 #include <lib/syslog/global.h>
 #include <zircon/status.h>

 #include <fbl/auto_lock.h>

 #include "buffer.h"

 namespace network {
 namespace tun {

 namespace {
 template <typename F>
 void WithWireState(F fn, InternalState& state) {
   fidl::WireTableFrame<fuchsia_net_tun::wire::InternalState> frame;
   fuchsia_net_tun::wire::InternalState wire_state(
       fidl::ObjectView<fidl::WireTableFrame<fuchsia_net_tun::wire::InternalState>>::FromExternal(
           &frame));
   wire_state.set_has_session(state.has_session);

   fidl::WireTableFrame<fuchsia_net_tun::wire::MacState> frame_mac;
   fuchsia_net_tun::wire::MacState wire_mac(
       fidl::ObjectView<fidl::WireTableFrame<fuchsia_net_tun::wire::MacState>>::FromExternal(
           &frame_mac));
   fidl::VectorView<fuchsia_net::wire::MacAddress> multicast_filters;
   if (state.mac.has_value()) {
     MacState& mac = state.mac.value();
     wire_mac.set_mode(mac.mode);
     multicast_filters =
         fidl::VectorView<fuchsia_net::wire::MacAddress>::FromExternal(mac.multicast_filters);
     wire_mac.set_multicast_filters(
         fidl::ObjectView<fidl::VectorView<fuchsia_net::wire::MacAddress>>::FromExternal(
             &multicast_filters));
     wire_state.set_mac(fidl::ObjectView<fuchsia_net_tun::wire::MacState>::FromExternal(&wire_mac));
   }

   fn(std::move(wire_state));
 }
 }  // namespace

 TunDevice::TunDevice(fdf::Dispatcher* dispatcher, fit::callback<void(TunDevice*)> teardown,
                      DeviceConfig&& config)
     : teardown_callback_(std::move(teardown)),
       config_(std::move(config)),
       loop_(&kAsyncLoopConfigNoAttachToCurrentThread),
       dispatcher_(dispatcher) {}

 zx::result<std::unique_ptr<TunDevice>> TunDevice::Create(
     const DeviceInterfaceDispatchers& dispatchers, const ShimDispatchers& shim_dispatchers,
     fit::callback<void(TunDevice*)> teardown, DeviceConfig&& config) {
   fbl::AllocChecker ac;
   std::unique_ptr<TunDevice> tun(new (&ac)
                                      TunDevice(nullptr, std::move(teardown), std::move(config)));
   if (!ac.check()) {
     return zx::error(ZX_ERR_NO_MEMORY);
   }

   if (zx_status_t status = zx::eventpair::create(0, &tun->signals_peer_, &tun->signals_self_);
       status != ZX_OK) {
     FX_LOGF(ERROR, "tun", "TunDevice::Init failed to create eventpair %s",
             zx_status_get_string(status));
     return zx::error(status);
   }

   zx::result device = DeviceAdapter::Create(dispatchers, shim_dispatchers, tun.get());
   if (device.is_error()) {
     FX_LOGF(ERROR, "tun", "TunDevice::Init device init failed with %s", device.status_string());
     return device.take_error();
   }
   tun->device_ = std::move(device.value());

   thrd_t thread;
   if (zx_status_t status = tun->loop_.StartThread("tun-device", &thread); status != ZX_OK) {
     return zx::error(status);
   }
   tun->loop_thread_ = thread;

   return zx::ok(std::move(tun));
 }

 TunDevice::~TunDevice() {
   if (loop_thread_.has_value()) {
     // not allowed to destroy a tun device on the loop thread, will cause deadlock
     ZX_ASSERT(loop_thread_.value() != thrd_current());
   }
   // make sure that device is torn down:
   if (device_) {
     device_->TeardownSync();
   }
   loop_.Shutdown();

   FX_VLOG(1, "tun", "TunDevice destroyed");
 }

 void TunDevice::Bind(fidl::ServerEnd<fuchsia_net_tun::Device> req) {
   binding_ = fidl::BindServer(loop_.dispatcher(), std::move(req), this,
                               [](TunDevice* impl, fidl::UnbindInfo,
                                  fidl::ServerEnd<fuchsia_net_tun::Device>) { impl->Teardown(); });
 }

 void TunDevice::Teardown() {
   if (teardown_callback_) {
     teardown_callback_(this);
   }
 }

 template <typename F, typename C>
 bool TunDevice::WriteWith(F fn, C& completer) {
   zx::result avail = fn();
   switch (zx_status_t status = avail.status_value(); status) {
     case ZX_OK:
       if (avail.value() == 0) {
         // Clear the writable signal if no more buffers are available afterwards.
         signals_self_.signal_peer(uint32_t(fuchsia_net_tun::wire::Signals::kWritable), 0);
       }
       completer.ReplySuccess();
       return true;
     case ZX_ERR_SHOULD_WAIT:
       if (IsBlocking()) {
         return false;
       }
       __FALLTHROUGH;
     default:
       completer.ReplyError(status);
       return true;
   }
 }

 bool TunDevice::RunWriteFrame() {
   while (!pending_write_frame_.empty()) {
     auto& pending = pending_write_frame_.front();
     bool handled = WriteWith(
         [this, &pending]() -> zx::result<size_t> {
           std::unique_ptr<Port>& port = ports_[pending.port_id];
           if (!port) {
             return zx::error(ZX_ERR_NOT_FOUND);
           }
           return device_->WriteRxFrame(port->adapter(), pending.frame_type, pending.data,
                                        pending.meta);
         },
         pending.completer);
     if (!handled) {
       return false;
     }
     pending_write_frame_.pop();
   }
   return true;
 }

 void TunDevice::RunReadFrame() {
   while (!pending_read_frame_.empty()) {
     bool success = device_->TryGetTxBuffer([this](TxBuffer& buff, size_t avail) {
       uint8_t port_id = buff.port_id();
       if (!ports_[port_id] || !ports_[port_id]->adapter().online()) {
         return ZX_ERR_UNAVAILABLE;
       }
       std::vector<uint8_t> data;
       zx_status_t status = buff.Read(data);
       if (status != ZX_OK) {
         FX_LOGF(ERROR, "tun", "Failed to read from tx buffer: %s", zx_status_get_string(status));
         // The error reported here is relayed back to clients as an errored tx frame. There's a
         // contract about specific meanings of errors returned in a tx frame through the netdevice
         // banjo API and it might not match the semantics of the buffer API that generated this
         // error. To avoid the possible impedance mismatch, return a fixed error.
         return ZX_ERR_INTERNAL;
       }
       if (data.empty()) {
         FX_LOG(WARNING, "tun", "Ignoring empty tx buffer");
         return ZX_OK;
       }
       fidl::WireTableFrame<fuchsia_net_tun::wire::Frame> fidl_frame;
       fuchsia_net_tun::wire::Frame frame(
           fidl::ObjectView<fidl::WireTableFrame<fuchsia_net_tun::wire::Frame>>::FromExternal(
               &fidl_frame));
       fidl::VectorView data_view = fidl::VectorView<uint8_t>::FromExternal(data);
       frame.set_data(fidl::ObjectView<fidl::VectorView<uint8_t>>::FromExternal(&data_view));
       frame.set_frame_type(buff.frame_type());
       frame.set_port(port_id);
       std::optional meta = buff.TakeMetadata();
       if (meta.has_value()) {
         frame.set_meta(
             fidl::ObjectView<fuchsia_net_tun::wire::FrameMetadata>::FromExternal(&meta.value()));
       }
       pending_read_frame_.front().ReplySuccess(frame);
       pending_read_frame_.pop();
       if (avail == 0) {
         // clear Signals::READABLE if we don't have any more tx buffers.
         signals_self_.signal_peer(uint32_t(fuchsia_net_tun::wire::Signals::kReadable), 0);
       }
       return ZX_OK;
     });
     if (!success) {
       if (IsBlocking()) {
         return;
       }
       pending_read_frame_.front().ReplyError(ZX_ERR_SHOULD_WAIT);
       pending_read_frame_.pop();
     }
   }
 }

 InternalState TunDevice::Port::State() const {
   InternalState state = {
       .has_session = adapter_->has_sessions(),
   };

   const std::unique_ptr<MacAdapter>& mac = adapter_->mac();
   if (mac) {
     state.mac = mac->GetMacState();
   }
   return state;
 }

 void TunDevice::Port::RunStateChange() {
   if (!pending_watch_state_.has_value()) {
     return;
   }

   InternalState state = State();
   // only continue if any changes actually occurred compared to the last observed state
   if (last_state_.has_value() && last_state_.value() == state) {
     return;
   }

   WatchStateCompleter::Async completer = std::exchange(pending_watch_state_, std::nullopt).value();

   WithWireState(
       [&completer](fuchsia_net_tun::wire::InternalState state) { completer.Reply(state); }, state);

   // store the last informed state through WatchState
   last_state_ = std::move(state);
 }

 void TunDevice::Port::PostRunStateChange() {
   // Skip any spurious calls that might happen before initialization.
   if (!adapter_) {
     return;
   }
   async::PostTask(parent_->loop_.dispatcher(), [parent = parent_, port_id = adapter_->id()]() {
     // Port could be destroyed between callback and dispatch.
     const std::unique_ptr<Port>& port = parent->ports_[port_id];
     if (port) {
       port->RunStateChange();
     }
   });
 }

 void TunDevice::WriteFrame(WriteFrameRequestView request, WriteFrameCompleter::Sync& completer) {
   if (pending_write_frame_.size() >= kMaxPendingOps) {
     completer.ReplyError(ZX_ERR_NO_RESOURCES);
     return;
   }
   fuchsia_net_tun::wire::Frame& frame = request->frame;
   if (!frame.has_frame_type()) {
     completer.ReplyError(ZX_ERR_INVALID_ARGS);
     return;
   }
   fuchsia_hardware_network::wire::FrameType& frame_type = frame.frame_type();
   if (!frame.has_data() || frame.data().empty()) {
     completer.ReplyError(ZX_ERR_INVALID_ARGS);
     return;
   }
   fidl::VectorView<uint8_t>& frame_data = frame.data();
   if (!frame.has_port() || frame.port() >= fuchsia_hardware_network::wire::kMaxPorts) {
     completer.ReplyError(ZX_ERR_INVALID_ARGS);
     return;
   }
   uint8_t& port_id = frame.port();

   bool ready = RunWriteFrame();
   if (ready) {
     std::optional<fuchsia_net_tun::wire::FrameMetadata> meta;
     if (frame.has_meta()) {
       meta = frame.meta();
     }
     bool handled = WriteWith(
         [this, &frame_type, &frame_data, &port_id, &meta]() -> zx::result<size_t> {
           std::unique_ptr<Port>& port = ports_[port_id];
           if (!port) {
             return zx::error(ZX_ERR_NOT_FOUND);
           }
           return device_->WriteRxFrame(port->adapter(), frame_type, frame_data, meta);
         },
         completer);
     if (handled) {
       return;
     }
   }
   pending_write_frame_.emplace(frame, completer.ToAsync());
 }

 void TunDevice::ReadFrame(ReadFrameCompleter::Sync& completer) {
   if (pending_read_frame_.size() >= kMaxPendingOps) {
     completer.ReplyError(ZX_ERR_NO_RESOURCES);
     return;
   }
   pending_read_frame_.push(completer.ToAsync());
   RunReadFrame();
 }

 void TunDevice::GetSignals(GetSignalsCompleter::Sync& completer) {
   zx::eventpair dup;
   signals_peer_.duplicate(ZX_RIGHTS_BASIC, &dup);
   completer.Reply(std::move(dup));
 }

 void TunDevice::AddPort(AddPortRequestView request, AddPortCompleter::Sync& _completer) {
   zx_status_t status = [&request, this]() {
     std::optional maybe_port_config = DevicePortConfig::Create(request->config);

     if (!maybe_port_config.has_value()) {
       return ZX_ERR_INVALID_ARGS;
     }
     DevicePortConfig& port_config = maybe_port_config.value();
     std::unique_ptr<Port>& port_slot = ports_[port_config.port_id];
     if (port_slot) {
       FX_LOGF(WARNING, "tun", "port %d already exists", port_config.port_id);
       return ZX_ERR_ALREADY_EXISTS;
     }

     zx::result maybe_port = Port::Create(this, port_config);
     if (maybe_port.is_error()) {
       return maybe_port.status_value();
     }
     port_slot = std::move(maybe_port.value());
     port_slot->Bind(std::move(request->port));
     return ZX_OK;
   }();
   if (status != ZX_OK) {
     request->port.Close(status);
   }
 }

 void TunDevice::GetDevice(GetDeviceRequestView request, GetDeviceCompleter::Sync& _completer) {
   zx_status_t status = device_->Bind(std::move(request->device));
   if (status != ZX_OK) {
     FX_LOGF(ERROR, "tun", "Failed to bind to network device: %s", zx_status_get_string(status));
   }
 }

 void TunDevice::OnTxAvail(DeviceAdapter* device) {
   signals_self_.signal_peer(0, uint32_t(fuchsia_net_tun::wire::Signals::kReadable));
   async::PostTask(loop_.dispatcher(), [this]() { RunReadFrame(); });
 }

 void TunDevice::OnRxAvail(DeviceAdapter* device) {
   signals_self_.signal_peer(0, uint32_t(fuchsia_net_tun::wire::Signals::kWritable));
   async::PostTask(loop_.dispatcher(), [this]() { RunWriteFrame(); });
 }

 zx::result<std::unique_ptr<TunDevice::Port>> TunDevice::Port::Create(
     TunDevice* parent, const DevicePortConfig& config) {
   std::unique_ptr<Port> port(new Port(parent));
   std::unique_ptr<MacAdapter> mac;
   if (config.mac.has_value()) {
     zx::result status = MacAdapter::Create(port.get(), config.mac.value(), false);
     if (status.is_error()) {
       return status.take_error();
     }
     mac = std::move(*status);
   }
   port->adapter_ = std::make_unique<PortAdapter>(port.get(), config, std::move(mac));
   zx_status_t status = parent->device_->AddPort(port->adapter());
   if (status != ZX_OK) {
     FX_LOGF(ERROR, "tun", "Failed to add port: %s", zx_status_get_string(status));
     return zx::error(status);
   }
   // At this point the port has been added to netdevice and the Port object should only complete
   // destruction once the netdevice port removal notification has been received in OnPortDestroyed.
   port->port_destroyed_.emplace();
   port->SetOnline(config.online);
   return zx::ok(std::move(port));
 }

 TunDevice::Port::~Port() {
   if (binding_.has_value()) {
     binding_->Unbind();
   }
   if (port_destroyed_.has_value()) {
     port_destroyed_->Wait();
   }
 }

 void TunDevice::Port::OnHasSessionsChanged(PortAdapter& port) { PostRunStateChange(); }

 void TunDevice::Port::OnPortStatusChanged(PortAdapter& port, const port_status_t& new_status) {
   parent_->device_->OnPortStatusChanged(port.id(), new_status);
 }

 void TunDevice::Port::OnPortDestroyed(PortAdapter& port) {
   TunDevice& parent = *parent_;
   async::PostTask(parent.loop_.dispatcher(),
                   [&parent, port_id = adapter_->id()]() { parent.ports_[port_id] = nullptr; });
   if (port_destroyed_.has_value()) {
     port_destroyed_->Signal();
   }
 }

 void TunDevice::Port::OnMacStateChanged(MacAdapter* adapter) { PostRunStateChange(); }

 void TunDevice::Port::GetState(GetStateCompleter::Sync& completer) {
   InternalState state = State();
   WithWireState(
       [&completer](fuchsia_net_tun::wire::InternalState state) {
         completer.Reply(std::move(state));
       },
       state);
 }

 void TunDevice::Port::WatchState(WatchStateCompleter::Sync& completer) {
   if (pending_watch_state_) {
     // this is a programming error, we enforce that clients don't do this by closing their channel.
     completer.Close(ZX_ERR_INTERNAL);
     return;
   }
   pending_watch_state_ = completer.ToAsync();
   RunStateChange();
 }

 void TunDevice::Port::SetOnline(SetOnlineRequestView request, SetOnlineCompleter::Sync& completer) {
   SetOnline(request->online);
   completer.Reply();
 }

 void TunDevice::Port::SetOnline(bool online) {
   if (!adapter_->SetOnline(online) || online) {
     return;
   }
   // If we just went offline, we may need to complete all pending writes.
   parent_->RunWriteFrame();
   // Discard pending tx frames for all offline ports.
   auto& ports = parent_->ports_;
   parent_->device_->RetainTxBuffers([&ports](TxBuffer& buffer) {
     if (!ports[buffer.port_id()] || !ports[buffer.port_id()]->adapter().online()) {
       return ZX_ERR_UNAVAILABLE;
     }
     return ZX_OK;
   });
 }

 void TunDevice::Port::GetPort(GetPortRequestView request, GetPortCompleter::Sync& _completer) {
   zx_status_t status = parent_->device_->BindPort(adapter_->id(), std::move(request->port));
   if (status != ZX_OK) {
     FX_LOGF(ERROR, "tun", "BindPort %d failed: %s", adapter_->id(), zx_status_get_string(status));
   }
 }

 void TunDevice::Port::Remove(RemoveCompleter::Sync& _completer) {
   parent_->device_->RemovePort(adapter().id());
 }

 void TunDevice::Port::Bind(fidl::ServerEnd<fuchsia_net_tun::Port> req) {
   binding_ =
       fidl::BindServer(parent_->loop_.dispatcher(), std::move(req), this,
                        [parent = parent_, id = adapter().id()](
                            Port*, fidl::UnbindInfo info, fidl::ServerEnd<fuchsia_net_tun::Port>) {
                          // User initiated unbinds are only triggered by the
                          // destructor, which means the port was already
                          // removed.
                          if (!info.is_user_initiated()) {
                            parent->device_->RemovePort(id);
                          }
                        });
 }

 }  // namespace tun
 }  // namespace network
	// Copyright 2020 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 "tun_device.h"

	#include <lib/async-loop/default.h>
	#include <lib/async/cpp/task.h>
	#include <lib/syslog/global.h>
	#include <zircon/status.h>

	#include <fbl/auto_lock.h>

	#include "buffer.h"

	namespace network {
	namespace tun {

	namespace {
	template <typename F>
	void WithWireState(F fn, InternalState& state) {
	fidl::WireTableFrame<fuchsia_net_tun::wire::InternalState> frame;
	fuchsia_net_tun::wire::InternalState wire_state(
	fidl::ObjectView<fidl::WireTableFrame<fuchsia_net_tun::wire::InternalState>>::FromExternal(
	&frame));
	wire_state.set_has_session(state.has_session);

	fidl::WireTableFrame<fuchsia_net_tun::wire::MacState> frame_mac;
	fuchsia_net_tun::wire::MacState wire_mac(
	fidl::ObjectView<fidl::WireTableFrame<fuchsia_net_tun::wire::MacState>>::FromExternal(
	&frame_mac));
	fidl::VectorView<fuchsia_net::wire::MacAddress> multicast_filters;
	if (state.mac.has_value()) {
	MacState& mac = state.mac.value();
	wire_mac.set_mode(mac.mode);
	multicast_filters =
	fidl::VectorView<fuchsia_net::wire::MacAddress>::FromExternal(mac.multicast_filters);
	wire_mac.set_multicast_filters(
	fidl::ObjectView<fidl::VectorView<fuchsia_net::wire::MacAddress>>::FromExternal(
	&multicast_filters));
	wire_state.set_mac(fidl::ObjectView<fuchsia_net_tun::wire::MacState>::FromExternal(&wire_mac));
	}

	fn(std::move(wire_state));
	}
	} // namespace

	TunDevice::TunDevice(fdf::Dispatcher* dispatcher, fit::callback<void(TunDevice*)> teardown,
	DeviceConfig&& config)
	: teardown_callback_(std::move(teardown)),
	config_(std::move(config)),
	loop_(&kAsyncLoopConfigNoAttachToCurrentThread),
	dispatcher_(dispatcher) {}

	zx::result<std::unique_ptr<TunDevice>> TunDevice::Create(
	const DeviceInterfaceDispatchers& dispatchers, const ShimDispatchers& shim_dispatchers,
	fit::callback<void(TunDevice*)> teardown, DeviceConfig&& config) {
	fbl::AllocChecker ac;
	std::unique_ptr<TunDevice> tun(new (&ac)
	TunDevice(nullptr, std::move(teardown), std::move(config)));
	if (!ac.check()) {
	return zx::error(ZX_ERR_NO_MEMORY);
	}

	if (zx_status_t status = zx::eventpair::create(0, &tun->signals_peer_, &tun->signals_self_);
	status != ZX_OK) {
	FX_LOGF(ERROR, "tun", "TunDevice::Init failed to create eventpair %s",
	zx_status_get_string(status));
	return zx::error(status);
	}

	zx::result device = DeviceAdapter::Create(dispatchers, shim_dispatchers, tun.get());
	if (device.is_error()) {
	FX_LOGF(ERROR, "tun", "TunDevice::Init device init failed with %s", device.status_string());
	return device.take_error();
	}
	tun->device_ = std::move(device.value());

	thrd_t thread;
	if (zx_status_t status = tun->loop_.StartThread("tun-device", &thread); status != ZX_OK) {
	return zx::error(status);
	}
	tun->loop_thread_ = thread;

	return zx::ok(std::move(tun));
	}

	TunDevice::~TunDevice() {
	if (loop_thread_.has_value()) {
	// not allowed to destroy a tun device on the loop thread, will cause deadlock
	ZX_ASSERT(loop_thread_.value() != thrd_current());
	}
	// make sure that device is torn down:
	if (device_) {
	device_->TeardownSync();
	}
	loop_.Shutdown();

	FX_VLOG(1, "tun", "TunDevice destroyed");
	}

	void TunDevice::Bind(fidl::ServerEnd<fuchsia_net_tun::Device> req) {
	binding_ = fidl::BindServer(loop_.dispatcher(), std::move(req), this,
	[](TunDevice* impl, fidl::UnbindInfo,
	fidl::ServerEnd<fuchsia_net_tun::Device>) { impl->Teardown(); });
	}

	void TunDevice::Teardown() {
	if (teardown_callback_) {
	teardown_callback_(this);
	}
	}

	template <typename F, typename C>
	bool TunDevice::WriteWith(F fn, C& completer) {
	zx::result avail = fn();
	switch (zx_status_t status = avail.status_value(); status) {
	case ZX_OK:
	if (avail.value() == 0) {
	// Clear the writable signal if no more buffers are available afterwards.
	signals_self_.signal_peer(uint32_t(fuchsia_net_tun::wire::Signals::kWritable), 0);
	}
	completer.ReplySuccess();
	return true;
	case ZX_ERR_SHOULD_WAIT:
	if (IsBlocking()) {
	return false;
	}
	__FALLTHROUGH;
	default:
	completer.ReplyError(status);
	return true;
	}
	}

	bool TunDevice::RunWriteFrame() {
	while (!pending_write_frame_.empty()) {
	auto& pending = pending_write_frame_.front();
	bool handled = WriteWith(
	[this, &pending]() -> zx::result<size_t> {
	std::unique_ptr<Port>& port = ports_[pending.port_id];
	if (!port) {
	return zx::error(ZX_ERR_NOT_FOUND);
	}
	return device_->WriteRxFrame(port->adapter(), pending.frame_type, pending.data,
	pending.meta);
	},
	pending.completer);
	if (!handled) {
	return false;
	}
	pending_write_frame_.pop();
	}
	return true;
	}

	void TunDevice::RunReadFrame() {
	while (!pending_read_frame_.empty()) {
	bool success = device_->TryGetTxBuffer([this](TxBuffer& buff, size_t avail) {
	uint8_t port_id = buff.port_id();
	if (!ports_[port_id] \|\| !ports_[port_id]->adapter().online()) {
	return ZX_ERR_UNAVAILABLE;
	}
	std::vector<uint8_t> data;
	zx_status_t status = buff.Read(data);
	if (status != ZX_OK) {
	FX_LOGF(ERROR, "tun", "Failed to read from tx buffer: %s", zx_status_get_string(status));
	// The error reported here is relayed back to clients as an errored tx frame. There's a
	// contract about specific meanings of errors returned in a tx frame through the netdevice
	// banjo API and it might not match the semantics of the buffer API that generated this
	// error. To avoid the possible impedance mismatch, return a fixed error.
	return ZX_ERR_INTERNAL;
	}
	if (data.empty()) {
	FX_LOG(WARNING, "tun", "Ignoring empty tx buffer");
	return ZX_OK;
	}
	fidl::WireTableFrame<fuchsia_net_tun::wire::Frame> fidl_frame;
	fuchsia_net_tun::wire::Frame frame(
	fidl::ObjectView<fidl::WireTableFrame<fuchsia_net_tun::wire::Frame>>::FromExternal(
	&fidl_frame));
	fidl::VectorView data_view = fidl::VectorView<uint8_t>::FromExternal(data);
	frame.set_data(fidl::ObjectView<fidl::VectorView<uint8_t>>::FromExternal(&data_view));
	frame.set_frame_type(buff.frame_type());
	frame.set_port(port_id);
	std::optional meta = buff.TakeMetadata();
	if (meta.has_value()) {
	frame.set_meta(
	fidl::ObjectView<fuchsia_net_tun::wire::FrameMetadata>::FromExternal(&meta.value()));
	}
	pending_read_frame_.front().ReplySuccess(frame);
	pending_read_frame_.pop();
	if (avail == 0) {
	// clear Signals::READABLE if we don't have any more tx buffers.
	signals_self_.signal_peer(uint32_t(fuchsia_net_tun::wire::Signals::kReadable), 0);
	}
	return ZX_OK;
	});
	if (!success) {
	if (IsBlocking()) {
	return;
	}
	pending_read_frame_.front().ReplyError(ZX_ERR_SHOULD_WAIT);
	pending_read_frame_.pop();
	}
	}
	}

	InternalState TunDevice::Port::State() const {
	InternalState state = {
	.has_session = adapter_->has_sessions(),
	};

	const std::unique_ptr<MacAdapter>& mac = adapter_->mac();
	if (mac) {
	state.mac = mac->GetMacState();
	}
	return state;
	}

	void TunDevice::Port::RunStateChange() {
	if (!pending_watch_state_.has_value()) {
	return;
	}

	InternalState state = State();
	// only continue if any changes actually occurred compared to the last observed state
	if (last_state_.has_value() && last_state_.value() == state) {
	return;
	}

	WatchStateCompleter::Async completer = std::exchange(pending_watch_state_, std::nullopt).value();

	WithWireState(
	[&completer](fuchsia_net_tun::wire::InternalState state) { completer.Reply(state); }, state);

	// store the last informed state through WatchState
	last_state_ = std::move(state);
	}

	void TunDevice::Port::PostRunStateChange() {
	// Skip any spurious calls that might happen before initialization.
	if (!adapter_) {
	return;
	}
	async::PostTask(parent_->loop_.dispatcher(), [parent = parent_, port_id = adapter_->id()]() {
	// Port could be destroyed between callback and dispatch.
	const std::unique_ptr<Port>& port = parent->ports_[port_id];
	if (port) {
	port->RunStateChange();
	}
	});
	}

	void TunDevice::WriteFrame(WriteFrameRequestView request, WriteFrameCompleter::Sync& completer) {
	if (pending_write_frame_.size() >= kMaxPendingOps) {
	completer.ReplyError(ZX_ERR_NO_RESOURCES);
	return;
	}
	fuchsia_net_tun::wire::Frame& frame = request->frame;
	if (!frame.has_frame_type()) {
	completer.ReplyError(ZX_ERR_INVALID_ARGS);
	return;
	}
	fuchsia_hardware_network::wire::FrameType& frame_type = frame.frame_type();
	if (!frame.has_data() \|\| frame.data().empty()) {
	completer.ReplyError(ZX_ERR_INVALID_ARGS);
	return;
	}
	fidl::VectorView<uint8_t>& frame_data = frame.data();
	if (!frame.has_port() \|\| frame.port() >= fuchsia_hardware_network::wire::kMaxPorts) {
	completer.ReplyError(ZX_ERR_INVALID_ARGS);
	return;
	}
	uint8_t& port_id = frame.port();

	bool ready = RunWriteFrame();
	if (ready) {
	std::optional<fuchsia_net_tun::wire::FrameMetadata> meta;
	if (frame.has_meta()) {
	meta = frame.meta();
	}
	bool handled = WriteWith(
	[this, &frame_type, &frame_data, &port_id, &meta]() -> zx::result<size_t> {
	std::unique_ptr<Port>& port = ports_[port_id];
	if (!port) {
	return zx::error(ZX_ERR_NOT_FOUND);
	}
	return device_->WriteRxFrame(port->adapter(), frame_type, frame_data, meta);
	},
	completer);
	if (handled) {
	return;
	}
	}
	pending_write_frame_.emplace(frame, completer.ToAsync());
	}

	void TunDevice::ReadFrame(ReadFrameCompleter::Sync& completer) {
	if (pending_read_frame_.size() >= kMaxPendingOps) {
	completer.ReplyError(ZX_ERR_NO_RESOURCES);
	return;
	}
	pending_read_frame_.push(completer.ToAsync());
	RunReadFrame();
	}

	void TunDevice::GetSignals(GetSignalsCompleter::Sync& completer) {
	zx::eventpair dup;
	signals_peer_.duplicate(ZX_RIGHTS_BASIC, &dup);
	completer.Reply(std::move(dup));
	}

	void TunDevice::AddPort(AddPortRequestView request, AddPortCompleter::Sync& _completer) {
	zx_status_t status = [&request, this]() {
	std::optional maybe_port_config = DevicePortConfig::Create(request->config);

	if (!maybe_port_config.has_value()) {
	return ZX_ERR_INVALID_ARGS;
	}
	DevicePortConfig& port_config = maybe_port_config.value();
	std::unique_ptr<Port>& port_slot = ports_[port_config.port_id];
	if (port_slot) {
	FX_LOGF(WARNING, "tun", "port %d already exists", port_config.port_id);
	return ZX_ERR_ALREADY_EXISTS;
	}

	zx::result maybe_port = Port::Create(this, port_config);
	if (maybe_port.is_error()) {
	return maybe_port.status_value();
	}
	port_slot = std::move(maybe_port.value());
	port_slot->Bind(std::move(request->port));
	return ZX_OK;
	}();
	if (status != ZX_OK) {
	request->port.Close(status);
	}
	}

	void TunDevice::GetDevice(GetDeviceRequestView request, GetDeviceCompleter::Sync& _completer) {
	zx_status_t status = device_->Bind(std::move(request->device));
	if (status != ZX_OK) {
	FX_LOGF(ERROR, "tun", "Failed to bind to network device: %s", zx_status_get_string(status));
	}
	}

	void TunDevice::OnTxAvail(DeviceAdapter* device) {
	signals_self_.signal_peer(0, uint32_t(fuchsia_net_tun::wire::Signals::kReadable));
	async::PostTask(loop_.dispatcher(), [this]() { RunReadFrame(); });
	}

	void TunDevice::OnRxAvail(DeviceAdapter* device) {
	signals_self_.signal_peer(0, uint32_t(fuchsia_net_tun::wire::Signals::kWritable));
	async::PostTask(loop_.dispatcher(), [this]() { RunWriteFrame(); });
	}

	zx::result<std::unique_ptr<TunDevice::Port>> TunDevice::Port::Create(
	TunDevice* parent, const DevicePortConfig& config) {
	std::unique_ptr<Port> port(new Port(parent));
	std::unique_ptr<MacAdapter> mac;
	if (config.mac.has_value()) {
	zx::result status = MacAdapter::Create(port.get(), config.mac.value(), false);
	if (status.is_error()) {
	return status.take_error();
	}
	mac = std::move(*status);
	}
	port->adapter_ = std::make_unique<PortAdapter>(port.get(), config, std::move(mac));
	zx_status_t status = parent->device_->AddPort(port->adapter());
	if (status != ZX_OK) {
	FX_LOGF(ERROR, "tun", "Failed to add port: %s", zx_status_get_string(status));
	return zx::error(status);
	}
	// At this point the port has been added to netdevice and the Port object should only complete
	// destruction once the netdevice port removal notification has been received in OnPortDestroyed.
	port->port_destroyed_.emplace();
	port->SetOnline(config.online);
	return zx::ok(std::move(port));
	}

	TunDevice::Port::~Port() {
	if (binding_.has_value()) {
	binding_->Unbind();
	}
	if (port_destroyed_.has_value()) {
	port_destroyed_->Wait();
	}
	}

	void TunDevice::Port::OnHasSessionsChanged(PortAdapter& port) { PostRunStateChange(); }

	void TunDevice::Port::OnPortStatusChanged(PortAdapter& port, const port_status_t& new_status) {
	parent_->device_->OnPortStatusChanged(port.id(), new_status);
	}

	void TunDevice::Port::OnPortDestroyed(PortAdapter& port) {
	TunDevice& parent = *parent_;
	async::PostTask(parent.loop_.dispatcher(),
	[&parent, port_id = adapter_->id()]() { parent.ports_[port_id] = nullptr; });
	if (port_destroyed_.has_value()) {
	port_destroyed_->Signal();
	}
	}

	void TunDevice::Port::OnMacStateChanged(MacAdapter* adapter) { PostRunStateChange(); }

	void TunDevice::Port::GetState(GetStateCompleter::Sync& completer) {
	InternalState state = State();
	WithWireState(
	[&completer](fuchsia_net_tun::wire::InternalState state) {
	completer.Reply(std::move(state));
	},
	state);
	}

	void TunDevice::Port::WatchState(WatchStateCompleter::Sync& completer) {
	if (pending_watch_state_) {
	// this is a programming error, we enforce that clients don't do this by closing their channel.
	completer.Close(ZX_ERR_INTERNAL);
	return;
	}
	pending_watch_state_ = completer.ToAsync();
	RunStateChange();
	}

	void TunDevice::Port::SetOnline(SetOnlineRequestView request, SetOnlineCompleter::Sync& completer) {
	SetOnline(request->online);
	completer.Reply();
	}

	void TunDevice::Port::SetOnline(bool online) {
	if (!adapter_->SetOnline(online) \|\| online) {
	return;
	}
	// If we just went offline, we may need to complete all pending writes.
	parent_->RunWriteFrame();
	// Discard pending tx frames for all offline ports.
	auto& ports = parent_->ports_;
	parent_->device_->RetainTxBuffers([&ports](TxBuffer& buffer) {
	if (!ports[buffer.port_id()] \|\| !ports[buffer.port_id()]->adapter().online()) {
	return ZX_ERR_UNAVAILABLE;
	}
	return ZX_OK;
	});
	}

	void TunDevice::Port::GetPort(GetPortRequestView request, GetPortCompleter::Sync& _completer) {
	zx_status_t status = parent_->device_->BindPort(adapter_->id(), std::move(request->port));
	if (status != ZX_OK) {
	FX_LOGF(ERROR, "tun", "BindPort %d failed: %s", adapter_->id(), zx_status_get_string(status));
	}
	}

	void TunDevice::Port::Remove(RemoveCompleter::Sync& _completer) {
	parent_->device_->RemovePort(adapter().id());
	}

	void TunDevice::Port::Bind(fidl::ServerEnd<fuchsia_net_tun::Port> req) {
	binding_ =
	fidl::BindServer(parent_->loop_.dispatcher(), std::move(req), this,
	[parent = parent_, id = adapter().id()](
	Port*, fidl::UnbindInfo info, fidl::ServerEnd<fuchsia_net_tun::Port>) {
	// User initiated unbinds are only triggered by the
	// destructor, which means the port was already
	// removed.
	if (!info.is_user_initiated()) {
	parent->device_->RemovePort(id);
	}
	});
	}

	} // namespace tun
	} // namespace network