[NFC] Adding a new wrapper for getaddrinfo

[beanz]

Summary

This patch adds a new wrapper for getaddrinfo which returns a std::vector of SocketAddresses. While this patch doesn't add any uses of the new function, I have two separable patches that are dependent on this, so I put it in its own patch.

[zturner]

include/lldb/Host/SocketAddress.h

44–45 ↗

(On Diff #94550)

What about using Twine here instead of const char * literals?

source/Host/common/SocketAddress.cpp

260 ↗

(On Diff #94550)

How about emplace_back(service_ptr)

[beanz]

include/lldb/Host/SocketAddress.h

44–45 ↗

(On Diff #94550)

I don't want to use Twine for this because in other patches I'm pulling this into debugserver which doesn't have any dependency on LLVM.

lldb/trunk/include/lldb/Host/SocketAddress.h

 #if defined(__FreeBSD__)
 #include <sys/types.h>
 #endif
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include <string>
+#include <vector>
 
 namespace lldb_private {
 
 class SocketAddress {
 public:
+  //----------------------------------------------------------------------------
+  // Static method to get all address information for a host and/or service
+  //----------------------------------------------------------------------------
+  static std::vector<SocketAddress> GetAddressInfo(const char *hostname,
+                                                 const char *servname);
+
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
   SocketAddress();
+  SocketAddress(const struct addrinfo *addr_info);
   SocketAddress(const struct sockaddr &s);
   SocketAddress(const struct sockaddr_in &s);
   SocketAddress(const struct sockaddr_in6 &s);
   SocketAddress(const struct sockaddr_storage &s);
   SocketAddress(const SocketAddress &rhs);
   ~SocketAddress();
 
   //------------------------------------------------------------------
   // Operators
   //------------------------------------------------------------------
   const SocketAddress &operator=(const SocketAddress &rhs);
 
   const SocketAddress &operator=(const struct addrinfo *addr_info);
 
   const SocketAddress &operator=(const struct sockaddr &s);
 
   const SocketAddress &operator=(const struct sockaddr_in &s);
 
   const SocketAddress &operator=(const struct sockaddr_in6 &s);
 
   const SocketAddress &operator=(const struct sockaddr_storage &s);
 
+  bool operator==(const SocketAddress &rhs) const;
+  bool operator!=(const SocketAddress &rhs) const;
+
   //------------------------------------------------------------------
   // Clear the contents of this socket address
   //------------------------------------------------------------------
   void Clear();
 
   //------------------------------------------------------------------
   // Get the length for the current socket address family
   //------------------------------------------------------------------
public:
   bool SetToAnyAddress(sa_family_t family, uint16_t port);
 
   //------------------------------------------------------------------
   // Returns true if there is a valid socket address in this object.
   //------------------------------------------------------------------
   bool IsValid() const;
 
   //------------------------------------------------------------------
+  // Returns true if the socket is INADDR_ANY
+  //------------------------------------------------------------------
+  bool IsAnyAddr() const;
+
+  //------------------------------------------------------------------
   // Direct access to all of the sockaddr structures
   //------------------------------------------------------------------
   struct sockaddr &sockaddr() {
     return m_socket_addr.sa;
   }
 
   const struct sockaddr &sockaddr() const { return m_socket_addr.sa; }
 

lldb/trunk/source/Host/common/SocketAddress.cpp

 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;
+}
+
 //----------------------------------------------------------------------
 // SocketAddress copy constructor
 //----------------------------------------------------------------------
 SocketAddress::SocketAddress(const SocketAddress &rhs)
     : m_socket_addr(rhs.m_socket_addr) {}
 
 //----------------------------------------------------------------------
 // Destructor
bool SocketAddress::getaddrinfo(const char *host, const char *service,
   }
 
   if (service_info_list)
     ::freeaddrinfo(service_info_list);
 
   return result;
 }
 
+std::vector<SocketAddress> SocketAddress::GetAddressInfo(const char *hostname,
+                                                       const char *servname) {
+  std::vector<SocketAddress> addr_list;
+
+  struct addrinfo *service_info_list = NULL;
+  int err = ::getaddrinfo(hostname, servname, NULL, &service_info_list);
+  if (err == 0 && service_info_list) {
+    for (struct addrinfo *service_ptr = service_info_list; service_ptr != NULL;
+         service_ptr = service_ptr->ai_next) {
+      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;
     }
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 == htonl(INADDR_ANY)
+             : 0 == memcmp(&m_socket_addr.sa_ipv6.sin6_addr, &in6addr_any, 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);
+}