1/*
2 *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
3 *
4 *  Use of this source code is governed by a BSD-style license
5 *  that can be found in the LICENSE file in the root of the source
6 *  tree. An additional intellectual property rights grant can be found
7 *  in the file PATENTS.  All contributing project authors may
8 *  be found in the AUTHORS file in the root of the source tree.
9 */
10
11#include "webrtc/base/socketaddress.h"
12
13#if defined(WEBRTC_POSIX)
14#include <sys/types.h>
15#include <sys/socket.h>
16#include <netinet/in.h>
17#if defined(OPENBSD)
18#include <netinet/in_systm.h>
19#endif
20#if !defined(__native_client__)
21#include <netinet/ip.h>
22#endif
23#include <arpa/inet.h>
24#include <netdb.h>
25#include <unistd.h>
26#endif
27
28#include <sstream>
29
30#include "webrtc/base/byteorder.h"
31#include "webrtc/base/common.h"
32#include "webrtc/base/logging.h"
33#include "webrtc/base/nethelpers.h"
34
35#if defined(WEBRTC_WIN)
36#include "webrtc/base/win32.h"
37#endif
38
39namespace rtc {
40
41SocketAddress::SocketAddress() {
42  Clear();
43}
44
45SocketAddress::SocketAddress(const std::string& hostname, int port) {
46  SetIP(hostname);
47  SetPort(port);
48}
49
50SocketAddress::SocketAddress(uint32 ip_as_host_order_integer, int port) {
51  SetIP(IPAddress(ip_as_host_order_integer));
52  SetPort(port);
53}
54
55SocketAddress::SocketAddress(const IPAddress& ip, int port) {
56  SetIP(ip);
57  SetPort(port);
58}
59
60SocketAddress::SocketAddress(const SocketAddress& addr) {
61  this->operator=(addr);
62}
63
64void SocketAddress::Clear() {
65  hostname_.clear();
66  literal_ = false;
67  ip_ = IPAddress();
68  port_ = 0;
69  scope_id_ = 0;
70}
71
72bool SocketAddress::IsNil() const {
73  return hostname_.empty() && IPIsUnspec(ip_) && 0 == port_;
74}
75
76bool SocketAddress::IsComplete() const {
77  return (!IPIsAny(ip_)) && (0 != port_);
78}
79
80SocketAddress& SocketAddress::operator=(const SocketAddress& addr) {
81  hostname_ = addr.hostname_;
82  ip_ = addr.ip_;
83  port_ = addr.port_;
84  literal_ = addr.literal_;
85  scope_id_ = addr.scope_id_;
86  return *this;
87}
88
89void SocketAddress::SetIP(uint32 ip_as_host_order_integer) {
90  hostname_.clear();
91  literal_ = false;
92  ip_ = IPAddress(ip_as_host_order_integer);
93  scope_id_ = 0;
94}
95
96void SocketAddress::SetIP(const IPAddress& ip) {
97  hostname_.clear();
98  literal_ = false;
99  ip_ = ip;
100  scope_id_ = 0;
101}
102
103void SocketAddress::SetIP(const std::string& hostname) {
104  hostname_ = hostname;
105  literal_ = IPFromString(hostname, &ip_);
106  if (!literal_) {
107    ip_ = IPAddress();
108  }
109  scope_id_ = 0;
110}
111
112void SocketAddress::SetResolvedIP(uint32 ip_as_host_order_integer) {
113  ip_ = IPAddress(ip_as_host_order_integer);
114  scope_id_ = 0;
115}
116
117void SocketAddress::SetResolvedIP(const IPAddress& ip) {
118  ip_ = ip;
119  scope_id_ = 0;
120}
121
122void SocketAddress::SetPort(int port) {
123  ASSERT((0 <= port) && (port < 65536));
124  port_ = static_cast<uint16>(port);
125}
126
127uint32 SocketAddress::ip() const {
128  return ip_.v4AddressAsHostOrderInteger();
129}
130
131const IPAddress& SocketAddress::ipaddr() const {
132  return ip_;
133}
134
135uint16 SocketAddress::port() const {
136  return port_;
137}
138
139std::string SocketAddress::HostAsURIString() const {
140  // If the hostname was a literal IP string, it may need to have square
141  // brackets added (for SocketAddress::ToString()).
142  if (!literal_ && !hostname_.empty())
143    return hostname_;
144  if (ip_.family() == AF_INET6) {
145    return "[" + ip_.ToString() + "]";
146  } else {
147    return ip_.ToString();
148  }
149}
150
151std::string SocketAddress::HostAsSensitiveURIString() const {
152  // If the hostname was a literal IP string, it may need to have square
153  // brackets added (for SocketAddress::ToString()).
154  if (!literal_ && !hostname_.empty())
155    return hostname_;
156  if (ip_.family() == AF_INET6) {
157    return "[" + ip_.ToSensitiveString() + "]";
158  } else {
159    return ip_.ToSensitiveString();
160  }
161}
162
163std::string SocketAddress::PortAsString() const {
164  std::ostringstream ost;
165  ost << port_;
166  return ost.str();
167}
168
169std::string SocketAddress::ToString() const {
170  std::ostringstream ost;
171  ost << *this;
172  return ost.str();
173}
174
175std::string SocketAddress::ToSensitiveString() const {
176  std::ostringstream ost;
177  ost << HostAsSensitiveURIString() << ":" << port();
178  return ost.str();
179}
180
181bool SocketAddress::FromString(const std::string& str) {
182  if (str.at(0) == '[') {
183    std::string::size_type closebracket = str.rfind(']');
184    if (closebracket != std::string::npos) {
185      std::string::size_type colon = str.find(':', closebracket);
186      if (colon != std::string::npos && colon > closebracket) {
187        SetPort(strtoul(str.substr(colon + 1).c_str(), NULL, 10));
188        SetIP(str.substr(1, closebracket - 1));
189      } else {
190        return false;
191      }
192    }
193  } else {
194    std::string::size_type pos = str.find(':');
195    if (std::string::npos == pos)
196      return false;
197    SetPort(strtoul(str.substr(pos + 1).c_str(), NULL, 10));
198    SetIP(str.substr(0, pos));
199  }
200  return true;
201}
202
203std::ostream& operator<<(std::ostream& os, const SocketAddress& addr) {
204  os << addr.HostAsURIString() << ":" << addr.port();
205  return os;
206}
207
208bool SocketAddress::IsAnyIP() const {
209  return IPIsAny(ip_);
210}
211
212bool SocketAddress::IsLoopbackIP() const {
213  return IPIsLoopback(ip_) || (IPIsAny(ip_) &&
214                               0 == strcmp(hostname_.c_str(), "localhost"));
215}
216
217bool SocketAddress::IsPrivateIP() const {
218  return IPIsPrivate(ip_);
219}
220
221bool SocketAddress::IsUnresolvedIP() const {
222  return IPIsUnspec(ip_) && !literal_ && !hostname_.empty();
223}
224
225bool SocketAddress::operator==(const SocketAddress& addr) const {
226  return EqualIPs(addr) && EqualPorts(addr);
227}
228
229bool SocketAddress::operator<(const SocketAddress& addr) const {
230  if (ip_ != addr.ip_)
231    return ip_ < addr.ip_;
232
233  // We only check hostnames if both IPs are ANY or unspecified.  This matches
234  // EqualIPs().
235  if ((IPIsAny(ip_) || IPIsUnspec(ip_)) && hostname_ != addr.hostname_)
236    return hostname_ < addr.hostname_;
237
238  return port_ < addr.port_;
239}
240
241bool SocketAddress::EqualIPs(const SocketAddress& addr) const {
242  return (ip_ == addr.ip_) &&
243      ((!IPIsAny(ip_) && !IPIsUnspec(ip_)) || (hostname_ == addr.hostname_));
244}
245
246bool SocketAddress::EqualPorts(const SocketAddress& addr) const {
247  return (port_ == addr.port_);
248}
249
250size_t SocketAddress::Hash() const {
251  size_t h = 0;
252  h ^= HashIP(ip_);
253  h ^= port_ | (port_ << 16);
254  return h;
255}
256
257void SocketAddress::ToSockAddr(sockaddr_in* saddr) const {
258  memset(saddr, 0, sizeof(*saddr));
259  if (ip_.family() != AF_INET) {
260    saddr->sin_family = AF_UNSPEC;
261    return;
262  }
263  saddr->sin_family = AF_INET;
264  saddr->sin_port = HostToNetwork16(port_);
265  if (IPIsAny(ip_)) {
266    saddr->sin_addr.s_addr = INADDR_ANY;
267  } else {
268    saddr->sin_addr = ip_.ipv4_address();
269  }
270}
271
272bool SocketAddress::FromSockAddr(const sockaddr_in& saddr) {
273  if (saddr.sin_family != AF_INET)
274    return false;
275  SetIP(NetworkToHost32(saddr.sin_addr.s_addr));
276  SetPort(NetworkToHost16(saddr.sin_port));
277  literal_ = false;
278  return true;
279}
280
281static size_t ToSockAddrStorageHelper(sockaddr_storage* addr,
282                                      IPAddress ip, uint16 port, int scope_id) {
283  memset(addr, 0, sizeof(sockaddr_storage));
284  addr->ss_family = static_cast<unsigned short>(ip.family());
285  if (addr->ss_family == AF_INET6) {
286    sockaddr_in6* saddr = reinterpret_cast<sockaddr_in6*>(addr);
287    saddr->sin6_addr = ip.ipv6_address();
288    saddr->sin6_port = HostToNetwork16(port);
289    saddr->sin6_scope_id = scope_id;
290    return sizeof(sockaddr_in6);
291  } else if (addr->ss_family == AF_INET) {
292    sockaddr_in* saddr = reinterpret_cast<sockaddr_in*>(addr);
293    saddr->sin_addr = ip.ipv4_address();
294    saddr->sin_port = HostToNetwork16(port);
295    return sizeof(sockaddr_in);
296  }
297  return 0;
298}
299
300size_t SocketAddress::ToDualStackSockAddrStorage(sockaddr_storage *addr) const {
301  return ToSockAddrStorageHelper(addr, ip_.AsIPv6Address(), port_, scope_id_);
302}
303
304size_t SocketAddress::ToSockAddrStorage(sockaddr_storage* addr) const {
305  return ToSockAddrStorageHelper(addr, ip_, port_, scope_id_);
306}
307
308std::string SocketAddress::IPToString(uint32 ip_as_host_order_integer) {
309  return IPAddress(ip_as_host_order_integer).ToString();
310}
311
312std::string IPToSensitiveString(uint32 ip_as_host_order_integer) {
313  return IPAddress(ip_as_host_order_integer).ToSensitiveString();
314}
315
316bool SocketAddress::StringToIP(const std::string& hostname, uint32* ip) {
317  in_addr addr;
318  if (rtc::inet_pton(AF_INET, hostname.c_str(), &addr) == 0)
319    return false;
320  *ip = NetworkToHost32(addr.s_addr);
321  return true;
322}
323
324bool SocketAddress::StringToIP(const std::string& hostname, IPAddress* ip) {
325  in_addr addr4;
326  if (rtc::inet_pton(AF_INET, hostname.c_str(), &addr4) > 0) {
327    if (ip) {
328      *ip = IPAddress(addr4);
329    }
330    return true;
331  }
332
333  in6_addr addr6;
334  if (rtc::inet_pton(AF_INET6, hostname.c_str(), &addr6) > 0) {
335    if (ip) {
336      *ip = IPAddress(addr6);
337    }
338    return true;
339  }
340  return false;
341}
342
343uint32 SocketAddress::StringToIP(const std::string& hostname) {
344  uint32 ip = 0;
345  StringToIP(hostname, &ip);
346  return ip;
347}
348
349bool SocketAddressFromSockAddrStorage(const sockaddr_storage& addr,
350                                      SocketAddress* out) {
351  if (!out) {
352    return false;
353  }
354  if (addr.ss_family == AF_INET) {
355    const sockaddr_in* saddr = reinterpret_cast<const sockaddr_in*>(&addr);
356    *out = SocketAddress(IPAddress(saddr->sin_addr),
357                         NetworkToHost16(saddr->sin_port));
358    return true;
359  } else if (addr.ss_family == AF_INET6) {
360    const sockaddr_in6* saddr = reinterpret_cast<const sockaddr_in6*>(&addr);
361    *out = SocketAddress(IPAddress(saddr->sin6_addr),
362                         NetworkToHost16(saddr->sin6_port));
363    out->SetScopeID(saddr->sin6_scope_id);
364    return true;
365  }
366  return false;
367}
368
369SocketAddress EmptySocketAddressWithFamily(int family) {
370  if (family == AF_INET) {
371    return SocketAddress(IPAddress(INADDR_ANY), 0);
372  } else if (family == AF_INET6) {
373    return SocketAddress(IPAddress(in6addr_any), 0);
374  }
375  return SocketAddress();
376}
377
378}  // namespace rtc
379