1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
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 "build/build_config.h"
8
9 #if defined(OS_WIN)
10 #include <winsock2.h>
11 #include <ws2bth.h>
12 #elif defined(OS_POSIX)
13 #include <netinet/in.h>
14 #endif
15
16 #include <string.h>
17
18 #include <tuple>
19
20 #include "base/check.h"
21 #include "base/notreached.h"
22 #include "base/strings/string_number_conversions.h"
23 #include "base/sys_byteorder.h"
24 #include "net/base/ip_address.h"
25
26 #if defined(OS_WIN)
27 #include "net/base/winsock_util.h"
28 #endif
29
30 namespace net {
31
32 namespace {
33
34 // By definition, socklen_t is large enough to hold both sizes.
35 const socklen_t kSockaddrInSize = sizeof(struct sockaddr_in);
36 const socklen_t kSockaddrIn6Size = sizeof(struct sockaddr_in6);
37
38 // Extracts the address and port portions of a sockaddr.
GetIPAddressFromSockAddr(const struct sockaddr * sock_addr,socklen_t sock_addr_len,const uint8_t ** address,size_t * address_len,uint16_t * port)39 bool GetIPAddressFromSockAddr(const struct sockaddr* sock_addr,
40 socklen_t sock_addr_len,
41 const uint8_t** address,
42 size_t* address_len,
43 uint16_t* port) {
44 if (sock_addr->sa_family == AF_INET) {
45 if (sock_addr_len < static_cast<socklen_t>(sizeof(struct sockaddr_in)))
46 return false;
47 const struct sockaddr_in* addr =
48 reinterpret_cast<const struct sockaddr_in*>(sock_addr);
49 *address = reinterpret_cast<const uint8_t*>(&addr->sin_addr);
50 *address_len = IPAddress::kIPv4AddressSize;
51 if (port)
52 *port = base::NetToHost16(addr->sin_port);
53 return true;
54 }
55
56 if (sock_addr->sa_family == AF_INET6) {
57 if (sock_addr_len < static_cast<socklen_t>(sizeof(struct sockaddr_in6)))
58 return false;
59 const struct sockaddr_in6* addr =
60 reinterpret_cast<const struct sockaddr_in6*>(sock_addr);
61 *address = reinterpret_cast<const uint8_t*>(&addr->sin6_addr);
62 *address_len = IPAddress::kIPv6AddressSize;
63 if (port)
64 *port = base::NetToHost16(addr->sin6_port);
65 return true;
66 }
67
68 #if defined(OS_WIN)
69 if (sock_addr->sa_family == AF_BTH) {
70 if (sock_addr_len < static_cast<socklen_t>(sizeof(SOCKADDR_BTH)))
71 return false;
72 const SOCKADDR_BTH* addr = reinterpret_cast<const SOCKADDR_BTH*>(sock_addr);
73 *address = reinterpret_cast<const uint8_t*>(&addr->btAddr);
74 *address_len = kBluetoothAddressSize;
75 if (port)
76 *port = static_cast<uint16_t>(addr->port);
77 return true;
78 }
79 #endif
80
81 return false; // Unrecognized |sa_family|.
82 }
83
84 } // namespace
85
IPEndPoint()86 IPEndPoint::IPEndPoint() : port_(0) {}
87
88 IPEndPoint::~IPEndPoint() = default;
89
IPEndPoint(const IPAddress & address,uint16_t port)90 IPEndPoint::IPEndPoint(const IPAddress& address, uint16_t port)
91 : address_(address), port_(port) {}
92
IPEndPoint(const IPEndPoint & endpoint)93 IPEndPoint::IPEndPoint(const IPEndPoint& endpoint) {
94 address_ = endpoint.address_;
95 port_ = endpoint.port_;
96 }
97
GetFamily() const98 AddressFamily IPEndPoint::GetFamily() const {
99 return GetAddressFamily(address_);
100 }
101
GetSockAddrFamily() const102 int IPEndPoint::GetSockAddrFamily() const {
103 switch (address_.size()) {
104 case IPAddress::kIPv4AddressSize:
105 return AF_INET;
106 case IPAddress::kIPv6AddressSize:
107 return AF_INET6;
108 default:
109 NOTREACHED() << "Bad IP address";
110 return AF_UNSPEC;
111 }
112 }
113
ToSockAddr(struct sockaddr * address,socklen_t * address_length) const114 bool IPEndPoint::ToSockAddr(struct sockaddr* address,
115 socklen_t* address_length) const {
116 DCHECK(address);
117 DCHECK(address_length);
118 switch (address_.size()) {
119 case IPAddress::kIPv4AddressSize: {
120 if (*address_length < kSockaddrInSize)
121 return false;
122 *address_length = kSockaddrInSize;
123 struct sockaddr_in* addr = reinterpret_cast<struct sockaddr_in*>(address);
124 memset(addr, 0, sizeof(struct sockaddr_in));
125 addr->sin_family = AF_INET;
126 addr->sin_port = base::HostToNet16(port_);
127 memcpy(&addr->sin_addr, address_.bytes().data(),
128 IPAddress::kIPv4AddressSize);
129 break;
130 }
131 case IPAddress::kIPv6AddressSize: {
132 if (*address_length < kSockaddrIn6Size)
133 return false;
134 *address_length = kSockaddrIn6Size;
135 struct sockaddr_in6* addr6 =
136 reinterpret_cast<struct sockaddr_in6*>(address);
137 memset(addr6, 0, sizeof(struct sockaddr_in6));
138 addr6->sin6_family = AF_INET6;
139 addr6->sin6_port = base::HostToNet16(port_);
140 memcpy(&addr6->sin6_addr, address_.bytes().data(),
141 IPAddress::kIPv6AddressSize);
142 break;
143 }
144 default:
145 return false;
146 }
147 return true;
148 }
149
FromSockAddr(const struct sockaddr * sock_addr,socklen_t sock_addr_len)150 bool IPEndPoint::FromSockAddr(const struct sockaddr* sock_addr,
151 socklen_t sock_addr_len) {
152 DCHECK(sock_addr);
153
154 const uint8_t* address;
155 size_t address_len;
156 uint16_t port;
157 if (!GetIPAddressFromSockAddr(sock_addr, sock_addr_len, &address,
158 &address_len, &port)) {
159 return false;
160 }
161
162 address_ = net::IPAddress(address, address_len);
163 port_ = port;
164 return true;
165 }
166
ToString() const167 std::string IPEndPoint::ToString() const {
168 return IPAddressToStringWithPort(address_, port_);
169 }
170
ToStringWithoutPort() const171 std::string IPEndPoint::ToStringWithoutPort() const {
172 return address_.ToString();
173 }
174
operator <(const IPEndPoint & other) const175 bool IPEndPoint::operator<(const IPEndPoint& other) const {
176 // Sort IPv4 before IPv6.
177 if (address_.size() != other.address_.size()) {
178 return address_.size() < other.address_.size();
179 }
180 return std::tie(address_, port_) < std::tie(other.address_, other.port_);
181 }
182
operator ==(const IPEndPoint & other) const183 bool IPEndPoint::operator==(const IPEndPoint& other) const {
184 return address_ == other.address_ && port_ == other.port_;
185 }
186
operator !=(const IPEndPoint & that) const187 bool IPEndPoint::operator!=(const IPEndPoint& that) const {
188 return !(*this == that);
189 }
190
191 } // namespace net
192