folly::SocketAddress Class Reference

#include <SocketAddress.h>

Classes
union	AddrStorage
struct	ExternalUnixAddr

Public Member Functions
	SocketAddress ()=default
	SocketAddress (const char *host, uint16_t port, bool allowNameLookup=false)
	SocketAddress (const std::string &host, uint16_t port, bool allowNameLookup=false)
	SocketAddress (const IPAddress &ipAddr, uint16_t port)
	SocketAddress (const SocketAddress &addr)
SocketAddress &	operator= (const SocketAddress &addr)
	SocketAddress (SocketAddress &&addr) noexcept
SocketAddress &	operator= (SocketAddress &&addr)
	~SocketAddress ()
bool	isInitialized () const
bool	isPrivateAddress () const
bool	isLoopbackAddress () const
void	reset ()
void	setFromHostPort (const char *host, uint16_t port)
void	setFromHostPort (const std::string &host, uint16_t port)
void	setFromIpPort (const char *ip, uint16_t port)
void	setFromIpPort (const std::string &ip, uint16_t port)
void	setFromIpAddrPort (const IPAddress &ip, uint16_t port)
void	setFromLocalPort (uint16_t port)
void	setFromLocalPort (const char *port)
void	setFromLocalPort (const std::string &port)
void	setFromLocalIpPort (const char *addressAndPort)
void	setFromLocalIpPort (const std::string &addressAndPort)
void	setFromIpPort (const char *addressAndPort)
void	setFromIpPort (const std::string &addressAndPort)
void	setFromHostPort (const char *hostAndPort)
void	setFromHostPort (const std::string &hostAndPort)
void	setFromPath (StringPiece path)
void	setFromPath (const char *path, size_t length)
void	setFromPeerAddress (int socket)
void	setFromPeerAddress (NetworkSocket socket)
void	setFromLocalAddress (int socket)
void	setFromLocalAddress (NetworkSocket socket)
void	setFromSockaddr (const struct sockaddr *address)
void	setFromSockaddr (const struct sockaddr *address, socklen_t addrlen)
void	setFromSockaddr (const struct sockaddr_in *address)
void	setFromSockaddr (const struct sockaddr_in6 *address)
void	setFromSockaddr (const struct sockaddr_un *address, socklen_t addrlen)
socklen_t	getAddress (sockaddr_storage *addr) const
const folly::IPAddress &	getIPAddress () const
socklen_t	getActualSize () const
sa_family_t	getFamily () const
bool	empty () const
std::string	getAddressStr () const
void	getAddressStr (char *buf, size_t buflen) const
bool	isFamilyInet () const
std::string	getFullyQualified () const
uint16_t	getPort () const
void	setPort (uint16_t port)
bool	isIPv4Mapped () const
void	convertToIPv4 ()
bool	tryConvertToIPv4 ()
bool	mapToIPv6 ()
std::string	getHostStr () const
std::string	getPath () const
std::string	describe () const
bool	operator== (const SocketAddress &other) const
bool	operator!= (const SocketAddress &other) const
bool	prefixMatch (const SocketAddress &other, unsigned prefixLength) const
bool	operator< (const SocketAddress &other) const
size_t	hash () const

Static Public Member Functions
static int	getPortFrom (const struct sockaddr *address)
static const char *	getFamilyNameFrom (const struct sockaddr *address, const char *defaultResult=nullptr)
static SocketAddress	makeFromPath (StringPiece path)

Private Member Functions
struct addrinfo *	getAddrInfo (const char *host, uint16_t port, int flags)
struct addrinfo *	getAddrInfo (const char *host, const char *port, int flags)
void	setFromAddrInfo (const struct addrinfo *results)
void	setFromLocalAddr (const struct addrinfo *results)
void	setFromSocket (NetworkSocket socket, int(*fn)(NetworkSocket, struct sockaddr *, socklen_t *))
std::string	getIpString (int flags) const
void	getIpString (char *buf, size_t buflen, int flags) const
void	updateUnixAddressLength (socklen_t addrlen)

Private Attributes
union folly::SocketAddress::AddrStorage	storage_
uint16_t	port_
bool	external_ {false}

Detailed Description

Definition at line 32 of file SocketAddress.h.

Constructor & Destructor Documentation

folly::SocketAddress::SocketAddress ( )

default

folly::SocketAddress::SocketAddress ( const char *  host, uint16_t  port, bool  allowNameLookup = false  )

inline

Construct a SocketAddress from a hostname and port.

Note: If the host parameter is not a numeric IP address, hostname resolution will be performed, which can be quite slow.

Raises std::system_error on error.

Parameters

host	The IP address (or hostname, if allowNameLookup is true)
port	The port (in host byte order) allowNameLookup If true, attempt to perform hostname lookup if the hostname does not appear to be a numeric IP address. This is potentially a very slow operation, so is disabled by default.

Definition at line 51 of file SocketAddress.h.

References setFromHostPort(), and setFromIpPort().

                                                                               {
    // Initialize the address family first,
    // since setFromHostPort() and setFromIpPort() will check it.

    if (allowNameLookup) {
      setFromHostPort(host, port);
    } else {
      setFromIpPort(host, port);
    }
  }

folly::SocketAddress::SocketAddress ( const std::string &  host, uint16_t  port, bool  allowNameLookup = false  )

inline

Definition at line 62 of file SocketAddress.h.

References setFromHostPort(), and setFromIpPort().

                                    {
    // Initialize the address family first,
    // since setFromHostPort() and setFromIpPort() will check it.

    if (allowNameLookup) {
      setFromHostPort(host.c_str(), port);
    } else {
      setFromIpPort(host.c_str(), port);
    }
  }

folly::SocketAddress::SocketAddress ( const IPAddress &  ipAddr, uint16_t  port  )

inline

Definition at line 76 of file SocketAddress.h.

References setFromIpAddrPort().

                                                        {
    setFromIpAddrPort(ipAddr, port);
  }

folly::SocketAddress::SocketAddress ( const SocketAddress &  addr )

inline

Definition at line 80 of file SocketAddress.h.

References external_, getFamily(), folly::SocketAddress::ExternalUnixAddr::init(), port_, storage_, and folly::SocketAddress::AddrStorage::un.

                                           {
    port_ = addr.port_;
    if (addr.getFamily() == AF_UNIX) {
      storage_.un.init(addr.storage_.un);
    } else {
      storage_ = addr.storage_;
    }
    external_ = addr.external_;
  }

folly::SocketAddress::SocketAddress ( SocketAddress &&  addr )

inlinenoexcept

Definition at line 111 of file SocketAddress.h.

References addr, external_, port_, and storage_.

                                               {
    storage_ = addr.storage_;
    port_ = addr.port_;
    external_ = addr.external_;
    addr.external_ = false;
  }

folly::SocketAddress::~SocketAddress ( )

inline

Definition at line 125 of file SocketAddress.h.

References external_, folly::SocketAddress::ExternalUnixAddr::free(), storage_, and folly::SocketAddress::AddrStorage::un.

                   {
    if (external_) {
      storage_.un.free();
    }
  }

Member Function Documentation

void folly::SocketAddress::convertToIPv4

(

)

Convert an IPv4-mapped IPv6 address to an IPv4 address.

Raises std::invalid_argument if this is not an IPv4-mapped IPv6 address.

Definition at line 430 of file SocketAddress.cpp.

Referenced by isIPv4Mapped(), and TEST().

                                  {
  if (!tryConvertToIPv4()) {
    throw std::invalid_argument(
        "convertToIPv4() called on an addresse that is "
        "not an IPv4-mapped address");
  }
}

std::string folly::SocketAddress::describe

(

)

const

Get human-readable string representation of the address.

This prints a string representation of the address, for human consumption. For IP addresses, the string is of the form "<IP>:<port>".

Definition at line 482 of file SocketAddress.cpp.

References string.

Referenced by wangle::SSLContextManager::addSSLContextConfig(), folly::AsyncUDPSocket::bind(), folly::AsyncServerSocket::bindSocket(), wangle::Acceptor::canAccept(), folly::AsyncSocket::fail(), folly::AsyncSocket::failConnect(), folly::AsyncSocket::failErrMessageRead(), folly::AsyncSocket::failRead(), folly::AsyncSocket::failWrite(), folly::AsyncSocket::handleConnect(), isIPv4Mapped(), proxygen::HTTPSessionAcceptor::onNewConnection(), folly::operator<<(), folly::AsyncServerSocket::setupSocket(), proxygen::HTTPSession::shutdownTransport(), TEST(), TelnetHandler::transportActive(), FileServerHandler::transportActive(), and folly::AsyncSocket::withAddr().

                                        {
  if (external_) {
    if (storage_.un.pathLength() == 0) {
      return "<anonymous unix address>";
    }

    if (storage_.un.addr->sun_path[0] == '\0') {
      // Linux supports an abstract namespace for unix socket addresses
      return "<abstract unix address>";
    }

    return std::string(
        storage_.un.addr->sun_path,
        strnlen(storage_.un.addr->sun_path, size_t(storage_.un.pathLength())));
  }
  switch (getFamily()) {
    case AF_UNSPEC:
      return "<uninitialized address>";
    case AF_INET: {
      char buf[NI_MAXHOST + 16];
      getAddressStr(buf, sizeof(buf));
      size_t iplen = strlen(buf);
      snprintf(buf + iplen, sizeof(buf) - iplen, ":%" PRIu16, getPort());
      return buf;
    }
    case AF_INET6: {
      char buf[NI_MAXHOST + 18];
      buf[0] = '[';
      getAddressStr(buf + 1, sizeof(buf) - 1);
      size_t iplen = strlen(buf);
      snprintf(buf + iplen, sizeof(buf) - iplen, "]:%" PRIu16, getPort());
      return buf;
    }
    default: {
      char buf[64];
      snprintf(buf, sizeof(buf), "<unknown address family %d>", getFamily());
      return buf;
    }
  }
}

bool folly::SocketAddress::empty ( ) const

inline

Definition at line 412 of file SocketAddress.h.

References getAddressStr(), getFamily(), getFullyQualified(), getPort(), isFamilyInet(), setPort(), string, and uint16_t.

Referenced by TEST().

                     {
    return getFamily() == AF_UNSPEC;
  }

socklen_t folly::SocketAddress::getActualSize

(

)

const

Definition at line 362 of file SocketAddress.cpp.

Referenced by folly::AsyncUDPSocket::bind(), folly::AsyncServerSocket::bindSocket(), folly::AsyncUDPSocket::connect(), folly::AsyncSocket::connect(), getAddress(), testSetFromSocket(), and folly::AsyncUDPSocket::writev().

                                             {
  if (external_) {
    return storage_.un.len;
  }
  switch (getFamily()) {
    case AF_UNSPEC:
    case AF_INET:
      return sizeof(struct sockaddr_in);
    case AF_INET6:
      return sizeof(struct sockaddr_in6);
    default:
      throw std::invalid_argument(
          "SocketAddress::getActualSize() called "
          "with unrecognized address family");
  }
}

socklen_t folly::SocketAddress::getAddress ( sockaddr_storage *  addr ) const

inline

Fill in a given sockaddr_storage with the ip or unix address.

Returns the actual size of the storage used.

Definition at line 393 of file SocketAddress.h.

References folly::SocketAddress::ExternalUnixAddr::addr, folly::SocketAddress::AddrStorage::addr, external_, getActualSize(), getIPAddress(), folly::SocketAddress::ExternalUnixAddr::len, port_, storage_, and folly::SocketAddress::AddrStorage::un.

Referenced by folly::AsyncUDPSocket::bind(), folly::AsyncServerSocket::bindSocket(), folly::AsyncUDPSocket::connect(), folly::AsyncSocket::sendSocketMessage(), folly::TEST(), TEST(), testSetFromSocket(), and folly::AsyncUDPSocket::writev().

                                                     {
    if (!external_) {
      return storage_.addr.toSockaddrStorage(addr, htons(port_));
    } else {
      memcpy(addr, storage_.un.addr, sizeof(*storage_.un.addr));
      return storage_.un.len;
    }
  }

std::string folly::SocketAddress::getAddressStr

(

)

const

Get a string representation of the IPv4 or IPv6 address.

Raises std::invalid_argument if an error occurs (for example, if the address is not an IPv4 or IPv6 address).

Definition at line 386 of file SocketAddress.cpp.

Referenced by empty(), main(), proxygen::HTTPMessage::setClientAddress(), proxygen::HTTPMessage::setDstAddress(), and TEST().

                                             {
  if (!isFamilyInet()) {
    throw std::invalid_argument("Can't get address str for non ip address");
  }
  return storage_.addr.str();
}

void folly::SocketAddress::getAddressStr	(	char *	buf,
		size_t	buflen
	)		const

Get a string representation of the IPv4 or IPv6 address.

Raises std::invalid_argument if an error occurs (for example, if the address is not an IPv4 or IPv6 address).

Definition at line 398 of file SocketAddress.cpp.

References min.

                                                                {
  auto ret = getAddressStr();
  size_t len = std::min(buflen - 1, ret.size());
  memcpy(buf, ret.data(), len);
  buf[len] = '\0';
}

struct addrinfo * folly::SocketAddress::getAddrInfo ( const char *  host, uint16_t  port, int  flags  )

private

Definition at line 609 of file SocketAddress.cpp.

Referenced by folly::SocketAddress::ExternalUnixAddr::free().

                                                                     {
  // getaddrinfo() requires the port number as a string
  char portString[sizeof("65535")];
  snprintf(portString, sizeof(portString), "%" PRIu16, port);

  return getAddrInfo(host, portString, flags);
}

struct addrinfo * folly::SocketAddress::getAddrInfo ( const char *  host, const char *  port, int  flags  )

private

Definition at line 618 of file SocketAddress.cpp.

References folly::pushmi::operators::error(), and folly::sformat().

                                                                        {
  struct addrinfo hints;
  memset(&hints, 0, sizeof(hints));
  hints.ai_family = AF_UNSPEC;
  hints.ai_socktype = SOCK_STREAM;
  hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV | flags;

  struct addrinfo* results;
  int error = getaddrinfo(host, port, &hints, &results);
  if (error != 0) {
    auto os = folly::sformat(
        "Failed to resolve address for '{}': {} (error={})",
        host,
        gai_strerror(error),
        error);
    throw std::system_error(error, std::generic_category(), os);
  }

  return results;
}

sa_family_t folly::SocketAddress::getFamily ( ) const

inline

Definition at line 407 of file SocketAddress.h.

References folly::SocketAddress::AddrStorage::addr, external_, and storage_.

Referenced by folly::AsyncUDPSocket::bind(), folly::AsyncServerSocket::bind(), folly::AsyncServerSocket::bindSocket(), CheckPrefixMatch(), folly::AsyncUDPSocket::dontFragment(), empty(), folly::AsyncUDPSocket::handleRead(), isInitialized(), isIPv4Mapped(), operator<(), operator=(), operator==(), prefixMatch(), folly::AsyncUDPSocket::setErrMessageCallback(), folly::AsyncSocket::setErrMessageCB(), wangle::ServerSocketConfig::setSocketOptions(), SocketAddress(), TEST(), testSetFromSocket(), and folly::AsyncServerSocket::useExistingSockets().

                                {
    DCHECK(external_ || AF_UNIX != storage_.addr.family());
    return external_ ? sa_family_t(AF_UNIX) : storage_.addr.family();
  }

const char * folly::SocketAddress::getFamilyNameFrom ( const struct sockaddr *  address, const char *  defaultResult = nullptr  )

static

Returns the family name from the given socketaddr structure (e.g.: AF_INET6 for IPv6).

Returns defaultResult for unsupported socket families.

Definition at line 199 of file SocketAddress.cpp.

References GETFAMILYNAMEFROM_IMPL.

Referenced by folly::AsyncServerSocket::bind(), and setFromHostPort().

                               {
#define GETFAMILYNAMEFROM_IMPL(Family) \
  case Family:                         \
    return #Family

  switch (address->sa_family) {
    GETFAMILYNAMEFROM_IMPL(AF_INET);
    GETFAMILYNAMEFROM_IMPL(AF_INET6);
    GETFAMILYNAMEFROM_IMPL(AF_UNIX);
    GETFAMILYNAMEFROM_IMPL(AF_UNSPEC);

    default:
      return defaultResult;
  }

#undef GETFAMILYNAMEFROM_IMPL
}

std::string folly::SocketAddress::getFullyQualified

(

)

const

For v4 & v6 addresses, return the fully qualified address string

Definition at line 379 of file SocketAddress.cpp.

Referenced by empty().

                                                 {
  if (!isFamilyInet()) {
    throw std::invalid_argument("Can't get address str for non ip address");
  }
  return storage_.addr.toFullyQualified();
}

std::string folly::SocketAddress::getHostStr

(

)

const

Get string representation of the host name (or IP address if the host name cannot be resolved).

Warning: Using this method is strongly discouraged. It performs a DNS lookup, which may block for many seconds.

Raises std::invalid_argument if an error occurs.

Definition at line 456 of file SocketAddress.cpp.

Referenced by isIPv4Mapped().

                                          {
  return getIpString(0);
}

const folly::IPAddress & folly::SocketAddress::getIPAddress

(

)

const

Definition at line 354 of file SocketAddress.cpp.

Referenced by getAddress(), wangle::LoadShedConfiguration::AddressOnlyCompare::operator()(), and TEST().

                                                        {
  auto family = getFamily();
  if (family != AF_INET && family != AF_INET6) {
    throw InvalidAddressFamilyException(family);
  }
  return storage_.addr;
}

std::string folly::SocketAddress::getIpString ( int  flags ) const

private

Definition at line 670 of file SocketAddress.cpp.

References string.

Referenced by folly::SocketAddress::ExternalUnixAddr::free().

                                                    {
  char addrString[NI_MAXHOST];
  getIpString(addrString, sizeof(addrString), flags);
  return std::string(addrString);
}

void folly::SocketAddress::getIpString ( char *  buf, size_t  buflen, int  flags  ) const

private

Definition at line 676 of file SocketAddress.cpp.

References folly::sformat().

                                                                         {
  auto family = getFamily();
  if (family != AF_INET && family != AF_INET6) {
    throw std::invalid_argument(
        "SocketAddress: attempting to get IP address "
        "for a non-IP address");
  }

  sockaddr_storage tmp_sock;
  storage_.addr.toSockaddrStorage(&tmp_sock, port_);
  int rc = getnameinfo(
      (sockaddr*)&tmp_sock,
      sizeof(sockaddr_storage),
      buf,
      buflen,
      nullptr,
      0,
      flags);
  if (rc != 0) {
    auto os = sformat(
        "getnameinfo() failed in getIpString() error = {}", gai_strerror(rc));
    throw std::system_error(rc, std::generic_category(), os);
  }
}

std::string folly::SocketAddress::getPath

(

)

const

Get the path name for a Unix domain socket.

Returns a std::string containing the path. For anonymous sockets, an empty string is returned.

For addresses in the abstract namespace (Linux-specific), a std::string containing binary data is returned. In this case the first character will always be a NUL character.

Raises std::invalid_argument if called on a non-Unix domain socket.

Definition at line 460 of file SocketAddress.cpp.

References string.

Referenced by isIPv4Mapped(), and TEST().

                                       {
  if (!external_) {
    throw std::invalid_argument(
        "SocketAddress: attempting to get path "
        "for a non-Unix address");
  }

  if (storage_.un.pathLength() == 0) {
    // anonymous address
    return std::string();
  }
  if (storage_.un.addr->sun_path[0] == '\0') {
    // abstract namespace
    return std::string(
        storage_.un.addr->sun_path, size_t(storage_.un.pathLength()));
  }

  return std::string(
      storage_.un.addr->sun_path,
      strnlen(storage_.un.addr->sun_path, size_t(storage_.un.pathLength())));
}

uint16_t folly::SocketAddress::getPort

(

)

const

Get the IPv4 or IPv6 port for this address.

Raises std::invalid_argument if this is not an IPv4 or IPv6 address.

Returns

Returns the port, in host byte order.

Definition at line 405 of file SocketAddress.cpp.

Referenced by folly::AsyncUDPSocket::bind(), folly::AsyncServerSocket::bind(), empty(), proxygen::HTTPMessage::setClientAddress(), proxygen::HTTPMessage::setDstAddress(), folly::TEST(), and TEST().

                                      {
  switch (getFamily()) {
    case AF_INET:
    case AF_INET6:
      return port_;
    default:
      throw std::invalid_argument(
          "SocketAddress::getPort() called on non-IP "
          "address");
  }
}

int folly::SocketAddress::getPortFrom ( const struct sockaddr *  address )

static

Returns the port number from the given socketaddr structure.

Currently only IPv4 and IPv6 are supported.

Returns -1 for unsupported socket families.

Definition at line 186 of file SocketAddress.cpp.

Referenced by folly::AsyncServerSocket::bind(), and setFromHostPort().

                                                             {
  switch (address->sa_family) {
    case AF_INET:
      return ntohs(((sockaddr_in*)address)->sin_port);

    case AF_INET6:
      return ntohs(((sockaddr_in6*)address)->sin6_port);

    default:
      return -1;
  }
}

size_t folly::SocketAddress::hash

(

)

const

Compuate a hash of a SocketAddress.

Definition at line 575 of file SocketAddress.cpp.

References folly::hash::hash_combine(), seed, folly::hash::twang_mix64(), and uint64_t.

Referenced by folly::hash_value(), operator!=(), std::hash< folly::SocketAddress >::operator()(), and TEST().

                                 {
  size_t seed = folly::hash::twang_mix64(getFamily());

  if (external_) {
    enum { kUnixPathMax = sizeof(storage_.un.addr->sun_path) };
    const char* path = storage_.un.addr->sun_path;
    auto pathLength = storage_.un.pathLength();
    // TODO: this probably could be made more efficient
    for (off_t n = 0; n < pathLength; ++n) {
      boost::hash_combine(seed, folly::hash::twang_mix64(uint64_t(path[n])));
    }
  }

  switch (getFamily()) {
    case AF_INET:
    case AF_INET6: {
      boost::hash_combine(seed, port_);
      boost::hash_combine(seed, storage_.addr.hash());
      break;
    }
    case AF_UNIX:
      DCHECK(external_);
      break;
    case AF_UNSPEC:
    default:
      throw std::invalid_argument(
          "SocketAddress: unsupported address family "
          "for hashing");
  }

  return seed;
}

bool folly::SocketAddress::isFamilyInet

(

)

const

Return true if it is a valid IPv4 or IPv6 address.

Definition at line 393 of file SocketAddress.cpp.

Referenced by empty(), proxygen::HTTPSessionAcceptor::onNewConnection(), and TEST().

                                       {
  auto family = getFamily();
  return family == AF_INET || family == AF_INET6;
}

bool folly::SocketAddress::isInitialized ( ) const

inline

Definition at line 131 of file SocketAddress.h.

References getFamily(), isLoopbackAddress(), and isPrivateAddress().

Referenced by folly::AsyncSocket::cacheLocalAddress(), folly::AsyncSocket::cachePeerAddress(), and TEST().

                             {
    return (getFamily() != AF_UNSPEC);
  }

bool folly::SocketAddress::isIPv4Mapped ( ) const

inline

Return true if this is an IPv4-mapped IPv6 address.

Definition at line 461 of file SocketAddress.h.

References folly::SocketAddress::AddrStorage::addr, convertToIPv4(), describe(), getFamily(), getHostStr(), getPath(), mapToIPv6(), operator==(), storage_, string, and tryConvertToIPv4().

Referenced by TEST().

                            {
    return (getFamily() == AF_INET6 && storage_.addr.isIPv4Mapped());
  }

bool folly::SocketAddress::isLoopbackAddress

(

)

const

Return whether this address is a loopback address.

Definition at line 127 of file SocketAddress.cpp.

Referenced by isInitialized(), and TEST().

                                            {
  auto family = getFamily();
  if (family == AF_INET || family == AF_INET6) {
    return storage_.addr.isLoopback();
  } else if (external_) {
    // Return true for UNIX addresses, since they are always local to a host.
    return true;
  }
  return false;
}

bool folly::SocketAddress::isPrivateAddress

(

)

const

Return whether this address is within private network.

According to RFC1918, the 10/8 prefix, 172.16/12 prefix, and 192.168/16 prefix are reserved for private networks. fc00::/7 is the IPv6 version, defined in RFC4139. IPv6 link-local addresses (fe80::/10) are also considered private addresses.

The loopback addresses 127/8 and ::1 are also regarded as private networks for the purpose of this function.

Returns true if this is a private network address, and false otherwise.

Definition at line 113 of file SocketAddress.cpp.

Referenced by proxygen::HTTPSessionAcceptor::getErrorPage(), isInitialized(), and TEST().

                                           {
  auto family = getFamily();
  if (family == AF_INET || family == AF_INET6) {
    return storage_.addr.isPrivate() ||
        (storage_.addr.isV6() && storage_.addr.asV6().isLinkLocal());
  } else if (external_) {
    // Unix addresses are always local to a host.  Return true,
    // since this conforms to the semantics of returning true for IP loopback
    // addresses.
    return true;
  }
  return false;
}

static SocketAddress folly::SocketAddress::makeFromPath ( StringPiece  path )

inlinestatic

Construct a SocketAddress from a local unix socket path.

Raises std::invalid_argument on error.

Parameters

path	The Unix domain socket path.

Definition at line 317 of file SocketAddress.h.

References addr, setFromLocalAddress(), setFromPath(), setFromPeerAddress(), setFromSockaddr(), and folly::netops::socket().

                                                      {
    SocketAddress addr;
    addr.setFromPath(path);
    return addr;
  }

bool folly::SocketAddress::mapToIPv6

(

)

Convert an IPv4 address to IPv6 [::ffff:a.b.c.d]

Definition at line 447 of file SocketAddress.cpp.

Referenced by isIPv4Mapped().

                              {
  if (getFamily() != AF_INET) {
    return false;
  }

  storage_.addr = folly::IPAddress::createIPv6(storage_.addr);
  return true;
}

bool folly::SocketAddress::operator!= ( const SocketAddress &  other ) const

inline

Definition at line 522 of file SocketAddress.h.

References hash(), operator<(), and prefixMatch().

                                                    {
    return !(*this == other);
  }

bool folly::SocketAddress::operator<

(

const SocketAddress &

other

)

const

Use this operator for storing maps based on SocketAddress.

Definition at line 725 of file SocketAddress.cpp.

References folly::SocketAddress::ExternalUnixAddr::addr, folly::SocketAddress::AddrStorage::addr, getFamily(), folly::SocketAddress::ExternalUnixAddr::pathLength(), port_, storage_, and folly::SocketAddress::AddrStorage::un.

Referenced by operator!=().

                                                              {
  if (getFamily() != other.getFamily()) {
    return getFamily() < other.getFamily();
  }

  if (external_) {
    // Anonymous addresses can't be compared to anything else.
    // Return that they are never less than anything.
    //
    // Note that this still meets the requirements for a strict weak
    // ordering, so we can use this operator<() with standard C++ containers.
    auto thisPathLength = storage_.un.pathLength();
    if (thisPathLength == 0) {
      return false;
    }
    auto otherPathLength = other.storage_.un.pathLength();
    if (otherPathLength == 0) {
      return true;
    }

    // Compare based on path length first, for efficiency
    if (thisPathLength != otherPathLength) {
      return thisPathLength < otherPathLength;
    }
    int cmp = memcmp(
        storage_.un.addr->sun_path,
        other.storage_.un.addr->sun_path,
        size_t(thisPathLength));
    return cmp < 0;
  }
  switch (getFamily()) {
    case AF_INET:
    case AF_INET6: {
      if (port_ != other.port_) {
        return port_ < other.port_;
      }

      return storage_.addr < other.storage_.addr;
    }
    case AF_UNSPEC:
    default:
      throw std::invalid_argument(
          "SocketAddress: unsupported address family for comparing");
  }
}

SocketAddress& folly::SocketAddress::operator= ( const SocketAddress &  addr )

inline

Definition at line 90 of file SocketAddress.h.

References folly::SocketAddress::ExternalUnixAddr::copy(), external_, folly::SocketAddress::ExternalUnixAddr::free(), getFamily(), folly::SocketAddress::ExternalUnixAddr::init(), port_, storage_, and folly::SocketAddress::AddrStorage::un.

                                                      {
    if (!external_) {
      if (addr.getFamily() != AF_UNIX) {
        storage_ = addr.storage_;
      } else {
        storage_ = addr.storage_;
        storage_.un.init(addr.storage_.un);
      }
    } else {
      if (addr.getFamily() == AF_UNIX) {
        storage_.un.copy(addr.storage_.un);
      } else {
        storage_.un.free();
        storage_ = addr.storage_;
      }
    }
    port_ = addr.port_;
    external_ = addr.external_;
    return *this;
  }

SocketAddress& folly::SocketAddress::operator= ( SocketAddress &&  addr )

inline

Definition at line 118 of file SocketAddress.h.

References addr, external_, port_, storage_, and folly::f14::swap().

                                                 {
    std::swap(storage_, addr.storage_);
    std::swap(port_, addr.port_);
    std::swap(external_, addr.external_);
    return *this;
  }

bool folly::SocketAddress::operator==

(

const SocketAddress &

other

)

const

Definition at line 523 of file SocketAddress.cpp.

References folly::SocketAddress::ExternalUnixAddr::addr, folly::SocketAddress::AddrStorage::addr, external_, getFamily(), folly::SocketAddress::ExternalUnixAddr::len, folly::SocketAddress::ExternalUnixAddr::pathLength(), port_, storage_, and folly::SocketAddress::AddrStorage::un.

Referenced by isIPv4Mapped().

                                                               {
  if (external_ != other.external_ || other.getFamily() != getFamily()) {
    return false;
  }
  if (external_) {
    // anonymous addresses are never equal to any other addresses
    if (storage_.un.pathLength() == 0 || other.storage_.un.pathLength() == 0) {
      return false;
    }

    if (storage_.un.len != other.storage_.un.len) {
      return false;
    }
    int cmp = memcmp(
        storage_.un.addr->sun_path,
        other.storage_.un.addr->sun_path,
        size_t(storage_.un.pathLength()));
    return cmp == 0;
  }

  switch (getFamily()) {
    case AF_INET:
    case AF_INET6:
      return (other.storage_.addr == storage_.addr) && (other.port_ == port_);
    default:
      throw std::invalid_argument(
          "SocketAddress: unsupported address family "
          "for comparison");
  }
}

bool folly::SocketAddress::prefixMatch	(	const SocketAddress &	other,
		unsigned	prefixLength
	)		const

Check whether the first N bits of this address match the first N bits of another address.

Note

returns false if the addresses are not from the same address family or if the family is neither IPv4 nor IPv6

Definition at line 554 of file SocketAddress.cpp.

References folly::SocketAddress::AddrStorage::addr, FOLLY_FALLTHROUGH, getFamily(), prefix(), storage_, and uint8_t.

Referenced by CheckPrefixMatch(), wangle::NetworkAddress::contains(), operator!=(), and TEST().

                                 {
  if (other.getFamily() != getFamily()) {
    return false;
  }
  uint8_t mask_length = 128;
  switch (getFamily()) {
    case AF_INET:
      mask_length = 32;
      FOLLY_FALLTHROUGH;
    case AF_INET6: {
      auto prefix = folly::IPAddress::longestCommonPrefix(
          {storage_.addr, mask_length}, {other.storage_.addr, mask_length});
      return prefix.second >= prefixLength;
    }
    default:
      return false;
  }
}

void folly::SocketAddress::reset ( )

inline

Definition at line 155 of file SocketAddress.h.

References folly::SocketAddress::AddrStorage::addr, external_, folly::SocketAddress::ExternalUnixAddr::free(), setFromHostPort(), storage_, uint16_t, and folly::SocketAddress::AddrStorage::un.

Referenced by folly::SSLClient::SSLClient(), and TEST().

               {
    if (external_) {
      storage_.un.free();
    }
    storage_.addr = folly::IPAddress();
    external_ = false;
  }

void folly::SocketAddress::setFromAddrInfo ( const struct addrinfo *  results )

private

Definition at line 639 of file SocketAddress.cpp.

Referenced by folly::SocketAddress::ExternalUnixAddr::free().

                                                               {
  setFromSockaddr(info->ai_addr, socklen_t(info->ai_addrlen));
}

void folly::SocketAddress::setFromHostPort	(	const char *	host,
		uint16_t	port
	)

Initialize this SocketAddress from a hostname and port.

Note: If the host parameter is not a numeric IP address, hostname resolution will be performed, which can be quite slow.

If the hostname resolves to multiple addresses, only the first will be returned.

Raises std::system_error on error.

Parameters

host	The hostname or IP address
port	The port (in host byte order)

Definition at line 138 of file SocketAddress.cpp.

Referenced by main(), reset(), setFromHostPort(), setFromIpPort(), SocketAddress(), and TEST().

                                                                   {
  ScopedAddrInfo results(getAddrInfo(host, port, 0));
  setFromAddrInfo(results.info);
}

void folly::SocketAddress::setFromHostPort ( const std::string &  host, uint16_t  port  )

inline

Definition at line 179 of file SocketAddress.h.

References setFromHostPort(), setFromIpPort(), and uint16_t.

                                                             {
    setFromHostPort(host.c_str(), port);
  }

void folly::SocketAddress::setFromHostPort

(

const char *

hostAndPort

)

Initialize this SocketAddress from a host name and port number.

The addressAndPort string must be of the form "<host>:<port>". E.g., "www.facebook.com:443".

If the host name is not a numeric IP address, a DNS lookup will be performed. Beware that the DNS lookup may be very slow. The port number must be numeric; non-numeric service port names are not accepted.

Definition at line 180 of file SocketAddress.cpp.

                                                           {
  HostAndPort hp(hostAndPort, true);
  ScopedAddrInfo results(getAddrInfo(hp.host, hp.port, 0));
  setFromAddrInfo(results.info);
}

void folly::SocketAddress::setFromHostPort ( const std::string &  hostAndPort )

inline

Definition at line 276 of file SocketAddress.h.

References getFamilyNameFrom(), getPortFrom(), setFromHostPort(), and setFromPath().

                                                     {
    return setFromHostPort(hostAndPort.c_str());
  }

void folly::SocketAddress::setFromIpAddrPort	(	const IPAddress &	ip,
		uint16_t	port
	)

Initialize this SocketAddress from an IPAddress struct and port.

Parameters

ip	The IP address in IPAddress format
port	The port (in host byte order)

Definition at line 148 of file SocketAddress.cpp.

Referenced by setFromIpPort(), SocketAddress(), and TEST().

                                                                            {
  if (external_) {
    storage_.un.free();
    external_ = false;
  }
  storage_.addr = ipAddr;
  port_ = port;
}

void folly::SocketAddress::setFromIpPort	(	const char *	ip,
		uint16_t	port
	)

Initialize this SocketAddress from an IP address and port.

This is similar to setFromHostPort(), but only accepts numeric IP addresses. If the IP string does not look like an IP address, it throws a std::invalid_argument rather than trying to perform a hostname resolution.

Raises std::system_error on error.

Parameters

ip	The IP address, as a human-readable string.
port	The port (in host byte order)

Definition at line 143 of file SocketAddress.cpp.

Referenced by TestAsyncTransport::getLocalAddress(), TestAsyncTransport::getPeerAddress(), setFromHostPort(), setFromIpPort(), setFromLocalIpPort(), SocketAddress(), and TEST().

                                                               {
  ScopedAddrInfo results(getAddrInfo(ip, port, AI_NUMERICHOST));
  setFromAddrInfo(results.info);
}

void folly::SocketAddress::setFromIpPort ( const std::string &  ip, uint16_t  port  )

inline

Definition at line 197 of file SocketAddress.h.

References setFromIpAddrPort(), setFromIpPort(), setFromLocalPort(), and uint16_t.

                                                         {
    setFromIpPort(ip.c_str(), port);
  }

void folly::SocketAddress::setFromIpPort

(

const char *

addressAndPort

)

Initialize this SocketAddress from an IP address and port number.

The addressAndPort string must be of the form "<ip>:<port>". E.g., "10.0.0.1:1234".

Both the IP address and port number must be numeric. DNS host names and non-numeric service port names are not accepted.

Definition at line 174 of file SocketAddress.cpp.

                                                            {
  HostAndPort hp(addressAndPort, true);
  ScopedAddrInfo results(getAddrInfo(hp.host, hp.port, AI_NUMERICHOST));
  setFromAddrInfo(results.info);
}

void folly::SocketAddress::setFromIpPort ( const std::string &  addressAndPort )

inline

Definition at line 261 of file SocketAddress.h.

References setFromHostPort(), and setFromIpPort().

                                                      {
    return setFromIpPort(addressAndPort.c_str());
  }

void folly::SocketAddress::setFromLocalAddr ( const struct addrinfo *  results )

private

Definition at line 643 of file SocketAddress.cpp.

Referenced by folly::SocketAddress::ExternalUnixAddr::free().

                                                                {
  // If an IPv6 address is present, prefer to use it, since IPv4 addresses
  // can be mapped into IPv6 space.
  for (const struct addrinfo* ai = info; ai != nullptr; ai = ai->ai_next) {
    if (ai->ai_family == AF_INET6) {
      setFromSockaddr(ai->ai_addr, socklen_t(ai->ai_addrlen));
      return;
    }
  }

  // Otherwise, just use the first address in the list.
  setFromSockaddr(info->ai_addr, socklen_t(info->ai_addrlen));
}

void folly::SocketAddress::setFromLocalAddress

(

int

socket

)

Initialize this SocketAddress from a socket's local address.

Raises std::system_error on error.

Definition at line 253 of file SocketAddress.cpp.

Referenced by folly::AsyncUDPSocket::bind(), folly::AsyncServerSocket::bind(), folly::AsyncSocket::cacheLocalAddress(), folly::AsyncServerSocket::getAddress(), makeFromPath(), folly::AsyncUDPSocket::setFD(), folly::AsyncServerSocket::setupSocket(), TEST(), testSetFromSocket(), and folly::AsyncServerSocket::useExistingSockets().

                                                  {
  setFromLocalAddress(NetworkSocket::fromFd(socket));
}

void folly::SocketAddress::setFromLocalAddress

(

NetworkSocket

socket

)

Definition at line 257 of file SocketAddress.cpp.

References folly::netops::getsockname().

                                                            {
  setFromSocket(socket, netops::getsockname);
}

void folly::SocketAddress::setFromLocalIpPort

(

const char *

addressAndPort

)

Initialize this SocketAddress from a local port number and optional IP address.

The addressAndPort string may be specified either as "<ip>:<port>", or just as "<port>". If the IP is not specified, the address will be initialized to 0, so that a server socket bound to this address will accept connections on all local IP addresses.

Both the IP address and port number must be numeric. DNS host names and non-numeric service port names are not accepted.

Definition at line 167 of file SocketAddress.cpp.

Referenced by setFromLocalIpPort(), setFromLocalPort(), and TEST().

                                                                 {
  HostAndPort hp(addressAndPort, false);
  ScopedAddrInfo results(
      getAddrInfo(hp.host, hp.port, AI_NUMERICHOST | AI_ADDRCONFIG));
  setFromLocalAddr(results.info);
}

void folly::SocketAddress::setFromLocalIpPort ( const std::string &  addressAndPort )

inline

Definition at line 247 of file SocketAddress.h.

References setFromIpPort(), and setFromLocalIpPort().

                                                           {
    return setFromLocalIpPort(addressAndPort.c_str());
  }

void folly::SocketAddress::setFromLocalPort

(

uint16_t

port

)

Initialize this SocketAddress from a local port number.

This is intended to be used by server code to determine the address to listen on.

If the current machine has any IPv6 addresses configured, an IPv6 address will be returned (since connections from IPv4 clients can be mapped to the IPv6 address). If the machine does not have any IPv6 addresses, an IPv4 address will be returned.

Definition at line 157 of file SocketAddress.cpp.

Referenced by wangle::ServerBootstrap< DefaultPipeline >::bind(), SimpleServerPool::connect(), proxygen::ScopedHTTPServer::start< std::unique_ptr< RequestHandlerFactory > >(), setFromIpPort(), setFromLocalPort(), and TEST().

                                                  {
  ScopedAddrInfo results(getAddrInfo(nullptr, port, AI_ADDRCONFIG));
  setFromLocalAddr(results.info);
}

void folly::SocketAddress::setFromLocalPort

(

const char *

port

)

Initialize this SocketAddress from a local port number.

This version of setFromLocalPort() accepts the port as a string. A std::invalid_argument will be raised if the string does not refer to a port number. Non-numeric service port names are not accepted.

Definition at line 162 of file SocketAddress.cpp.

                                                     {
  ScopedAddrInfo results(getAddrInfo(nullptr, port, AI_ADDRCONFIG));
  setFromLocalAddr(results.info);
}

void folly::SocketAddress::setFromLocalPort ( const std::string &  port )

inline

Definition at line 230 of file SocketAddress.h.

References setFromLocalIpPort(), and setFromLocalPort().

                                               {
    return setFromLocalPort(port.c_str());
  }

void folly::SocketAddress::setFromPath

(

StringPiece

path

)

Initialize this SocketAddress from a local unix path.

Raises std::invalid_argument on error.

Definition at line 219 of file SocketAddress.cpp.

References folly::Range< Iter >::data(), and folly::Range< Iter >::size().

Referenced by makeFromPath(), setFromHostPort(), setFromPath(), and TEST().

                                                {
  // Before we touch storage_, check to see if the length is too big.
  // Note that "storage_.un.addr->sun_path" may not be safe to evaluate here,
  // but sizeof() just uses its type, and does't evaluate it.
  if (path.size() > sizeof(storage_.un.addr->sun_path)) {
    throw std::invalid_argument(
        "socket path too large to fit into sockaddr_un");
  }

  if (!external_) {
    storage_.un.init();
    external_ = true;
  }

  size_t len = path.size();
  storage_.un.len = socklen_t(offsetof(struct sockaddr_un, sun_path) + len);
  memcpy(storage_.un.addr->sun_path, path.data(), len);
  // If there is room, put a terminating NUL byte in sun_path.  In general the
  // path should be NUL terminated, although getsockname() and getpeername()
  // may return Unix socket addresses with paths that fit exactly in sun_path
  // with no terminating NUL.
  if (len < sizeof(storage_.un.addr->sun_path)) {
    storage_.un.addr->sun_path[len] = '\0';
  }
}

void folly::SocketAddress::setFromPath ( const char *  path, size_t  length  )

inline

Definition at line 306 of file SocketAddress.h.

References setFromPath().

                                                    {
    setFromPath(StringPiece{path, length});
  }

void folly::SocketAddress::setFromPeerAddress

(

int

socket

)

Initialize this SocketAddress from a socket's peer address.

Raises std::system_error on error.

Definition at line 245 of file SocketAddress.cpp.

Referenced by folly::AsyncSocket::cachePeerAddress(), makeFromPath(), TEST(), and testSetFromSocket().

                                                 {
  setFromPeerAddress(NetworkSocket::fromFd(socket));
}

void folly::SocketAddress::setFromPeerAddress

(

NetworkSocket

socket

)

Definition at line 249 of file SocketAddress.cpp.

References folly::netops::getpeername().

                                                           {
  setFromSocket(socket, netops::getpeername);
}

void folly::SocketAddress::setFromSockaddr

(

const struct sockaddr *

address

)

Initialize this folly::SocketAddress from a struct sockaddr.

Raises std::system_error on error.

This method is not supported for AF_UNIX addresses. For unix addresses, the address length must be explicitly specified.

Parameters

address

A struct sockaddr. The size of the address is implied from address->sa_family.

Definition at line 261 of file SocketAddress.cpp.

References uint16_t.

Referenced by folly::AsyncUDPSocket::handleRead(), folly::AsyncServerSocket::handlerReady(), makeFromPath(), and testSetFromSocket().

                                                                  {
  uint16_t port;

  if (address->sa_family == AF_INET) {
    port = ntohs(((sockaddr_in*)address)->sin_port);
  } else if (address->sa_family == AF_INET6) {
    port = ntohs(((sockaddr_in6*)address)->sin6_port);
  } else if (address->sa_family == AF_UNIX) {
    // We need an explicitly specified length for AF_UNIX addresses,
    // to be able to distinguish anonymous addresses from addresses
    // in Linux's abstract namespace.
    throw std::invalid_argument(
        "SocketAddress::setFromSockaddr(): the address "
        "length must be explicitly specified when "
        "setting AF_UNIX addresses");
  } else {
    throw std::invalid_argument(
        "SocketAddress::setFromSockaddr() called "
        "with unsupported address type");
  }

  setFromIpAddrPort(folly::IPAddress(address), port);
}

void folly::SocketAddress::setFromSockaddr	(	const struct sockaddr *	address,
		socklen_t	addrlen
	)

Initialize this SocketAddress from a struct sockaddr.

Raises std::system_error on error.

Parameters

address	A struct sockaddr.
addrlen	The length of address data available. This must be long enough for the full address type required by address->sa_family.

Definition at line 285 of file SocketAddress.cpp.

                       {
  // Check the length to make sure we can access address->sa_family
  if (addrlen <
      (offsetof(struct sockaddr, sa_family) + sizeof(address->sa_family))) {
    throw std::invalid_argument(
        "SocketAddress::setFromSockaddr() called "
        "with length too short for a sockaddr");
  }

  if (address->sa_family == AF_INET) {
    if (addrlen < sizeof(struct sockaddr_in)) {
      throw std::invalid_argument(
          "SocketAddress::setFromSockaddr() called "
          "with length too short for a sockaddr_in");
    }
    setFromSockaddr(reinterpret_cast<const struct sockaddr_in*>(address));
  } else if (address->sa_family == AF_INET6) {
    if (addrlen < sizeof(struct sockaddr_in6)) {
      throw std::invalid_argument(
          "SocketAddress::setFromSockaddr() called "
          "with length too short for a sockaddr_in6");
    }
    setFromSockaddr(reinterpret_cast<const struct sockaddr_in6*>(address));
  } else if (address->sa_family == AF_UNIX) {
    setFromSockaddr(
        reinterpret_cast<const struct sockaddr_un*>(address), addrlen);
  } else {
    throw std::invalid_argument(
        "SocketAddress::setFromSockaddr() called "
        "with unsupported address type");
  }
}

void folly::SocketAddress::setFromSockaddr

(

const struct sockaddr_in *

address

)

Initialize this SocketAddress from a struct sockaddr_in.

Definition at line 320 of file SocketAddress.cpp.

                                                                     {
  assert(address->sin_family == AF_INET);
  setFromSockaddr((sockaddr*)address);
}

void folly::SocketAddress::setFromSockaddr

(

const struct sockaddr_in6 *

address

)

Initialize this SocketAddress from a struct sockaddr_in6.

Definition at line 325 of file SocketAddress.cpp.

                                                                      {
  assert(address->sin6_family == AF_INET6);
  setFromSockaddr((sockaddr*)address);
}

void folly::SocketAddress::setFromSockaddr	(	const struct sockaddr_un *	address,
		socklen_t	addrlen
	)

Initialize this SocketAddress from a struct sockaddr_un.

Note that the addrlen parameter is necessary to properly detect anonymous addresses, which have 0 valid path bytes, and may not even have a NUL character at the start of the path.

Parameters

address	A struct sockaddr_un.
addrlen	The length of address data. This should include all of the valid bytes of sun_path, not including any NUL terminator.

Definition at line 330 of file SocketAddress.cpp.

                       {
  assert(address->sun_family == AF_UNIX);
  if (addrlen > sizeof(struct sockaddr_un)) {
    throw std::invalid_argument(
        "SocketAddress::setFromSockaddr() called "
        "with length too long for a sockaddr_un");
  }

  if (!external_) {
    storage_.un.init();
  }
  external_ = true;
  memcpy(storage_.un.addr, address, size_t(addrlen));
  updateUnixAddressLength(addrlen);

  // Fill the rest with 0s, just for safety
  if (addrlen < sizeof(struct sockaddr_un)) {
    char* p = reinterpret_cast<char*>(storage_.un.addr);
    memset(p + addrlen, 0, sizeof(struct sockaddr_un) - addrlen);
  }
}

void folly::SocketAddress::setFromSocket ( NetworkSocket  socket, int(*)(NetworkSocket, struct sockaddr *, socklen_t *)  fn  )

private

Definition at line 657 of file SocketAddress.cpp.

References folly::throwSystemError().

Referenced by folly::SocketAddress::ExternalUnixAddr::free().

                                                            {
  // Try to put the address into a local storage buffer.
  sockaddr_storage tmp_sock;
  socklen_t addrLen = sizeof(tmp_sock);
  if (fn(socket, (sockaddr*)&tmp_sock, &addrLen) != 0) {
    folly::throwSystemError("setFromSocket() failed");
  }

  setFromSockaddr((sockaddr*)&tmp_sock, addrLen);
}

void folly::SocketAddress::setPort

(

uint16_t

port

)

Set the IPv4 or IPv6 port for this address.

Raises std::invalid_argument if this is not an IPv4 or IPv6 address.

Definition at line 417 of file SocketAddress.cpp.

Referenced by empty(), and TEST().

                                         {
  switch (getFamily()) {
    case AF_INET:
    case AF_INET6:
      port_ = port;
      return;
    default:
      throw std::invalid_argument(
          "SocketAddress::setPort() called on non-IP "
          "address");
  }
}

bool folly::SocketAddress::tryConvertToIPv4

(

)

Try to convert an address to IPv4.

This attempts to convert an address to an IPv4 address if possible. If the address is an IPv4-mapped IPv6 address, it is converted to an IPv4 address and true is returned. Otherwise nothing is done, and false is returned.

Definition at line 438 of file SocketAddress.cpp.

Referenced by proxygen::HTTPSessionBase::HTTPSessionBase(), and isIPv4Mapped().

                                     {
  if (!isIPv4Mapped()) {
    return false;
  }

  storage_.addr = folly::IPAddress::createIPv4(storage_.addr);
  return true;
}

void folly::SocketAddress::updateUnixAddressLength ( socklen_t  addrlen )

private

Definition at line 701 of file SocketAddress.cpp.

Referenced by folly::SocketAddress::ExternalUnixAddr::free().

                                                             {
  if (addrlen < offsetof(struct sockaddr_un, sun_path)) {
    throw std::invalid_argument(
        "SocketAddress: attempted to set a Unix socket "
        "with a length too short for a sockaddr_un");
  }

  storage_.un.len = addrlen;
  if (storage_.un.pathLength() == 0) {
    // anonymous address
    return;
  }

  if (storage_.un.addr->sun_path[0] == '\0') {
    // abstract namespace.  honor the specified length
  } else {
    // Call strnlen(), just in case the length was overspecified.
    size_t maxLength = addrlen - offsetof(struct sockaddr_un, sun_path);
    size_t pathLength = strnlen(storage_.un.addr->sun_path, maxLength);
    storage_.un.len =
        socklen_t(offsetof(struct sockaddr_un, sun_path) + pathLength);
  }
}

Member Data Documentation

bool folly::SocketAddress::external_ {false}

private

Definition at line 609 of file SocketAddress.h.

Referenced by getAddress(), getFamily(), operator=(), operator==(), reset(), SocketAddress(), and ~SocketAddress().

uint16_t folly::SocketAddress::port_

private

Definition at line 607 of file SocketAddress.h.

Referenced by getAddress(), operator<(), operator=(), operator==(), and SocketAddress().

union folly::SocketAddress::AddrStorage folly::SocketAddress::storage_

private

Referenced by folly::SocketAddress::AddrStorage::AddrStorage(), getAddress(), getFamily(), isIPv4Mapped(), operator<(), operator=(), operator==(), prefixMatch(), reset(), SocketAddress(), and ~SocketAddress().

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/SocketAddress.h
• proxygen/folly/folly/SocketAddress.cpp