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 
39 namespace rtc {
40 
SocketAddress()41 SocketAddress::SocketAddress() {
42   Clear();
43 }
44 
SocketAddress(const std::string & hostname,int port)45 SocketAddress::SocketAddress(const std::string& hostname, int port) {
46   SetIP(hostname);
47   SetPort(port);
48 }
49 
SocketAddress(uint32_t ip_as_host_order_integer,int port)50 SocketAddress::SocketAddress(uint32_t ip_as_host_order_integer, int port) {
51   SetIP(IPAddress(ip_as_host_order_integer));
52   SetPort(port);
53 }
54 
SocketAddress(const IPAddress & ip,int port)55 SocketAddress::SocketAddress(const IPAddress& ip, int port) {
56   SetIP(ip);
57   SetPort(port);
58 }
59 
SocketAddress(const SocketAddress & addr)60 SocketAddress::SocketAddress(const SocketAddress& addr) {
61   this->operator=(addr);
62 }
63 
Clear()64 void SocketAddress::Clear() {
65   hostname_.clear();
66   literal_ = false;
67   ip_ = IPAddress();
68   port_ = 0;
69   scope_id_ = 0;
70 }
71 
IsNil() const72 bool SocketAddress::IsNil() const {
73   return hostname_.empty() && IPIsUnspec(ip_) && 0 == port_;
74 }
75 
IsComplete() const76 bool SocketAddress::IsComplete() const {
77   return (!IPIsAny(ip_)) && (0 != port_);
78 }
79 
operator =(const SocketAddress & addr)80 SocketAddress& 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 
SetIP(uint32_t ip_as_host_order_integer)89 void SocketAddress::SetIP(uint32_t 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 
SetIP(const IPAddress & ip)96 void SocketAddress::SetIP(const IPAddress& ip) {
97   hostname_.clear();
98   literal_ = false;
99   ip_ = ip;
100   scope_id_ = 0;
101 }
102 
SetIP(const std::string & hostname)103 void 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 
SetResolvedIP(uint32_t ip_as_host_order_integer)112 void SocketAddress::SetResolvedIP(uint32_t ip_as_host_order_integer) {
113   ip_ = IPAddress(ip_as_host_order_integer);
114   scope_id_ = 0;
115 }
116 
SetResolvedIP(const IPAddress & ip)117 void SocketAddress::SetResolvedIP(const IPAddress& ip) {
118   ip_ = ip;
119   scope_id_ = 0;
120 }
121 
SetPort(int port)122 void SocketAddress::SetPort(int port) {
123   ASSERT((0 <= port) && (port < 65536));
124   port_ = static_cast<uint16_t>(port);
125 }
126 
ip() const127 uint32_t SocketAddress::ip() const {
128   return ip_.v4AddressAsHostOrderInteger();
129 }
130 
ipaddr() const131 const IPAddress& SocketAddress::ipaddr() const {
132   return ip_;
133 }
134 
port() const135 uint16_t SocketAddress::port() const {
136   return port_;
137 }
138 
HostAsURIString() const139 std::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 
HostAsSensitiveURIString() const151 std::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 
PortAsString() const163 std::string SocketAddress::PortAsString() const {
164   std::ostringstream ost;
165   ost << port_;
166   return ost.str();
167 }
168 
ToString() const169 std::string SocketAddress::ToString() const {
170   std::ostringstream ost;
171   ost << *this;
172   return ost.str();
173 }
174 
ToSensitiveString() const175 std::string SocketAddress::ToSensitiveString() const {
176   std::ostringstream ost;
177   ost << HostAsSensitiveURIString() << ":" << port();
178   return ost.str();
179 }
180 
FromString(const std::string & str)181 bool 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 
operator <<(std::ostream & os,const SocketAddress & addr)203 std::ostream& operator<<(std::ostream& os, const SocketAddress& addr) {
204   os << addr.HostAsURIString() << ":" << addr.port();
205   return os;
206 }
207 
IsAnyIP() const208 bool SocketAddress::IsAnyIP() const {
209   return IPIsAny(ip_);
210 }
211 
IsLoopbackIP() const212 bool SocketAddress::IsLoopbackIP() const {
213   return IPIsLoopback(ip_) || (IPIsAny(ip_) &&
214                                0 == strcmp(hostname_.c_str(), "localhost"));
215 }
216 
IsPrivateIP() const217 bool SocketAddress::IsPrivateIP() const {
218   return IPIsPrivate(ip_);
219 }
220 
IsUnresolvedIP() const221 bool SocketAddress::IsUnresolvedIP() const {
222   return IPIsUnspec(ip_) && !literal_ && !hostname_.empty();
223 }
224 
operator ==(const SocketAddress & addr) const225 bool SocketAddress::operator==(const SocketAddress& addr) const {
226   return EqualIPs(addr) && EqualPorts(addr);
227 }
228 
operator <(const SocketAddress & addr) const229 bool 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 
EqualIPs(const SocketAddress & addr) const241 bool SocketAddress::EqualIPs(const SocketAddress& addr) const {
242   return (ip_ == addr.ip_) &&
243       ((!IPIsAny(ip_) && !IPIsUnspec(ip_)) || (hostname_ == addr.hostname_));
244 }
245 
EqualPorts(const SocketAddress & addr) const246 bool SocketAddress::EqualPorts(const SocketAddress& addr) const {
247   return (port_ == addr.port_);
248 }
249 
Hash() const250 size_t SocketAddress::Hash() const {
251   size_t h = 0;
252   h ^= HashIP(ip_);
253   h ^= port_ | (port_ << 16);
254   return h;
255 }
256 
ToSockAddr(sockaddr_in * saddr) const257 void 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 
FromSockAddr(const sockaddr_in & saddr)272 bool 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 
ToSockAddrStorageHelper(sockaddr_storage * addr,IPAddress ip,uint16_t port,int scope_id)281 static size_t ToSockAddrStorageHelper(sockaddr_storage* addr,
282                                       IPAddress ip,
283                                       uint16_t port,
284                                       int scope_id) {
285   memset(addr, 0, sizeof(sockaddr_storage));
286   addr->ss_family = static_cast<unsigned short>(ip.family());
287   if (addr->ss_family == AF_INET6) {
288     sockaddr_in6* saddr = reinterpret_cast<sockaddr_in6*>(addr);
289     saddr->sin6_addr = ip.ipv6_address();
290     saddr->sin6_port = HostToNetwork16(port);
291     saddr->sin6_scope_id = scope_id;
292     return sizeof(sockaddr_in6);
293   } else if (addr->ss_family == AF_INET) {
294     sockaddr_in* saddr = reinterpret_cast<sockaddr_in*>(addr);
295     saddr->sin_addr = ip.ipv4_address();
296     saddr->sin_port = HostToNetwork16(port);
297     return sizeof(sockaddr_in);
298   }
299   return 0;
300 }
301 
ToDualStackSockAddrStorage(sockaddr_storage * addr) const302 size_t SocketAddress::ToDualStackSockAddrStorage(sockaddr_storage *addr) const {
303   return ToSockAddrStorageHelper(addr, ip_.AsIPv6Address(), port_, scope_id_);
304 }
305 
ToSockAddrStorage(sockaddr_storage * addr) const306 size_t SocketAddress::ToSockAddrStorage(sockaddr_storage* addr) const {
307   return ToSockAddrStorageHelper(addr, ip_, port_, scope_id_);
308 }
309 
SocketAddressFromSockAddrStorage(const sockaddr_storage & addr,SocketAddress * out)310 bool SocketAddressFromSockAddrStorage(const sockaddr_storage& addr,
311                                       SocketAddress* out) {
312   if (!out) {
313     return false;
314   }
315   if (addr.ss_family == AF_INET) {
316     const sockaddr_in* saddr = reinterpret_cast<const sockaddr_in*>(&addr);
317     *out = SocketAddress(IPAddress(saddr->sin_addr),
318                          NetworkToHost16(saddr->sin_port));
319     return true;
320   } else if (addr.ss_family == AF_INET6) {
321     const sockaddr_in6* saddr = reinterpret_cast<const sockaddr_in6*>(&addr);
322     *out = SocketAddress(IPAddress(saddr->sin6_addr),
323                          NetworkToHost16(saddr->sin6_port));
324     out->SetScopeID(saddr->sin6_scope_id);
325     return true;
326   }
327   return false;
328 }
329 
EmptySocketAddressWithFamily(int family)330 SocketAddress EmptySocketAddressWithFamily(int family) {
331   if (family == AF_INET) {
332     return SocketAddress(IPAddress(INADDR_ANY), 0);
333   } else if (family == AF_INET6) {
334     return SocketAddress(IPAddress(in6addr_any), 0);
335   }
336   return SocketAddress();
337 }
338 
339 }  // namespace rtc
340