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 <string.h>
8
9 #include <optional>
10 #include <ostream>
11 #include <tuple>
12 #include <utility>
13
14 #include "base/check.h"
15 #include "base/check_op.h"
16 #include "base/containers/span.h"
17 #include "base/notreached.h"
18 #include "base/numerics/safe_conversions.h"
19 #include "base/strings/string_number_conversions.h"
20 #include "base/sys_byteorder.h"
21 #include "base/values.h"
22 #include "build/build_config.h"
23 #include "net/base/ip_address.h"
24 #include "net/base/sys_addrinfo.h"
25
26 #if BUILDFLAG(IS_WIN)
27 #include <winsock2.h>
28 #include <winternl.h>
29
30 #include <netioapi.h>
31 #include <ntstatus.h>
32 #include <ws2bth.h>
33
34 #include "net/base/winsock_util.h" // For kBluetoothAddressSize
35 #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
36 #include <net/if.h>
37 #endif
38
39 namespace net {
40
41 namespace {
42
43 // Value dictionary keys
44 constexpr std::string_view kValueAddressKey = "address";
45 constexpr std::string_view kValuePortKey = "port";
46 constexpr std::string_view kInterfaceName = "interface_name";
47
48 } // namespace
49
50 IPEndPoint::IndexToNameFunc IPEndPoint::index_to_name_func_for_testing_ =
51 nullptr;
52 IPEndPoint::NameToIndexFunc IPEndPoint::name_to_index_func_for_testing_ =
53 nullptr;
54
55 // static
SetNameToIndexFuncForTesting(NameToIndexFunc func)56 void IPEndPoint::SetNameToIndexFuncForTesting(NameToIndexFunc func) {
57 name_to_index_func_for_testing_ = func;
58 }
59
SetIndexToNameFuncForTesting(IndexToNameFunc func)60 void IPEndPoint::SetIndexToNameFuncForTesting(IndexToNameFunc func) {
61 index_to_name_func_for_testing_ = func;
62 }
63
64 // static
ScopeIdFromDict(const base::Value::Dict & dict)65 std::optional<uint32_t> IPEndPoint::ScopeIdFromDict(
66 const base::Value::Dict& dict) {
67 const std::string* name = dict.FindString(kInterfaceName);
68 if (!name) {
69 return std::nullopt;
70 }
71
72 unsigned int index = 0;
73 if (name_to_index_func_for_testing_) {
74 index = name_to_index_func_for_testing_(name->c_str());
75 } else {
76 index = if_nametoindex(name->c_str());
77 }
78
79 return index;
80 }
81
82 // static
ScopeIdToValue(std::optional<uint32_t> scope_id)83 base::Value IPEndPoint::ScopeIdToValue(std::optional<uint32_t> scope_id) {
84 if (!scope_id.has_value()) {
85 return base::Value();
86 }
87
88 char* name = nullptr;
89 char buf[IF_NAMESIZE + 1];
90 memset(buf, 0, sizeof(buf));
91 if (index_to_name_func_for_testing_) {
92 name = index_to_name_func_for_testing_(scope_id.value(), buf);
93 } else {
94 name = if_indextoname(scope_id.value(), buf);
95 }
96
97 if (!name) {
98 return base::Value();
99 }
100
101 return base::Value(name);
102 }
103
104 // static
FromValue(const base::Value & value)105 std::optional<IPEndPoint> IPEndPoint::FromValue(const base::Value& value) {
106 const base::Value::Dict* dict = value.GetIfDict();
107 if (!dict)
108 return std::nullopt;
109
110 const base::Value* address_value = dict->Find(kValueAddressKey);
111 if (!address_value)
112 return std::nullopt;
113 std::optional<IPAddress> address = IPAddress::FromValue(*address_value);
114 if (!address.has_value())
115 return std::nullopt;
116 // Expect IPAddress to only allow deserializing valid addresses.
117 DCHECK(address.value().IsValid());
118
119 std::optional<int> port = dict->FindInt(kValuePortKey);
120 if (!port.has_value() ||
121 !base::IsValueInRangeForNumericType<uint16_t>(port.value())) {
122 return std::nullopt;
123 }
124
125 IPEndPoint endpoint(address.value(),
126 base::checked_cast<uint16_t>(port.value()));
127
128 std::optional<uint32_t> scope_id = ScopeIdFromDict(*dict);
129 if (scope_id.has_value()) {
130 if (scope_id.value() == 0 || !endpoint.IsIPv6LinkLocal() ||
131 !base::IsValueInRangeForNumericType<uint32_t>(scope_id.value())) {
132 return std::nullopt;
133 }
134 endpoint.scope_id_ = scope_id.value();
135 }
136
137 return endpoint;
138 }
139
140 IPEndPoint::IPEndPoint() = default;
141
142 IPEndPoint::~IPEndPoint() = default;
143
IPEndPoint(const IPAddress & address,uint16_t port,std::optional<uint32_t> scope_id)144 IPEndPoint::IPEndPoint(const IPAddress& address,
145 uint16_t port,
146 std::optional<uint32_t> scope_id)
147 : address_(address), port_(port), scope_id_(scope_id) {}
148
149 IPEndPoint::IPEndPoint(const IPEndPoint& endpoint) = default;
150
port() const151 uint16_t IPEndPoint::port() const {
152 #if BUILDFLAG(IS_WIN)
153 DCHECK_NE(address_.size(), kBluetoothAddressSize);
154 #endif
155 return port_;
156 }
157
GetFamily() const158 AddressFamily IPEndPoint::GetFamily() const {
159 return GetAddressFamily(address_);
160 }
161
GetSockAddrFamily() const162 int IPEndPoint::GetSockAddrFamily() const {
163 switch (address_.size()) {
164 case IPAddress::kIPv4AddressSize:
165 return AF_INET;
166 case IPAddress::kIPv6AddressSize:
167 return AF_INET6;
168 #if BUILDFLAG(IS_WIN)
169 case kBluetoothAddressSize:
170 return AF_BTH;
171 #endif
172 default:
173 NOTREACHED() << "Bad IP address";
174 }
175 }
176
ToSockAddr(struct sockaddr * address,socklen_t * address_length) const177 bool IPEndPoint::ToSockAddr(struct sockaddr* address,
178 socklen_t* address_length) const {
179 // By definition, socklen_t is large enough to hold both sizes.
180 constexpr socklen_t kSockaddrInSize =
181 static_cast<socklen_t>(sizeof(struct sockaddr_in));
182 constexpr socklen_t kSockaddrIn6Size =
183 static_cast<socklen_t>(sizeof(struct sockaddr_in6));
184
185 DCHECK(address);
186 DCHECK(address_length);
187 #if BUILDFLAG(IS_WIN)
188 DCHECK_NE(address_.size(), kBluetoothAddressSize);
189 #endif
190 switch (address_.size()) {
191 case IPAddress::kIPv4AddressSize: {
192 if (*address_length < kSockaddrInSize)
193 return false;
194 *address_length = kSockaddrInSize;
195 struct sockaddr_in* addr = reinterpret_cast<struct sockaddr_in*>(address);
196 memset(addr, 0, sizeof(struct sockaddr_in));
197 addr->sin_family = AF_INET;
198 addr->sin_port = base::HostToNet16(port_);
199 memcpy(&addr->sin_addr, address_.bytes().data(),
200 IPAddress::kIPv4AddressSize);
201 break;
202 }
203 case IPAddress::kIPv6AddressSize: {
204 if (*address_length < kSockaddrIn6Size)
205 return false;
206 *address_length = kSockaddrIn6Size;
207 struct sockaddr_in6* addr6 =
208 reinterpret_cast<struct sockaddr_in6*>(address);
209 memset(addr6, 0, sizeof(struct sockaddr_in6));
210 addr6->sin6_family = AF_INET6;
211 addr6->sin6_port = base::HostToNet16(port_);
212 memcpy(&addr6->sin6_addr, address_.bytes().data(),
213 IPAddress::kIPv6AddressSize);
214 if (IsIPv6LinkLocal() && scope_id_) {
215 addr6->sin6_scope_id = *scope_id_;
216 }
217 break;
218 }
219 default:
220 return false;
221 }
222 return true;
223 }
224
FromSockAddr(const struct sockaddr * sock_addr,socklen_t sock_addr_len)225 bool IPEndPoint::FromSockAddr(const struct sockaddr* sock_addr,
226 socklen_t sock_addr_len) {
227 DCHECK(sock_addr);
228 switch (sock_addr->sa_family) {
229 case AF_INET: {
230 if (sock_addr_len < static_cast<socklen_t>(sizeof(struct sockaddr_in)))
231 return false;
232 const struct sockaddr_in* addr =
233 reinterpret_cast<const struct sockaddr_in*>(sock_addr);
234 *this = IPEndPoint(
235 // `s_addr` is a `uint32_t`, but it is already in network byte order.
236 IPAddress(base::as_bytes(base::span_from_ref(addr->sin_addr.s_addr))),
237 base::NetToHost16(addr->sin_port));
238 return true;
239 }
240 case AF_INET6: {
241 if (sock_addr_len < static_cast<socklen_t>(sizeof(struct sockaddr_in6)))
242 return false;
243 const struct sockaddr_in6* addr =
244 reinterpret_cast<const struct sockaddr_in6*>(sock_addr);
245 *this = IPEndPoint(IPAddress(addr->sin6_addr.s6_addr),
246 base::NetToHost16(addr->sin6_port));
247 if (IsIPv6LinkLocal() && addr->sin6_scope_id != 0) {
248 scope_id_ = addr->sin6_scope_id;
249 }
250 return true;
251 }
252 #if BUILDFLAG(IS_WIN)
253 case AF_BTH: {
254 if (sock_addr_len < static_cast<socklen_t>(sizeof(SOCKADDR_BTH)))
255 return false;
256 const SOCKADDR_BTH* addr =
257 reinterpret_cast<const SOCKADDR_BTH*>(sock_addr);
258 *this = IPEndPoint();
259 // A bluetooth address is 6 bytes, but btAddr is a ULONGLONG, so we take a
260 // prefix of it.
261 address_ = IPAddress(base::as_bytes(base::span_from_ref(addr->btAddr))
262 .first(kBluetoothAddressSize));
263 // Intentionally ignoring Bluetooth port. It is a ULONG, but
264 // `IPEndPoint::port_` is a uint16_t. See https://crbug.com/1231273.
265 return true;
266 }
267 #endif
268 }
269 return false; // Unrecognized |sa_family|.
270 }
271
ToString() const272 std::string IPEndPoint::ToString() const {
273 #if BUILDFLAG(IS_WIN)
274 DCHECK_NE(address_.size(), kBluetoothAddressSize);
275 #endif
276 return IPAddressToStringWithPort(address_, port_);
277 }
278
ToStringWithoutPort() const279 std::string IPEndPoint::ToStringWithoutPort() const {
280 #if BUILDFLAG(IS_WIN)
281 DCHECK_NE(address_.size(), kBluetoothAddressSize);
282 #endif
283 return address_.ToString();
284 }
285
operator <(const IPEndPoint & other) const286 bool IPEndPoint::operator<(const IPEndPoint& other) const {
287 // Sort IPv4 before IPv6.
288 if (address_.size() != other.address_.size()) {
289 return address_.size() < other.address_.size();
290 }
291 return std::tie(address_, port_, scope_id_) <
292 std::tie(other.address_, other.port_, other.scope_id_);
293 }
294
operator ==(const IPEndPoint & other) const295 bool IPEndPoint::operator==(const IPEndPoint& other) const {
296 return address_ == other.address_ && port_ == other.port_ &&
297 scope_id_ == other.scope_id_;
298 }
299
operator !=(const IPEndPoint & that) const300 bool IPEndPoint::operator!=(const IPEndPoint& that) const {
301 return !(*this == that);
302 }
303
ToValue() const304 base::Value IPEndPoint::ToValue() const {
305 base::Value::Dict dict;
306
307 DCHECK(address_.IsValid());
308 dict.Set(kValueAddressKey, address_.ToValue());
309 dict.Set(kValuePortKey, port_);
310
311 base::Value interface_name = ScopeIdToValue(scope_id_);
312 if (!interface_name.is_none()) {
313 DCHECK(IsIPv6LinkLocal());
314 dict.Set(kInterfaceName, std::move(interface_name));
315 }
316
317 return base::Value(std::move(dict));
318 }
319
IsIPv6LinkLocal() const320 bool IPEndPoint::IsIPv6LinkLocal() const {
321 return address_.IsValid() && address_.IsIPv6() &&
322 !address_.IsIPv4MappedIPv6() && address_.IsLinkLocal();
323 }
324
operator <<(std::ostream & os,const IPEndPoint & ip_endpoint)325 std::ostream& operator<<(std::ostream& os, const IPEndPoint& ip_endpoint) {
326 return os << ip_endpoint.ToString();
327 }
328
329 } // namespace net
330