← Back to branch summary

~ubuntu-branches/debian/experimental/kopete/experimental

« back to all changes in this revision

Viewing changes to protocols/jabber/googletalk/libjingle/talk/base/socketaddress.cc

  • Committer: Package Import Robot
  • Author(s): Maximiliano Curia
  • Date: 2015-02-24 11:32:57 UTC
  • mfrom: (1.1.41 vivid)
  • Revision ID: package-import@ubuntu.com-20150224113257-gnupg4v7lzz18ij0
Tags: 4:14.12.2-1
* New upstream release (14.12.2).
* Bump Standards-Version to 3.9.6, no changes needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
protocols/jabber/googletalk/libjingle/talk/base/socketaddress.cc
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
 
#include "talk/base/socketaddress.h"
29
 
 
30
 
#ifdef POSIX
31
 
#include <sys/types.h>
32
 
#include <sys/socket.h>
33
 
#include <netinet/in.h>
34
 
#if defined(OPENBSD)
35
 
#include <netinet/in_systm.h>
36
 
#endif
37
 
#include <netinet/ip.h>
38
 
#include <arpa/inet.h>
39
 
#include <netdb.h>
40
 
#include <unistd.h>
41
 
#endif
42
 
 
43
 
#include <sstream>
44
 
 
45
 
#include "talk/base/byteorder.h"
46
 
#include "talk/base/common.h"
47
 
#include "talk/base/logging.h"
48
 
#include "talk/base/nethelpers.h"
49
 
 
50
 
#ifdef WIN32
51
 
#include "talk/base/win32.h"
52
 
#endif
53
 
 
54
 
namespace talk_base {
55
 
 
56
 
// Address family constants for STUN (see RFC 5389).
57
 
static const int kStunFamilyIPv4 = 1;
58
 
static const int kStunFamilyIPv6 = 2;
59
 
 
60
 
SocketAddress::SocketAddress() {
61
 
  Clear();
62
 
}
63
 
 
64
 
SocketAddress::SocketAddress(const std::string& hostname, int port) {
65
 
  SetIP(hostname);
66
 
  SetPort(port);
67
 
}
68
 
 
69
 
SocketAddress::SocketAddress(uint32 ip_as_host_order_integer, int port) {
70
 
  SetIP(IPAddress(ip_as_host_order_integer));
71
 
  SetPort(port);
72
 
}
73
 
 
74
 
SocketAddress::SocketAddress(const IPAddress& ip, int port) {
75
 
  SetIP(ip);
76
 
  SetPort(port);
77
 
}
78
 
 
79
 
SocketAddress::SocketAddress(const SocketAddress& addr) {
80
 
  this->operator=(addr);
81
 
}
82
 
 
83
 
void SocketAddress::Clear() {
84
 
  hostname_.clear();
85
 
  literal_ = false;
86
 
  ip_ = IPAddress(INADDR_ANY);
87
 
  port_ = 0;
88
 
}
89
 
 
90
 
bool SocketAddress::IsNil() const {
91
 
  return hostname_.empty() && IPIsAny(ip_) && 0 == port_;
92
 
}
93
 
 
94
 
bool SocketAddress::IsComplete() const {
95
 
  return (!IPIsAny(ip_)) && (0 != port_);
96
 
}
97
 
 
98
 
SocketAddress& SocketAddress::operator=(const SocketAddress& addr) {
99
 
  hostname_ = addr.hostname_;
100
 
  ip_ = addr.ip_;
101
 
  port_ = addr.port_;
102
 
  literal_ = addr.literal_;
103
 
  return *this;
104
 
}
105
 
 
106
 
void SocketAddress::SetIP(uint32 ip_as_host_order_integer) {
107
 
  hostname_.clear();
108
 
  literal_ = false;
109
 
  ip_ = IPAddress(ip_as_host_order_integer);
110
 
}
111
 
 
112
 
void SocketAddress::SetIP(const IPAddress& ip) {
113
 
  hostname_.clear();
114
 
  literal_ = false;
115
 
  ip_ = ip;
116
 
}
117
 
 
118
 
void SocketAddress::SetIP(const std::string& hostname) {
119
 
  hostname_ = hostname;
120
 
  literal_ = IPFromString(hostname, &ip_);
121
 
  if (!literal_) {
122
 
    ip_ = IPAddress(INADDR_ANY);
123
 
  }
124
 
}
125
 
 
126
 
void SocketAddress::SetResolvedIP(uint32 ip_as_host_order_integer) {
127
 
  ip_ = IPAddress(ip_as_host_order_integer);
128
 
}
129
 
 
130
 
void SocketAddress::SetResolvedIP(const IPAddress& ip) {
131
 
  ip_ = ip;
132
 
}
133
 
 
134
 
void SocketAddress::SetPort(int port) {
135
 
  ASSERT((0 <= port) && (port < 65536));
136
 
  port_ = port;
137
 
}
138
 
 
139
 
uint32 SocketAddress::ip() const {
140
 
  return ip_.v4AddressAsHostOrderInteger();
141
 
}
142
 
 
143
 
const IPAddress& SocketAddress::ipaddr() const {
144
 
  return ip_;
145
 
}
146
 
 
147
 
uint16 SocketAddress::port() const {
148
 
  return port_;
149
 
}
150
 
 
151
 
std::string SocketAddress::IPAsString() 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_.ToString() + "]";
158
 
  } else {
159
 
    return ip_.ToString();
160
 
  }
161
 
}
162
 
 
163
 
std::string SocketAddress::PortAsString() const {
164
 
  std::ostringstream ost;
165
 
  ost << port_;
166
 
  return ost.str();
167
 
}
168
 
 
169
 
std::string SocketAddress::ToString() const {
170
 
  std::ostringstream ost;
171
 
  ost << IPAsString();
172
 
  ost << ":";
173
 
  ost << port();
174
 
  return ost.str();
175
 
}
176
 
 
177
 
bool SocketAddress::FromString(const std::string& str) {
178
 
  if (str.at(0) == '[') {
179
 
    std::string::size_type closebracket = str.rfind(']');
180
 
    if (closebracket != std::string::npos) {
181
 
      std::string::size_type colon = str.find(':', closebracket);
182
 
      if (colon != std::string::npos && colon > closebracket) {
183
 
        SetPort(strtoul(str.substr(colon + 1).c_str(), NULL, 10));
184
 
        SetIP(str.substr(1, closebracket - 1));
185
 
      } else {
186
 
        return false;
187
 
      }
188
 
    }
189
 
  } else {
190
 
    std::string::size_type pos = str.find(':');
191
 
    if (std::string::npos == pos)
192
 
      return false;
193
 
    SetPort(strtoul(str.substr(pos + 1).c_str(), NULL, 10));
194
 
    SetIP(str.substr(0, pos));
195
 
  }
196
 
  return true;
197
 
}
198
 
 
199
 
std::ostream& operator<<(std::ostream& os, const SocketAddress& addr) {
200
 
  os << addr.IPAsString() << ":" << addr.port();
201
 
  return os;
202
 
}
203
 
 
204
 
bool SocketAddress::IsAnyIP() const {
205
 
  return IPIsAny(ip_);
206
 
}
207
 
 
208
 
bool SocketAddress::IsLoopbackIP() const {
209
 
  return IPIsLoopback(ip_) || (IPIsAny(ip_) &&
210
 
                               0 == strcmp(hostname_.c_str(), "localhost"));
211
 
}
212
 
 
213
 
bool SocketAddress::IsLocalIP() const {
214
 
  if (IsLoopbackIP())
215
 
    return true;
216
 
 
217
 
  std::vector<IPAddress> ips;
218
 
  if (IPIsAny(ip_)) {
219
 
    if (!hostname_.empty()
220
 
        && (0 == stricmp(hostname_.c_str(), GetHostname().c_str()))) {
221
 
      return true;
222
 
    }
223
 
  } else if (GetLocalIPs(&ips)) {
224
 
    for (size_t i = 0; i < ips.size(); ++i) {
225
 
      if (ips[i] == ip_) {
226
 
        return true;
227
 
      }
228
 
    }
229
 
  }
230
 
  return false;
231
 
}
232
 
 
233
 
bool SocketAddress::IsPrivateIP() const {
234
 
  return IPIsPrivate(ip_);
235
 
}
236
 
 
237
 
bool SocketAddress::IsUnresolvedIP() const {
238
 
  return IsAny() && !literal_ && !hostname_.empty();
239
 
}
240
 
 
241
 
bool SocketAddress::ResolveIP(bool force, int* error) {
242
 
  if (hostname_.empty()) {
243
 
    // nothing to resolve
244
 
  } else if (!force && !IsAny()) {
245
 
    // already resolved
246
 
  } else {
247
 
    LOG_F(LS_VERBOSE) << "(" << hostname_ << ")";
248
 
    int errcode = 0;
249
 
    if (hostent* pHost = SafeGetHostByName(hostname_.c_str(), &errcode)) {
250
 
      if (IPFromHostEnt(pHost, &ip_)) {
251
 
        LOG_F(LS_VERBOSE) << "(" << hostname_ << ") resolved to: "
252
 
                          << ip_.ToString();
253
 
      }
254
 
      FreeHostEnt(pHost);
255
 
    } else {
256
 
      LOG_F(LS_ERROR) << "(" << hostname_ << ") err: " << errcode;
257
 
    }
258
 
    if (error) {
259
 
      *error = errcode;
260
 
    }
261
 
  }
262
 
  return (!IPIsAny(ip_));
263
 
}
264
 
 
265
 
bool SocketAddress::operator==(const SocketAddress& addr) const {
266
 
  return EqualIPs(addr) && EqualPorts(addr);
267
 
}
268
 
 
269
 
bool SocketAddress::operator<(const SocketAddress& addr) const {
270
 
  if (ip_ < addr.ip_)
271
 
    return true;
272
 
  else if (addr.ip_ < ip_)
273
 
    return false;
274
 
 
275
 
  // We only check hostnames if both IPs are zero.  This matches EqualIPs()
276
 
  if (addr.IsAnyIP()) {
277
 
    if (hostname_ < addr.hostname_)
278
 
      return true;
279
 
    else if (addr.hostname_ < hostname_)
280
 
      return false;
281
 
  }
282
 
 
283
 
  return port_ < addr.port_;
284
 
}
285
 
 
286
 
bool SocketAddress::EqualIPs(const SocketAddress& addr) const {
287
 
  return (ip_ == addr.ip_) &&
288
 
      ((!IPIsAny(ip_)) || (hostname_ == addr.hostname_));
289
 
}
290
 
 
291
 
bool SocketAddress::EqualPorts(const SocketAddress& addr) const {
292
 
  return (port_ == addr.port_);
293
 
}
294
 
 
295
 
size_t SocketAddress::Hash() const {
296
 
  size_t h = 0;
297
 
  h ^= HashIP(ip_);
298
 
  h ^= port_ | (port_ << 16);
299
 
  return h;
300
 
}
301
 
 
302
 
void SocketAddress::ToSockAddr(sockaddr_in* saddr) const {
303
 
  memset(saddr, 0, sizeof(*saddr));
304
 
  if (ip_.family() != AF_INET) {
305
 
    saddr->sin_family = AF_UNSPEC;
306
 
    return;
307
 
  }
308
 
  saddr->sin_family = AF_INET;
309
 
  saddr->sin_port = HostToNetwork16(port_);
310
 
  if (IPIsAny(ip_)) {
311
 
    saddr->sin_addr.s_addr = INADDR_ANY;
312
 
  } else {
313
 
    saddr->sin_addr = ip_.ipv4_address();
314
 
  }
315
 
}
316
 
 
317
 
bool SocketAddress::FromSockAddr(const sockaddr_in& saddr) {
318
 
  if (saddr.sin_family != AF_INET)
319
 
    return false;
320
 
  SetIP(NetworkToHost32(saddr.sin_addr.s_addr));
321
 
  SetPort(NetworkToHost16(saddr.sin_port));
322
 
  literal_ = false;
323
 
  return true;
324
 
}
325
 
 
326
 
static size_t ToSockAddrStorageHelper(sockaddr_storage* addr,
327
 
                                      IPAddress ip, int port, int scope_id) {
328
 
  memset(addr, 0, sizeof(sockaddr_storage));
329
 
  addr->ss_family = ip.family();
330
 
  if (addr->ss_family == AF_INET6) {
331
 
    sockaddr_in6* saddr = reinterpret_cast<sockaddr_in6*>(addr);
332
 
    saddr->sin6_addr = ip.ipv6_address();
333
 
    saddr->sin6_port = HostToNetwork16(port);
334
 
    saddr->sin6_scope_id = scope_id;
335
 
    return sizeof(sockaddr_in6);
336
 
  } else if (addr->ss_family == AF_INET) {
337
 
    sockaddr_in* saddr = reinterpret_cast<sockaddr_in*>(addr);
338
 
    saddr->sin_addr = ip.ipv4_address();
339
 
    saddr->sin_port = HostToNetwork16(port);
340
 
    return sizeof(sockaddr_in);
341
 
  }
342
 
  return 0;
343
 
}
344
 
 
345
 
size_t SocketAddress::ToDualStackSockAddrStorage(sockaddr_storage *addr) const {
346
 
  return ToSockAddrStorageHelper(addr, ip_.AsIPv6Address(), port_, scope_id_);
347
 
}
348
 
 
349
 
size_t SocketAddress::ToSockAddrStorage(sockaddr_storage* addr) const {
350
 
  return ToSockAddrStorageHelper(addr, ip_, port_, scope_id_);
351
 
}
352
 
 
353
 
std::string SocketAddress::IPToString(uint32 ip_as_host_order_integer) {
354
 
  std::ostringstream ost;
355
 
  ost << ((ip_as_host_order_integer >> 24) & 0xff);
356
 
  ost << '.';
357
 
  ost << ((ip_as_host_order_integer >> 16) & 0xff);
358
 
  ost << '.';
359
 
  ost << ((ip_as_host_order_integer >> 8) & 0xff);
360
 
  ost << '.';
361
 
  ost << ((ip_as_host_order_integer >> 0) & 0xff);
362
 
  return ost.str();
363
 
}
364
 
 
365
 
bool SocketAddress::StringToIP(const std::string& hostname, uint32* ip) {
366
 
  in_addr addr;
367
 
  if (talk_base::inet_pton(AF_INET, hostname.c_str(), &addr) == 0)
368
 
    return false;
369
 
  *ip = NetworkToHost32(addr.s_addr);
370
 
  return true;
371
 
}
372
 
 
373
 
bool SocketAddress::StringToIP(const std::string& hostname, IPAddress* ip) {
374
 
  in_addr addr4;
375
 
  if (talk_base::inet_pton(AF_INET, hostname.c_str(), &addr4) > 0) {
376
 
    if (ip) {
377
 
      *ip = IPAddress(addr4);
378
 
    }
379
 
    return true;
380
 
  }
381
 
 
382
 
  in6_addr addr6;
383
 
  if (talk_base::inet_pton(AF_INET6, hostname.c_str(), &addr6) > 0) {
384
 
    if (ip) {
385
 
      *ip = IPAddress(addr6);
386
 
    }
387
 
    return true;
388
 
  }
389
 
  return false;
390
 
}
391
 
 
392
 
uint32 SocketAddress::StringToIP(const std::string& hostname) {
393
 
  uint32 ip = 0;
394
 
  StringToIP(hostname, &ip);
395
 
  return ip;
396
 
}
397
 
 
398
 
std::string SocketAddress::GetHostname() {
399
 
  char hostname[256];
400
 
  if (gethostname(hostname, ARRAY_SIZE(hostname)) == 0)
401
 
    return hostname;
402
 
  return "";
403
 
}
404
 
 
405
 
bool SocketAddress::GetLocalIPs(std::vector<IPAddress>* ips) {
406
 
  if (!ips) {
407
 
    return false;
408
 
  }
409
 
  ips->clear();
410
 
 
411
 
  const std::string hostname = SocketAddress::GetHostname();
412
 
  if (hostname.empty())
413
 
    return false;
414
 
 
415
 
  int errcode;
416
 
  if (hostent* pHost = SafeGetHostByName(hostname.c_str(), &errcode)) {
417
 
    for (int i = 0; pHost->h_addr_list[i]; ++i) {
418
 
      IPAddress ip;
419
 
      if (IPFromHostEnt(pHost, i, &ip)) {
420
 
        ips->push_back(ip);
421
 
      }
422
 
    }
423
 
    FreeHostEnt(pHost);
424
 
    return !ips->empty();
425
 
  }
426
 
  LOG(LS_ERROR) << "gethostbyname err: " << errcode;
427
 
  return false;
428
 
}
429
 
 
430
 
bool SocketAddressFromSockAddrStorage(const sockaddr_storage& addr,
431
 
                                      SocketAddress* out) {
432
 
  if (!out) {
433
 
    return false;
434
 
  }
435
 
  if (addr.ss_family == AF_INET) {
436
 
    const sockaddr_in* saddr = reinterpret_cast<const sockaddr_in*>(&addr);
437
 
    *out = SocketAddress(IPAddress(saddr->sin_addr),
438
 
                         NetworkToHost16(saddr->sin_port));
439
 
    return true;
440
 
  } else if (addr.ss_family == AF_INET6) {
441
 
    const sockaddr_in6* saddr = reinterpret_cast<const sockaddr_in6*>(&addr);
442
 
    *out = SocketAddress(IPAddress(saddr->sin6_addr),
443
 
                         NetworkToHost16(saddr->sin6_port));
444
 
    out->SetScopeID(saddr->sin6_scope_id);
445
 
    return true;
446
 
  }
447
 
  return false;
448
 
}
449
 
}  // namespace talk_base