SockAddr.cpp

/**************************************************************
* Copyright (c) 2013, Dynamic Network Services, Inc. Jake Montgomery
* (jmontgomery@dyn.com) & Tom Daly (tom@dyn.com) Distributed under the FreeBSD
* License - see LICENSE
***************************************************************/
#include "common.h"
#include "SockAddr.h"
#include "utils.h"
#include "lookup3.h"
#include <net/if.h>
#include <cstring>


/**
 * Sets the address to invalid, and m_addr to the default for the given type.
 *
 * @param type
 */
void sockAddrBase::init(Addr::Type type)
{
  switch (type)
  {
  case Addr::IPv4:
  {
    sockaddr_in *storage = getIPv4Storage();
    storage->sin_family = AF_INET;
    storage->sin_port = 0;
    storage->sin_addr.s_addr = INADDR_ANY;
  }
    break;
  case Addr::IPv6:
  {
    sockaddr_in6 *storage = getIPv6Storage();
    *storage = sockaddr_in6();
    storage->sin6_family = AF_INET6;
    storage->sin6_addr = in6addr_any;  /** Probably not necessary. Is  in6addr_any _guaranteed_ to be 0?*/
  }
    break;
  default:
    m_addr.ss_family = AF_UNSPEC;
    break;
  }
}

sockAddrBase::sockAddrBase(bool allowPort) : m_allowPort(allowPort)
{
  init(Addr::Invalid);
}

sockAddrBase::sockAddrBase(bool allowPort, const sockaddr_in6 *addr) : m_allowPort(allowPort)
{
  sockaddr_in6 *storage = getIPv6Storage();

  if (!addr || addr->sin6_family != AF_INET6)
  {
    init(Addr::IPv6);
    return;
  }

  memcpy(storage, addr, sizeof(sockaddr_in6));
  if (!m_allowPort)
    clearPort();
}

sockAddrBase::sockAddrBase(bool allowPort, const sockaddr_in *addr) : m_allowPort(allowPort)
{
  sockaddr_in *storage = getIPv4Storage();

  if (!addr || addr->sin_family != AF_INET)
  {
    init(Addr::IPv4);
    return;
  }

  memcpy(storage, addr, sizeof(sockaddr_in));
  if (!m_allowPort)
    clearPort();
}


sockAddrBase::sockAddrBase(bool allowPort, const in6_addr *addr) : m_allowPort(allowPort)
{
  init(Addr::IPv6);

  if (!addr)
    return;

  sockaddr_in6 *storage = getIPv6Storage();

  storage->sin6_addr = *addr;
}


sockAddrBase::sockAddrBase(bool allowPort, const in_addr *addr) : m_allowPort(allowPort)
{
  init(Addr::IPv4);

  if (!addr)
    return;

  sockaddr_in *storage = getIPv4Storage();

  storage->sin_addr.s_addr = addr->s_addr;
}

sockAddrBase::sockAddrBase(bool allowPort, Addr::Type type, in_port_t port) : m_allowPort(allowPort)
{
  init(Addr::Invalid);
  if (type != Addr::Invalid)
    SetAny(type, port);
}


sockAddrBase::sockAddrBase(bool allowPort, const sockaddr *addr, socklen_t addrlen) : m_allowPort(allowPort)
{
  if (!addr || (addrlen < sizeof(sockaddr_in) && addrlen < sizeof(sockaddr_in6)))
  {
    init(Addr::Invalid);
    return;
  }

  int family = ((sockaddr_in *)addr)->sin_family;

  if (family == AF_INET)
    init(Addr::IPv4);
  else if (family == AF_INET6)
    init(Addr::IPv6);
  else
  {
    init(Addr::Invalid);
    return;
  }

  if (addrlen < GetSize())
    return;
  memcpy(&m_addr, addr, GetSize());
  if (!m_allowPort)
    clearPort();
}

sockAddrBase::sockAddrBase(bool allowPort, const sockAddrBase &src) : m_allowPort(allowPort)
{
  copy(src);
}

sockAddrBase::sockAddrBase(bool allowPort, const char *str) : m_allowPort(allowPort)
{
  FromString(str);
}


sockAddrBase::sockAddrBase(bool allowPort, const char *str, in_port_t port) : m_allowPort(allowPort)
{
  FromString(str, port);
}


void sockAddrBase::copy(const sockAddrBase &src)
{
  if (!src.IsValid())
  {
    init(Addr::Invalid);
    return;
  }

  // Note that GetSize will work, because
  // we already made sure src was valid.
  memcpy(&m_addr, &src.m_addr, src.GetSize());
  if (!m_allowPort)
    clearPort();
}

sockAddrBase& sockAddrBase::operator = (const sockAddrBase &src)
{
  copy(src);
  return *this;
}

void sockAddrBase::SetAny(Addr::Type type, in_port_t port /*0*/)
{
  init(type);
  if (type != Addr::Invalid)
  {
    if (port != 0 && m_allowPort)
      SetPort(port);
  }
}

bool sockAddrBase::IsAny() const
{
  if (!IsValid())
    return false;

  if (IsIPv6())
  {
    // Can not use IN6_IS_ADDR_UNSPECIFIED because it breaks strict aliasing on some
    // platforms?
    const sockaddr_in6 *storage = getIPv6Storage();
    return (storage->sin6_addr.s6_addr[0] == 0
            && storage->sin6_addr.s6_addr[1] == 0
            && storage->sin6_addr.s6_addr[2] == 0
            && storage->sin6_addr.s6_addr[3] == 0
            && storage->sin6_addr.s6_addr[4] == 0
            && storage->sin6_addr.s6_addr[5] == 0
            && storage->sin6_addr.s6_addr[6] == 0
            && storage->sin6_addr.s6_addr[7] == 0
            && storage->sin6_addr.s6_addr[8] == 0
            && storage->sin6_addr.s6_addr[9] == 0
            && storage->sin6_addr.s6_addr[10] == 0
            && storage->sin6_addr.s6_addr[11] == 0
            && storage->sin6_addr.s6_addr[12] == 0
            && storage->sin6_addr.s6_addr[13] == 0
            && storage->sin6_addr.s6_addr[14] == 0
            && storage->sin6_addr.s6_addr[15] == 0);
  }
  else
    return getIPv4Storage()->sin_addr.s_addr == INADDR_ANY;
}


bool sockAddrBase::IsLinkLocal() const
{
  if (!IsValid())
    return false;

  if (IsIPv6())
    return IN6_IS_ADDR_LINKLOCAL(&getIPv6Storage()->sin6_addr);
  else
  {
    const uint8_t *bytes = reinterpret_cast<const uint8_t *>(&getIPv4Storage()->sin_addr.s_addr);
    return bytes[0] == 169 && bytes[1] == 254;
  }
}


void sockAddrBase::clearPort()
{
  if (IsValid())
  {
    if (IsIPv6())
      getIPv6Storage()->sin6_port = 0;
    else
      getIPv4Storage()->sin_port  = 0;
  }
}

void sockAddrBase::SetPort(in_port_t port)
{
  if (IsValid() && m_allowPort)
  {
    if (IsIPv6())
      getIPv6Storage()->sin6_port = htons(port);
    else
      getIPv4Storage()->sin_port  = htons(port);
  }
}

void sockAddrBase::SetScopIdIfLinkLocal(uint32_t id)
{
  if (!IsIPv6() || !IsLinkLocal())
    return;
  getIPv6Storage()->sin6_scope_id = id;
}

void sockAddrBase::clear()
{
  init(Addr::Invalid);
}


bool sockAddrBase::IsValid() const
{
  return (m_addr.ss_family == AF_INET6 || m_addr.ss_family == AF_INET);
}

bool sockAddrBase::IsIPv6() const
{
  return m_addr.ss_family == AF_INET6;
}

bool sockAddrBase::IsIPv4() const
{
  return m_addr.ss_family == AF_INET;
}

Addr::Type sockAddrBase::Type() const
{
  if (IsValid())
  {
    if (m_addr.ss_family == AF_INET)
      return Addr::IPv4;
    else if (m_addr.ss_family == AF_INET6)
      return Addr::IPv6;
  }
  return Addr::Invalid;

}

in_port_t sockAddrBase::Port() const
{
  uint16_t port;

  if (!IsValid() || !m_allowPort)
    return 0;

  if (IsIPv6())
    port = getIPv6Storage()->sin6_port;
  else
    port = getIPv4Storage()->sin_port;

  return ntohs(port);
}

int sockAddrBase::ProtocolFamily() const
{
  if (m_addr.ss_family == AF_INET6)
    return PF_INET6;
  else
    return PF_INET;
}


int sockAddrBase::AddressFamily() const
{
  return m_addr.ss_family;
}

socklen_t sockAddrBase::GetSize() const
{
  return AddressFamily() == AF_INET6 ? sizeof(sockaddr_in6) : sizeof(sockaddr_in);
}

/**
 * @warning does no checking at all
 */
inline sockaddr_in6* sockAddrBase::getIPv6Storage()
{
  return (sockaddr_in6 *)&m_addr;
}

/**
 * @warning does no checking at all
 */
inline sockaddr_in* sockAddrBase::getIPv4Storage()
{
  return (sockaddr_in *)&m_addr;
}

/**
 * @warning does no checking at all
 */
inline const sockaddr_in6* sockAddrBase::getIPv6Storage() const
{
  return (const sockaddr_in6 *)&m_addr;
}

/**
 * @warning does no checking at all
 */
inline const sockaddr_in* sockAddrBase::getIPv4Storage() const
{
  return (const sockaddr_in *)&m_addr;
}

const char* sockAddrBase::ToString(bool includePort /*true*/) const
{
  in_port_t port = includePort ? Port() : 0;

  if (IsIPv4())
  {
    if (port == 0)
      return Ip4ToString(getIPv4Storage()->sin_addr);
    else
      return Ip4ToString(getIPv4Storage()->sin_addr, port);
  }
  else if (IsIPv6())
  {
    const sockaddr_in6 *storage = getIPv6Storage();

    if (storage->sin6_scope_id == 0 && !port)
    {
      // Just IPv6 address
      char *buffer;
      size_t bufsize = GetSmallTLSBuffer(&buffer);
      if (!bufsize)
        return "<memerror>";
      if (!inet_ntop(AF_INET6, &storage->sin6_addr, buffer, bufsize))
        return "<Invalid Address>";
      return buffer;
    }
    else
    {
      // composite address
      char ifNameBuf[IF_NAMESIZE];
      char addrStrBuf[INET6_ADDRSTRLEN];
      const char *ifName = NULL;
      const char *addrStr = NULL;

      if (storage->sin6_scope_id)
      {
        ifName = if_indextoname(storage->sin6_scope_id, ifNameBuf);
        if (!ifName)
          ifName = "???";
      }

      addrStr = inet_ntop(AF_INET6, &storage->sin6_addr, addrStrBuf, sizeof(addrStrBuf));
      if (!addrStr)
        addrStr = "<Invalid IPv6>";

      if (port)
      {
        if (ifName)
          return FormatShortStr("[%s%%%s]:%d", addrStr, ifName, (int)port);
        else
          return FormatShortStr("[%s]:%d", addrStr, (int)port);
      }
      else
      {
        if (ifName)
          return FormatShortStr("%s%%%s", addrStr, ifName);
        else
        {
          LogVerify(false); // should never happen
          return FormatShortStr("%s", addrStr);
        }
      }
    }
  }
  else
    return "<Invalid Address>";
}

/**
 * Compares two addresses.
 * Invalid addresses always compare the same, and below anything else.
 * IPv4 addresses always compare smaller than IPv6.
 * Assumes that IPv4 Addresses are in network order.
 *
 * If is IPv6 then comparison is:
 *    sin6_addr
 *    sin6_scope_id
 *    sin6_port
 *    sin6_flowinfo
 *
 * If is IPv4 then comparison is:
 *    sin_addr
 *    sin_port
 *
 * @param rhs
 *
 * @return: -1, 0, or 1 like strcmp.
 */
int sockAddrBase::compare(const sockAddrBase &rhs, bool comparePort) const
{
  if (Type() != rhs.Type())
  {
    if (!IsValid())
      return -1;
    if (!rhs.IsValid())
      return 1;
    if (IsIPv4())
      return -1;
    // We must be IPv6
    return 1;
  }

  if (!IsValid())
    return 0;
  if (IsIPv4())
  {
    in_addr_t addrLhs = getIPv4Storage()->sin_addr.s_addr;
    in_addr_t addrRhs = rhs.getIPv4Storage()->sin_addr.s_addr;

    if (addrLhs == addrRhs)
    {
      if (!comparePort || Port() == rhs.Port())
        return 0;
      return Port() > rhs.Port() ? 1 : -1;
    }
    return ntohl(addrLhs) > ntohl(addrRhs) ? 1 : -1;
  }
  else
  {
    // IPv6
    const sockaddr_in6 *storageLhs = getIPv6Storage();
    const sockaddr_in6 *storageRhs = rhs.getIPv6Storage();
    int val = memcmp(&storageLhs->sin6_addr, &storageRhs->sin6_addr, sizeof(in6_addr));
    if (val != 0)
      return val;
    if (storageLhs->sin6_scope_id != storageRhs->sin6_scope_id)
      return ntohl(storageLhs->sin6_scope_id) > ntohl(storageRhs->sin6_scope_id) ? 1 : -1;
    if (comparePort && Port() != rhs.Port())
      return Port() > rhs.Port() ? 1 : -1;
    if (storageLhs->sin6_flowinfo != storageRhs->sin6_flowinfo)
      return ntohl(storageLhs->sin6_flowinfo) > ntohl(storageRhs->sin6_flowinfo) ? 1 : -1;
    return 0;
  }
}

/**
 * This needs a  to match compare.
 *
 * @return size_t
 */
size_t sockAddrBase::hash() const
{

  /**
   * Invalid always hashes to a constant ... 0 seems as good as any?
   */
  if (!IsValid())
    return 0;
  else if (IsIPv4())
  {
    // May not be the 'best' hash, but it should work. We add DNSP_HASHINIT
    // So that address 0.0.0.0 does not collide with !IsValid().
    if (!m_allowPort)
      return getIPv4Storage()->sin_addr.s_addr + DNSP_HASHINIT;
    else
    {
      const sockaddr_in *storage = getIPv4Storage();
      return hashlittle(&storage->sin_port, sizeof(storage->sin_port), storage->sin_addr.s_addr + DNSP_HASHINIT);
    }
  }
  else
  {
    const sockaddr_in6 *storage = getIPv6Storage();

    // Below is to make sure that we can use hashword. This should never fail, but
    // without the 'if' some compilers issue a warning.
    if (!LogVerify((sizeof(in6_addr) % 4) == 0))
      return 0;

    // May not be the 'best' hash, but it should work.
    uint32_t port = m_allowPort ? storage->sin6_port : 0;
    uint32_t hash = hashword(reinterpret_cast<const uint32_t *>(&storage->sin6_addr),
                             sizeof(in6_addr) / 4, DNSP_HASHINIT + port);
    return (hash + storage->sin6_scope_id + storage->sin6_flowinfo);
  }
}

bool sockAddrBase::FromString(const char *str)
{
  // This is called from the constructor, so it must work with an uninitialized
  // structure.
  init(Addr::Invalid);
  // First determine if it is IPv4 or IPv6
  str = SkipWhite(str);
  const char *firstColon = strchr(str, ':');
  const char *firstDot = strchr(str, '.');
  const char *firstPercent = strchr(str, '%');

  if (!firstDot && !firstColon)
    return false;
  if (!firstColon
      || (firstDot && firstDot < firstColon))
  {
    // IPv4
    uint16_t port;
    uint32_t addr;

    if (firstPercent)
      return false;

    if (!firstColon)
    {
      if (!ParseIPv4(str, &addr, &str))
        return false;
      str = SkipWhite(str);
      if (*str != '\0')
        return false;
      init(Addr::IPv4);
      getIPv4Storage()->sin_addr.s_addr = addr;
      return true;
    }
    // Has dots and a colon, presumably its an IPv4 with port
    if (!m_allowPort)
      return false;

    if (!ParseIPv4Port(str, &addr, &port))
      return false;
    init(Addr::IPv4);
    getIPv4Storage()->sin_addr.s_addr = addr;
    SetPort(port);
    return true;
  }

  // Not IPv4
  if (!firstColon || (firstPercent && (firstPercent < firstColon)))
    return false;
  else
  {
    // IPv6
    sockaddr_in6 tmp = sockaddr_in6();

    if (firstPercent || *str == '[')
    {
      char addrStr[INET6_ADDRSTRLEN];
      const char *last, *lastBrace = NULL;

      if (*str == '[')
      {
        ++str;
        last = lastBrace = strchr(str,  ']');
        if (!lastBrace)
          return false;
      }
      if (firstPercent)
      {
        if (lastBrace && lastBrace < firstPercent + 2)
          return false;
        last = firstPercent;
      }

      if (last == str || size_t(last - str) >= sizeof(addrStr))
        return false;
      memcpy(addrStr, str, last - str);
      addrStr[last - str] = '\0';
      if (1 != inet_pton(AF_INET6, addrStr, &tmp.sin6_addr))
        return false;
      if (firstPercent)
      {
        // ONLY allow interface (scope) for link local addresses (for now)
        // Otherwise address comparison breaks for regular addresses, one of which has a
        // scope.
        if (!IN6_IS_ADDR_LINKLOCAL(&tmp.sin6_addr))
          return false;

        if (lastBrace)
        {
          // already checked that (lastBrace-firstPercent >= 2)
          memcpy(addrStr, firstPercent + 1, lastBrace - (firstPercent + 1));
          addrStr[lastBrace - (firstPercent + 1)] = '\0';
          last = addrStr;
        }
        else
          last = firstPercent + 1;

        unsigned int index = if_nametoindex(last);
        if (index == 0 || index > UINT32_MAX)
          return false;
        tmp.sin6_scope_id = uint32_t(index);
      }

      if (lastBrace)
      {
        last = lastBrace + 1;
        if (*last != ':')
        {
          last = SkipWhite(last);
          if (*last != '\0')
            return false;
        }
        else
        {
          // We have a port
          uint64_t val;

          if (!m_allowPort)
            return false;
          ++last;
          if (!StringToInt(last, val))
            return false;
          if (val > UINT16_MAX)
            return false;
          tmp.sin6_port = htons(uint16_t(val));
        }
      }
    }
    else
    {
      // no [] and no % so the string can be parsed directly
      if (1 != inet_pton(AF_INET6, str, &tmp.sin6_addr))
        return false;
    }

    // Set the actual value
    init(Addr::IPv6);
    sockaddr_in6 *storage = getIPv6Storage();
    storage->sin6_addr = tmp.sin6_addr;
    storage->sin6_port = tmp.sin6_port;
    storage->sin6_scope_id = tmp.sin6_scope_id;
    return true;
  }
}


bool sockAddrBase::FromString(const char *str, in_port_t port)
{
  if (!FromString(str))
    return false;
  if (m_allowPort)
    SetPort(port);
  return true;
}