contrib/llvm/tools/lldb/source/Host/common/SocketAddress.cpp

   1 //===-- SocketAddress.cpp ---------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Note: This file is used on Darwin by debugserver, so it needs to remain as
  11 //       self contained as possible, and devoid of references to LLVM unless
  12 //       there is compelling reason.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #if defined(_MSC_VER)
  17 #define _WINSOCK_DEPRECATED_NO_WARNINGS
  18 #endif
  19
  20 #include "lldb/Host/SocketAddress.h"
  21 #include <stddef.h>
  22 #include <stdio.h>
  23
  24 #if !defined(_WIN32)
  25 #include <arpa/inet.h>
  26 #endif
  27
  28 #include <assert.h>
  29 #include <string.h>
  30
  31 #include "lldb/Host/PosixApi.h"
  32
  33 // WindowsXP needs an inet_ntop implementation
  34 #ifdef _WIN32
  35
  36 #ifndef INET6_ADDRSTRLEN // might not be defined in older Windows SDKs
  37 #define INET6_ADDRSTRLEN 46
  38 #endif
  39
  40 // TODO: implement shortened form "::" for runs of zeros
  41 const char *inet_ntop(int af, const void *src, char *dst, socklen_t size) {
  42   if (size == 0) {
  43     return nullptr;
  44   }
  45
  46   switch (af) {
  47   case AF_INET: {
  48     {
  49       const char *formatted = inet_ntoa(*static_cast<const in_addr *>(src));
  50       if (formatted && strlen(formatted) < static_cast<size_t>(size)) {
  51         return ::strcpy(dst, formatted);
  52       }
  53     }
  54     return nullptr;
  55   case AF_INET6: {
  56     char tmp[INET6_ADDRSTRLEN] = {0};
  57     const uint16_t *src16 = static_cast<const uint16_t *>(src);
  58     int full_size = ::snprintf(
  59         tmp, sizeof(tmp), "%x:%x:%x:%x:%x:%x:%x:%x", ntohs(src16[0]),
  60         ntohs(src16[1]), ntohs(src16[2]), ntohs(src16[3]), ntohs(src16[4]),
  61         ntohs(src16[5]), ntohs(src16[6]), ntohs(src16[7]));
  62     if (full_size < static_cast<int>(size)) {
  63       return ::strcpy(dst, tmp);
  64     }
  65     return nullptr;
  66   }
  67   }
  68   }
  69   return nullptr;
  70 }
  71 #endif
  72
  73 using namespace lldb_private;
  74
  75 //----------------------------------------------------------------------
  76 // SocketAddress constructor
  77 //----------------------------------------------------------------------
  78 SocketAddress::SocketAddress() { Clear(); }
  79
  80 SocketAddress::SocketAddress(const struct sockaddr &s) { m_socket_addr.sa = s; }
  81
  82 SocketAddress::SocketAddress(const struct sockaddr_in &s) {
  83   m_socket_addr.sa_ipv4 = s;
  84 }
  85
  86 SocketAddress::SocketAddress(const struct sockaddr_in6 &s) {
  87   m_socket_addr.sa_ipv6 = s;
  88 }
  89
  90 SocketAddress::SocketAddress(const struct sockaddr_storage &s) {
  91   m_socket_addr.sa_storage = s;
  92 }
  93
  94 SocketAddress::SocketAddress(const struct addrinfo *addr_info) {
  95   *this = addr_info;
  96 }
  97
  98 //----------------------------------------------------------------------
  99 // SocketAddress copy constructor
 100 //----------------------------------------------------------------------
 101 SocketAddress::SocketAddress(const SocketAddress &rhs)
 102     : m_socket_addr(rhs.m_socket_addr) {}
 103
 104 //----------------------------------------------------------------------
 105 // Destructor
 106 //----------------------------------------------------------------------
 107 SocketAddress::~SocketAddress() {}
 108
 109 void SocketAddress::Clear() {
 110   memset(&m_socket_addr, 0, sizeof(m_socket_addr));
 111 }
 112
 113 bool SocketAddress::IsValid() const { return GetLength() != 0; }
 114
 115 static socklen_t GetFamilyLength(sa_family_t family) {
 116   switch (family) {
 117   case AF_INET:
 118     return sizeof(struct sockaddr_in);
 119   case AF_INET6:
 120     return sizeof(struct sockaddr_in6);
 121   }
 122   assert(0 && "Unsupported address family");
 123   return 0;
 124 }
 125
 126 socklen_t SocketAddress::GetLength() const {
 127 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
 128   return m_socket_addr.sa.sa_len;
 129 #else
 130   return GetFamilyLength(GetFamily());
 131 #endif
 132 }
 133
 134 socklen_t SocketAddress::GetMaxLength() { return sizeof(sockaddr_t); }
 135
 136 sa_family_t SocketAddress::GetFamily() const {
 137   return m_socket_addr.sa.sa_family;
 138 }
 139
 140 void SocketAddress::SetFamily(sa_family_t family) {
 141   m_socket_addr.sa.sa_family = family;
 142 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
 143   m_socket_addr.sa.sa_len = GetFamilyLength(family);
 144 #endif
 145 }
 146
 147 std::string SocketAddress::GetIPAddress() const {
 148   char str[INET6_ADDRSTRLEN] = {0};
 149   switch (GetFamily()) {
 150   case AF_INET:
 151     if (inet_ntop(GetFamily(), &m_socket_addr.sa_ipv4.sin_addr, str,
 152                   sizeof(str)))
 153       return str;
 154     break;
 155   case AF_INET6:
 156     if (inet_ntop(GetFamily(), &m_socket_addr.sa_ipv6.sin6_addr, str,
 157                   sizeof(str)))
 158       return str;
 159     break;
 160   }
 161   return "";
 162 }
 163
 164 uint16_t SocketAddress::GetPort() const {
 165   switch (GetFamily()) {
 166   case AF_INET:
 167     return ntohs(m_socket_addr.sa_ipv4.sin_port);
 168   case AF_INET6:
 169     return ntohs(m_socket_addr.sa_ipv6.sin6_port);
 170   }
 171   return 0;
 172 }
 173
 174 bool SocketAddress::SetPort(uint16_t port) {
 175   switch (GetFamily()) {
 176   case AF_INET:
 177     m_socket_addr.sa_ipv4.sin_port = htons(port);
 178     return true;
 179
 180   case AF_INET6:
 181     m_socket_addr.sa_ipv6.sin6_port = htons(port);
 182     return true;
 183   }
 184   return false;
 185 }
 186
 187 //----------------------------------------------------------------------
 188 // SocketAddress assignment operator
 189 //----------------------------------------------------------------------
 190 const SocketAddress &SocketAddress::operator=(const SocketAddress &rhs) {
 191   if (this != &rhs)
 192     m_socket_addr = rhs.m_socket_addr;
 193   return *this;
 194 }
 195
 196 const SocketAddress &SocketAddress::
 197 operator=(const struct addrinfo *addr_info) {
 198   Clear();
 199   if (addr_info && addr_info->ai_addr && addr_info->ai_addrlen > 0 &&
 200       size_t(addr_info->ai_addrlen) <= sizeof m_socket_addr) {
 201     ::memcpy(&m_socket_addr, addr_info->ai_addr, addr_info->ai_addrlen);
 202   }
 203   return *this;
 204 }
 205
 206 const SocketAddress &SocketAddress::operator=(const struct sockaddr &s) {
 207   m_socket_addr.sa = s;
 208   return *this;
 209 }
 210
 211 const SocketAddress &SocketAddress::operator=(const struct sockaddr_in &s) {
 212   m_socket_addr.sa_ipv4 = s;
 213   return *this;
 214 }
 215
 216 const SocketAddress &SocketAddress::operator=(const struct sockaddr_in6 &s) {
 217   m_socket_addr.sa_ipv6 = s;
 218   return *this;
 219 }
 220
 221 const SocketAddress &SocketAddress::
 222 operator=(const struct sockaddr_storage &s) {
 223   m_socket_addr.sa_storage = s;
 224   return *this;
 225 }
 226
 227 bool SocketAddress::getaddrinfo(const char *host, const char *service,
 228                                 int ai_family, int ai_socktype, int ai_protocol,
 229                                 int ai_flags) {
 230   Clear();
 231
 232   auto addresses = GetAddressInfo(host, service, ai_family, ai_socktype,
 233                                   ai_protocol, ai_flags);
 234   if (!addresses.empty())
 235     *this = addresses[0];
 236   return IsValid();
 237 }
 238
 239 std::vector<SocketAddress>
 240 SocketAddress::GetAddressInfo(const char *hostname, const char *servname,
 241                               int ai_family, int ai_socktype, int ai_protocol,
 242                               int ai_flags) {
 243   std::vector<SocketAddress> addr_list;
 244
 245   struct addrinfo hints;
 246   memset(&hints, 0, sizeof(hints));
 247   hints.ai_family = ai_family;
 248   hints.ai_socktype = ai_socktype;
 249   hints.ai_protocol = ai_protocol;
 250   hints.ai_flags = ai_flags;
 251
 252   struct addrinfo *service_info_list = NULL;
 253   int err = ::getaddrinfo(hostname, servname, &hints, &service_info_list);
 254   if (err == 0 && service_info_list) {
 255     for (struct addrinfo *service_ptr = service_info_list; service_ptr != NULL;
 256          service_ptr = service_ptr->ai_next) {
 257       addr_list.emplace_back(SocketAddress(service_ptr));
 258     }
 259   }
 260
 261   if (service_info_list)
 262     ::freeaddrinfo(service_info_list);
 263   return addr_list;
 264 }
 265
 266 bool SocketAddress::SetToLocalhost(sa_family_t family, uint16_t port) {
 267   switch (family) {
 268   case AF_INET:
 269     SetFamily(AF_INET);
 270     if (SetPort(port)) {
 271       m_socket_addr.sa_ipv4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 272       return true;
 273     }
 274     break;
 275
 276   case AF_INET6:
 277     SetFamily(AF_INET6);
 278     if (SetPort(port)) {
 279       m_socket_addr.sa_ipv6.sin6_addr = in6addr_loopback;
 280       return true;
 281     }
 282     break;
 283   }
 284   Clear();
 285   return false;
 286 }
 287
 288 bool SocketAddress::SetToAnyAddress(sa_family_t family, uint16_t port) {
 289   switch (family) {
 290   case AF_INET:
 291     SetFamily(AF_INET);
 292     if (SetPort(port)) {
 293       m_socket_addr.sa_ipv4.sin_addr.s_addr = htonl(INADDR_ANY);
 294       return true;
 295     }
 296     break;
 297
 298   case AF_INET6:
 299     SetFamily(AF_INET6);
 300     if (SetPort(port)) {
 301       m_socket_addr.sa_ipv6.sin6_addr = in6addr_any;
 302       return true;
 303     }
 304     break;
 305   }
 306   Clear();
 307   return false;
 308 }
 309
 310 bool SocketAddress::IsAnyAddr() const {
 311   return (GetFamily() == AF_INET)
 312              ? m_socket_addr.sa_ipv4.sin_addr.s_addr == htonl(INADDR_ANY)
 313              : 0 == memcmp(&m_socket_addr.sa_ipv6.sin6_addr, &in6addr_any, 16);
 314 }
 315
 316 bool SocketAddress::IsLocalhost() const {
 317   return (GetFamily() == AF_INET)
 318              ? m_socket_addr.sa_ipv4.sin_addr.s_addr == htonl(INADDR_LOOPBACK)
 319              : 0 == memcmp(&m_socket_addr.sa_ipv6.sin6_addr, &in6addr_loopback,
 320                            16);
 321 }
 322
 323 bool SocketAddress::operator==(const SocketAddress &rhs) const {
 324   if (GetFamily() != rhs.GetFamily())
 325     return false;
 326   if (GetLength() != rhs.GetLength())
 327     return false;
 328   switch (GetFamily()) {
 329   case AF_INET:
 330     return m_socket_addr.sa_ipv4.sin_addr.s_addr ==
 331            rhs.m_socket_addr.sa_ipv4.sin_addr.s_addr;
 332   case AF_INET6:
 333     return 0 == memcmp(&m_socket_addr.sa_ipv6.sin6_addr,
 334                        &rhs.m_socket_addr.sa_ipv6.sin6_addr, 16);
 335   }
 336   return false;
 337 }
 338
 339 bool SocketAddress::operator!=(const SocketAddress &rhs) const {
 340   return !(*this == rhs);
 341 }