/src/wpantund/src/util/TunnelIPv6Interface.cpp

Source
/*
 *
 * Copyright (c) 2016 Nest Labs, Inc.
 * All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *    Description:
 *      This file contains the implementation for a C++ wrapper around the
 *      `tunnel.c`/`tunnel.h` interface.
 *
 */

#if HAVE_CONFIG_H
#include <config.h>
#endif

#include "assert-macros.h"
#include "TunnelIPv6Interface.h"
#include <syslog.h>
#include "IPv6Helpers.h"

#if __linux__
#include <asm/types.h>
#include <linux/if_link.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <fcntl.h>
#include <ifaddrs.h>
#endif

#include <sys/select.h>

#ifndef O_NONBLOCK
#define O_NONBLOCK          O_NDELAY
#endif

namespace {

  const char* kMLDv2MulticastAddress= "ff02::16";

  const char *kFilterMulticastAddresses[] = {
      kMLDv2MulticastAddress,
      "ff02::01", //Link local all nodes
      "ff02::02", //Link local all routers
      "ff03::01", //realm local all nodes
      "ff03::02", //realm local all routers
      "ff03::fc", //realm local all mpl
  };

  struct MLDv2Header {
    uint8_t mType;
    uint8_t _rsv0;
    uint16_t mChecksum;
    uint16_t _rsv1;
    uint16_t mNumRecords;
  } __attribute__((packed));

  struct MLDv2Record {
    uint8_t mRecordType;
    uint8_t mAuxDataLen;
    uint16_t mNumSources;
    struct in6_addr mMulticastAddress;
    struct in6_addr mSourceAddresses[];
  } __attribute__((packed));

} // namespace

static bool
is_addr_multicast(const struct in6_addr &address)
{
  return (address.s6_addr[0] == 0xff);
}

TunnelIPv6Interface::TunnelIPv6Interface(const std::string& interface_name, int mtu):
#if FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
  UnixSocket(open("/dev/null",O_RDWR), true),
#else
  UnixSocket(tunnel_open(interface_name.c_str()), true),
#endif
  mInterfaceName(interface_name),
  mLastError(0),
  mNetlinkFD(-1),
#if FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
  mNetifMgmtFD(-1),
#else
  mNetifMgmtFD(netif_mgmt_open()),
#endif
  mMLDMonitorFD(-1),
  mIsRunning(false),
  mIsUp(false)
{
  if (0 > mFDRead) {
    throw std::invalid_argument("Unable to open tunnel interface");
  }

#if !FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
  {
    char ActualInterfaceName[TUNNEL_MAX_INTERFACE_NAME_LEN] = "";
    int ret = 0;
    ret = tunnel_get_name(mFDRead, ActualInterfaceName, sizeof(ActualInterfaceName));
    if (ret) {
      syslog(LOG_WARNING,
           "TunnelIPv6Interface: Couldn't get tunnel name! errno=%d, %s",
           errno,
           strerror(errno));
    } else if (mInterfaceName != ActualInterfaceName) {
      syslog(LOG_WARNING,
           "TunnelIPv6Interface: Couldn't create tunnel named \"%s\", got \"%s\" instead!",
           mInterfaceName.c_str(),
           ActualInterfaceName);
      mInterfaceName = ActualInterfaceName;
    }
  }

  netif_mgmt_set_mtu(mNetifMgmtFD, mInterfaceName.c_str(), mtu);

  setup_signals();
  setup_mld_listener();
#endif
}

TunnelIPv6Interface::~TunnelIPv6Interface()
{
  close(mNetlinkFD);
  if (mMLDMonitorFD >= 0) {
    close(mMLDMonitorFD);
  }
  netif_mgmt_close(mNetifMgmtFD);
}

void
TunnelIPv6Interface::on_link_state_changed(bool isUp, bool isRunning)
{
  syslog(LOG_INFO, "TunnelIPv6Interface::on_link_state_changed() UP=%d RUNNING=%d", isUp, isRunning);
  if (isRunning != mIsRunning || isUp != mIsUp) {
    if (isRunning && !mIsRunning) {
      std::map<struct in6_addr, Entry>::iterator iter;

      for (iter = mUnicastAddresses.begin(); iter != mUnicastAddresses.end(); ++iter) {
        if (iter->second.mState != Entry::kWaitingToAdd) {
          continue;
        }

        syslog(LOG_INFO, "Adding address \"%s/%d\" to interface \"%s\"",
               in6_addr_to_string(iter->first).c_str(), iter->second.mPrefixLen,
               mInterfaceName.c_str());

        IGNORE_RETURN_VALUE(netif_mgmt_add_ipv6_address(mNetifMgmtFD, mInterfaceName.c_str(),
                            iter->first.s6_addr, iter->second.mPrefixLen));
        iter->second.mState = Entry::kWaitingForAddConfirm;
      }

      for (iter = mPendingMulticastAddresses.begin(); iter != mPendingMulticastAddresses.end(); ++iter) {
        if (iter->second.mState != Entry::kWaitingToAdd) {
          continue;
        }

        syslog(LOG_INFO, "Joining multicast address \"%s\" on interface \"%s\".",
               in6_addr_to_string(iter->first).c_str(), mInterfaceName.c_str());

        IGNORE_RETURN_VALUE(netif_mgmt_join_ipv6_multicast_address(mNetifMgmtFD, mInterfaceName.c_str(),
                            iter->first.s6_addr));
      }
      mPendingMulticastAddresses.clear();
    }
    mIsUp = isUp;
    mIsRunning = isRunning;
    mLinkStateChanged(isUp, isRunning);
  }
}

void
TunnelIPv6Interface::on_address_added(const struct in6_addr &address, uint8_t prefix_len)
{
  if (mUnicastAddresses.count(address)) {
    mUnicastAddresses.erase(address);
  }

  syslog(LOG_INFO, "TunnelIPv6Interface: \"%s/%d\" was added to \"%s\"", in6_addr_to_string(address).c_str(), prefix_len,
         get_interface_name().c_str());

  mUnicastAddressWasAdded(address, prefix_len);
}

void
TunnelIPv6Interface::on_multicast_address_joined(const struct in6_addr &address)
{
  if (mPendingMulticastAddresses.count(address)) {
    mPendingMulticastAddresses.erase(address);
  }

  syslog(LOG_INFO, "TunnelIPv6Interface: \"%s\" was added to \"%s\"", in6_addr_to_string(address).c_str(),
         get_interface_name().c_str());

  mMulticastAddressWasJoined(address);
}

void
TunnelIPv6Interface::on_address_removed(const struct in6_addr &address, uint8_t prefix_len)
{
  // Ignore "removed" signal if address is the list
  // meaning it was added earlier and we are still
  // waiting to confirm that it is added.
  // This is to address the case where before adding an
  // address on interface it may be first removed.

  if (!mUnicastAddresses.count(address)) {
    syslog(LOG_INFO, "TunnelIPv6Interface: \"%s/%d\" was removed from \"%s\"", in6_addr_to_string(address).c_str(), prefix_len,
           get_interface_name().c_str());

    mUnicastAddressWasRemoved(address, prefix_len);
  }

}

void
TunnelIPv6Interface::on_multicast_address_left(const struct in6_addr &address)
{
  // Ignore "removed" signal if address is the list
  // meaning it was added earlier and we are still
  // waiting to confirm that it is added.
  // This is to address the case where before adding an
  // address on interface it may be first removed.

  if (!mPendingMulticastAddresses.count(address)) {
    syslog(LOG_INFO, "TunnelIPv6Interface: \"%s\" was removed from \"%s\"", in6_addr_to_string(address).c_str(),
           get_interface_name().c_str());

    mMulticastAddressWasLeft(address);
  }
}

#if __linux__ // --------------------------------------------------------------

#define LCG32(x)    ((uint32_t)(x)*1664525+1013904223)

void
TunnelIPv6Interface::setup_signals(void)
{
  int status;
  int fd;
  struct sockaddr_nl la;

  fd = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);

  require(fd != -1, bail);

  memset(&la, 0, sizeof(la));
  la.nl_family = AF_NETLINK;
  la.nl_pad = 0;
  la.nl_groups = RTMGRP_LINK | RTMGRP_IPV6_IFADDR;

  // We calculate the PID in a pseudo-random way based on the
  // address pointer and the actual process ID.
  la.nl_pid = LCG32(getpid()) ^ LCG32((uint32_t)reinterpret_cast<uintptr_t>(this));

  status = bind(fd, (struct sockaddr*) &la, sizeof(la));

  require(status != -1, bail);

  // Success!
  IGNORE_RETURN_VALUE(fcntl(fd, F_SETFL, O_NONBLOCK));

  mNetlinkFD = fd;
  fd = -1;

bail:

  // Cleanup (If necessary)
  if (fd > 0) {
    close(fd);
  }

  return;
}

void
TunnelIPv6Interface::setup_mld_listener(void)
{
  unsigned interfaceIndex = netif_mgmt_get_ifindex(mNetifMgmtFD, mInterfaceName.c_str());
  bool success = false;
  struct ipv6_mreq mreq6;

  mMLDMonitorFD = socket(AF_INET6, SOCK_RAW | SOCK_NONBLOCK, IPPROTO_ICMPV6);
  mreq6.ipv6mr_interface = interfaceIndex;
  inet_pton(AF_INET6, kMLDv2MulticastAddress, &mreq6.ipv6mr_multiaddr);

  require(setsockopt(mMLDMonitorFD, IPPROTO_IPV6, IPV6_JOIN_GROUP, &mreq6, sizeof(mreq6)) == 0, bail);
  require(setsockopt(mMLDMonitorFD, SOL_SOCKET, SO_BINDTODEVICE, mInterfaceName.c_str(), mInterfaceName.size()) == 0, bail);

  success = true;

bail:
  if (!success) {
    if (mMLDMonitorFD >= 0) {
      close(mMLDMonitorFD);
    }
    syslog(LOG_ERR, "listen to MLD messages on interface failed\n");
  }
  return;
}

int
TunnelIPv6Interface::process(void)
{
  processNetlinkFD();
  processMLDMonitorFD();

  return nl::UnixSocket::process();
}

void
TunnelIPv6Interface::processNetlinkFD(void)
{
  uint8_t buffer[4096];
  ssize_t buffer_len(-1);

  if (mNetlinkFD >= 0) {
    buffer_len = recv(mNetlinkFD, buffer, sizeof(buffer), 0);
  }

  if (buffer_len > 0) {
    struct nlmsghdr *nlp;
    struct rtmsg *rtp;
    int rta_len;
    struct rtattr *rta;

    nlp = (struct nlmsghdr *)buffer;
    for (;NLMSG_OK(nlp, buffer_len); nlp=NLMSG_NEXT(nlp, buffer_len))
    {
      char ifnamebuf[IF_NAMESIZE];
      if (nlp->nlmsg_type == RTM_NEWADDR || nlp->nlmsg_type == RTM_DELADDR) {
        struct ifaddrmsg *ifaddr = (struct ifaddrmsg *)NLMSG_DATA(nlp);
        const char *ifname = if_indextoname(ifaddr->ifa_index, ifnamebuf);
        struct in6_addr addr;

        if ((ifname == NULL) || (get_interface_name() != ifname)) {
          continue;
        }

        // get RTNETLINK message header
        // get start of attributes
        rta = (struct rtattr *) IFA_RTA(ifaddr);

        // get length of attributes
        rta_len = IFA_PAYLOAD(nlp);

        for(;RTA_OK(rta, rta_len); rta = RTA_NEXT(rta, rta_len)) {
          switch(rta->rta_type) {
          case IFA_ADDRESS:
          case IFA_LOCAL:
          case IFA_BROADCAST:
          case IFA_ANYCAST:
            memcpy(addr.s6_addr, RTA_DATA(rta), sizeof(addr));

            if (nlp->nlmsg_type == RTM_NEWADDR) {
              on_address_added(addr, ifaddr->ifa_prefixlen);
            } else if (nlp->nlmsg_type == RTM_DELADDR) {
              on_address_removed(addr, ifaddr->ifa_prefixlen);
            }
            break;
          default:
            break;
          }
        }
      } else if (nlp->nlmsg_type == RTM_NEWLINK || nlp->nlmsg_type == RTM_DELLINK) {
        struct ifinfomsg *ifinfo = (struct ifinfomsg *)NLMSG_DATA(nlp);
        const char *ifname = if_indextoname(ifinfo->ifi_index, ifnamebuf);
        bool isUp, isRunning;

        if ((ifname == NULL) || (get_interface_name() != ifname)) {
          continue;
        }

        isUp = ((ifinfo->ifi_flags & IFF_UP) == IFF_UP);
        isRunning = ((ifinfo->ifi_flags & IFF_RUNNING) == IFF_RUNNING);

        on_link_state_changed(isUp, isRunning);
      }
    }
  }
}

static bool IsMulticastAddressFiltered(const struct in6_addr& addr_to_check) 
{
  bool found = false;

  for (size_t i = 0; i < sizeof(kFilterMulticastAddresses) /
                             sizeof(kFilterMulticastAddresses[0]);
       i++) {
      struct in6_addr addr; 

      inet_pton(AF_INET6, kFilterMulticastAddresses[i], &addr);
      if (memcmp(&addr, &addr_to_check, sizeof(addr)) == 0) {
        found = true;
        break;
      }
  }

  return found;
}

void
TunnelIPv6Interface::processMLDMonitorFD(void)
{
  uint8_t buffer[4096];
  ssize_t bufferLen(-1);
  struct sockaddr_in6 srcAddr;
  socklen_t addrLen;
  bool fromSelf = false;
  MLDv2Header* hdr = reinterpret_cast<MLDv2Header *>(buffer);
  ssize_t offset;
  uint8_t type;
  struct ifaddrs *ifAddrs = NULL;

  if (mNetlinkFD >= 0) {
    bufferLen = recvfrom(mMLDMonitorFD, buffer, sizeof(buffer), 0, reinterpret_cast<sockaddr *>(&srcAddr), &addrLen);
  }
  require_quiet(bufferLen > 0, bail);

  type = buffer[0];
  require_quiet(type == kICMPv6MLDv2Type && bufferLen >= sizeof(MLDv2Header), bail);

  // Check whether it is sent by self
  require(getifaddrs(&ifAddrs) == 0, bail);
  for (struct ifaddrs* ifAddr = ifAddrs; ifAddr != NULL; ifAddr = ifAddr->ifa_next) {
    if (ifAddr->ifa_addr != NULL && ifAddr->ifa_addr->sa_family == AF_INET6 &&
        mInterfaceName == std::string(ifAddr->ifa_name)) {
      struct sockaddr_in6 *addr6 = reinterpret_cast<struct sockaddr_in6 *>(ifAddr->ifa_addr);

      if (memcmp(&addr6->sin6_addr, &srcAddr.sin6_addr, sizeof(in6_addr)) == 0) {
        fromSelf = true;
        break;
      }
    }
  }
  require_quiet(fromSelf, bail);

  hdr = reinterpret_cast<MLDv2Header *>(buffer);
  offset = sizeof(MLDv2Header);

  for (size_t i = 0; i < ntohs(hdr->mNumRecords) && offset < bufferLen; i++) {
    if (bufferLen - offset >= sizeof(MLDv2Record)) {
      MLDv2Record *record = reinterpret_cast<MLDv2Record *>(&buffer[offset]);

      if (!IsMulticastAddressFiltered(record->mMulticastAddress)) {
        if (record->mRecordType == kICMPv6MLDv2RecordChangeToIncludeType) {
          on_multicast_address_joined(record->mMulticastAddress);
        } else if (record->mRecordType == kICMPv6MLDv2RecordChangeToExcludeType) {
          on_multicast_address_left(record->mMulticastAddress);
        }
      }

      offset += sizeof(MLDv2Record) + sizeof(in6_addr) * ntohs(record->mNumSources);
    }
  }

bail:
  if (ifAddrs) {
    freeifaddrs(ifAddrs);
  }

  return;
}

#else // ----------------------------------------------------------------------

void
TunnelIPv6Interface::setup_signals(void)
{
  // Unknown platform.
}

int
TunnelIPv6Interface::process(void)
{
  return nl::UnixSocket::process();
}

void
TunnelIPv6Interface::processNetlinkFD(void)
{
}

void
TunnelIPv6Interface::processMLDMonitorFD(void)
{
}

#endif // ---------------------------------------------------------------------

int
TunnelIPv6Interface::update_fd_set(fd_set *read_fd_set, fd_set *write_fd_set, fd_set *error_fd_set, int *max_fd, cms_t *timeout)
{
  if (read_fd_set) {
    if (mNetlinkFD >= 0)  {
      FD_SET(mNetlinkFD, read_fd_set);
    }

    if (mMLDMonitorFD >= 0) {
      FD_SET(mMLDMonitorFD, read_fd_set);
    }

    if ((max_fd != NULL)) {
      *max_fd = std::max(*max_fd, mNetlinkFD);
      *max_fd = std::max(*max_fd, mMLDMonitorFD);
    }
  }

  return nl::UnixSocket::update_fd_set(read_fd_set, write_fd_set, error_fd_set, max_fd, timeout);
}

const std::string&
TunnelIPv6Interface::get_interface_name(void)
{
  return mInterfaceName;
}

int
TunnelIPv6Interface::get_last_error(void)
{
  return mLastError;
}

bool
TunnelIPv6Interface::is_up(void)
{
  return netif_mgmt_is_up(mNetifMgmtFD, mInterfaceName.c_str());
}

bool
TunnelIPv6Interface::is_running(void)
{
  return netif_mgmt_is_running(mNetifMgmtFD, mInterfaceName.c_str());
}

bool
TunnelIPv6Interface::is_online(void)
{
  static const int online_flags = IFF_UP | IFF_RUNNING;
  return (netif_mgmt_get_flags(mNetifMgmtFD, mInterfaceName.c_str()) & online_flags) == online_flags;
}

int
TunnelIPv6Interface::set_up(bool isUp)
{
  int ret = 0;
  bool old = is_up();

  if (isUp != old) {
    if (isUp) {
      syslog(LOG_INFO, "Bringing interface %s up. . .", mInterfaceName.c_str());
    } else {
      syslog(LOG_INFO, "Taking interface %s down. . .", mInterfaceName.c_str());
    }

    ret = netif_mgmt_set_up(mNetifMgmtFD, mInterfaceName.c_str(), isUp);

    require_action(ret == 0, bail, mLastError = errno);
  }

bail:
  return ret;
}

int
TunnelIPv6Interface::set_running(bool isRunning)
{
  int ret = 0;
  bool old = is_running();

  if (isRunning != old) {
    if (isRunning) {
      syslog(LOG_INFO, "Bringing interface %s online. . .", mInterfaceName.c_str());
    } else {
      syslog(LOG_INFO, "Taking interface %s offline. . .", mInterfaceName.c_str());
    }

    ret = netif_mgmt_set_running(mNetifMgmtFD, mInterfaceName.c_str(), isRunning);

    mLastError = errno;

    require_action(ret == 0, bail, mLastError = errno);

  }

bail:
  return ret;
}


int
TunnelIPv6Interface::set_online(bool online)
{
  return set_running(online);
}

void
TunnelIPv6Interface::reset(void)
{
  syslog(LOG_INFO, "Resetting interface %s. . .", mInterfaceName.c_str());
  set_online(false);
}


bool
TunnelIPv6Interface::add_address(const struct in6_addr *addr, int prefixlen)
{
  bool ret = false;

  require_action(!IN6_IS_ADDR_UNSPECIFIED(addr), bail, mLastError = EINVAL);

  if (mUnicastAddresses.count(*addr)) {
    ret = true;
    goto bail;
  }

  if (is_online()) {
    syslog(LOG_INFO, "Adding address \"%s/%d\" to interface \"%s\"",
           in6_addr_to_string(*addr).c_str(), prefixlen, mInterfaceName.c_str());

    require_noerr_action(
      netif_mgmt_add_ipv6_address(mNetifMgmtFD, mInterfaceName.c_str(), addr->s6_addr, prefixlen),
      bail,
      mLastError = errno
    );
    mUnicastAddresses[*addr] = Entry(Entry::kWaitingForAddConfirm, prefixlen);
  } else {
    mUnicastAddresses[*addr] = Entry(Entry::kWaitingToAdd, prefixlen);
  }

  ret = true;

bail:
  return ret;
}

bool
TunnelIPv6Interface::remove_address(const struct in6_addr *addr, int prefixlen)
{
  bool ret = false;

  require_action(!IN6_IS_ADDR_UNSPECIFIED(addr), bail, mLastError = EINVAL);

  if (mUnicastAddresses.count(*addr)) {
    mUnicastAddresses.erase(*addr);
  }

  if (netif_mgmt_remove_ipv6_address(mNetifMgmtFD, mInterfaceName.c_str(), addr->s6_addr) != 0) {
    mLastError = errno;
    goto bail;
  }

  syslog(LOG_INFO,"Removing address \"%s\" from interface \"%s\"",
         in6_addr_to_string(*addr).c_str(), mInterfaceName.c_str());
  ret = true;

bail:
  return ret;
}

bool
TunnelIPv6Interface::join_multicast_address(const struct in6_addr *addr)
{
  bool ret = false;

  require_action(!IN6_IS_ADDR_UNSPECIFIED(addr), bail, mLastError = EINVAL);

  if (is_online()) {
    if (netif_mgmt_join_ipv6_multicast_address(mNetifMgmtFD, mInterfaceName.c_str(), addr->s6_addr) != 0) {
      mLastError = errno;
      goto bail;
    }

    syslog(LOG_INFO, "Joining multicast address \"%s\" on interface \"%s\".",
           in6_addr_to_string(*addr).c_str(), mInterfaceName.c_str());
  } else {
    mPendingMulticastAddresses[*addr] = Entry(Entry::kWaitingToAdd);
  }

  ret = true;

bail:
  return ret;
}

bool
TunnelIPv6Interface::leave_multicast_address(const struct in6_addr *addr)
{
  bool ret = false;

  require_action(!IN6_IS_ADDR_UNSPECIFIED(addr), bail, mLastError = EINVAL);

  if (mPendingMulticastAddresses.count(*addr)) {
    mPendingMulticastAddresses.erase(*addr);
  }

  if (netif_mgmt_leave_ipv6_multicast_address(mNetifMgmtFD, mInterfaceName.c_str(), addr->s6_addr) != 0) {
    mLastError = errno;
    goto bail;
  }

  syslog(LOG_INFO, "Leaving multicast address \"%s\" on interface \"%s\".",
         in6_addr_to_string(*addr).c_str(), mInterfaceName.c_str());
  ret = true;

bail:
  return ret;
}


bool
TunnelIPv6Interface::add_route(const struct in6_addr *route, int prefixlen, uint32_t metric)
{
  bool ret = false;

  if (netif_mgmt_add_ipv6_route(mNetifMgmtFD, mInterfaceName.c_str(), route->s6_addr, prefixlen, metric) != 0) {
    mLastError = errno;
    goto bail;
  }
  syslog(LOG_INFO, "Adding route prefix \"%s/%d\" on interface \"%s\".",
         in6_addr_to_string(*route).c_str(), prefixlen, mInterfaceName.c_str());

  ret = true;

bail:
  return ret;
}

bool
TunnelIPv6Interface::remove_route(const struct in6_addr *route, int prefixlen, uint32_t metric)
{
  bool ret = false;

  if (netif_mgmt_remove_ipv6_route(mNetifMgmtFD, mInterfaceName.c_str(), route->s6_addr, prefixlen, metric) != 0) {
    mLastError = errno;
    goto bail;
  }

  syslog(LOG_INFO, "Removing route prefix \"%s/%d\" on interface \"%s\".",
         in6_addr_to_string(*route).c_str(), prefixlen, mInterfaceName.c_str());

  ret = true;

bail:
  return ret;
}

ssize_t
TunnelIPv6Interface::read(void* data, size_t len)
{
  ssize_t ret = nl::UnixSocket::read(data, len);
  uint8_t *data_bytes = static_cast<uint8_t*>(data);

  // Remove any subheader, if present.
  if ((ret >= 4) && (data_bytes[0] == 0) && (data_bytes[1] == 0)) {
    ret -= 4;
    memmove(data, static_cast<const void*>(data_bytes + 4), ret);
  }

  return ret;
}

ssize_t
TunnelIPv6Interface::write(const void* data, size_t len)
{
#ifdef __APPLE__
  const uint8_t* const data_bytes = static_cast<const uint8_t*>(data);

  if ((data_bytes[0] != 0) || (data_bytes[0] != 0)) {
    // The utun interface on OS X needs this header.
    // Linux seems to be able to infer the type of the packet
    // with no problems.
    uint8_t packet[len + 4];
    packet[0] = 0;
    packet[1] = 0;
    packet[2] = (PF_INET6 << 8) & 0xFF;
    packet[3] = (PF_INET6 << 0) & 0xFF;
    memcpy(static_cast<void*>(packet + 4), data, len);
    ssize_t ret = nl::UnixSocket::write(packet, len + 4);
    return (ret >= 4)?(ret - 4):(-1);
  }
#endif
  return nl::UnixSocket::write(data, len);
}

Coverage Report

Created: 2026-01-16 06:45