//===-- SocketAddress.cpp -------------------------------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// Note: This file is used on Darwin by debugserver, so it needs to remain as

//       self contained as possible, and devoid of references to LLVM unless 

//       there is compelling reason.

//

//===----------------------------------------------------------------------===//

#if defined(_MSC_VER)

#define _WINSOCK_DEPRECATED_NO_WARNINGS

#endif

#include "lldb/Host/SocketAddress.h"

#include <cstddef>

#include <cstdio>

#if !defined(_WIN32)

#include <arpa/inet.h>

#endif

#include <cassert>

#include <cstring>

#include "lldb/Host/PosixApi.h"

// WindowsXP needs an inet_ntop implementation

#ifdef _WIN32

#ifndef INET6_ADDRSTRLEN // might not be defined in older Windows SDKs

#define INET6_ADDRSTRLEN 46

#endif

// TODO: implement shortened form "::" for runs of zeros

const char *inet_ntop(int af, const void *src, char *dst, socklen_t size) {

  if (size == 0) {

    return nullptr;

  }

  switch (af) {

  case AF_INET: {

    {

      const char *formatted = inet_ntoa(*static_cast<const in_addr *>(src));

      if (formatted && strlen(formatted) < static_cast<size_t>(size)) {

        return ::strcpy(dst, formatted);

      }

    }

    return nullptr;

  case AF_INET6: {

    char tmp[INET6_ADDRSTRLEN] = {0};

    const uint16_t *src16 = static_cast<const uint16_t *>(src);

    int full_size = ::snprintf(

        tmp, sizeof(tmp), "%x:%x:%x:%x:%x:%x:%x:%x", ntohs(src16[0]),

        ntohs(src16[1]), ntohs(src16[2]), ntohs(src16[3]), ntohs(src16[4]),

        ntohs(src16[5]), ntohs(src16[6]), ntohs(src16[7]));

    if (full_size < static_cast<int>(size)) {

      return ::strcpy(dst, tmp);

    }

    return nullptr;

  }

  }

  }

  return nullptr;

}

#endif

using namespace lldb_private;

// SocketAddress constructor

SocketAddress::SocketAddress() { Clear(); }

SocketAddress::SocketAddress(const struct sockaddr &s) { m_socket_addr.sa = s; }

SocketAddress::SocketAddress(const struct sockaddr_in &s) {

  m_socket_addr.sa_ipv4 = s;

}

SocketAddress::SocketAddress(const struct sockaddr_in6 &s) {

  m_socket_addr.sa_ipv6 = s;

}

SocketAddress::SocketAddress(const struct sockaddr_storage &s) {

  m_socket_addr.sa_storage = s;

}

SocketAddress::SocketAddress(const struct addrinfo *addr_info) {

  *this = addr_info;

}

// Destructor

SocketAddress::~SocketAddress() = default;

void SocketAddress::Clear() {

  memset(&m_socket_addr, 0, sizeof(m_socket_addr));

}

bool SocketAddress::IsValid() const { return GetLength() != 0; }

static socklen_t GetFamilyLength(sa_family_t family) {

  switch (family) {

  case AF_INET:

    return sizeof(struct sockaddr_in);

  case AF_INET6:

    return sizeof(struct sockaddr_in6);

  }

  assert(0 && "Unsupported address family");

  return 0;

}

socklen_t SocketAddress::GetLength() const {

#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)

  return m_socket_addr.sa.sa_len;

#else

  return GetFamilyLength(GetFamily());

#endif

}

socklen_t SocketAddress::GetMaxLength() { return sizeof(sockaddr_t); }

sa_family_t SocketAddress::GetFamily() const {

  return m_socket_addr.sa.sa_family;

}

void SocketAddress::SetFamily(sa_family_t family) {

  m_socket_addr.sa.sa_family = family;

#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)

  m_socket_addr.sa.sa_len = GetFamilyLength(family);

#endif

}

std::string SocketAddress::GetIPAddress() const {

  char str[INET6_ADDRSTRLEN] = {0};

  switch (GetFamily()) {

  case AF_INET:

    if (inet_ntop(GetFamily(), &m_socket_addr.sa_ipv4.sin_addr, str,

                  sizeof(str)))

      return str;

    break;

  case AF_INET6:

    if (inet_ntop(GetFamily(), &m_socket_addr.sa_ipv6.sin6_addr, str,

                  sizeof(str)))

      return str;

    break;

  }

  return "";

}

uint16_t SocketAddress::GetPort() const {

  switch (GetFamily()) {

  case AF_INET:

    return ntohs(m_socket_addr.sa_ipv4.sin_port);

  case AF_INET6:

    return ntohs(m_socket_addr.sa_ipv6.sin6_port);

  }

  return 0;

}

bool SocketAddress::SetPort(uint16_t port) {

  switch (GetFamily()) {

  case AF_INET:

    m_socket_addr.sa_ipv4.sin_port = htons(port);

    return true;

  case AF_INET6:

    m_socket_addr.sa_ipv6.sin6_port = htons(port);

    return true;

  }

  return false;

}

// SocketAddress assignment operator

const SocketAddress &SocketAddress::

operator=(const struct addrinfo *addr_info) {

  Clear();

  if (addr_info && addr_info->ai_addr && addr_info->ai_addrlen > 0 &&

      size_t(addr_info->ai_addrlen) <= sizeof m_socket_addr) {

    ::memcpy(&m_socket_addr, addr_info->ai_addr, addr_info->ai_addrlen);

  }

  return *this;

}

const SocketAddress &SocketAddress::operator=(const struct sockaddr &s) {

  m_socket_addr.sa = s;

  return *this;

}

const SocketAddress &SocketAddress::operator=(const struct sockaddr_in &s) {

  m_socket_addr.sa_ipv4 = s;

  return *this;

}

const SocketAddress &SocketAddress::operator=(const struct sockaddr_in6 &s) {

  m_socket_addr.sa_ipv6 = s;

  return *this;

}

const SocketAddress &SocketAddress::

operator=(const struct sockaddr_storage &s) {

  m_socket_addr.sa_storage = s;

  return *this;

}

bool SocketAddress::getaddrinfo(const char *host, const char *service,

                                int ai_family, int ai_socktype, int ai_protocol,

                                int ai_flags) {

  Clear();

  auto addresses = GetAddressInfo(host, service, ai_family, ai_socktype,

                                  ai_protocol, ai_flags);

  if (!addresses.empty())

    *this = addresses[0];

  return IsValid();

}

std::vector<SocketAddress>

SocketAddress::GetAddressInfo(const char *hostname, const char *servname,

                              int ai_family, int ai_socktype, int ai_protocol,

                              int ai_flags) {

  std::vector<SocketAddress> addr_list;

  struct addrinfo hints;

  memset(&hints, 0, sizeof(hints));

  hints.ai_family = ai_family;

  hints.ai_socktype = ai_socktype;

  hints.ai_protocol = ai_protocol;

  hints.ai_flags = ai_flags;

  struct addrinfo *service_info_list = nullptr;

  int err = ::getaddrinfo(hostname, servname, &hints, &service_info_list);

  if (err == 0 && service_info_list) {

    for (struct addrinfo *service_ptr = service_info_list;

         service_ptr != nullptr; 
service_ptr = service_ptr->ai_next330
) {

      addr_list.emplace_back(SocketAddress(service_ptr));

    }

  }

  if (service_info_list)

    ::freeaddrinfo(service_info_list);

  return addr_list;

}

bool SocketAddress::SetToLocalhost(sa_family_t family, uint16_t port) {

  switch (family) {

  case AF_INET:

    SetFamily(AF_INET);

    if (SetPort(port)) {

      m_socket_addr.sa_ipv4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

      return true;

    }

    break;

  case AF_INET6:

    SetFamily(AF_INET6);

    if (SetPort(port)) {

      m_socket_addr.sa_ipv6.sin6_addr = in6addr_loopback;

      return true;

    }

    break;

  }

  Clear();

  return false;

}

bool SocketAddress::SetToAnyAddress(sa_family_t family, uint16_t port) {

  switch (family) {

  case AF_INET:

    SetFamily(AF_INET);

    if (SetPort(port)) {

      m_socket_addr.sa_ipv4.sin_addr.s_addr = htonl(INADDR_ANY);

      return true;

    }

    break;

  case AF_INET6:

    SetFamily(AF_INET6);

    if (SetPort(port)) {

      m_socket_addr.sa_ipv6.sin6_addr = in6addr_any;

      return true;

    }

    break;

  }

  Clear();

  return false;

}

bool SocketAddress::IsAnyAddr() const {

  return (GetFamily() == AF_INET)

             ? 
m_socket_addr.sa_ipv4.sin_addr.s_addr == htonl6
(INADDR_ANY)

             : 
0 == memcmp(&m_socket_addr.sa_ipv6.sin6_addr, &in6addr_any, 16)44
;

}

bool SocketAddress::IsLocalhost() const {

  return (GetFamily() == AF_INET)

             ? 
m_socket_addr.sa_ipv4.sin_addr.s_addr == htonl60
(INADDR_LOOPBACK)

             : 0 == memcmp(&m_socket_addr.sa_ipv6.sin6_addr, &in6addr_loopback,

                           16);

}

bool SocketAddress::operator==(const SocketAddress &rhs) const {

  if (GetFamily() != rhs.GetFamily())

    return false;

  if (GetLength() != rhs.GetLength())

    return false;

  switch (GetFamily()) {

  case AF_INET:

    return m_socket_addr.sa_ipv4.sin_addr.s_addr ==

           rhs.m_socket_addr.sa_ipv4.sin_addr.s_addr;

  case AF_INET6:

    return 0 == memcmp(&m_socket_addr.sa_ipv6.sin6_addr,

                       &rhs.m_socket_addr.sa_ipv6.sin6_addr, 16);

  }

  return false;

}

bool SocketAddress::operator!=(const SocketAddress &rhs) const {

  return !(*this == rhs);

}