633 lines
18 KiB
C++
633 lines
18 KiB
C++
/*
|
|
* Copyright (c) Facebook, Inc. and its affiliates.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <cassert>
|
|
#include <cstddef>
|
|
#include <iosfwd>
|
|
#include <string>
|
|
|
|
#include <folly/IPAddress.h>
|
|
#include <folly/Portability.h>
|
|
#include <folly/Range.h>
|
|
#include <folly/net/NetworkSocket.h>
|
|
#include <folly/portability/Sockets.h>
|
|
|
|
namespace folly {
|
|
|
|
class SocketAddress {
|
|
public:
|
|
SocketAddress() = default;
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* @param host The IP address (or hostname, if allowNameLookup is true)
|
|
* @param port The port (in host byte order)
|
|
* @pram 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.
|
|
*/
|
|
SocketAddress(const char* host, uint16_t port, bool allowNameLookup = false) {
|
|
// Initialize the address family first,
|
|
// since setFromHostPort() and setFromIpPort() will check it.
|
|
|
|
if (allowNameLookup) {
|
|
setFromHostPort(host, port);
|
|
} else {
|
|
setFromIpPort(host, port);
|
|
}
|
|
}
|
|
|
|
SocketAddress(
|
|
const std::string& host,
|
|
uint16_t port,
|
|
bool allowNameLookup = false) {
|
|
// 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);
|
|
}
|
|
}
|
|
|
|
SocketAddress(const IPAddress& ipAddr, uint16_t port) {
|
|
setFromIpAddrPort(ipAddr, port);
|
|
}
|
|
|
|
SocketAddress(const SocketAddress& addr) {
|
|
port_ = addr.port_;
|
|
if (addr.getFamily() == AF_UNIX) {
|
|
storage_.un.init(addr.storage_.un);
|
|
} else {
|
|
storage_ = addr.storage_;
|
|
}
|
|
external_ = addr.external_;
|
|
}
|
|
|
|
SocketAddress& operator=(const SocketAddress& addr) {
|
|
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(SocketAddress&& addr) noexcept {
|
|
storage_ = addr.storage_;
|
|
port_ = addr.port_;
|
|
external_ = addr.external_;
|
|
addr.external_ = false;
|
|
}
|
|
|
|
SocketAddress& operator=(SocketAddress&& addr) {
|
|
std::swap(storage_, addr.storage_);
|
|
std::swap(port_, addr.port_);
|
|
std::swap(external_, addr.external_);
|
|
return *this;
|
|
}
|
|
|
|
~SocketAddress() {
|
|
if (external_) {
|
|
storage_.un.free();
|
|
}
|
|
}
|
|
|
|
bool isInitialized() const {
|
|
return (getFamily() != AF_UNSPEC);
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
bool isPrivateAddress() const;
|
|
|
|
/**
|
|
* Return whether this address is a loopback address.
|
|
*/
|
|
bool isLoopbackAddress() const;
|
|
|
|
void reset() {
|
|
if (external_) {
|
|
storage_.un.free();
|
|
}
|
|
storage_.addr = folly::IPAddress();
|
|
external_ = false;
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* @param host The hostname or IP address
|
|
* @param port The port (in host byte order)
|
|
*/
|
|
void setFromHostPort(const char* host, uint16_t port);
|
|
|
|
void setFromHostPort(const std::string& host, uint16_t port) {
|
|
setFromHostPort(host.c_str(), 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.
|
|
*
|
|
* @param ip The IP address, as a human-readable string.
|
|
* @param port The port (in host byte order)
|
|
*/
|
|
void setFromIpPort(const char* ip, uint16_t port);
|
|
|
|
void setFromIpPort(const std::string& ip, uint16_t port) {
|
|
setFromIpPort(ip.c_str(), port);
|
|
}
|
|
|
|
/**
|
|
* Initialize this SocketAddress from an IPAddress struct and port.
|
|
*
|
|
* @param ip The IP address in IPAddress format
|
|
* @param port The port (in host byte order)
|
|
*/
|
|
void setFromIpAddrPort(const IPAddress& ip, 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.
|
|
*/
|
|
void setFromLocalPort(uint16_t 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.
|
|
*/
|
|
void setFromLocalPort(const char* port);
|
|
void setFromLocalPort(const std::string& port) {
|
|
return setFromLocalPort(port.c_str());
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
void setFromLocalIpPort(const char* addressAndPort);
|
|
void setFromLocalIpPort(const std::string& addressAndPort) {
|
|
return setFromLocalIpPort(addressAndPort.c_str());
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
void setFromIpPort(const char* addressAndPort);
|
|
void setFromIpPort(const std::string& addressAndPort) {
|
|
return setFromIpPort(addressAndPort.c_str());
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
void setFromHostPort(const char* hostAndPort);
|
|
void setFromHostPort(const std::string& hostAndPort) {
|
|
return setFromHostPort(hostAndPort.c_str());
|
|
}
|
|
|
|
/**
|
|
* Returns the port number from the given socketaddr structure.
|
|
*
|
|
* Currently only IPv4 and IPv6 are supported.
|
|
*
|
|
* Returns -1 for unsupported socket families.
|
|
*/
|
|
static int getPortFrom(const struct sockaddr* address);
|
|
|
|
/**
|
|
* Returns the family name from the given socketaddr structure (e.g.: AF_INET6
|
|
* for IPv6).
|
|
*
|
|
* Returns `defaultResult` for unsupported socket families.
|
|
*/
|
|
static const char* getFamilyNameFrom(
|
|
const struct sockaddr* address,
|
|
const char* defaultResult = nullptr);
|
|
|
|
/**
|
|
* Initialize this SocketAddress from a local unix path.
|
|
*
|
|
* Raises std::invalid_argument on error.
|
|
*/
|
|
void setFromPath(StringPiece path);
|
|
|
|
void setFromPath(const char* path, size_t length) {
|
|
setFromPath(StringPiece{path, length});
|
|
}
|
|
|
|
/**
|
|
* Construct a SocketAddress from a local unix socket path.
|
|
*
|
|
* Raises std::invalid_argument on error.
|
|
*
|
|
* @param path The Unix domain socket path.
|
|
*/
|
|
static SocketAddress makeFromPath(StringPiece path) {
|
|
SocketAddress addr;
|
|
addr.setFromPath(path);
|
|
return addr;
|
|
}
|
|
|
|
/**
|
|
* Initialize this SocketAddress from a socket's peer address.
|
|
*
|
|
* Raises std::system_error on error.
|
|
*/
|
|
void setFromPeerAddress(NetworkSocket socket);
|
|
|
|
/**
|
|
* Initialize this SocketAddress from a socket's local address.
|
|
*
|
|
* Raises std::system_error on error.
|
|
*/
|
|
void setFromLocalAddress(NetworkSocket socket);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* @param address A struct sockaddr. The size of the address is implied
|
|
* from address->sa_family.
|
|
*/
|
|
void setFromSockaddr(const struct sockaddr* address);
|
|
|
|
/**
|
|
* Initialize this SocketAddress from a struct sockaddr.
|
|
*
|
|
* Raises std::system_error on error.
|
|
*
|
|
* @param address A struct sockaddr.
|
|
* @param addrlen The length of address data available. This must be long
|
|
* enough for the full address type required by
|
|
* address->sa_family.
|
|
*/
|
|
void setFromSockaddr(const struct sockaddr* address, socklen_t addrlen);
|
|
|
|
/**
|
|
* Initialize this SocketAddress from a struct sockaddr_in.
|
|
*/
|
|
void setFromSockaddr(const struct sockaddr_in* address);
|
|
|
|
/**
|
|
* Initialize this SocketAddress from a struct sockaddr_in6.
|
|
*/
|
|
void setFromSockaddr(const struct sockaddr_in6* address);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* @param address A struct sockaddr_un.
|
|
* @param addrlen The length of address data. This should include all of
|
|
* the valid bytes of sun_path, not including any NUL
|
|
* terminator.
|
|
*/
|
|
void setFromSockaddr(const struct sockaddr_un* address, socklen_t addrlen);
|
|
|
|
/**
|
|
* Fill in a given sockaddr_storage with the ip or unix address.
|
|
*
|
|
* Returns the actual size of the storage used.
|
|
*/
|
|
socklen_t getAddress(sockaddr_storage* addr) const {
|
|
if (!external_) {
|
|
return storage_.addr.toSockaddrStorage(addr, htons(port_));
|
|
} else {
|
|
memcpy(addr, storage_.un.addr, sizeof(*storage_.un.addr));
|
|
return storage_.un.len;
|
|
}
|
|
}
|
|
|
|
const folly::IPAddress& getIPAddress() const;
|
|
|
|
// Deprecated: getAddress() above returns the same size as getActualSize()
|
|
socklen_t getActualSize() const;
|
|
|
|
sa_family_t getFamily() const {
|
|
assert(external_ || AF_UNIX != storage_.addr.family());
|
|
return external_ ? sa_family_t(AF_UNIX) : storage_.addr.family();
|
|
}
|
|
|
|
bool empty() const {
|
|
return getFamily() == AF_UNSPEC;
|
|
}
|
|
|
|
/**
|
|
* 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).
|
|
*/
|
|
std::string 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).
|
|
*/
|
|
void getAddressStr(char* buf, size_t buflen) const;
|
|
|
|
/**
|
|
* Return true if it is a valid IPv4 or IPv6 address.
|
|
*/
|
|
bool isFamilyInet() const;
|
|
|
|
/**
|
|
* For v4 & v6 addresses, return the fully qualified address string
|
|
*/
|
|
std::string getFullyQualified() const;
|
|
|
|
/**
|
|
* Get the IPv4 or IPv6 port for this address.
|
|
*
|
|
* Raises std::invalid_argument if this is not an IPv4 or IPv6 address.
|
|
*
|
|
* @return Returns the port, in host byte order.
|
|
*/
|
|
uint16_t getPort() const;
|
|
|
|
/**
|
|
* Set the IPv4 or IPv6 port for this address.
|
|
*
|
|
* Raises std::invalid_argument if this is not an IPv4 or IPv6 address.
|
|
*/
|
|
void setPort(uint16_t port);
|
|
|
|
/**
|
|
* Return true if this is an IPv4-mapped IPv6 address.
|
|
*/
|
|
bool isIPv4Mapped() const {
|
|
return (getFamily() == AF_INET6 && storage_.addr.isIPv4Mapped());
|
|
}
|
|
|
|
/**
|
|
* Convert an IPv4-mapped IPv6 address to an IPv4 address.
|
|
*
|
|
* Raises std::invalid_argument if this is not an IPv4-mapped IPv6 address.
|
|
*/
|
|
void convertToIPv4();
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
bool tryConvertToIPv4();
|
|
|
|
/**
|
|
* Convert an IPv4 address to IPv6 [::ffff:a.b.c.d]
|
|
*/
|
|
|
|
bool mapToIPv6();
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
std::string getHostStr() 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.
|
|
*/
|
|
std::string getPath() 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>".
|
|
*/
|
|
std::string describe() const;
|
|
|
|
bool operator==(const SocketAddress& other) const;
|
|
bool operator!=(const SocketAddress& other) const {
|
|
return !(*this == other);
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
bool prefixMatch(const SocketAddress& other, unsigned prefixLength) const;
|
|
|
|
/**
|
|
* Use this operator for storing maps based on SocketAddress.
|
|
*/
|
|
bool operator<(const SocketAddress& other) const;
|
|
|
|
/**
|
|
* Compuate a hash of a SocketAddress.
|
|
*/
|
|
size_t hash() const;
|
|
|
|
private:
|
|
/**
|
|
* Unix socket addresses require more storage than IPv4 and IPv6 addresses,
|
|
* and are comparatively little-used.
|
|
*
|
|
* Therefore SocketAddress' internal storage_ member variable doesn't
|
|
* contain room for a full unix address, to avoid wasting space in the common
|
|
* case. When we do need to store a Unix socket address, we use this
|
|
* ExternalUnixAddr structure to allocate a struct sockaddr_un separately on
|
|
* the heap.
|
|
*/
|
|
struct ExternalUnixAddr {
|
|
struct sockaddr_un* addr;
|
|
socklen_t len;
|
|
|
|
socklen_t pathLength() const {
|
|
return socklen_t(len - offsetof(struct sockaddr_un, sun_path));
|
|
}
|
|
|
|
void init() {
|
|
addr = new struct sockaddr_un;
|
|
addr->sun_family = AF_UNIX;
|
|
len = 0;
|
|
}
|
|
void init(const ExternalUnixAddr& other) {
|
|
addr = new struct sockaddr_un;
|
|
len = other.len;
|
|
memcpy(addr, other.addr, size_t(len));
|
|
}
|
|
void copy(const ExternalUnixAddr& other) {
|
|
len = other.len;
|
|
memcpy(addr, other.addr, size_t(len));
|
|
}
|
|
void free() {
|
|
delete addr;
|
|
}
|
|
};
|
|
|
|
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* info);
|
|
void setFromLocalAddr(const struct addrinfo* info);
|
|
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);
|
|
|
|
/*
|
|
* storage_ contains room for a full IPv4 or IPv6 address, so they can be
|
|
* stored inline without a separate allocation on the heap.
|
|
*
|
|
* If we need to store a Unix socket address, ExternalUnixAddr is a shim to
|
|
* track a struct sockaddr_un allocated separately on the heap.
|
|
*/
|
|
union AddrStorage {
|
|
folly::IPAddress addr;
|
|
ExternalUnixAddr un;
|
|
AddrStorage() : addr() {}
|
|
} storage_{};
|
|
// IPAddress class does nto save zone or port, and must be saved here
|
|
uint16_t port_;
|
|
|
|
bool external_{false};
|
|
};
|
|
|
|
/**
|
|
* Hash a SocketAddress object.
|
|
*
|
|
* boost::hash uses hash_value(), so this allows boost::hash to automatically
|
|
* work for SocketAddress.
|
|
*/
|
|
size_t hash_value(const SocketAddress& address);
|
|
|
|
std::ostream& operator<<(std::ostream& os, const SocketAddress& addr);
|
|
} // namespace folly
|
|
|
|
namespace std {
|
|
|
|
// Provide an implementation for std::hash<SocketAddress>
|
|
template <>
|
|
struct hash<folly::SocketAddress> {
|
|
size_t operator()(const folly::SocketAddress& addr) const {
|
|
return addr.hash();
|
|
}
|
|
};
|
|
} // namespace std
|