← 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/p2p/client/connectivitychecker.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/p2p/client/connectivitychecker.cc
1
 
// Copyright 2011 Google Inc. All Rights Reserved.
2
 
 
3
 
 
4
 
#include <string>
5
 
 
6
 
#include "talk/p2p/client/connectivitychecker.h"
7
 
 
8
 
#include "talk/base/asynchttprequest.h"
9
 
#include "talk/base/autodetectproxy.h"
10
 
#include "talk/base/basicpacketsocketfactory.h"
11
 
#include "talk/base/helpers.h"
12
 
#include "talk/base/httpcommon.h"
13
 
#include "talk/base/httpcommon-inl.h"
14
 
#include "talk/base/logging.h"
15
 
#include "talk/base/proxydetect.h"
16
 
#include "talk/base/thread.h"
17
 
#include "talk/p2p/base/candidate.h"
18
 
#include "talk/p2p/base/common.h"
19
 
#include "talk/p2p/base/port.h"
20
 
#include "talk/p2p/base/relayport.h"
21
 
#include "talk/p2p/base/stunport.h"
22
 
 
23
 
namespace cricket {
24
 
 
25
 
static const char kSessionTypeVideo[] =
26
 
    "http://www.google.com/session/video";
27
 
static const char kSessionNameRtp[] = "rtp";
28
 
 
29
 
static const char kDefaultStunHostname[] = "stun.l.google.com";
30
 
static const int kDefaultStunPort = 19302;
31
 
 
32
 
// Default maximum time in milliseconds we will wait for connections.
33
 
static const uint32 kDefaultTimeoutMs = 3000;
34
 
 
35
 
enum {
36
 
  MSG_START = 1,
37
 
  MSG_STOP = 2,
38
 
  MSG_TIMEOUT = 3,
39
 
  MSG_SIGNAL_RESULTS = 4
40
 
};
41
 
 
42
 
class TestHttpPortAllocator : public HttpPortAllocator {
43
 
 public:
44
 
  TestHttpPortAllocator(talk_base::NetworkManager* network_manager,
45
 
                        const std::string& user_agent,
46
 
                        const std::string& relay_token) :
47
 
      HttpPortAllocator(network_manager, user_agent) {
48
 
    SetRelayToken(relay_token);
49
 
  }
50
 
  PortAllocatorSession* CreateSession(
51
 
      const std::string& name, const std::string& session_type) {
52
 
    return new TestHttpPortAllocatorSession(this, name, session_type,
53
 
                                            stun_hosts(), relay_hosts(),
54
 
                                            relay_token(), user_agent());
55
 
  }
56
 
};
57
 
 
58
 
void TestHttpPortAllocatorSession::ConfigReady(PortConfiguration* config) {
59
 
  SignalConfigReady(config, proxy_);
60
 
}
61
 
 
62
 
void TestHttpPortAllocatorSession::OnRequestDone(
63
 
    talk_base::SignalThread* data) {
64
 
  talk_base::AsyncHttpRequest* request =
65
 
      static_cast<talk_base::AsyncHttpRequest*>(data);
66
 
 
67
 
  // Tell the checker that the request is complete.
68
 
  SignalRequestDone(request);
69
 
 
70
 
  // Pass on the response to super class.
71
 
  HttpPortAllocatorSession::OnRequestDone(data);
72
 
}
73
 
 
74
 
ConnectivityChecker::ConnectivityChecker(
75
 
    talk_base::Thread* worker,
76
 
    const std::string& jid,
77
 
    const std::string& session_id,
78
 
    const std::string& user_agent,
79
 
    const std::string& relay_token,
80
 
    const std::string& connection)
81
 
    : worker_(worker),
82
 
      jid_(jid),
83
 
      session_id_(session_id),
84
 
      user_agent_(user_agent),
85
 
      relay_token_(relay_token),
86
 
      connection_(connection),
87
 
      proxy_detect_(NULL),
88
 
      timeout_ms_(kDefaultTimeoutMs),
89
 
      stun_address_(kDefaultStunHostname, kDefaultStunPort) {
90
 
}
91
 
 
92
 
ConnectivityChecker::~ConnectivityChecker() {
93
 
  Stop();
94
 
  nics_.clear();
95
 
}
96
 
 
97
 
bool ConnectivityChecker::Initialize() {
98
 
  network_manager_.reset(CreateNetworkManager());
99
 
  socket_factory_.reset(CreateSocketFactory(worker_));
100
 
  port_allocator_.reset(CreatePortAllocator(network_manager_.get(),
101
 
                                            user_agent_, relay_token_));
102
 
  return true;
103
 
}
104
 
 
105
 
void ConnectivityChecker::Start() {
106
 
  main_ = talk_base::Thread::Current();
107
 
  worker_->Post(this, MSG_START);
108
 
}
109
 
 
110
 
void ConnectivityChecker::Stop() {
111
 
  worker_->Post(this, MSG_STOP);
112
 
}
113
 
 
114
 
void ConnectivityChecker::CleanUp() {
115
 
  ASSERT(worker_ == talk_base::Thread::Current());
116
 
  worker_->Clear(this, MSG_TIMEOUT);
117
 
  if (proxy_detect_) {
118
 
    proxy_detect_->Release();
119
 
    proxy_detect_ = NULL;
120
 
  }
121
 
 
122
 
  for (uint32 i = 0; i < sessions_.size(); ++i) {
123
 
    delete sessions_[i];
124
 
  }
125
 
  sessions_.clear();
126
 
  for (uint32 i = 0; i < ports_.size(); ++i) {
127
 
    delete ports_[i];
128
 
  }
129
 
  ports_.clear();
130
 
}
131
 
 
132
 
bool ConnectivityChecker::AddNic(const talk_base::IPAddress& ip,
133
 
                                 const talk_base::SocketAddress& proxy_addr) {
134
 
  NicMap::iterator i = nics_.find(NicId(ip, proxy_addr));
135
 
  if (i != nics_.end()) {
136
 
    // Already have it.
137
 
    return false;
138
 
  }
139
 
  uint32 now = talk_base::Time();
140
 
  NicInfo info;
141
 
  info.ip = ip;
142
 
  info.proxy_info = GetProxyInfo();
143
 
  info.stun.start_time_ms = now;
144
 
  nics_.insert(std::pair<NicId, NicInfo>(NicId(ip, proxy_addr), info));
145
 
  return true;
146
 
}
147
 
 
148
 
void ConnectivityChecker::SetProxyInfo(const talk_base::ProxyInfo& proxy_info) {
149
 
  port_allocator_->set_proxy(user_agent_, proxy_info);
150
 
  AllocatePorts();
151
 
}
152
 
 
153
 
talk_base::ProxyInfo ConnectivityChecker::GetProxyInfo() const {
154
 
  talk_base::ProxyInfo proxy_info;
155
 
  if (proxy_detect_) {
156
 
    proxy_info = proxy_detect_->proxy();
157
 
  }
158
 
  return proxy_info;
159
 
}
160
 
 
161
 
void ConnectivityChecker::CheckNetworks() {
162
 
  network_manager_->SignalNetworksChanged.connect(
163
 
      this, &ConnectivityChecker::OnNetworksChanged);
164
 
  network_manager_->StartUpdating();
165
 
}
166
 
 
167
 
void ConnectivityChecker::OnMessage(talk_base::Message *msg) {
168
 
  switch (msg->message_id) {
169
 
    case MSG_START:
170
 
      ASSERT(worker_ == talk_base::Thread::Current());
171
 
      worker_->PostDelayed(timeout_ms_, this, MSG_TIMEOUT);
172
 
      CheckNetworks();
173
 
      break;
174
 
    case MSG_STOP:
175
 
      // We were stopped, just close down without signaling.
176
 
      OnCheckDone(false);
177
 
      break;
178
 
    case MSG_TIMEOUT:
179
 
      // Close down and signal results.
180
 
      OnCheckDone(true);
181
 
      break;
182
 
    case MSG_SIGNAL_RESULTS:
183
 
      ASSERT(main_ == talk_base::Thread::Current());
184
 
      SignalCheckDone(this);
185
 
      break;
186
 
    default:
187
 
      LOG(LS_ERROR) << "Unknown message: " << msg->message_id;
188
 
  }
189
 
}
190
 
 
191
 
void ConnectivityChecker::OnCheckDone(bool signal_results) {
192
 
  // Clean up memory allocated by the worker thread.
193
 
  CleanUp();
194
 
 
195
 
  if (signal_results) {
196
 
    main_->Post(this, MSG_SIGNAL_RESULTS);
197
 
  }
198
 
}
199
 
 
200
 
void ConnectivityChecker::OnProxyDetect(talk_base::SignalThread* thread) {
201
 
  ASSERT(worker_ == talk_base::Thread::Current());
202
 
  if (proxy_detect_->proxy().type != talk_base::PROXY_NONE) {
203
 
    SetProxyInfo(proxy_detect_->proxy());
204
 
  }
205
 
}
206
 
 
207
 
void ConnectivityChecker::OnRequestDone(talk_base::AsyncHttpRequest* request) {
208
 
  ASSERT(worker_ == talk_base::Thread::Current());
209
 
  // Since we don't know what nic were actually used for the http request,
210
 
  // for now, just use the first one.
211
 
  std::vector<talk_base::Network*> networks;
212
 
  network_manager_->GetNetworks(&networks);
213
 
  if (networks.empty()) {
214
 
    LOG(LS_ERROR) << "No networks while registering http start.";
215
 
    return;
216
 
  }
217
 
  talk_base::ProxyInfo proxy_info = request->proxy();
218
 
  NicMap::iterator i = nics_.find(NicId(networks[0]->ip(), proxy_info.address));
219
 
  if (i != nics_.end()) {
220
 
    int port = request->port();
221
 
    uint32 now = talk_base::Time();
222
 
    NicInfo* nic_info = &i->second;
223
 
    if (port == talk_base::HTTP_DEFAULT_PORT) {
224
 
      nic_info->http.rtt = now - nic_info->http.start_time_ms;
225
 
    } else if (port == talk_base::HTTP_SECURE_PORT) {
226
 
      nic_info->https.rtt = now - nic_info->https.start_time_ms;
227
 
    } else {
228
 
      LOG(LS_ERROR) << "Got response with unknown port: " << port;
229
 
    }
230
 
  } else {
231
 
    LOG(LS_ERROR) << "No nic info found while receiving response.";
232
 
  }
233
 
}
234
 
 
235
 
void ConnectivityChecker::OnConfigReady(
236
 
    const PortConfiguration* config,
237
 
    const talk_base::ProxyInfo& proxy_info) {
238
 
  ASSERT(worker_ == talk_base::Thread::Current());
239
 
 
240
 
  // Since we send requests on both HTTP and HTTPS we will get two
241
 
  // configs per nic. Results from the second will overwrite the
242
 
  // result from the first.
243
 
  // TODO: Handle multiple pings on one nic.
244
 
  CreateRelayPorts(config, proxy_info);
245
 
}
246
 
 
247
 
void ConnectivityChecker::OnRelayAddressReady(Port* port) {
248
 
  ASSERT(worker_ == talk_base::Thread::Current());
249
 
  RelayPort* relay_port = reinterpret_cast<RelayPort*>(port);
250
 
  const ProtocolAddress* address = relay_port->ServerAddress(0);
251
 
  talk_base::IPAddress ip = port->network()->ip();
252
 
  NicMap::iterator i = nics_.find(NicId(ip, port->proxy().address));
253
 
  if (i != nics_.end()) {
254
 
    // We have it already, add the new information.
255
 
    NicInfo* nic_info = &i->second;
256
 
    ConnectInfo* connect_info = NULL;
257
 
    if (address) {
258
 
      switch (address->proto) {
259
 
        case PROTO_UDP:
260
 
          connect_info = &nic_info->udp;
261
 
          break;
262
 
        case PROTO_TCP:
263
 
          connect_info = &nic_info->tcp;
264
 
          break;
265
 
        case PROTO_SSLTCP:
266
 
          connect_info = &nic_info->ssltcp;
267
 
          break;
268
 
        default:
269
 
          LOG(LS_ERROR) << " relay address with bad protocol added";
270
 
      }
271
 
      if (connect_info) {
272
 
        connect_info->rtt =
273
 
            talk_base::TimeSince(connect_info->start_time_ms);
274
 
      }
275
 
    }
276
 
  } else {
277
 
    LOG(LS_ERROR) << " got relay address for non-existing nic";
278
 
  }
279
 
}
280
 
 
281
 
void ConnectivityChecker::OnStunAddressReady(Port* port) {
282
 
  ASSERT(worker_ == talk_base::Thread::Current());
283
 
  const std::vector<Candidate> candidates = port->candidates();
284
 
  Candidate c = candidates[0];
285
 
  talk_base::IPAddress ip = port->network()->ip();
286
 
  NicMap::iterator i = nics_.find(NicId(ip, port->proxy().address));
287
 
  if (i != nics_.end()) {
288
 
    // We have it already, add the new information.
289
 
    uint32 now = talk_base::Time();
290
 
    NicInfo* nic_info = &i->second;
291
 
    nic_info->external_address = c.address();
292
 
    nic_info->stun_server_address = static_cast<StunPort*>(port)->server_addr();
293
 
    nic_info->stun.rtt = now - nic_info->stun.start_time_ms;
294
 
  } else {
295
 
    LOG(LS_ERROR) << "Got stun address for non-existing nic";
296
 
  }
297
 
}
298
 
 
299
 
void ConnectivityChecker::OnStunAddressError(Port* port) {
300
 
  ASSERT(worker_ == talk_base::Thread::Current());
301
 
  LOG(LS_ERROR) << "Stun address error.";
302
 
  talk_base::IPAddress ip = port->network()->ip();
303
 
  NicMap::iterator i = nics_.find(NicId(ip, port->proxy().address));
304
 
  if (i != nics_.end()) {
305
 
    // We have it already, add the new information.
306
 
    NicInfo* nic_info = &i->second;
307
 
    nic_info->stun_server_address = static_cast<StunPort*>(port)->server_addr();
308
 
  }
309
 
}
310
 
 
311
 
void ConnectivityChecker::OnRelayAddressError(Port* port) {
312
 
  ASSERT(worker_ == talk_base::Thread::Current());
313
 
  LOG(LS_ERROR) << "Relay address error.";
314
 
}
315
 
 
316
 
void ConnectivityChecker::OnNetworksChanged() {
317
 
  ASSERT(worker_ == talk_base::Thread::Current());
318
 
  std::vector<talk_base::Network*> networks;
319
 
  network_manager_->GetNetworks(&networks);
320
 
  if (networks.empty()) {
321
 
    LOG(LS_ERROR) << "Machine has no networks; nothing to do";
322
 
    return;
323
 
  }
324
 
  AllocatePorts();
325
 
}
326
 
 
327
 
HttpPortAllocator* ConnectivityChecker::CreatePortAllocator(
328
 
    talk_base::NetworkManager* network_manager,
329
 
    const std::string& user_agent,
330
 
    const std::string& relay_token) {
331
 
  return new TestHttpPortAllocator(network_manager, user_agent, relay_token);
332
 
}
333
 
 
334
 
StunPort* ConnectivityChecker::CreateStunPort(
335
 
    const PortConfiguration* config, talk_base::Network* network) {
336
 
  return StunPort::Create(worker_,
337
 
                          socket_factory_.get(),
338
 
                          network,
339
 
                          network->ip(),
340
 
                          0,
341
 
                          0,
342
 
                          config->stun_address);
343
 
}
344
 
 
345
 
RelayPort* ConnectivityChecker::CreateRelayPort(
346
 
    const PortConfiguration* config, talk_base::Network* network) {
347
 
  return RelayPort::Create(worker_,
348
 
                           socket_factory_.get(),
349
 
                           network,
350
 
                           network->ip(),
351
 
                           port_allocator_->min_port(),
352
 
                           port_allocator_->max_port(),
353
 
                           config->username,
354
 
                           config->password,
355
 
                           config->magic_cookie);
356
 
}
357
 
 
358
 
void ConnectivityChecker::CreateRelayPorts(
359
 
    const PortConfiguration* config,
360
 
    const talk_base::ProxyInfo& proxy_info) {
361
 
  PortConfiguration::RelayList::const_iterator relay;
362
 
  std::vector<talk_base::Network*> networks;
363
 
  network_manager_->GetNetworks(&networks);
364
 
  if (networks.empty()) {
365
 
    LOG(LS_ERROR) << "Machine has no networks; no relay ports created.";
366
 
    return;
367
 
  }
368
 
  for (relay = config->relays.begin();
369
 
       relay != config->relays.end(); ++relay) {
370
 
    for (uint32 i = 0; i < networks.size(); ++i) {
371
 
      NicMap::iterator iter = nics_.find(NicId(networks[i]->ip(),
372
 
                                               proxy_info.address));
373
 
      if (iter != nics_.end()) {
374
 
        // TODO: Now setting the same start time for all protocols.
375
 
        // This might affect accuracy, but since we are mainly looking for
376
 
        // connect failures or number that stick out, this is good enough.
377
 
        uint32 now = talk_base::Time();
378
 
        NicInfo* nic_info = &iter->second;
379
 
        nic_info->udp.start_time_ms = now;
380
 
        nic_info->tcp.start_time_ms = now;
381
 
        nic_info->ssltcp.start_time_ms = now;
382
 
 
383
 
        // Add the addresses of this protocol.
384
 
        PortConfiguration::PortList::const_iterator relay_port;
385
 
        for (relay_port = relay->ports.begin();
386
 
             relay_port != relay->ports.end();
387
 
             ++relay_port) {
388
 
          RelayPort* port = CreateRelayPort(config, networks[i]);
389
 
          port->AddServerAddress(*relay_port);
390
 
          port->AddExternalAddress(*relay_port);
391
 
 
392
 
          nic_info->media_server_address = port->ServerAddress(0)->address;
393
 
 
394
 
          // Listen to network events.
395
 
          port->SignalAddressReady.connect(
396
 
              this, &ConnectivityChecker::OnRelayAddressReady);
397
 
          port->SignalAddressError.connect(
398
 
              this, &ConnectivityChecker::OnRelayAddressError);
399
 
 
400
 
          port->set_proxy(user_agent_, proxy_info);
401
 
 
402
 
          // Start fetching an address for this port.
403
 
          port->PrepareAddress();
404
 
          ports_.push_back(port);
405
 
        }
406
 
      } else {
407
 
        LOG(LS_ERROR) << "Failed to find nic info when creating relay ports.";
408
 
      }
409
 
    }
410
 
  }
411
 
}
412
 
 
413
 
void ConnectivityChecker::AllocatePorts() {
414
 
  PortConfiguration config(stun_address_,
415
 
                           talk_base::CreateRandomString(16),
416
 
                           talk_base::CreateRandomString(16),
417
 
                           "");
418
 
  std::vector<talk_base::Network*> networks;
419
 
  network_manager_->GetNetworks(&networks);
420
 
  if (networks.empty()) {
421
 
    LOG(LS_ERROR) << "Machine has no networks; no ports will be allocated";
422
 
    return;
423
 
  }
424
 
  talk_base::ProxyInfo proxy_info = GetProxyInfo();
425
 
  bool allocate_relay_ports = false;
426
 
  for (uint32 i = 0; i < networks.size(); ++i) {
427
 
    if (AddNic(networks[i]->ip(), proxy_info.address)) {
428
 
      Port* port = CreateStunPort(&config, networks[i]);
429
 
 
430
 
      // Listen to network events.
431
 
      port->SignalAddressReady.connect(
432
 
          this, &ConnectivityChecker::OnStunAddressReady);
433
 
      port->SignalAddressError.connect(
434
 
          this, &ConnectivityChecker::OnStunAddressError);
435
 
 
436
 
      port->set_proxy(user_agent_, proxy_info);
437
 
      port->PrepareAddress();
438
 
      ports_.push_back(port);
439
 
      allocate_relay_ports = true;
440
 
    }
441
 
  }
442
 
 
443
 
  // If any new ip/proxy combinations were added, send a relay allocate.
444
 
  if (allocate_relay_ports) {
445
 
    AllocateRelayPorts();
446
 
  }
447
 
 
448
 
  // Initiate proxy detection.
449
 
  InitiateProxyDetection();
450
 
}
451
 
 
452
 
void ConnectivityChecker::InitiateProxyDetection() {
453
 
  // Only start if we haven't been started before.
454
 
  if (!proxy_detect_) {
455
 
    proxy_detect_ = new talk_base::AutoDetectProxy(user_agent_);
456
 
    talk_base::Url<char> host_url("/", "relay.google.com",
457
 
                                  talk_base::HTTP_DEFAULT_PORT);
458
 
    host_url.set_secure(true);
459
 
    proxy_detect_->set_server_url(host_url.url());
460
 
    proxy_detect_->SignalWorkDone.connect(
461
 
        this, &ConnectivityChecker::OnProxyDetect);
462
 
    proxy_detect_->Start();
463
 
  }
464
 
}
465
 
 
466
 
void ConnectivityChecker::AllocateRelayPorts() {
467
 
  // Currently we are using the 'default' nic for http(s) requests.
468
 
  TestHttpPortAllocatorSession* allocator_session =
469
 
      reinterpret_cast<TestHttpPortAllocatorSession*>(
470
 
          port_allocator_->CreateSession(kSessionNameRtp, kSessionTypeVideo));
471
 
  allocator_session->set_proxy(port_allocator_->proxy());
472
 
  allocator_session->SignalConfigReady.connect(
473
 
      this, &ConnectivityChecker::OnConfigReady);
474
 
  allocator_session->SignalRequestDone.connect(
475
 
      this, &ConnectivityChecker::OnRequestDone);
476
 
 
477
 
  // Try both http and https.
478
 
  RegisterHttpStart(talk_base::HTTP_SECURE_PORT);
479
 
  allocator_session->SendSessionRequest("relay.l.google.com",
480
 
                                        talk_base::HTTP_SECURE_PORT);
481
 
  RegisterHttpStart(talk_base::HTTP_DEFAULT_PORT);
482
 
  allocator_session->SendSessionRequest("relay.l.google.com",
483
 
                                        talk_base::HTTP_DEFAULT_PORT);
484
 
 
485
 
  sessions_.push_back(allocator_session);
486
 
}
487
 
 
488
 
void ConnectivityChecker::RegisterHttpStart(int port) {
489
 
  // Since we don't know what nic were actually used for the http request,
490
 
  // for now, just use the first one.
491
 
  std::vector<talk_base::Network*> networks;
492
 
  network_manager_->GetNetworks(&networks);
493
 
  if (networks.empty()) {
494
 
    LOG(LS_ERROR) << "No networks while registering http start.";
495
 
    return;
496
 
  }
497
 
  talk_base::ProxyInfo proxy_info = GetProxyInfo();
498
 
  NicMap::iterator i = nics_.find(NicId(networks[0]->ip(), proxy_info.address));
499
 
  if (i != nics_.end()) {
500
 
    uint32 now = talk_base::Time();
501
 
    NicInfo* nic_info = &i->second;
502
 
    if (port == talk_base::HTTP_DEFAULT_PORT) {
503
 
      nic_info->http.start_time_ms = now;
504
 
    } else if (port == talk_base::HTTP_SECURE_PORT) {
505
 
      nic_info->https.start_time_ms = now;
506
 
    } else {
507
 
      LOG(LS_ERROR) << "Registering start time for unknown port: " << port;
508
 
    }
509
 
  } else {
510
 
    LOG(LS_ERROR) << "Error, no nic info found while registering http start.";
511
 
  }
512
 
}
513
 
 
514
 
}  // namespace talk_base