EIC code displayed by LXR master/​include/​lldb/​Host/​SocketAddress.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:42:49

 //===-- SocketAddress.h -----------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_HOST_SOCKETADDRESS_H
 #define LLDB_HOST_SOCKETADDRESS_H
 
 #include <cstdint>
 
 #ifdef _WIN32
 #include "lldb/Host/windows/windows.h"
 #include <winsock2.h>
 #include <ws2tcpip.h>
 typedef ADDRESS_FAMILY sa_family_t;
 #else
 #include <netdb.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #endif
 
 #if defined(__FreeBSD__)
 #include <sys/types.h>
 #endif
 
 #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, int ai_family,
                  int ai_socktype, int ai_protocol, int ai_flags = 0);
 
   // 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();
 
   // Operators
   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
   socklen_t GetLength() const;
 
   // Get the max length for the largest socket address supported.
   static socklen_t GetMaxLength();
 
   // Get the socket address family
   sa_family_t GetFamily() const;
 
   // Set the socket address family
   void SetFamily(sa_family_t family);
 
   // Get the address
   std::string GetIPAddress() const;
 
   // Get the port if the socket address for the family has a port
   uint16_t GetPort() const;
 
   // Set the port if the socket address for the family has a port. The family
   // must be set correctly prior to calling this function.
   bool SetPort(uint16_t port);
 
   // Set the socket address according to the first match from a call to
   // getaddrinfo() (or equivalent functions for systems that don't have
   // getaddrinfo(). If "addr_info_ptr" is not NULL, it will get filled in with
   // the match that was used to populate this socket address.
   bool
   getaddrinfo(const char *host,    // Hostname ("foo.bar.com" or "foo" or IP
                                    // address string ("123.234.12.1" or
                                    // "2001:0db8:85a3:0000:0000:8a2e:0370:7334")
               const char *service, // Protocol name ("tcp", "http", etc) or a
                                    // raw port number string ("81")
               int ai_family = PF_UNSPEC, int ai_socktype = 0,
               int ai_protocol = 0, int ai_flags = 0);
 
   // Quick way to set the SocketAddress to localhost given the family. Returns
   // true if successful, false if "family" doesn't support localhost or if
   // "family" is not supported by this class.
   bool SetToLocalhost(sa_family_t family, uint16_t port);
 
   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;
 
   // Returns true if the socket is INADDR_LOOPBACK
   bool IsLocalhost() 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; }
 
   struct sockaddr_in &sockaddr_in() {
     return m_socket_addr.sa_ipv4;
   }
 
   const struct sockaddr_in &sockaddr_in() const {
     return m_socket_addr.sa_ipv4;
   }
 
   struct sockaddr_in6 &sockaddr_in6() {
     return m_socket_addr.sa_ipv6;
   }
 
   const struct sockaddr_in6 &sockaddr_in6() const {
     return m_socket_addr.sa_ipv6;
   }
 
   struct sockaddr_storage &sockaddr_storage() {
     return m_socket_addr.sa_storage;
   }
 
   const struct sockaddr_storage &sockaddr_storage() const {
     return m_socket_addr.sa_storage;
   }
 
   // Conversion operators to allow getting the contents of this class as a
   // pointer to the appropriate structure. This allows an instance of this
   // class to be used in calls that take one of the sockaddr structure variants
   // without having to manually use the correct accessor function.
 
   operator struct sockaddr *() { return &m_socket_addr.sa; }
 
   operator const struct sockaddr *() const { return &m_socket_addr.sa; }
 
   operator struct sockaddr_in *() { return &m_socket_addr.sa_ipv4; }
 
   operator const struct sockaddr_in *() const { return &m_socket_addr.sa_ipv4; }
 
   operator struct sockaddr_in6 *() { return &m_socket_addr.sa_ipv6; }
 
   operator const struct sockaddr_in6 *() const {
     return &m_socket_addr.sa_ipv6;
   }
 
   operator const struct sockaddr_storage *() const {
     return &m_socket_addr.sa_storage;
   }
 
   operator struct sockaddr_storage *() { return &m_socket_addr.sa_storage; }
 
 protected:
   typedef union sockaddr_tag {
     struct sockaddr sa;
     struct sockaddr_in sa_ipv4;
     struct sockaddr_in6 sa_ipv6;
     struct sockaddr_storage sa_storage;
   } sockaddr_t;
 
   // Classes that inherit from SocketAddress can see and modify these
   sockaddr_t m_socket_addr;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_SOCKETADDRESS_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team