diff --git a/zircon/system/utest/usb-virtual-bus/BUILD.gn b/zircon/system/utest/usb-virtual-bus/BUILD.gn
index 9131ab3..24d5263 100644
--- a/zircon/system/utest/usb-virtual-bus/BUILD.gn
+++ b/zircon/system/utest/usb-virtual-bus/BUILD.gn
@@ -9,6 +9,7 @@
   ]
   deps = [
     "$zx/system/fidl/fuchsia-hardware-block:c",
+    "$zx/system/fidl/fuchsia-hardware-ethernet:c",
     "$zx/system/fidl/fuchsia-hardware-nand:c",
     "$zx/system/fidl/fuchsia-hardware-usb-peripheral:c",
     "$zx/system/fidl/fuchsia-hardware-usb-peripheral-block:c",
@@ -24,6 +25,7 @@
     "$zx/system/ulib/fbl",
     "$zx/system/ulib/fdio",
     "$zx/system/ulib/fidl-async",
+    "$zx/system/ulib/fzl",
     "$zx/system/ulib/launchpad",
     "$zx/system/ulib/ramdevice-client",
     "$zx/system/ulib/sync",
diff --git a/zircon/system/utest/usb-virtual-bus/usb-virtual-bus.cpp b/zircon/system/utest/usb-virtual-bus/usb-virtual-bus.cpp
index 597278db..9a8b76c 100644
--- a/zircon/system/utest/usb-virtual-bus/usb-virtual-bus.cpp
+++ b/zircon/system/utest/usb-virtual-bus/usb-virtual-bus.cpp
@@ -4,6 +4,7 @@
 
 #include <blktest/blktest.h>
 #include <block-client/client.h>
+#include <cstring>
 #include <ddk/platform-defs.h>
 #include <dirent.h>
 #include <endian.h>
@@ -12,6 +13,7 @@
 #include <fbl/string.h>
 #include <fbl/unique_ptr.h>
 #include <fcntl.h>
+#include <fuchsia/hardware/ethernet/c/fidl.h>
 #include <fuchsia/hardware/usb/peripheral/block/c/fidl.h>
 #include <fuchsia/hardware/usb/peripheral/c/fidl.h>
 #include <fuchsia/usb/virtualbus/c/fidl.h>
@@ -25,9 +27,14 @@
 #include <lib/fdio/unsafe.h>
 #include <lib/fdio/watcher.h>
 #include <lib/fidl-async/bind.h>
+#include <lib/fzl/vmo-mapper.h>
+#include <lib/zx/fifo.h>
+#include <lib/zx/vmo.h>
 #include <sys/stat.h>
 #include <unistd.h>
+#include <zircon/device/ethernet.h>
 #include <zircon/hw/usb.h>
+#include <zircon/hw/usb/cdc.h>
 #include <zircon/processargs.h>
 #include <zircon/syscalls.h>
 #include <zxtest/zxtest.h>
@@ -105,6 +112,61 @@
 public:
     static zx_status_t create(USBVirtualBus* bus) { return ZX_OK; }
 
+    // Initialize CDC. Asserts on failure.
+    void InitCDC(fbl::String* devpath, fbl::String* devpath1) {
+        fuchsia_hardware_usb_peripheral_DeviceDescriptor device_desc = {};
+        device_desc.bcdUSB = htole16(0x0200);
+        device_desc.bDeviceClass = 0;
+        device_desc.bDeviceSubClass = 0;
+        device_desc.bDeviceProtocol = 0;
+        device_desc.bMaxPacketSize0 = 64;
+        //   idVendor and idProduct are filled in later
+        device_desc.bcdDevice = htole16(0x0100);
+        // iManufacturer; iProduct and iSerialNumber are filled in later
+        device_desc.bNumConfigurations = 1;
+        ASSERT_EQ(ZX_OK, AllocateString(peripheral_, "Google", &device_desc.iManufacturer));
+        ASSERT_EQ(ZX_OK, AllocateString(peripheral_, "CDC Ethernet", &device_desc.iProduct));
+        ASSERT_EQ(ZX_OK, AllocateString(peripheral_, "ebfd5ad49d2a", &device_desc.iSerialNumber));
+        device_desc.idVendor = htole16(0x18D1);
+        device_desc.idProduct = htole16(0xA020);
+        ASSERT_EQ(ZX_OK, FidlCall(fuchsia_hardware_usb_peripheral_DeviceSetDeviceDescriptor,
+                                  peripheral_.get(), &device_desc));
+        fuchsia_hardware_usb_peripheral_FunctionDescriptor ums_function_desc = {
+            .interface_class = USB_CLASS_COMM,
+            .interface_subclass = USB_CDC_SUBCLASS_ETHERNET,
+            .interface_protocol = 0,
+        };
+        ASSERT_EQ(ZX_OK, FidlCall(fuchsia_hardware_usb_peripheral_DeviceAddFunction,
+                                  peripheral_.get(), &ums_function_desc));
+        zx::channel handles[2];
+        ASSERT_EQ(ZX_OK, zx::channel::create(0, handles, handles + 1));
+        ASSERT_EQ(ZX_OK, fuchsia_hardware_usb_peripheral_DeviceSetStateChangeListener(
+                             peripheral_.get(), handles[1].get()));
+        async_loop_config_t config = {};
+        async::Loop loop(&config);
+        DispatchContext context = {};
+        context.loop = &loop;
+        fuchsia_hardware_usb_peripheral_Events_ops ops;
+        ops.FunctionRegistered = DispatchStateChange;
+        async_dispatcher_t* dispatcher = loop.dispatcher();
+        fidl_bind(dispatcher, handles[0].get(), dispatch_wrapper, &context, &ops);
+        ASSERT_EQ(ZX_OK,
+                  FidlCall(fuchsia_hardware_usb_peripheral_DeviceBindFunctions, peripheral_.get()));
+        loop.Run();
+        ASSERT_TRUE(context.state_changed);
+        ASSERT_EQ(ZX_OK, FidlCall(fuchsia_usb_virtualbus_BusConnect, virtual_bus_handle_.get()));
+        fbl::unique_fd fd(openat(devmgr_.devfs_root().get(), "class/ethernet", O_RDONLY));
+        while (fdio_watch_directory(fd.get(), WaitForAnyFile, ZX_TIME_INFINITE, devpath) !=
+               ZX_ERR_STOP) {
+        }
+        *devpath = fbl::String::Concat({fbl::String("class/ethernet/"), *devpath});
+        const char* name2 = "001";
+        while (fdio_watch_directory(fd.get(), WaitForFile, ZX_TIME_INFINITE,
+                                    const_cast<char*>(name2)) != ZX_ERR_STOP) {
+        }
+        *devpath1 = "class/ethernet/001";
+    }
+
     // Initialize UMS. Asserts on failure.
     void InitUMS(fbl::String* devpath) {
         fuchsia_hardware_usb_peripheral_DeviceDescriptor device_desc = {};
@@ -161,6 +223,7 @@
     USBVirtualBus() {
         zx::channel chn;
         args_.disable_block_watcher = true;
+        args_.disable_netsvc = true;
         args_.driver_search_paths.push_back("/boot/driver");
         args_.driver_search_paths.push_back("/boot/driver/test");
         board_test::DeviceEntry dev = {};
@@ -314,6 +377,84 @@
     int root_fd_;
 };
 
+class CDCDeviceController {
+public:
+    explicit CDCDeviceController(zx::unowned_channel peripheral, zx::unowned_channel bus,
+                                 int root_fd)
+        : peripheral_(peripheral), bus_(bus), root_fd_(root_fd) {}
+
+    zx_status_t Disconnect() {
+        zx_status_t status =
+            FidlCall(fuchsia_hardware_usb_peripheral_DeviceClearFunctions, peripheral_->get());
+        if (status != ZX_OK) {
+            return status;
+        }
+        status = FidlCall(fuchsia_usb_virtualbus_BusDisconnect, bus_->get());
+        if (status != ZX_OK) {
+            return status;
+        }
+
+        return ZX_OK;
+    }
+
+    zx_status_t Connect() {
+        fuchsia_hardware_usb_peripheral_FunctionDescriptor ums_function_desc = {
+            .interface_class = USB_CLASS_COMM,
+            .interface_subclass = USB_CDC_SUBCLASS_ETHERNET,
+            .interface_protocol = 0,
+        };
+        zx_status_t status = FidlCall(fuchsia_hardware_usb_peripheral_DeviceAddFunction,
+                                      peripheral_->get(), &ums_function_desc);
+        if (status != ZX_OK) {
+            return status;
+        }
+        zx_handle_t handles[2];
+        status = zx_channel_create(0, handles, handles + 1);
+        if (status != ZX_OK) {
+            return status;
+        }
+        status = fuchsia_hardware_usb_peripheral_DeviceSetStateChangeListener(peripheral_->get(),
+                                                                              handles[1]);
+        if (status != ZX_OK) {
+            return status;
+        }
+        async_loop_config_t config = {};
+        async::Loop loop(&config);
+        DispatchContext context = {};
+        context.loop = &loop;
+        fuchsia_hardware_usb_peripheral_Events_ops ops;
+        ops.FunctionRegistered = DispatchStateChange;
+        async_dispatcher_t* dispatcher = loop.dispatcher();
+        fidl_bind(dispatcher, handles[0], dispatch_wrapper, &context, &ops);
+        status = loop.StartThread("async-thread");
+        if (status != ZX_OK) {
+            return status;
+        }
+        status = FidlCall(fuchsia_hardware_usb_peripheral_DeviceBindFunctions, peripheral_->get());
+        if (status != ZX_OK) {
+            return status;
+        }
+        loop.JoinThreads();
+        fbl::String devpath;
+        while (fdio_watch_directory(openat(root_fd_, "class/ethernet", O_RDONLY), WaitForAnyFile,
+                                    ZX_TIME_INFINITE, &devpath) != ZX_ERR_STOP)
+            ;
+        if (!context.state_changed) {
+            return ZX_ERR_INTERNAL;
+        }
+        if (status != ZX_OK) {
+            return status;
+        }
+        status = FidlCall(fuchsia_usb_virtualbus_BusConnect, bus_->get());
+        return ZX_OK;
+    }
+
+private:
+    zx::unowned_channel peripheral_;
+    zx::unowned_channel bus_;
+    int root_fd_;
+};
+
 class UmsTest : public zxtest::Test {
 public:
     void SetUp() override;
@@ -321,9 +462,10 @@
 
 protected:
     USBVirtualBus bus_;
-    fbl::String devpath_;
+    fbl::String peripheral_path_;
     zx::unowned_channel peripheral_;
     zx::unowned_channel virtual_bus_handle_;
+
     fbl::String GetTestdevPath() {
         // Open the block device
         // Special case for bad block mode. Need to enumerate the singleton block device.
@@ -360,8 +502,68 @@
     fbl::String last_known_devpath_;
 };
 
+class CDCTest : public zxtest::Test {
+public:
+    void SetUp() override;
+    void TearDown() override;
+
+protected:
+    USBVirtualBus bus_;
+    fbl::String peripheral_path_;
+    fbl::String host_path_;
+    zx::unowned_channel peripheral_;
+    zx::unowned_channel virtual_bus_handle_;
+    void GetTestdevPath() {
+        // Open the Ethernet device
+        peripheral_path_ = "";
+        host_path_ = "";
+        while (true) {
+            fbl::unique_fd fd(openat(bus_.GetRootFd(), "class/ethernet", O_RDONLY));
+            DIR* dir_handle = fdopendir(fd.get());
+            fbl::AutoCall release_dir([=]() { closedir(dir_handle); });
+            bool found = false;
+            for (dirent* ent = readdir(dir_handle); ent; ent = readdir(dir_handle)) {
+                if (strcmp(ent->d_name, ".") && strcmp(ent->d_name, "..")) {
+                    peripheral_path_ = fbl::String::Concat(
+                        {fbl::String("class/ethernet/"), fbl::String(ent->d_name)});
+                    found = true;
+                    break;
+                }
+            }
+            if (found) {
+                break;
+            }
+        }
+        while (true) {
+            fbl::unique_fd fd(openat(bus_.GetRootFd(), "class/ethernet", O_RDONLY));
+            DIR* dir_handle = fdopendir(fd.get());
+            fbl::AutoCall release_dir([=]() { closedir(dir_handle); });
+            for (dirent* ent = readdir(dir_handle); ent; ent = readdir(dir_handle)) {
+                if (strcmp(ent->d_name, ".") && strcmp(ent->d_name, "..") &&
+                    (strcmp(ent->d_name, peripheral_path_.c_str()))) {
+                    host_path_ = fbl::String::Concat(
+                        {fbl::String("class/ethernet/"), fbl::String(ent->d_name)});
+                    return;
+                }
+            }
+        }
+    }
+
+    // Waits for the Ethernet device to be removed
+    // TODO (ZX-3385, ZX-3586) -- Use something better
+    // than a busy loop.
+    void WaitForRemove() {
+        struct stat dirinfo;
+        while (!stat(last_known_devpath_.c_str(), &dirinfo))
+            ;
+    }
+
+private:
+    fbl::String last_known_devpath_;
+};
+
 void UmsTest::SetUp() {
-    ASSERT_NO_FATAL_FAILURES(bus_.InitUMS(&devpath_));
+    ASSERT_NO_FATAL_FAILURES(bus_.InitUMS(&peripheral_path_));
     bus_.GetHandles(&peripheral_, &virtual_bus_handle_);
 }
 
@@ -371,6 +573,16 @@
     ASSERT_EQ(ZX_OK, FidlCall(fuchsia_usb_virtualbus_BusDisable, virtual_bus_handle_->get()));
 }
 
+void CDCTest::SetUp() {
+    ASSERT_NO_FATAL_FAILURES(bus_.InitCDC(&peripheral_path_, &host_path_));
+    bus_.GetHandles(&peripheral_, &virtual_bus_handle_);
+}
+
+void CDCTest::TearDown() {
+    ASSERT_EQ(ZX_OK,
+              FidlCall(fuchsia_hardware_usb_peripheral_DeviceClearFunctions, peripheral_->get()));
+    ASSERT_EQ(ZX_OK, FidlCall(fuchsia_usb_virtualbus_BusDisable, virtual_bus_handle_->get()));
+}
 TEST_F(UmsTest, ReconnectTest) {
     // Disconnect and re-connect the block device 50 times as a sanity check
     // for race conditions and deadlocks.
@@ -399,14 +611,14 @@
     block_info_t info;
     __UNUSED ssize_t rc = ioctl_block_get_info(fd.get(), &info);
     uint32_t blk_size = info.block_size;
-    fbl::unique_ptr<uint8_t[]> write_buffer(new uint8_t[blk_size]);
-    fbl::unique_ptr<uint8_t[]> read_buffer(new uint8_t[blk_size]);
+    std::unique_ptr<uint8_t[]> write_buffer(new uint8_t[blk_size]);
+    std::unique_ptr<uint8_t[]> read_buffer(new uint8_t[blk_size]);
     ASSERT_EQ(blk_size, static_cast<uint64_t>(read(fd.get(), read_buffer.get(), blk_size)));
     close(fd.release());
     fd = fbl::unique_fd(openat(bus_.GetRootFd(), GetTestdevPath().c_str(), O_RDWR));
     // Create a pattern to write to the block device
     for (size_t i = 0; i < blk_size; i++) {
-        write_buffer.get()[i] = static_cast<unsigned char>(i);
+        write_buffer.get()[i] = static_cast<uint8_t>(i);
     }
     // Write the data to the block device
     ASSERT_EQ(blk_size, static_cast<uint64_t>(write(fd.get(), write_buffer.get(), blk_size)));
@@ -434,10 +646,10 @@
     __UNUSED ssize_t rc = ioctl_block_get_info(fd.get(), &info);
     uint32_t blk_size = info.block_size;
     // Allocate our buffer
-    fbl::unique_ptr<uint8_t[]> write_buffer(new uint8_t[blk_size]);
+    std::unique_ptr<uint8_t[]> write_buffer(new uint8_t[blk_size]);
     // Generate and write a pattern to the block device
     for (size_t i = 0; i < blk_size; i++) {
-        write_buffer.get()[i] = static_cast<unsigned char>(i);
+        write_buffer.get()[i] = static_cast<uint8_t>(i);
     }
     ASSERT_EQ(blk_size, static_cast<uint64_t>(write(fd.get(), write_buffer.get(), blk_size)));
     memset(write_buffer.get(), 0, blk_size);
@@ -450,7 +662,7 @@
     // since writeback caching was disabled.
     ASSERT_EQ(blk_size, static_cast<uint64_t>(read(fd.get(), write_buffer.get(), blk_size)));
     for (size_t i = 0; i < blk_size; i++) {
-        ASSERT_EQ(write_buffer.get()[i], static_cast<unsigned char>(i));
+        ASSERT_EQ(write_buffer.get()[i], static_cast<uint8_t>(i));
     }
 }
 
@@ -476,4 +688,227 @@
     EXPECT_EQ(proc_info.return_code, 0);
 }
 
+class EthernetInterface {
+public:
+    EthernetInterface(fbl::unique_fd fd) {
+        ASSERT_OK(fdio_get_service_handle(fd.get(), ethernet_handle_.reset_and_get_address()));
+
+        // Get device information
+        fuchsia_hardware_ethernet_Info info;
+        ASSERT_OK(fuchsia_hardware_ethernet_DeviceGetInfo(ethernet_handle_.get(), &info));
+        zx_status_t status1;
+        fuchsia_hardware_ethernet_Fifos fifos;
+        ASSERT_OK(
+            fuchsia_hardware_ethernet_DeviceGetFifos(ethernet_handle_.get(), &status1, &fifos));
+        ASSERT_OK(status1);
+        rx_depth_ = fifos.rx_depth;
+        tx_depth_ = fifos.tx_depth;
+        mtu_ = static_cast<uint16_t>(info.mtu);
+        // Calculate optimal size of VMO, and set up RX and TX buffers.
+        size_t optimal_vmo_size = (fifos.rx_depth * info.mtu) + (fifos.tx_depth * info.mtu);
+        uint64_t size;
+        ASSERT_OK(zx::vmo::create(optimal_vmo_size, ZX_VMO_NON_RESIZABLE, &vmo_));
+        ASSERT_OK(vmo_.get_size(&size));
+        ASSERT_OK(mapper_.Map(vmo_, 0, size, ZX_VM_FLAG_PERM_READ | ZX_VM_FLAG_PERM_WRITE));
+        xfer_region_ = static_cast<uint8_t*>(mapper_.start());
+        ASSERT_OK(FidlCall(fuchsia_hardware_ethernet_DeviceSetIOBuffer, ethernet_handle_.get(),
+                           vmo_.get()));
+        ASSERT_OK(FidlCall(fuchsia_hardware_ethernet_DeviceStart, ethernet_handle_.get()));
+        tx_.reset(fifos.tx);
+        rx_.reset(fifos.rx);
+        // Give all RX entries to the Ethernet driver
+        size_t count;
+        rx_entries_ = std::make_unique<eth_fifo_entry_t[]>(rx_depth_);
+        for (uint32_t i = 0; i < rx_depth_; i++) {
+            rx_entries_[i].offset = i * info.mtu;
+            rx_entries_[i].length = static_cast<uint16_t>(info.mtu);
+            rx_entries_[i].flags = 0;
+            rx_entries_[i].cookie = 0;
+        }
+        ASSERT_OK(rx_.write(sizeof(eth_fifo_entry_t), rx_entries_.get(), rx_depth_, &count));
+        ASSERT_EQ(count, rx_depth_);
+    }
+
+    // Receives data from the EthernetInterface
+    // Returns an array of eth_fifo_entry_t which are owned by this EthernetInterface.
+    // The number of entries received is stored in length.
+    // If this function returns something other than ZX_OK, the values of *output and *length
+    // are undefined.
+    zx_status_t Receive(eth_fifo_entry_t** output, size_t* length) {
+        zx_signals_t pending = 0;
+        rx_.wait_one(ZX_FIFO_READABLE | ZX_FIFO_PEER_CLOSED, zx::time::infinite(), &pending);
+        zx_status_t status =
+            rx_.read(sizeof(eth_fifo_entry_t), rx_entries_.get(), rx_depth_, length);
+        if (status != ZX_OK) {
+            return status;
+        }
+        *output = rx_entries_.get();
+        return ZX_OK;
+    }
+
+    zx_status_t Send(const eth_fifo_entry_t* data, size_t* length) {
+        return tx_.write(sizeof(eth_fifo_entry_t), data, *length, length);
+    }
+
+    std::unique_ptr<eth_fifo_entry_t[]> AllocateTXEntries() {
+        auto entries = std::make_unique<eth_fifo_entry_t[]>(tx_depth_);
+        for (uint32_t i = 0; i < tx_depth_; i++) {
+            entries[i].flags = 0;
+            entries[i].length = mtu_;
+            entries[i].offset = static_cast<uint32_t>((i * mtu_) + (rx_depth_ * mtu_));
+            entries[i].cookie = 1;
+        }
+        return entries;
+    }
+
+    size_t tx_depth() { return tx_depth_; }
+
+    uint8_t* xfer_region() { return xfer_region_; }
+
+private:
+    fzl::VmoMapper mapper_;
+    uint8_t* xfer_region_;
+    zx::channel ethernet_handle_;
+    zx::fifo rx_;
+    zx::fifo tx_;
+    zx::vmo vmo_;
+    size_t rx_depth_;
+    size_t tx_depth_;
+    uint16_t mtu_;
+    std::unique_ptr<eth_fifo_entry_t[]> rx_entries_;
+    DISALLOW_COPY_ASSIGN_AND_MOVE(EthernetInterface);
+};
+
+TEST_F(CDCTest, ReconnectTest) {
+    // Disconnect and re-connect the Ethernet interface 50 times as a sanity check
+    // for race conditions and deadlocks.
+    // If the test freezes; or something crashes at this point, it is likely
+    // a regression in a driver (not a test flake).
+    CDCDeviceController controller(zx::unowned_channel(peripheral_),
+                                   zx::unowned_channel(virtual_bus_handle_), bus_.GetRootFd());
+    for (size_t i = 0; i < 50; i++) {
+        ASSERT_OK(controller.Disconnect());
+        WaitForRemove();
+        ASSERT_OK(controller.Connect());
+        GetTestdevPath();
+        EthernetInterface peripheral_ethernet(
+            fbl::unique_fd(openat(bus_.GetRootFd(), peripheral_path_.c_str(), O_RDWR)));
+        EthernetInterface host_ethernet(
+            fbl::unique_fd(openat(bus_.GetRootFd(), host_path_.c_str(), O_RDWR)));
+        ASSERT_NO_FATAL_FAILURES();
+        auto tx_buffer = peripheral_ethernet.AllocateTXEntries();
+        size_t length = peripheral_ethernet.tx_depth();
+        ASSERT_OK(peripheral_ethernet.Send(tx_buffer.get(), &length));
+        ASSERT_EQ(length, peripheral_ethernet.tx_depth());
+    }
+}
+
+TEST_F(CDCTest, EthernetDoesNotCrashOnUnbindWithPendingTransmitsOnPeripheralSide) {
+    EthernetInterface peripheral_ethernet(
+        fbl::unique_fd(openat(bus_.GetRootFd(), peripheral_path_.c_str(), O_RDWR)));
+    EthernetInterface host_ethernet(
+        fbl::unique_fd(openat(bus_.GetRootFd(), host_path_.c_str(), O_RDWR)));
+    ASSERT_NO_FATAL_FAILURES();
+    auto tx_buffer = peripheral_ethernet.AllocateTXEntries();
+    size_t length = peripheral_ethernet.tx_depth();
+    ASSERT_OK(peripheral_ethernet.Send(tx_buffer.get(), &length));
+    ASSERT_EQ(length, peripheral_ethernet.tx_depth());
+}
+
+TEST_F(CDCTest, EthernetDoesNotCrashOnUnbindWithPendingTransmitsOnHostSide) {
+    EthernetInterface host_ethernet(
+        fbl::unique_fd(openat(bus_.GetRootFd(), host_path_.c_str(), O_RDWR)));
+    ASSERT_NO_FATAL_FAILURES();
+    auto tx = host_ethernet.AllocateTXEntries();
+    size_t length = host_ethernet.tx_depth();
+    ASSERT_OK(host_ethernet.Send(tx.get(), &length));
+    ASSERT_EQ(length, host_ethernet.tx_depth());
+}
+
+TEST_F(CDCTest, PeripheralTransmitsToHost) {
+    EthernetInterface peripheral_ethernet(
+        fbl::unique_fd(openat(bus_.GetRootFd(), peripheral_path_.c_str(), O_RDWR)));
+    EthernetInterface host_ethernet(
+        fbl::unique_fd(openat(bus_.GetRootFd(), host_path_.c_str(), O_RDWR)));
+    ASSERT_NO_FATAL_FAILURES();
+    auto tx_buffer = peripheral_ethernet.AllocateTXEntries();
+    for (size_t i = 0; i < peripheral_ethernet.tx_depth(); i++) {
+        auto info = tx_buffer[i];
+        memcpy(peripheral_ethernet.xfer_region() + info.offset, &i, sizeof(i));
+        for (size_t c = sizeof(i); c < info.length; c++) {
+            peripheral_ethernet.xfer_region()[c + info.offset] =
+                c == 16 ? 255 : static_cast<uint8_t>(c + i);
+        }
+    }
+    size_t length = peripheral_ethernet.tx_depth();
+    ASSERT_OK(peripheral_ethernet.Send(tx_buffer.get(), &length));
+    ASSERT_EQ(length, peripheral_ethernet.tx_depth());
+    auto completions = std::make_unique<bool[]>(length);
+    memset(completions.get(), 0, sizeof(bool) * length);
+    size_t packets_received = 0;
+    while (packets_received < length) {
+        eth_fifo_entry_t* entries = nullptr;
+        size_t len;
+        ASSERT_OK(host_ethernet.Receive(&entries, &len));
+        if (host_ethernet.xfer_region()[entries[0].offset + 16] == 255) {
+            for (size_t i = 0; i < len; i++) {
+                eth_fifo_entry_t entry = entries[i];
+                size_t idx;
+                memcpy(&idx, host_ethernet.xfer_region() + entry.offset, sizeof(idx));
+                for (size_t c = sizeof(size_t); c < entry.length; c++) {
+                    ASSERT_EQ(host_ethernet.xfer_region()[entry.offset + c],
+                              c == 16 ? 255 : static_cast<uint8_t>(c + idx));
+                }
+                if (!completions[idx]) {
+                    packets_received++;
+                    completions[idx] = true;
+                }
+            }
+        }
+    }
+}
+
+TEST_F(CDCTest, HostTransmitsToPeripheral) {
+    EthernetInterface peripheral_ethernet(
+        fbl::unique_fd(openat(bus_.GetRootFd(), peripheral_path_.c_str(), O_RDWR)));
+    EthernetInterface host_ethernet(
+        fbl::unique_fd(openat(bus_.GetRootFd(), host_path_.c_str(), O_RDWR)));
+    ASSERT_NO_FATAL_FAILURES();
+    auto tx_buffer = host_ethernet.AllocateTXEntries();
+    for (size_t i = 0; i < host_ethernet.tx_depth(); i++) {
+        auto info = tx_buffer[i];
+        memcpy(host_ethernet.xfer_region() + info.offset, &i, sizeof(i));
+        for (size_t c = sizeof(i); c < info.length; c++) {
+            host_ethernet.xfer_region()[c + info.offset] =
+                c == 16 ? 255 : static_cast<uint8_t>(c + i);
+        }
+    }
+    size_t length = host_ethernet.tx_depth();
+    ASSERT_OK(host_ethernet.Send(tx_buffer.get(), &length));
+    ASSERT_EQ(length, host_ethernet.tx_depth());
+    std::unique_ptr<bool[]> completions = std::make_unique<bool[]>(length);
+    memset(completions.get(), 0, sizeof(bool) * length);
+    size_t packets_received = 0;
+    while (packets_received < length) {
+        eth_fifo_entry_t* entries = nullptr;
+        size_t len;
+        ASSERT_OK(peripheral_ethernet.Receive(&entries, &len));
+        if (peripheral_ethernet.xfer_region()[entries[0].offset + 16] == 255) {
+            for (size_t i = 0; i < len; i++) {
+                eth_fifo_entry_t entry = entries[i];
+                size_t idx;
+                memcpy(&idx, peripheral_ethernet.xfer_region() + entry.offset, sizeof(idx));
+                for (size_t c = sizeof(size_t); c < entry.length; c++) {
+                    ASSERT_EQ(peripheral_ethernet.xfer_region()[entry.offset + c],
+                              c == 16 ? 255 : static_cast<uint8_t>(c + idx));
+                }
+                if (!completions[idx]) {
+                    packets_received++;
+                    completions[idx] = true;
+                }
+            }
+        }
+    }
+}
+
 } // namespace