|
150
|
1 //===-- SocketAddress.cpp -------------------------------------------------===//
|
|
|
2 //
|
|
|
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
4 // See https://llvm.org/LICENSE.txt for license information.
|
|
|
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
6 //
|
|
|
7 //===----------------------------------------------------------------------===//
|
|
|
8 //
|
|
|
9 // Note: This file is used on Darwin by debugserver, so it needs to remain as
|
|
|
10 // self contained as possible, and devoid of references to LLVM unless
|
|
|
11 // there is compelling reason.
|
|
|
12 //
|
|
|
13 //===----------------------------------------------------------------------===//
|
|
|
14
|
|
|
15 #if defined(_MSC_VER)
|
|
|
16 #define _WINSOCK_DEPRECATED_NO_WARNINGS
|
|
|
17 #endif
|
|
|
18
|
|
|
19 #include "lldb/Host/SocketAddress.h"
|
|
|
20 #include <stddef.h>
|
|
|
21 #include <stdio.h>
|
|
|
22
|
|
|
23 #if !defined(_WIN32)
|
|
|
24 #include <arpa/inet.h>
|
|
|
25 #endif
|
|
|
26
|
|
|
27 #include <assert.h>
|
|
|
28 #include <string.h>
|
|
|
29
|
|
|
30 #include "lldb/Host/PosixApi.h"
|
|
|
31
|
|
|
32 // WindowsXP needs an inet_ntop implementation
|
|
|
33 #ifdef _WIN32
|
|
|
34
|
|
|
35 #ifndef INET6_ADDRSTRLEN // might not be defined in older Windows SDKs
|
|
|
36 #define INET6_ADDRSTRLEN 46
|
|
|
37 #endif
|
|
|
38
|
|
|
39 // TODO: implement shortened form "::" for runs of zeros
|
|
|
40 const char *inet_ntop(int af, const void *src, char *dst, socklen_t size) {
|
|
|
41 if (size == 0) {
|
|
|
42 return nullptr;
|
|
|
43 }
|
|
|
44
|
|
|
45 switch (af) {
|
|
|
46 case AF_INET: {
|
|
|
47 {
|
|
|
48 const char *formatted = inet_ntoa(*static_cast<const in_addr *>(src));
|
|
|
49 if (formatted && strlen(formatted) < static_cast<size_t>(size)) {
|
|
|
50 return ::strcpy(dst, formatted);
|
|
|
51 }
|
|
|
52 }
|
|
|
53 return nullptr;
|
|
|
54 case AF_INET6: {
|
|
|
55 char tmp[INET6_ADDRSTRLEN] = {0};
|
|
|
56 const uint16_t *src16 = static_cast<const uint16_t *>(src);
|
|
|
57 int full_size = ::snprintf(
|
|
|
58 tmp, sizeof(tmp), "%x:%x:%x:%x:%x:%x:%x:%x", ntohs(src16[0]),
|
|
|
59 ntohs(src16[1]), ntohs(src16[2]), ntohs(src16[3]), ntohs(src16[4]),
|
|
|
60 ntohs(src16[5]), ntohs(src16[6]), ntohs(src16[7]));
|
|
|
61 if (full_size < static_cast<int>(size)) {
|
|
|
62 return ::strcpy(dst, tmp);
|
|
|
63 }
|
|
|
64 return nullptr;
|
|
|
65 }
|
|
|
66 }
|
|
|
67 }
|
|
|
68 return nullptr;
|
|
|
69 }
|
|
|
70 #endif
|
|
|
71
|
|
|
72 using namespace lldb_private;
|
|
|
73
|
|
|
74 // SocketAddress constructor
|
|
|
75 SocketAddress::SocketAddress() { Clear(); }
|
|
|
76
|
|
|
77 SocketAddress::SocketAddress(const struct sockaddr &s) { m_socket_addr.sa = s; }
|
|
|
78
|
|
|
79 SocketAddress::SocketAddress(const struct sockaddr_in &s) {
|
|
|
80 m_socket_addr.sa_ipv4 = s;
|
|
|
81 }
|
|
|
82
|
|
|
83 SocketAddress::SocketAddress(const struct sockaddr_in6 &s) {
|
|
|
84 m_socket_addr.sa_ipv6 = s;
|
|
|
85 }
|
|
|
86
|
|
|
87 SocketAddress::SocketAddress(const struct sockaddr_storage &s) {
|
|
|
88 m_socket_addr.sa_storage = s;
|
|
|
89 }
|
|
|
90
|
|
|
91 SocketAddress::SocketAddress(const struct addrinfo *addr_info) {
|
|
|
92 *this = addr_info;
|
|
|
93 }
|
|
|
94
|
|
|
95 // Destructor
|
|
|
96 SocketAddress::~SocketAddress() {}
|
|
|
97
|
|
|
98 void SocketAddress::Clear() {
|
|
|
99 memset(&m_socket_addr, 0, sizeof(m_socket_addr));
|
|
|
100 }
|
|
|
101
|
|
|
102 bool SocketAddress::IsValid() const { return GetLength() != 0; }
|
|
|
103
|
|
|
104 static socklen_t GetFamilyLength(sa_family_t family) {
|
|
|
105 switch (family) {
|
|
|
106 case AF_INET:
|
|
|
107 return sizeof(struct sockaddr_in);
|
|
|
108 case AF_INET6:
|
|
|
109 return sizeof(struct sockaddr_in6);
|
|
|
110 }
|
|
|
111 assert(0 && "Unsupported address family");
|
|
|
112 return 0;
|
|
|
113 }
|
|
|
114
|
|
|
115 socklen_t SocketAddress::GetLength() const {
|
|
|
116 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
|
|
|
117 return m_socket_addr.sa.sa_len;
|
|
|
118 #else
|
|
|
119 return GetFamilyLength(GetFamily());
|
|
|
120 #endif
|
|
|
121 }
|
|
|
122
|
|
|
123 socklen_t SocketAddress::GetMaxLength() { return sizeof(sockaddr_t); }
|
|
|
124
|
|
|
125 sa_family_t SocketAddress::GetFamily() const {
|
|
|
126 return m_socket_addr.sa.sa_family;
|
|
|
127 }
|
|
|
128
|
|
|
129 void SocketAddress::SetFamily(sa_family_t family) {
|
|
|
130 m_socket_addr.sa.sa_family = family;
|
|
|
131 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
|
|
|
132 m_socket_addr.sa.sa_len = GetFamilyLength(family);
|
|
|
133 #endif
|
|
|
134 }
|
|
|
135
|
|
|
136 std::string SocketAddress::GetIPAddress() const {
|
|
|
137 char str[INET6_ADDRSTRLEN] = {0};
|
|
|
138 switch (GetFamily()) {
|
|
|
139 case AF_INET:
|
|
|
140 if (inet_ntop(GetFamily(), &m_socket_addr.sa_ipv4.sin_addr, str,
|
|
|
141 sizeof(str)))
|
|
|
142 return str;
|
|
|
143 break;
|
|
|
144 case AF_INET6:
|
|
|
145 if (inet_ntop(GetFamily(), &m_socket_addr.sa_ipv6.sin6_addr, str,
|
|
|
146 sizeof(str)))
|
|
|
147 return str;
|
|
|
148 break;
|
|
|
149 }
|
|
|
150 return "";
|
|
|
151 }
|
|
|
152
|
|
|
153 uint16_t SocketAddress::GetPort() const {
|
|
|
154 switch (GetFamily()) {
|
|
|
155 case AF_INET:
|
|
|
156 return ntohs(m_socket_addr.sa_ipv4.sin_port);
|
|
|
157 case AF_INET6:
|
|
|
158 return ntohs(m_socket_addr.sa_ipv6.sin6_port);
|
|
|
159 }
|
|
|
160 return 0;
|
|
|
161 }
|
|
|
162
|
|
|
163 bool SocketAddress::SetPort(uint16_t port) {
|
|
|
164 switch (GetFamily()) {
|
|
|
165 case AF_INET:
|
|
|
166 m_socket_addr.sa_ipv4.sin_port = htons(port);
|
|
|
167 return true;
|
|
|
168
|
|
|
169 case AF_INET6:
|
|
|
170 m_socket_addr.sa_ipv6.sin6_port = htons(port);
|
|
|
171 return true;
|
|
|
172 }
|
|
|
173 return false;
|
|
|
174 }
|
|
|
175
|
|
|
176 // SocketAddress assignment operator
|
|
|
177 const SocketAddress &SocketAddress::
|
|
|
178 operator=(const struct addrinfo *addr_info) {
|
|
|
179 Clear();
|
|
|
180 if (addr_info && addr_info->ai_addr && addr_info->ai_addrlen > 0 &&
|
|
|
181 size_t(addr_info->ai_addrlen) <= sizeof m_socket_addr) {
|
|
|
182 ::memcpy(&m_socket_addr, addr_info->ai_addr, addr_info->ai_addrlen);
|
|
|
183 }
|
|
|
184 return *this;
|
|
|
185 }
|
|
|
186
|
|
|
187 const SocketAddress &SocketAddress::operator=(const struct sockaddr &s) {
|
|
|
188 m_socket_addr.sa = s;
|
|
|
189 return *this;
|
|
|
190 }
|
|
|
191
|
|
|
192 const SocketAddress &SocketAddress::operator=(const struct sockaddr_in &s) {
|
|
|
193 m_socket_addr.sa_ipv4 = s;
|
|
|
194 return *this;
|
|
|
195 }
|
|
|
196
|
|
|
197 const SocketAddress &SocketAddress::operator=(const struct sockaddr_in6 &s) {
|
|
|
198 m_socket_addr.sa_ipv6 = s;
|
|
|
199 return *this;
|
|
|
200 }
|
|
|
201
|
|
|
202 const SocketAddress &SocketAddress::
|
|
|
203 operator=(const struct sockaddr_storage &s) {
|
|
|
204 m_socket_addr.sa_storage = s;
|
|
|
205 return *this;
|
|
|
206 }
|
|
|
207
|
|
|
208 bool SocketAddress::getaddrinfo(const char *host, const char *service,
|
|
|
209 int ai_family, int ai_socktype, int ai_protocol,
|
|
|
210 int ai_flags) {
|
|
|
211 Clear();
|
|
|
212
|
|
|
213 auto addresses = GetAddressInfo(host, service, ai_family, ai_socktype,
|
|
|
214 ai_protocol, ai_flags);
|
|
|
215 if (!addresses.empty())
|
|
|
216 *this = addresses[0];
|
|
|
217 return IsValid();
|
|
|
218 }
|
|
|
219
|
|
|
220 std::vector<SocketAddress>
|
|
|
221 SocketAddress::GetAddressInfo(const char *hostname, const char *servname,
|
|
|
222 int ai_family, int ai_socktype, int ai_protocol,
|
|
|
223 int ai_flags) {
|
|
|
224 std::vector<SocketAddress> addr_list;
|
|
|
225
|
|
|
226 struct addrinfo hints;
|
|
|
227 memset(&hints, 0, sizeof(hints));
|
|
|
228 hints.ai_family = ai_family;
|
|
|
229 hints.ai_socktype = ai_socktype;
|
|
|
230 hints.ai_protocol = ai_protocol;
|
|
|
231 hints.ai_flags = ai_flags;
|
|
|
232
|
|
|
233 struct addrinfo *service_info_list = nullptr;
|
|
|
234 int err = ::getaddrinfo(hostname, servname, &hints, &service_info_list);
|
|
|
235 if (err == 0 && service_info_list) {
|
|
|
236 for (struct addrinfo *service_ptr = service_info_list;
|
|
|
237 service_ptr != nullptr; service_ptr = service_ptr->ai_next) {
|
|
|
238 addr_list.emplace_back(SocketAddress(service_ptr));
|
|
|
239 }
|
|
|
240 }
|
|
|
241
|
|
|
242 if (service_info_list)
|
|
|
243 ::freeaddrinfo(service_info_list);
|
|
|
244 return addr_list;
|
|
|
245 }
|
|
|
246
|
|
|
247 bool SocketAddress::SetToLocalhost(sa_family_t family, uint16_t port) {
|
|
|
248 switch (family) {
|
|
|
249 case AF_INET:
|
|
|
250 SetFamily(AF_INET);
|
|
|
251 if (SetPort(port)) {
|
|
|
252 m_socket_addr.sa_ipv4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
|
|
|
253 return true;
|
|
|
254 }
|
|
|
255 break;
|
|
|
256
|
|
|
257 case AF_INET6:
|
|
|
258 SetFamily(AF_INET6);
|
|
|
259 if (SetPort(port)) {
|
|
|
260 m_socket_addr.sa_ipv6.sin6_addr = in6addr_loopback;
|
|
|
261 return true;
|
|
|
262 }
|
|
|
263 break;
|
|
|
264 }
|
|
|
265 Clear();
|
|
|
266 return false;
|
|
|
267 }
|
|
|
268
|
|
|
269 bool SocketAddress::SetToAnyAddress(sa_family_t family, uint16_t port) {
|
|
|
270 switch (family) {
|
|
|
271 case AF_INET:
|
|
|
272 SetFamily(AF_INET);
|
|
|
273 if (SetPort(port)) {
|
|
|
274 m_socket_addr.sa_ipv4.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
|
275 return true;
|
|
|
276 }
|
|
|
277 break;
|
|
|
278
|
|
|
279 case AF_INET6:
|
|
|
280 SetFamily(AF_INET6);
|
|
|
281 if (SetPort(port)) {
|
|
|
282 m_socket_addr.sa_ipv6.sin6_addr = in6addr_any;
|
|
|
283 return true;
|
|
|
284 }
|
|
|
285 break;
|
|
|
286 }
|
|
|
287 Clear();
|
|
|
288 return false;
|
|
|
289 }
|
|
|
290
|
|
|
291 bool SocketAddress::IsAnyAddr() const {
|
|
|
292 return (GetFamily() == AF_INET)
|
|
|
293 ? m_socket_addr.sa_ipv4.sin_addr.s_addr == htonl(INADDR_ANY)
|
|
|
294 : 0 == memcmp(&m_socket_addr.sa_ipv6.sin6_addr, &in6addr_any, 16);
|
|
|
295 }
|
|
|
296
|
|
|
297 bool SocketAddress::IsLocalhost() const {
|
|
|
298 return (GetFamily() == AF_INET)
|
|
|
299 ? m_socket_addr.sa_ipv4.sin_addr.s_addr == htonl(INADDR_LOOPBACK)
|
|
|
300 : 0 == memcmp(&m_socket_addr.sa_ipv6.sin6_addr, &in6addr_loopback,
|
|
|
301 16);
|
|
|
302 }
|
|
|
303
|
|
|
304 bool SocketAddress::operator==(const SocketAddress &rhs) const {
|
|
|
305 if (GetFamily() != rhs.GetFamily())
|
|
|
306 return false;
|
|
|
307 if (GetLength() != rhs.GetLength())
|
|
|
308 return false;
|
|
|
309 switch (GetFamily()) {
|
|
|
310 case AF_INET:
|
|
|
311 return m_socket_addr.sa_ipv4.sin_addr.s_addr ==
|
|
|
312 rhs.m_socket_addr.sa_ipv4.sin_addr.s_addr;
|
|
|
313 case AF_INET6:
|
|
|
314 return 0 == memcmp(&m_socket_addr.sa_ipv6.sin6_addr,
|
|
|
315 &rhs.m_socket_addr.sa_ipv6.sin6_addr, 16);
|
|
|
316 }
|
|
|
317 return false;
|
|
|
318 }
|
|
|
319
|
|
|
320 bool SocketAddress::operator!=(const SocketAddress &rhs) const {
|
|
|
321 return !(*this == rhs);
|
|
|
322 }
|
