• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * libjingle
3  * Copyright 2004--2005, Google Inc.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are met:
7  *
8  *  1. Redistributions of source code must retain the above copyright notice,
9  *     this list of conditions and the following disclaimer.
10  *  2. Redistributions in binary form must reproduce the above copyright notice,
11  *     this list of conditions and the following disclaimer in the documentation
12  *     and/or other materials provided with the distribution.
13  *  3. The name of the author may not be used to endorse or promote products
14  *     derived from this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27 
28 #ifdef POSIX
29 #include <sys/types.h>
30 #include <sys/socket.h>
31 #include <netinet/in.h>
32 #include <netinet/ip.h>
33 #include <arpa/inet.h>
34 #include <netdb.h>
35 #include <unistd.h>
36 #endif
37 
38 #include <sstream>
39 
40 #include "talk/base/byteorder.h"
41 #include "talk/base/common.h"
42 #include "talk/base/logging.h"
43 #include "talk/base/nethelpers.h"
44 #include "talk/base/socketaddress.h"
45 
46 #ifdef WIN32
47 // Win32 doesn't provide inet_aton, so we add our own version here.
48 // Since inet_addr returns 0xFFFFFFFF on error, if we get this value
49 // we need to test the input to see if the address really was 255.255.255.255.
50 // This is slightly fragile, but better than doing nothing.
inet_aton(const char * cp,struct in_addr * inp)51 int inet_aton(const char* cp, struct in_addr* inp) {
52   inp->s_addr = inet_addr(cp);
53   return (inp->s_addr == INADDR_NONE &&
54           strcmp(cp, "255.255.255.255") != 0) ? 0 : 1;
55 }
56 #endif  // WIN32
57 
58 namespace talk_base {
59 
SocketAddress()60 SocketAddress::SocketAddress() {
61   Clear();
62 }
63 
SocketAddress(const std::string & hostname,int port)64 SocketAddress::SocketAddress(const std::string& hostname, int port) {
65   SetIP(hostname);
66   SetPort(port);
67 }
68 
SocketAddress(uint32 ip,int port)69 SocketAddress::SocketAddress(uint32 ip, int port) {
70   SetIP(ip);
71   SetPort(port);
72 }
73 
SocketAddress(const SocketAddress & addr)74 SocketAddress::SocketAddress(const SocketAddress& addr) {
75   this->operator=(addr);
76 }
77 
Clear()78 void SocketAddress::Clear() {
79   hostname_.clear();
80   ip_ = 0;
81   port_ = 0;
82 }
83 
IsNil() const84 bool SocketAddress::IsNil() const {
85   return hostname_.empty() && (0 == ip_) && (0 == port_);
86 }
87 
IsComplete() const88 bool SocketAddress::IsComplete() const {
89   return (0 != ip_) && (0 != port_);
90 }
91 
operator =(const SocketAddress & addr)92 SocketAddress& SocketAddress::operator=(const SocketAddress& addr) {
93   hostname_ = addr.hostname_;
94   ip_ = addr.ip_;
95   port_ = addr.port_;
96   return *this;
97 }
98 
SetIP(uint32 ip)99 void SocketAddress::SetIP(uint32 ip) {
100   hostname_.clear();
101   ip_ = ip;
102 }
103 
SetIP(const std::string & hostname)104 void SocketAddress::SetIP(const std::string& hostname) {
105   hostname_ = hostname;
106   ip_ = StringToIP(hostname);
107 }
108 
SetResolvedIP(uint32 ip)109 void SocketAddress::SetResolvedIP(uint32 ip) {
110   ip_ = ip;
111 }
112 
SetPort(int port)113 void SocketAddress::SetPort(int port) {
114   ASSERT((0 <= port) && (port < 65536));
115   port_ = port;
116 }
117 
ip() const118 uint32 SocketAddress::ip() const {
119   return ip_;
120 }
121 
port() const122 uint16 SocketAddress::port() const {
123   return port_;
124 }
125 
IPAsString() const126 std::string SocketAddress::IPAsString() const {
127   if (!hostname_.empty())
128     return hostname_;
129   return IPToString(ip_);
130 }
131 
PortAsString() const132 std::string SocketAddress::PortAsString() const {
133   std::ostringstream ost;
134   ost << port_;
135   return ost.str();
136 }
137 
ToString() const138 std::string SocketAddress::ToString() const {
139   std::ostringstream ost;
140   ost << IPAsString();
141   ost << ":";
142   ost << port();
143   return ost.str();
144 }
145 
FromString(const std::string & str)146 bool SocketAddress::FromString(const std::string& str) {
147   std::string::size_type pos = str.find(':');
148   if (std::string::npos == pos)
149     return false;
150   SetPort(strtoul(str.substr(pos + 1).c_str(), NULL, 10));
151   SetIP(str.substr(0, pos));
152   return true;
153 }
154 
operator <<(std::ostream & os,const SocketAddress & addr)155 std::ostream& operator<<(std::ostream& os, const SocketAddress& addr) {
156   os << addr.IPAsString() << ":" << addr.port();
157   return os;
158 }
159 
IsAnyIP() const160 bool SocketAddress::IsAnyIP() const {
161   return (ip_ == 0);
162 }
163 
IsLoopbackIP() const164 bool SocketAddress::IsLoopbackIP() const {
165   if (0 == ip_) {
166     return (0 == stricmp(hostname_.c_str(), "localhost"));
167   } else {
168     return ((ip_ >> 24) == 127);
169   }
170 }
171 
IsLocalIP() const172 bool SocketAddress::IsLocalIP() const {
173   if (IsLoopbackIP())
174     return true;
175 
176   std::vector<uint32> ips;
177   if (0 == ip_) {
178     if (!hostname_.empty()
179         && (0 == stricmp(hostname_.c_str(), GetHostname().c_str()))) {
180       return true;
181     }
182   } else if (GetLocalIPs(ips)) {
183     for (size_t i = 0; i < ips.size(); ++i) {
184       if (ips[i] == ip_) {
185         return true;
186       }
187     }
188   }
189   return false;
190 }
191 
IsPrivateIP() const192 bool SocketAddress::IsPrivateIP() const {
193   return ((ip_ >> 24) == 127) ||
194          ((ip_ >> 24) == 10) ||
195          ((ip_ >> 20) == ((172 << 4) | 1)) ||
196          ((ip_ >> 16) == ((192 << 8) | 168)) ||
197          ((ip_ >> 16) == ((169 << 8) | 254));
198 }
199 
IsUnresolvedIP() const200 bool SocketAddress::IsUnresolvedIP() const {
201   return IsAny() && !hostname_.empty();
202 }
203 
ResolveIP(bool force,int * error)204 bool SocketAddress::ResolveIP(bool force, int* error) {
205   if (hostname_.empty()) {
206     // nothing to resolve
207   } else if (!force && !IsAny()) {
208     // already resolved
209   } else {
210     LOG_F(LS_VERBOSE) << "(" << hostname_ << ")";
211     int errcode = 0;
212     if (hostent* pHost = SafeGetHostByName(hostname_.c_str(), &errcode)) {
213       ip_ = NetworkToHost32(*reinterpret_cast<uint32*>(pHost->h_addr_list[0]));
214       LOG_F(LS_VERBOSE) << "(" << hostname_ << ") resolved to: "
215                         << IPToString(ip_);
216       FreeHostEnt(pHost);
217     } else {
218       LOG_F(LS_ERROR) << "(" << hostname_ << ") err: " << errcode;
219     }
220     if (error) {
221       *error = errcode;
222     }
223   }
224   return (ip_ != 0);
225 }
226 
operator ==(const SocketAddress & addr) const227 bool SocketAddress::operator==(const SocketAddress& addr) const {
228   return EqualIPs(addr) && EqualPorts(addr);
229 }
230 
operator <(const SocketAddress & addr) const231 bool SocketAddress::operator<(const SocketAddress& addr) const {
232   if (ip_ < addr.ip_)
233     return true;
234   else if (addr.ip_ < ip_)
235     return false;
236 
237   // We only check hostnames if both IPs are zero.  This matches EqualIPs()
238   if (addr.ip_ == 0) {
239     if (hostname_ < addr.hostname_)
240       return true;
241     else if (addr.hostname_ < hostname_)
242       return false;
243   }
244 
245   return port_ < addr.port_;
246 }
247 
EqualIPs(const SocketAddress & addr) const248 bool SocketAddress::EqualIPs(const SocketAddress& addr) const {
249   return (ip_ == addr.ip_) && ((ip_ != 0) || (hostname_ == addr.hostname_));
250 }
251 
EqualPorts(const SocketAddress & addr) const252 bool SocketAddress::EqualPorts(const SocketAddress& addr) const {
253   return (port_ == addr.port_);
254 }
255 
Hash() const256 size_t SocketAddress::Hash() const {
257   size_t h = 0;
258   h ^= ip_;
259   h ^= port_ | (port_ << 16);
260   return h;
261 }
262 
Size_() const263 size_t SocketAddress::Size_() const {
264   return sizeof(ip_) + sizeof(port_) + 2;
265 }
266 
Write_(char * buf,int len) const267 bool SocketAddress::Write_(char* buf, int len) const {
268   if (len < static_cast<int>(Size_()))
269     return false;
270   buf[0] = 0;
271   buf[1] = AF_INET;
272   SetBE16(buf + 2, port_);
273   SetBE32(buf + 4, ip_);
274   return true;
275 }
276 
Read_(const char * buf,int len)277 bool SocketAddress::Read_(const char* buf, int len) {
278   if (len < static_cast<int>(Size_()) || buf[1] != AF_INET)
279     return false;
280   port_ = GetBE16(buf + 2);
281   ip_ = GetBE32(buf + 4);
282   return true;
283 }
284 
ToSockAddr(sockaddr_in * saddr) const285 void SocketAddress::ToSockAddr(sockaddr_in* saddr) const {
286   memset(saddr, 0, sizeof(*saddr));
287   saddr->sin_family = AF_INET;
288   saddr->sin_port = HostToNetwork16(port_);
289   if (0 == ip_) {
290     saddr->sin_addr.s_addr = INADDR_ANY;
291   } else {
292     saddr->sin_addr.s_addr = HostToNetwork32(ip_);
293   }
294 }
295 
FromSockAddr(const sockaddr_in & saddr)296 bool SocketAddress::FromSockAddr(const sockaddr_in& saddr) {
297   if (saddr.sin_family != AF_INET)
298     return false;
299   SetIP(NetworkToHost32(saddr.sin_addr.s_addr));
300   SetPort(NetworkToHost16(saddr.sin_port));
301   return true;
302 }
303 
IPToString(uint32 ip)304 std::string SocketAddress::IPToString(uint32 ip) {
305   std::ostringstream ost;
306   ost << ((ip >> 24) & 0xff);
307   ost << '.';
308   ost << ((ip >> 16) & 0xff);
309   ost << '.';
310   ost << ((ip >> 8) & 0xff);
311   ost << '.';
312   ost << ((ip >> 0) & 0xff);
313   return ost.str();
314 }
315 
StringToIP(const std::string & hostname,uint32 * ip)316 bool SocketAddress::StringToIP(const std::string& hostname, uint32* ip) {
317   in_addr addr;
318   if (inet_aton(hostname.c_str(), &addr) == 0)
319     return false;
320   *ip = NetworkToHost32(addr.s_addr);
321   return true;
322 }
323 
StringToIP(const std::string & hostname)324 uint32 SocketAddress::StringToIP(const std::string& hostname) {
325   uint32 ip = 0;
326   StringToIP(hostname, &ip);
327   return ip;
328 }
329 
GetHostname()330 std::string SocketAddress::GetHostname() {
331   char hostname[256];
332   if (gethostname(hostname, ARRAY_SIZE(hostname)) == 0)
333     return hostname;
334   return "";
335 }
336 
GetLocalIPs(std::vector<uint32> & ips)337 bool SocketAddress::GetLocalIPs(std::vector<uint32>& ips) {
338   ips.clear();
339 
340   const std::string hostname = GetHostname();
341   if (hostname.empty())
342     return false;
343 
344   int errcode;
345   if (hostent* pHost = SafeGetHostByName(hostname.c_str(), &errcode)) {
346     for (size_t i = 0; pHost->h_addr_list[i]; ++i) {
347       uint32 ip =
348         NetworkToHost32(*reinterpret_cast<uint32 *>(pHost->h_addr_list[i]));
349       ips.push_back(ip);
350     }
351     FreeHostEnt(pHost);
352     return !ips.empty();
353   }
354   LOG(LS_ERROR) << "gethostbyname err: " << errcode;
355   return false;
356 }
357 
358 }  // namespace talk_base
359