2 * Copyright 2017 Facebook, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include <sys/types.h>
24 #include <folly/IPAddress.h>
25 #include <folly/Portability.h>
26 #include <folly/Range.h>
27 #include <folly/portability/Sockets.h>
33 SocketAddress() = default;
36 * Construct a SocketAddress from a hostname and port.
38 * Note: If the host parameter is not a numeric IP address, hostname
39 * resolution will be performed, which can be quite slow.
41 * Raises std::system_error on error.
43 * @param host The IP address (or hostname, if allowNameLookup is true)
44 * @param port The port (in host byte order)
45 * @pram allowNameLookup If true, attempt to perform hostname lookup
46 * if the hostname does not appear to be a numeric IP address.
47 * This is potentially a very slow operation, so is disabled by
50 SocketAddress(const char* host, uint16_t port, bool allowNameLookup = false) {
51 // Initialize the address family first,
52 // since setFromHostPort() and setFromIpPort() will check it.
54 if (allowNameLookup) {
55 setFromHostPort(host, port);
57 setFromIpPort(host, port);
62 const std::string& host,
64 bool allowNameLookup = false) {
65 // Initialize the address family first,
66 // since setFromHostPort() and setFromIpPort() will check it.
68 if (allowNameLookup) {
69 setFromHostPort(host.c_str(), port);
71 setFromIpPort(host.c_str(), port);
75 SocketAddress(const IPAddress& ipAddr, uint16_t port) {
76 setFromIpAddrPort(ipAddr, port);
79 SocketAddress(const SocketAddress& addr) {
81 if (addr.getFamily() == AF_UNIX) {
82 storage_.un.init(addr.storage_.un);
84 storage_ = addr.storage_;
86 external_ = addr.external_;
89 SocketAddress& operator=(const SocketAddress& addr) {
91 if (addr.getFamily() != AF_UNIX) {
92 storage_ = addr.storage_;
94 storage_ = addr.storage_;
95 storage_.un.init(addr.storage_.un);
98 if (addr.getFamily() == AF_UNIX) {
99 storage_.un.copy(addr.storage_.un);
102 storage_ = addr.storage_;
106 external_ = addr.external_;
110 SocketAddress(SocketAddress&& addr) noexcept {
111 storage_ = addr.storage_;
113 external_ = addr.external_;
114 addr.external_ = false;
117 SocketAddress& operator=(SocketAddress&& addr) {
118 std::swap(storage_, addr.storage_);
119 std::swap(port_, addr.port_);
120 std::swap(external_, addr.external_);
130 bool isInitialized() const {
131 return (getFamily() != AF_UNSPEC);
135 * Return whether this address is within private network.
137 * According to RFC1918, the 10/8 prefix, 172.16/12 prefix, and 192.168/16
138 * prefix are reserved for private networks.
139 * fc00::/7 is the IPv6 version, defined in RFC4139. IPv6 link-local
140 * addresses (fe80::/10) are also considered private addresses.
142 * The loopback addresses 127/8 and ::1 are also regarded as private networks
143 * for the purpose of this function.
145 * Returns true if this is a private network address, and false otherwise.
147 bool isPrivateAddress() const;
150 * Return whether this address is a loopback address.
152 bool isLoopbackAddress() const;
158 storage_.addr = folly::IPAddress();
163 * Initialize this SocketAddress from a hostname and port.
165 * Note: If the host parameter is not a numeric IP address, hostname
166 * resolution will be performed, which can be quite slow.
168 * If the hostname resolves to multiple addresses, only the first will be
171 * Raises std::system_error on error.
173 * @param host The hostname or IP address
174 * @param port The port (in host byte order)
176 void setFromHostPort(const char* host, uint16_t port);
178 void setFromHostPort(const std::string& host, uint16_t port) {
179 setFromHostPort(host.c_str(), port);
183 * Initialize this SocketAddress from an IP address and port.
185 * This is similar to setFromHostPort(), but only accepts numeric IP
186 * addresses. If the IP string does not look like an IP address, it throws a
187 * std::invalid_argument rather than trying to perform a hostname resolution.
189 * Raises std::system_error on error.
191 * @param ip The IP address, as a human-readable string.
192 * @param port The port (in host byte order)
194 void setFromIpPort(const char* ip, uint16_t port);
196 void setFromIpPort(const std::string& ip, uint16_t port) {
197 setFromIpPort(ip.c_str(), port);
201 * Initialize this SocketAddress from an IPAddress struct and port.
203 * @param ip The IP address in IPAddress format
204 * @param port The port (in host byte order)
206 void setFromIpAddrPort(const IPAddress& ip, uint16_t port);
209 * Initialize this SocketAddress from a local port number.
211 * This is intended to be used by server code to determine the address to
214 * If the current machine has any IPv6 addresses configured, an IPv6 address
215 * will be returned (since connections from IPv4 clients can be mapped to the
216 * IPv6 address). If the machine does not have any IPv6 addresses, an IPv4
217 * address will be returned.
219 void setFromLocalPort(uint16_t port);
222 * Initialize this SocketAddress from a local port number.
224 * This version of setFromLocalPort() accepts the port as a string. A
225 * std::invalid_argument will be raised if the string does not refer to a port
226 * number. Non-numeric service port names are not accepted.
228 void setFromLocalPort(const char* port);
229 void setFromLocalPort(const std::string& port) {
230 return setFromLocalPort(port.c_str());
234 * Initialize this SocketAddress from a local port number and optional IP
237 * The addressAndPort string may be specified either as "<ip>:<port>", or
238 * just as "<port>". If the IP is not specified, the address will be
239 * initialized to 0, so that a server socket bound to this address will
240 * accept connections on all local IP addresses.
242 * Both the IP address and port number must be numeric. DNS host names and
243 * non-numeric service port names are not accepted.
245 void setFromLocalIpPort(const char* addressAndPort);
246 void setFromLocalIpPort(const std::string& addressAndPort) {
247 return setFromLocalIpPort(addressAndPort.c_str());
251 * Initialize this SocketAddress from an IP address and port number.
253 * The addressAndPort string must be of the form "<ip>:<port>". E.g.,
256 * Both the IP address and port number must be numeric. DNS host names and
257 * non-numeric service port names are not accepted.
259 void setFromIpPort(const char* addressAndPort);
260 void setFromIpPort(const std::string& addressAndPort) {
261 return setFromIpPort(addressAndPort.c_str());
265 * Initialize this SocketAddress from a host name and port number.
267 * The addressAndPort string must be of the form "<host>:<port>". E.g.,
268 * "www.facebook.com:443".
270 * If the host name is not a numeric IP address, a DNS lookup will be
271 * performed. Beware that the DNS lookup may be very slow. The port number
272 * must be numeric; non-numeric service port names are not accepted.
274 void setFromHostPort(const char* hostAndPort);
275 void setFromHostPort(const std::string& hostAndPort) {
276 return setFromHostPort(hostAndPort.c_str());
280 * Returns the port number from the given socketaddr structure.
282 * Currently only IPv4 and IPv6 are supported.
284 * Returns -1 for unsupported socket families.
286 static int getPortFrom(const struct sockaddr* address);
289 * Returns the family name from the given socketaddr structure (e.g.: AF_INET6
292 * Returns `defaultResult` for unsupported socket families.
294 static const char* getFamilyNameFrom(
295 const struct sockaddr* address,
296 const char* defaultResult = nullptr);
299 * Initialize this SocketAddress from a local unix path.
301 * Raises std::invalid_argument on error.
303 void setFromPath(StringPiece path);
305 void setFromPath(const char* path, size_t length) {
306 setFromPath(StringPiece{path, length});
310 * Construct a SocketAddress from a local unix socket path.
312 * Raises std::invalid_argument on error.
314 * @param path The Unix domain socket path.
316 static SocketAddress makeFromPath(StringPiece path) {
318 addr.setFromPath(path);
323 * Initialize this SocketAddress from a socket's peer address.
325 * Raises std::system_error on error.
327 void setFromPeerAddress(int socket);
330 * Initialize this SocketAddress from a socket's local address.
332 * Raises std::system_error on error.
334 void setFromLocalAddress(int socket);
337 * Initialize this folly::SocketAddress from a struct sockaddr.
339 * Raises std::system_error on error.
341 * This method is not supported for AF_UNIX addresses. For unix addresses,
342 * the address length must be explicitly specified.
344 * @param address A struct sockaddr. The size of the address is implied
345 * from address->sa_family.
347 void setFromSockaddr(const struct sockaddr* address);
350 * Initialize this SocketAddress from a struct sockaddr.
352 * Raises std::system_error on error.
354 * @param address A struct sockaddr.
355 * @param addrlen The length of address data available. This must be long
356 * enough for the full address type required by
357 * address->sa_family.
359 void setFromSockaddr(const struct sockaddr* address, socklen_t addrlen);
362 * Initialize this SocketAddress from a struct sockaddr_in.
364 void setFromSockaddr(const struct sockaddr_in* address);
367 * Initialize this SocketAddress from a struct sockaddr_in6.
369 void setFromSockaddr(const struct sockaddr_in6* address);
372 * Initialize this SocketAddress from a struct sockaddr_un.
374 * Note that the addrlen parameter is necessary to properly detect anonymous
375 * addresses, which have 0 valid path bytes, and may not even have a NUL
376 * character at the start of the path.
378 * @param address A struct sockaddr_un.
379 * @param addrlen The length of address data. This should include all of
380 * the valid bytes of sun_path, not including any NUL
383 void setFromSockaddr(const struct sockaddr_un* address, socklen_t addrlen);
386 * Fill in a given sockaddr_storage with the ip or unix address.
388 * Returns the actual size of the storage used.
390 socklen_t getAddress(sockaddr_storage* addr) const {
392 return storage_.addr.toSockaddrStorage(addr, htons(port_));
394 memcpy(addr, storage_.un.addr, sizeof(*storage_.un.addr));
395 return storage_.un.len;
399 const folly::IPAddress& getIPAddress() const;
401 // Deprecated: getAddress() above returns the same size as getActualSize()
402 socklen_t getActualSize() const;
404 sa_family_t getFamily() const {
405 DCHECK(external_ || AF_UNIX != storage_.addr.family());
406 return external_ ? sa_family_t(AF_UNIX) : storage_.addr.family();
410 return getFamily() == AF_UNSPEC;
414 * Get a string representation of the IPv4 or IPv6 address.
416 * Raises std::invalid_argument if an error occurs (for example, if
417 * the address is not an IPv4 or IPv6 address).
419 std::string getAddressStr() const;
422 * Get a string representation of the IPv4 or IPv6 address.
424 * Raises std::invalid_argument if an error occurs (for example, if
425 * the address is not an IPv4 or IPv6 address).
427 void getAddressStr(char* buf, size_t buflen) const;
430 * Return true if it is a valid IPv4 or IPv6 address.
432 bool isFamilyInet() const;
435 * For v4 & v6 addresses, return the fully qualified address string
437 std::string getFullyQualified() const;
440 * Get the IPv4 or IPv6 port for this address.
442 * Raises std::invalid_argument if this is not an IPv4 or IPv6 address.
444 * @return Returns the port, in host byte order.
446 uint16_t getPort() const;
449 * Set the IPv4 or IPv6 port for this address.
451 * Raises std::invalid_argument if this is not an IPv4 or IPv6 address.
453 void setPort(uint16_t port);
456 * Return true if this is an IPv4-mapped IPv6 address.
458 bool isIPv4Mapped() const {
459 return (getFamily() == AF_INET6 && storage_.addr.isIPv4Mapped());
463 * Convert an IPv4-mapped IPv6 address to an IPv4 address.
465 * Raises std::invalid_argument if this is not an IPv4-mapped IPv6 address.
467 void convertToIPv4();
470 * Try to convert an address to IPv4.
472 * This attempts to convert an address to an IPv4 address if possible.
473 * If the address is an IPv4-mapped IPv6 address, it is converted to an IPv4
474 * address and true is returned. Otherwise nothing is done, and false is
477 bool tryConvertToIPv4();
480 * Convert an IPv4 address to IPv6 [::ffff:a.b.c.d]
486 * Get string representation of the host name (or IP address if the host name
487 * cannot be resolved).
489 * Warning: Using this method is strongly discouraged. It performs a
490 * DNS lookup, which may block for many seconds.
492 * Raises std::invalid_argument if an error occurs.
494 std::string getHostStr() const;
497 * Get the path name for a Unix domain socket.
499 * Returns a std::string containing the path. For anonymous sockets, an
500 * empty string is returned.
502 * For addresses in the abstract namespace (Linux-specific), a std::string
503 * containing binary data is returned. In this case the first character will
504 * always be a NUL character.
506 * Raises std::invalid_argument if called on a non-Unix domain socket.
508 std::string getPath() const;
511 * Get human-readable string representation of the address.
513 * This prints a string representation of the address, for human consumption.
514 * For IP addresses, the string is of the form "<IP>:<port>".
516 std::string describe() const;
518 bool operator==(const SocketAddress& other) const;
519 bool operator!=(const SocketAddress& other) const {
520 return !(*this == other);
524 * Check whether the first N bits of this address match the first N
525 * bits of another address.
526 * @note returns false if the addresses are not from the same
527 * address family or if the family is neither IPv4 nor IPv6
529 bool prefixMatch(const SocketAddress& other, unsigned prefixLength) const;
532 * Use this operator for storing maps based on SocketAddress.
534 bool operator<(const SocketAddress& other) const;
537 * Compuate a hash of a SocketAddress.
543 * Unix socket addresses require more storage than IPv4 and IPv6 addresses,
544 * and are comparatively little-used.
546 * Therefore SocketAddress' internal storage_ member variable doesn't
547 * contain room for a full unix address, to avoid wasting space in the common
548 * case. When we do need to store a Unix socket address, we use this
549 * ExternalUnixAddr structure to allocate a struct sockaddr_un separately on
552 struct ExternalUnixAddr {
553 struct sockaddr_un* addr;
556 socklen_t pathLength() const {
557 return socklen_t(len - offsetof(struct sockaddr_un, sun_path));
561 addr = new struct sockaddr_un;
562 addr->sun_family = AF_UNIX;
565 void init(const ExternalUnixAddr& other) {
566 addr = new struct sockaddr_un;
568 memcpy(addr, other.addr, size_t(len));
570 void copy(const ExternalUnixAddr& other) {
572 memcpy(addr, other.addr, size_t(len));
579 struct addrinfo* getAddrInfo(const char* host, uint16_t port, int flags);
580 struct addrinfo* getAddrInfo(const char* host, const char* port, int flags);
581 void setFromAddrInfo(const struct addrinfo* results);
582 void setFromLocalAddr(const struct addrinfo* results);
583 void setFromSocket(int socket, int (*fn)(int, struct sockaddr*, socklen_t*));
584 std::string getIpString(int flags) const;
585 void getIpString(char* buf, size_t buflen, int flags) const;
587 void updateUnixAddressLength(socklen_t addrlen);
590 * storage_ contains room for a full IPv4 or IPv6 address, so they can be
591 * stored inline without a separate allocation on the heap.
593 * If we need to store a Unix socket address, ExternalUnixAddr is a shim to
594 * track a struct sockaddr_un allocated separately on the heap.
597 folly::IPAddress addr;
599 AddrStorage() : addr() {}
601 // IPAddress class does nto save zone or port, and must be saved here
604 bool external_{false};
608 * Hash a SocketAddress object.
610 * boost::hash uses hash_value(), so this allows boost::hash to automatically
611 * work for SocketAddress.
613 size_t hash_value(const SocketAddress& address);
615 std::ostream& operator<<(std::ostream& os, const SocketAddress& addr);
620 // Provide an implementation for std::hash<SocketAddress>
622 struct hash<folly::SocketAddress> {
623 size_t operator()(const folly::SocketAddress& addr) const {