// Copyright 2017 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 <arpa/inet.h>
#include <fcntl.h>
#include <fuchsia/hardware/ethernet/c/fidl.h>
#include <inttypes.h>
#include <lib/fdio/directory.h>
#include <lib/fdio/fd.h>
#include <lib/fdio/fdio.h>
#include <lib/zx/channel.h>
#include <lib/zx/clock.h>
#include <lib/zx/fifo.h>
#include <lib/zx/vmo.h>
#include <limits.h>
#include <netinet/if_ether.h>
#include <netinet/ip.h>
#include <netinet/ip6.h>
#include <netinet/tcp.h>
#include <netinet/udp.h>
#include <stdlib.h>
#include <unistd.h>
#include <zircon/assert.h>
#include <zircon/boot/netboot.h>
#include <zircon/device/ethernet.h>
#include <zircon/process.h>
#include <zircon/processargs.h>
#include <zircon/syscalls.h>

#include <cstdint>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <sstream>
#include <string>
#include <vector>

#include <pretty/hexdump.h>

#include "filter_builder_impl.h"

static constexpr size_t BUFSIZE = 2048;
static constexpr size_t STRBUFSIZE = 256;
static constexpr int64_t DEFAULT_TIMEOUT_SECONDS = 60;

namespace netdump {

enum class PrintFormat {
  LOG,
  HEXDUMP,
  PCAPNG,
};

class NetdumpOptions {
 public:
  std::string device;
  PrintFormat print_format = PrintFormat::LOG;
  bool link_level = false;
  bool promisc = false;
  std::optional<uint64_t> packet_count = std::nullopt;
  size_t verbose_level = 0;
  int dumpfile_fd = -1;
  zx::time timeout_deadline = zx::time::infinite();
  Tokenizer tokenizer{};
  parser::Parser parser{tokenizer};
  FilterPtr filter = nullptr;
  FilterPtr highlight_filter = nullptr;
};

typedef struct {
  uint32_t type;
  uint32_t blk_tot_len;
  uint32_t magic;
  uint16_t major;
  uint16_t minor;
  uint64_t section_len;
  // TODO(smklein): Add options here
  uint32_t blk_tot_len2;
} __attribute__((packed)) pcap_shb_t;

typedef struct {
  uint32_t type;
  uint32_t blk_tot_len;
  uint16_t linktype;
  uint16_t reserved;
  uint32_t snaplen;
  uint32_t blk_tot_len2;
} __attribute__((packed)) pcap_idb_t;

typedef struct {
  uint32_t type;
  uint32_t blk_tot_len;
  uint32_t pkt_len;
} __attribute__((packed)) simple_pkt_t;

// Statistics tracking netdump operations
struct Stats {
  // Packet counts
  uint64_t pkts_filtered_in;
  uint64_t pkts_filtered_out;
  uint64_t pkts_len_small;    // Too small to be parsed.
  uint64_t pkts_eth_rx_fail;  // ETH_FIFO_RX_OK flag unset

  // Byte counts
  uint64_t bytes_filtered_in;
  uint64_t bytes_filtered_out;
  uint64_t bytes_len_small;
  uint64_t bytes_eth_rx_fail;

  // File dump statistics
  uint64_t pkts_write_ok;
  uint64_t pkts_write_fail;

  // Extend below.
};

static constexpr size_t SIMPLE_PKT_MIN_SIZE = sizeof(simple_pkt_t) + sizeof(uint32_t);

static std::string mac_to_string(const uint8_t mac[ETH_ALEN]) {
  std::stringstream stream;
  stream.flags(std::ios::hex);
  stream.fill('0');
  // clang-format off
  // Cast is required to make `stream` not interpret input as a char.
  stream << std::setw(2) << static_cast<uint16_t>(mac[0]) << ":"
         << std::setw(2) << static_cast<uint16_t>(mac[1]) << ":"
         << std::setw(2) << static_cast<uint16_t>(mac[2]) << ":"
         << std::setw(2) << static_cast<uint16_t>(mac[3]) << ":"
         << std::setw(2) << static_cast<uint16_t>(mac[4]) << ":"
         << std::setw(2) << static_cast<uint16_t>(mac[5]);
  // clang-format on
  return stream.str();
}

static std::string ethtype_to_string(uint16_t ethtype) {
  switch (ethtype) {
    case ETH_P_IP:
      return "IPv4";
    case ETH_P_ARP:
      return "ARP";
    case ETH_P_IPV6:
      return "IPv6";
    case ETH_P_8021Q:
      return "802.1Q";
    default:
      return "Unknown";
  }
}

static std::string protocol_to_string(uint8_t protocol) {
  switch (protocol) {
    case IPPROTO_HOPOPTS:
      return "HOPOPTS";
    case IPPROTO_TCP:
      return "TCP";
    case IPPROTO_UDP:
      return "UDP";
    case IPPROTO_ICMP:
      return "ICMP";
    case IPPROTO_ROUTING:
      return "ROUTING";
    case IPPROTO_FRAGMENT:
      return "FRAGMENT";
    case IPPROTO_ICMPV6:
      return "ICMPV6";
    case IPPROTO_NONE:
      return "NONE";
    default:
      return "Transport Unknown";
  }
}

static std::string port_to_string(uint16_t port) {
  switch (port) {
    case 7:
      return "Echo";
    case 20:
      return "FTP xfer";
    case 21:
      return "FTP ctl";
    case 22:
      return "SSH";
    case 23:
      return "Telnet";
    case 53:
      return "DNS";
    case 69:
      return "TFTP";
    case 80:
      return "HTTP";
    case 115:
      return "SFTP";
    case 123:
      return "NTP";
    case 194:
      return "IRC";
    case 443:
      return "HTTPS";
    case DEBUGLOG_PORT:
      return "Netboot Debug";
    case DEBUGLOG_ACK_PORT:
      return "Netboot Debug ack";
    default:
      return "";
  }
}

static inline std::string port_string_by_verbosity(uint16_t port, size_t verbosity) {
  std::string port_name = port_to_string(port);
  std::stringstream stream;
  stream << port;
  if (verbosity && !port_name.empty()) {
    stream << " (" << port_name << ")";
  }
  return stream.str();
}

// Test if the packet should be highlit.
inline bool to_highlight(const Packet& packet, const NetdumpOptions& options) {
  return (options.highlight_filter != nullptr && options.highlight_filter->match(packet));
}

// Write link level information to `stream` and return the ethtype.
uint16_t parse_l2_packet(const Packet& packet, const NetdumpOptions& options,
                         std::stringstream* stream) {
  ZX_ASSERT(stream != nullptr);
  uint16_t ethtype = ntohs(packet.eth->h_proto);
  if (options.link_level) {
    *stream << mac_to_string(packet.eth->h_source) << " > " << mac_to_string(packet.eth->h_dest)
            << ", ethertype " << ethtype_to_string(ethtype) << " (0x" << std::hex << ethtype
            << std::dec << "), ";
  }
  return ethtype;
}

// Write L3 information to `stream` and return the transport protocol number if L3 protocol is IP.
uint8_t parse_l3_packet(uint16_t ethtype, const Packet& packet, const NetdumpOptions& options,
                        std::stringstream* stream) {
  ZX_ASSERT(stream != nullptr);
  const struct iphdr* ip = packet.ip;
  char buf[STRBUFSIZE];
  switch (ip->version) {
    case 4: {
      *stream << "IP4 " << inet_ntop(AF_INET, &ip->saddr, buf, sizeof(buf)) << " > "
              << inet_ntop(AF_INET, &ip->daddr, buf, sizeof(buf)) << ": "
              << protocol_to_string(ip->protocol) << ", "
              << "length " << ntohs(ip->tot_len) << ", ";
      return ip->protocol;
    }
    case 6: {
      const struct ip6_hdr* ipv6 = packet.ipv6;
      *stream << "IP6 " << inet_ntop(AF_INET6, &ipv6->ip6_src.s6_addr, buf, sizeof(buf)) << " > "
              << inet_ntop(AF_INET6, &ipv6->ip6_dst.s6_addr, buf, sizeof(buf)) << ": "
              << protocol_to_string(ipv6->ip6_nxt) << ", "
              << "length " << ntohs(ipv6->ip6_plen) << ", ";
      return ipv6->ip6_nxt;
    }
    default: {
      ZX_DEBUG_ASSERT_MSG(false, "Ethtype recognized but IP headers malformed.");
      return 0;
    }
  }
}

void parse_l4_packet(uint8_t transport_protocol, const Packet& packet,
                     const NetdumpOptions& options, std::stringstream* stream) {
  ZX_ASSERT(stream != nullptr);
  switch (transport_protocol) {
    case IPPROTO_TCP: {
      const struct tcphdr* tcp = packet.tcp;
      *stream << "Ports: " << port_string_by_verbosity(ntohs(tcp->source), options.verbose_level)
              << " > " << port_string_by_verbosity(ntohs(tcp->dest), options.verbose_level);
      return;
    }
    case IPPROTO_UDP: {
      const struct udphdr* udp = packet.udp;
      *stream << "Ports: " << port_string_by_verbosity(ntohs(udp->uh_sport), options.verbose_level)
              << " > " << port_string_by_verbosity(ntohs(udp->uh_dport), options.verbose_level);
      return;
    }
    default: {
      ZX_DEBUG_ASSERT_MSG(false, "Transport protocol recognized but headers malformed.");
      return;
    }
  }
}

void parse_packet(const Packet& packet, const NetdumpOptions& options) {
  std::stringstream stream;
  auto is_highlit = to_highlight(packet, options);
  if (is_highlit) {
    stream << parser::ANSI_HIGHLIGHT;
  }
  uint16_t ethtype = parse_l2_packet(packet, options, &stream);
  if (packet.ip != nullptr) {
    uint8_t transport_protocol = parse_l3_packet(ethtype, packet, options, &stream);
    if (packet.transport != nullptr) {
      parse_l4_packet(transport_protocol, packet, options, &stream);
    } else {
      stream << "L4 headers incomplete or unhandled";  // Protocol is displayed in L3 parsing.
    }
  } else {
    stream << "L3 headers incomplete or unhandled";  // Ethtype is displayed in L2 parsing.
  }

  if (is_highlit) {
    std::cout << stream.str() << parser::ANSI_RESET << std::endl;
  } else {
    std::cout << stream.str() << std::endl;
  }
}

inline bool filter_packet(const NetdumpOptions& options, Packet* packet) {
  if (options.filter == nullptr) {
    return true;
  }
  return options.filter->match(*packet);
}

int write_shb(int fd) {
  if (fd == -1) {
    return 0;
  }
  pcap_shb_t shb = {
      .type = 0x0A0D0D0A,
      .blk_tot_len = sizeof(pcap_shb_t),
      .magic = 0x1A2B3C4D,
      .major = 1,
      .minor = 0,
      .section_len = 0xFFFFFFFFFFFFFFFF,
      .blk_tot_len2 = sizeof(pcap_shb_t),
  };

  if (write(fd, &shb, sizeof(shb)) != sizeof(shb)) {
    std::cerr << "Couldn't write PCAP Section Header block" << std::endl;
    return -1;
  }
  return 0;
}

int write_idb(int fd) {
  if (fd == -1) {
    return 0;
  }
  pcap_idb_t idb = {
      .type = 0x00000001,
      .blk_tot_len = sizeof(pcap_idb_t),
      .linktype = 1,
      .reserved = 0,
      // We can't use a zero here, but tcpdump also rejects 2^32 - 1. Try 2^16 - 1.
      // See http://seclists.org/tcpdump/2012/q2/8.
      .snaplen = 0xFFFF,
      .blk_tot_len2 = sizeof(pcap_idb_t),
  };

  if (write(fd, &idb, sizeof(idb)) != sizeof(idb)) {
    std::cerr << "Couldn't write PCAP Interface Description block" << std::endl;
    return -1;
  }

  return 0;
}

inline size_t roundup(size_t a, size_t b) { return ((a) + ((b)-1)) & ~((b)-1); }

int write_packet(int fd, void* data, size_t len) {
  if (fd == -1) {
    return 0;
  }

  size_t padded_len = roundup(len, 4);
  simple_pkt_t pkt = {
      .type = 0x00000003,
      .blk_tot_len = static_cast<uint32_t>(SIMPLE_PKT_MIN_SIZE + padded_len),
      .pkt_len = static_cast<uint32_t>(len),
  };

  // TODO(tkilbourn): rewrite this to offload writing to another thread, and also deal with
  // partial writes
  if (write(fd, &pkt, sizeof(pkt)) != sizeof(pkt)) {
    std::cerr << "Couldn't write packet header" << std::endl;
    return -1;
  }
  if (write(fd, data, len) != static_cast<ssize_t>(len)) {
    std::cerr << "Couldn't write packet" << std::endl;
    return -1;
  }
  if (padded_len > len) {
    size_t padding = padded_len - len;
    ZX_DEBUG_ASSERT(padding <= 3);
    static const uint32_t zero = 0;
    if (write(fd, &zero, padding) != static_cast<ssize_t>(padding)) {
      std::cerr << "Couldn't write padding" << std::endl;
      return -1;
    }
  }
  if (write(fd, &pkt.blk_tot_len, sizeof(pkt.blk_tot_len)) != sizeof(pkt.blk_tot_len)) {
    std::cerr << "Couldn't write packet footer" << std::endl;
    return -1;
  }

  return 0;
}

void handle_rx(const zx::fifo& rx_fifo, char* iobuf, unsigned count, const NetdumpOptions& options,
               Stats* stats) {
  if (stats == nullptr) {
    std::cerr << "Couldn't track statistics. Bail out" << std::endl;
    return;
  }

  if (!count) {
    std::cerr << "Expected non-zero count value. Bail out" << std::endl;
    return;
  }

  eth_fifo_entry_t entries[count];

  bool dumpfile_write_error =
      write_shb(options.dumpfile_fd) < 0 || write_idb(options.dumpfile_fd) < 0;
  bool livedump_write_error = (options.print_format == PrintFormat::PCAPNG) &&
                              (write_shb(STDOUT_FILENO) < 0 || write_idb(STDOUT_FILENO) < 0);
  if (dumpfile_write_error || livedump_write_error) {
    return;
  }

  Packet packet{};
  uint64_t packets_remaining =
      (options.packet_count == std::nullopt ? std::numeric_limits<uint64_t>::max()
                                            : *options.packet_count);
  for (; packets_remaining > 0;) {
    size_t n;
    zx_status_t status;
    if ((status = rx_fifo.read(sizeof(entries[0]), entries, countof(entries), &n)) < 0) {
      if (status == ZX_ERR_SHOULD_WAIT) {
        rx_fifo.wait_one(ZX_FIFO_READABLE | ZX_FIFO_PEER_CLOSED, options.timeout_deadline, nullptr);
        if (zx::clock::get_monotonic() >= options.timeout_deadline) {
          return;
        }
        continue;
      }
      std::cerr << "netdump: failed to read rx packets: " << status << std::endl;
      return;
    }

    eth_fifo_entry_t* e = entries;
    for (size_t i = 0; i < n; ++i, ++e) {
      if (e->flags & ETH_FIFO_RX_OK) {
        void* buffer = iobuf + e->offset;
        uint16_t length = e->length;

        bool do_write = true;  // Whether the packet is included for write-out to dumpfile.
        packet.populate(buffer, length);
        if (packet.eth == nullptr) {
          stats->pkts_len_small++;
          stats->bytes_len_small += length;
          // Not setting `do_write` to false in order to record small frames.
          switch (options.print_format) {
            case PrintFormat::LOG:
              [[fallthrough]];
            case PrintFormat::HEXDUMP:
              if (options.verbose_level == 2 || options.print_format == PrintFormat::HEXDUMP) {
                hexdump8_very_ex(buffer, length, 0, hexdump_stdio_printf, stdout);
              }
              break;
            case PrintFormat::PCAPNG:
              if (write_packet(STDOUT_FILENO, buffer, length) < 0) {
                stats->pkts_write_fail += (n - i);
                return;
              }
              stats->pkts_write_ok++;
              break;
            default:
              ZX_ASSERT_MSG(false, "Unknown print format.");
              break;
          }

        } else {
          // pkts_eth_rx_ok++
          // bytes_eth_rx_ok += length
          if (filter_packet(options, &packet)) {
            stats->pkts_filtered_in++;
            stats->bytes_filtered_in += length;
            switch (options.print_format) {
              case PrintFormat::LOG:
                parse_packet(packet, options);
                break;
              case PrintFormat::HEXDUMP:
                std::cout << "---" << std::endl;
                hexdump8_very_ex(buffer, length, 0, hexdump_stdio_printf, stdout);
                break;
              case PrintFormat::PCAPNG:
                if (write_packet(STDOUT_FILENO, buffer, length) < 0) {
                  stats->pkts_write_fail += (n - i);
                  return;
                }
                stats->pkts_write_ok++;
                break;
              default:
                ZX_ASSERT_MSG(false, "Unknown print format.");
                break;
            }
            --packets_remaining;
          } else {
            stats->pkts_filtered_out++;
            stats->bytes_filtered_out += length;
            do_write = false;
          }
        }

        if (do_write && options.dumpfile_fd != -1) {
          auto write_status = write_packet(options.dumpfile_fd, buffer, length);
          if (write_status < 0) {
            stats->pkts_write_fail += (n - i);
            return;
          }
          stats->pkts_write_ok++;
        }

        if (packets_remaining == 0 || zx::clock::get_monotonic() >= options.timeout_deadline) {
          // Normal end condition
          return;
        }
      } else {
        stats->pkts_eth_rx_fail++;
      }

      e->length = BUFSIZE;
      e->flags = 0;
      if ((status = rx_fifo.write(sizeof(*e), e, 1, nullptr)) < 0) {
        std::cerr << "netdump: failed to queue rx packet: " << status << std::endl;
        break;
      }
    }
  }
}

int usage() {
  // clang-format off
  std::cerr << "usage: netdump [ <option>* ] <network-device>" << std::endl
            << " -t {sec}      : Exit after sec seconds, default " << DEFAULT_TIMEOUT_SECONDS
            << std::endl
            << " -w file       : Write packet output to file in pcapng format" << std::endl
            << " -c count      : Exit after receiving count packets" << std::endl
            << " -e            : Print link-level header information" << std::endl
            << " -f filter     : Capture only packets specified by filter" << std::endl
            << " -i filter     : Highlight packets specified by filter" << std::endl
            << " -p            : Use promiscuous mode" << std::endl
            << " -v            : Print verbose output" << std::endl
            << " -vv           : Print extra verbose output" << std::endl
            << " --pcapdump    : Print packet output in pcapng format, "
            << "can be combined with -w" << std::endl
            << " --hexdump     : Print packet output in hexdump format" << std::endl
            << " --help-filter : Show filter syntax usage" << std::endl
            << " --help        : Show this help message" << std::endl
            << "Filter syntax usage:" << std::endl;
  // clang-format on
  parser::parser_syntax(&std::cerr);
  return -1;
}

using StringIterator = std::vector<const std::string>::iterator;

int parse_args(StringIterator begin, StringIterator end, NetdumpOptions* options) {
  if (begin >= end) {
    return usage();
  }
  --end;
  std::string last = *end;

  for (; begin < end; ++begin) {
    std::string arg = *begin;
    if (arg == "-c") {
      ++begin;
      if (begin == end) {
        return usage();
      }
      size_t num_end;
      int64_t packet_count = stoll(*begin, &num_end, 10);
      if (packet_count < 0 || num_end < begin->length()) {
        return usage();
      }
      options->packet_count = std::optional(static_cast<uint64_t>(packet_count));
    } else if (arg == "-e") {
      options->link_level = true;
    } else if (arg == "-f" || arg == "-i") {
      ++begin;
      if (begin == end) {
        return usage();
      }
      parser::FilterTreeBuilder builder(options->tokenizer);
      auto parsed = options->parser.parse(*begin, &builder);
      if (auto error = std::get_if<parser::ParseError>(&parsed)) {
        std::cerr << *error << "Use '--help-filter' to see the filter syntax." << std::endl;
        return -1;
      }
      if (arg == "-f") {
        options->filter = std::move(std::get<FilterPtr>(parsed));
      } else {
        options->highlight_filter = std::move(std::get<FilterPtr>(parsed));
      }
    } else if (arg == "-p") {
      options->promisc = true;
    } else if (arg == "-w") {
      ++begin;
      if (begin == end || options->dumpfile_fd != -1) {
        return usage();
      }
      options->dumpfile_fd = open(begin->c_str(), O_WRONLY | O_CREAT);
      if (options->dumpfile_fd < 0) {
        std::cerr << "Error: Could not output to file: " << *begin << std::endl;
        return usage();
      }
    } else if (arg == "-v") {
      options->verbose_level = 1;
    } else if (!arg.compare(0, sizeof("-vv"), "-vv")) {
      // Since this is the max verbosity, adding extra 'v's does nothing.
      options->verbose_level = 2;
    } else if (arg == "--hexdump") {
      options->print_format = PrintFormat::HEXDUMP;
    } else if (arg == "--pcapdump") {
      options->print_format = PrintFormat::PCAPNG;
    } else if (arg == "-t") {
      int64_t timeout_seconds = DEFAULT_TIMEOUT_SECONDS;
      if (begin < end - 1) {
        size_t num_end;
        int64_t input = stoll(begin[1], &num_end, 10);
        if (num_end == begin[1].length()) {
          // Valid number.
          if (input < 0) {
            return usage();
          }
          timeout_seconds = input;
          ++begin;
        }
      }
      options->timeout_deadline = zx::clock::get_monotonic() + zx::sec(timeout_seconds);
    } else {
      return usage();
    }
  }

  if (last == "--help-filter") {
    parser::parser_syntax(&std::cerr);
    return -1;
  }
  if (last == "--help") {
    return usage();
  }

  options->device = last;
  return 0;
}

}  // namespace netdump

void show_stats(const netdump::Stats& stats) {
  // TODO(porce): Integration test with the emulated network.
  auto pkts_len_ok = stats.pkts_filtered_in + stats.pkts_filtered_out;
  auto pkts_eth_rx_ok = pkts_len_ok + stats.pkts_len_small;
  auto pkts_seen = pkts_eth_rx_ok + stats.pkts_eth_rx_fail;

  auto bytes_len_ok = stats.bytes_filtered_in + stats.bytes_filtered_out;
  auto bytes_eth_rx_ok = bytes_len_ok + stats.bytes_len_small;
  auto bytes_seen = bytes_eth_rx_ok + stats.bytes_eth_rx_fail;

  // Use stderr for auxiliary info not to disturb PCAPNG live streaming.
  fprintf(stderr, "\n --\nPacket capture statistics\n");

  fprintf(stderr, "  pkts_seen           : %" PRIu64 "\n", pkts_seen);
  fprintf(stderr, "  pkts_filtered_in    : %" PRIu64 "\n", stats.pkts_filtered_in);
  fprintf(stderr, "  pkts_filtered_out   : %" PRIu64 "\n", stats.pkts_filtered_out);
  fprintf(stderr, "  pkts_eth_rx_fail    : %" PRIu64 "\n", stats.pkts_eth_rx_fail);
  fprintf(stderr, "  pkts_len_small      : %" PRIu64 "\n", stats.pkts_len_small);

  fprintf(stderr, "  bytes_seen          : %" PRIu64 "\n", bytes_seen);
  fprintf(stderr, "  bytes_filtered_in   : %" PRIu64 "\n", stats.bytes_filtered_in);
  fprintf(stderr, "  bytes_filtered_out  : %" PRIu64 "\n", stats.bytes_filtered_out);
  fprintf(stderr, "  bytes_eth_rx_fail   : %" PRIu64 "\n", stats.bytes_eth_rx_fail);
  fprintf(stderr, "  bytes_len_small     : %" PRIu64 "\n", stats.bytes_len_small);

  fprintf(stderr, "  pkts_write_ok       : %" PRIu64 "\n", stats.pkts_write_ok);
  fprintf(stderr, "  pkts_write_fail     : %" PRIu64 "\n", stats.pkts_write_fail);

  fprintf(stderr, "\n");
}

int main(int argc, const char** argv) {
  netdump::NetdumpOptions options;
  std::vector<std::string> args(argv + 1, argv + argc);
  if (parse_args(args.begin(), args.end(), &options)) {
    return -1;
  }

  int fd;
  if ((fd = open(options.device.c_str(), O_RDWR)) < 0) {
    std::cerr << "netdump: cannot open '" << options.device << "'" << std::endl;
    return -1;
  }

  zx::channel svc;
  zx_status_t status = fdio_get_service_handle(fd, svc.reset_and_get_address());
  if (status != ZX_OK) {
    std::cerr << "netdump: failed to get service handle" << std::endl;
    return -1;
  }

  fuchsia_hardware_ethernet_Fifos fifos;
  zx_status_t call_status = ZX_OK;
  status = fuchsia_hardware_ethernet_DeviceGetFifos(svc.get(), &call_status, &fifos);
  if (status != ZX_OK || call_status != ZX_OK) {
    std::cerr << "netdump: failed to get fifos: " << status << ", " << call_status << std::endl;
    return -1;
  }
  zx::fifo rx_fifo = zx::fifo(fifos.rx);

  unsigned count = fifos.rx_depth / 2;
  zx::vmo iovmo;
  // Allocate shareable ethernet buffer data heap with no options. Non-resizable by default.
  if ((status = zx::vmo::create(count * BUFSIZE, 0, &iovmo)) < 0) {
    return -1;
  }

  char* iobuf;
  if ((status = zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, iovmo.get(),
                            0, count * BUFSIZE, reinterpret_cast<uintptr_t*>(&iobuf))) < 0) {
    return -1;
  }

  status = fuchsia_hardware_ethernet_DeviceSetIOBuffer(svc.get(), iovmo.get(), &call_status);
  if (status != ZX_OK || call_status != ZX_OK) {
    std::cerr << "netdump: failed to set iobuf: " << status << ", " << call_status << std::endl;
    return -1;
  }

  status = fuchsia_hardware_ethernet_DeviceSetClientName(svc.get(), "netdump", 7, &call_status);
  if (status != ZX_OK || call_status != ZX_OK) {
    std::cerr << "netdump: failed to set client name: " << status << ", " << call_status
              << std::endl;
  }

  if (options.promisc) {
    status = fuchsia_hardware_ethernet_DeviceSetPromiscuousMode(svc.get(), true, &call_status);
    if (status != ZX_OK || call_status != ZX_OK) {
      std::cerr << "netdump: failed to set promisc mode: " << status << ", " << call_status
                << std::endl;
    }
  }

  // assign data chunks to ethbufs
  for (unsigned n = 0; n < count; ++n) {
    eth_fifo_entry_t entry = {
        .offset = static_cast<uint32_t>(n * BUFSIZE),
        .length = BUFSIZE,
        .flags = 0,
        .cookie = 0,
    };
    if ((status = zx_fifo_write(fifos.rx, sizeof(entry), &entry, 1, nullptr)) < 0) {
      std::cerr << "netdump: failed to queue rx packet: " << status << std::endl;
      return -1;
    }
  }

  status = fuchsia_hardware_ethernet_DeviceStart(svc.get(), &call_status);
  if (status != ZX_OK || call_status != ZX_OK) {
    std::cerr << "netdump: failed to start network interface" << std::endl;
    return -1;
  }

  status = fuchsia_hardware_ethernet_DeviceListenStart(svc.get(), &call_status);
  if (status != ZX_OK || call_status != ZX_OK) {
    std::cerr << "netdump: failed to start listening" << std::endl;
    return -1;
  }

  zx_handle_t directory_request = zx_take_startup_handle(PA_DIRECTORY_REQUEST);
  if (directory_request != ZX_HANDLE_INVALID) {
    // We don't serve anything, we can close the directory request immediately.
    // This is used in integration tests as a signal that netdump is running and attached to the
    // device; if one day netdump needs to serve anything the integration tests need to be updated.
    zx_handle_close(directory_request);
  }
  netdump::Stats stats = {};
  handle_rx(rx_fifo, iobuf, count, options, &stats);

  if (options.dumpfile_fd != -1) {
    close(options.dumpfile_fd);
  }

  if (options.print_format == netdump::PrintFormat::LOG ||
      options.print_format == netdump::PrintFormat::HEXDUMP) {
    show_stats(stats);
  }

  return 0;
}