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