1 // Copyright 2012 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/base/ip_endpoint.h"
6
7 #include <ostream>
8
9 #include <string.h>
10 #include <tuple>
11 #include <utility>
12
13 #include "base/check.h"
14 #include "base/check_op.h"
15 #include "base/notreached.h"
16 #include "base/numerics/safe_conversions.h"
17 #include "base/strings/string_number_conversions.h"
18 #include "base/sys_byteorder.h"
19 #include "base/values.h"
20 #include "build/build_config.h"
21 #include "net/base/ip_address.h"
22 #include "net/base/sys_addrinfo.h"
23 #include "third_party/abseil-cpp/absl/types/optional.h"
24
25 #if BUILDFLAG(IS_WIN)
26 #include <winsock2.h>
27 #include <ws2bth.h>
28
29 #include "net/base/winsock_util.h" // For kBluetoothAddressSize
30 #endif
31
32 namespace net {
33
34 namespace {
35
36 // Value dictionary keys
37 constexpr base::StringPiece kValueAddressKey = "address";
38 constexpr base::StringPiece kValuePortKey = "port";
39
40 } // namespace
41
42 // static
FromValue(const base::Value & value)43 absl::optional<IPEndPoint> IPEndPoint::FromValue(const base::Value& value) {
44 const base::Value::Dict* dict = value.GetIfDict();
45 if (!dict)
46 return absl::nullopt;
47
48 const base::Value* address_value = dict->Find(kValueAddressKey);
49 if (!address_value)
50 return absl::nullopt;
51 absl::optional<IPAddress> address = IPAddress::FromValue(*address_value);
52 if (!address.has_value())
53 return absl::nullopt;
54 // Expect IPAddress to only allow deserializing valid addresses.
55 DCHECK(address.value().IsValid());
56
57 absl::optional<int> port = dict->FindInt(kValuePortKey);
58 if (!port.has_value() ||
59 !base::IsValueInRangeForNumericType<uint16_t>(port.value())) {
60 return absl::nullopt;
61 }
62
63 return IPEndPoint(address.value(),
64 base::checked_cast<uint16_t>(port.value()));
65 }
66
67 IPEndPoint::IPEndPoint() = default;
68
69 IPEndPoint::~IPEndPoint() = default;
70
IPEndPoint(const IPAddress & address,uint16_t port)71 IPEndPoint::IPEndPoint(const IPAddress& address, uint16_t port)
72 : address_(address), port_(port) {}
73
74 IPEndPoint::IPEndPoint(const IPEndPoint& endpoint) = default;
75
port() const76 uint16_t IPEndPoint::port() const {
77 #if BUILDFLAG(IS_WIN)
78 DCHECK_NE(address_.size(), kBluetoothAddressSize);
79 #endif
80 return port_;
81 }
82
GetFamily() const83 AddressFamily IPEndPoint::GetFamily() const {
84 return GetAddressFamily(address_);
85 }
86
GetSockAddrFamily() const87 int IPEndPoint::GetSockAddrFamily() const {
88 switch (address_.size()) {
89 case IPAddress::kIPv4AddressSize:
90 return AF_INET;
91 case IPAddress::kIPv6AddressSize:
92 return AF_INET6;
93 #if BUILDFLAG(IS_WIN)
94 case kBluetoothAddressSize:
95 return AF_BTH;
96 #endif
97 default:
98 NOTREACHED() << "Bad IP address";
99 return AF_UNSPEC;
100 }
101 }
102
ToSockAddr(struct sockaddr * address,socklen_t * address_length) const103 bool IPEndPoint::ToSockAddr(struct sockaddr* address,
104 socklen_t* address_length) const {
105 // By definition, socklen_t is large enough to hold both sizes.
106 constexpr socklen_t kSockaddrInSize =
107 static_cast<socklen_t>(sizeof(struct sockaddr_in));
108 constexpr socklen_t kSockaddrIn6Size =
109 static_cast<socklen_t>(sizeof(struct sockaddr_in6));
110
111 DCHECK(address);
112 DCHECK(address_length);
113 #if BUILDFLAG(IS_WIN)
114 DCHECK_NE(address_.size(), kBluetoothAddressSize);
115 #endif
116 switch (address_.size()) {
117 case IPAddress::kIPv4AddressSize: {
118 if (*address_length < kSockaddrInSize)
119 return false;
120 *address_length = kSockaddrInSize;
121 struct sockaddr_in* addr = reinterpret_cast<struct sockaddr_in*>(address);
122 memset(addr, 0, sizeof(struct sockaddr_in));
123 addr->sin_family = AF_INET;
124 addr->sin_port = base::HostToNet16(port_);
125 memcpy(&addr->sin_addr, address_.bytes().data(),
126 IPAddress::kIPv4AddressSize);
127 break;
128 }
129 case IPAddress::kIPv6AddressSize: {
130 if (*address_length < kSockaddrIn6Size)
131 return false;
132 *address_length = kSockaddrIn6Size;
133 struct sockaddr_in6* addr6 =
134 reinterpret_cast<struct sockaddr_in6*>(address);
135 memset(addr6, 0, sizeof(struct sockaddr_in6));
136 addr6->sin6_family = AF_INET6;
137 addr6->sin6_port = base::HostToNet16(port_);
138 memcpy(&addr6->sin6_addr, address_.bytes().data(),
139 IPAddress::kIPv6AddressSize);
140 break;
141 }
142 default:
143 return false;
144 }
145 return true;
146 }
147
FromSockAddr(const struct sockaddr * sock_addr,socklen_t sock_addr_len)148 bool IPEndPoint::FromSockAddr(const struct sockaddr* sock_addr,
149 socklen_t sock_addr_len) {
150 DCHECK(sock_addr);
151 switch (sock_addr->sa_family) {
152 case AF_INET: {
153 if (sock_addr_len < static_cast<socklen_t>(sizeof(struct sockaddr_in)))
154 return false;
155 const struct sockaddr_in* addr =
156 reinterpret_cast<const struct sockaddr_in*>(sock_addr);
157 *this = IPEndPoint(
158 IPAddress(reinterpret_cast<const uint8_t*>(&addr->sin_addr),
159 IPAddress::kIPv4AddressSize),
160 base::NetToHost16(addr->sin_port));
161 return true;
162 }
163 case AF_INET6: {
164 if (sock_addr_len < static_cast<socklen_t>(sizeof(struct sockaddr_in6)))
165 return false;
166 const struct sockaddr_in6* addr =
167 reinterpret_cast<const struct sockaddr_in6*>(sock_addr);
168 *this = IPEndPoint(
169 IPAddress(reinterpret_cast<const uint8_t*>(&addr->sin6_addr),
170 IPAddress::kIPv6AddressSize),
171 base::NetToHost16(addr->sin6_port));
172 return true;
173 }
174 #if BUILDFLAG(IS_WIN)
175 case AF_BTH: {
176 if (sock_addr_len < static_cast<socklen_t>(sizeof(SOCKADDR_BTH)))
177 return false;
178 const SOCKADDR_BTH* addr =
179 reinterpret_cast<const SOCKADDR_BTH*>(sock_addr);
180 *this = IPEndPoint();
181 address_ = IPAddress(reinterpret_cast<const uint8_t*>(&addr->btAddr),
182 kBluetoothAddressSize);
183 // Intentionally ignoring Bluetooth port. It is a ULONG, but
184 // `IPEndPoint::port_` is a uint16_t. See https://crbug.com/1231273.
185 return true;
186 }
187 #endif
188 }
189 return false; // Unrecognized |sa_family|.
190 }
191
ToString() const192 std::string IPEndPoint::ToString() const {
193 #if BUILDFLAG(IS_WIN)
194 DCHECK_NE(address_.size(), kBluetoothAddressSize);
195 #endif
196 return IPAddressToStringWithPort(address_, port_);
197 }
198
ToStringWithoutPort() const199 std::string IPEndPoint::ToStringWithoutPort() const {
200 #if BUILDFLAG(IS_WIN)
201 DCHECK_NE(address_.size(), kBluetoothAddressSize);
202 #endif
203 return address_.ToString();
204 }
205
operator <(const IPEndPoint & other) const206 bool IPEndPoint::operator<(const IPEndPoint& other) const {
207 // Sort IPv4 before IPv6.
208 if (address_.size() != other.address_.size()) {
209 return address_.size() < other.address_.size();
210 }
211 return std::tie(address_, port_) < std::tie(other.address_, other.port_);
212 }
213
operator ==(const IPEndPoint & other) const214 bool IPEndPoint::operator==(const IPEndPoint& other) const {
215 return address_ == other.address_ && port_ == other.port_;
216 }
217
operator !=(const IPEndPoint & that) const218 bool IPEndPoint::operator!=(const IPEndPoint& that) const {
219 return !(*this == that);
220 }
221
ToValue() const222 base::Value IPEndPoint::ToValue() const {
223 base::Value::Dict dict;
224
225 DCHECK(address_.IsValid());
226 dict.Set(kValueAddressKey, address_.ToValue());
227 dict.Set(kValuePortKey, port_);
228
229 return base::Value(std::move(dict));
230 }
231
operator <<(std::ostream & os,const IPEndPoint & ip_endpoint)232 std::ostream& operator<<(std::ostream& os, const IPEndPoint& ip_endpoint) {
233 return os << ip_endpoint.ToString();
234 }
235
236 } // namespace net
237