← Back to branch summary

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

« back to all changes in this revision

Viewing changes to protocols/jabber/libjingle/talk/p2p/base/relayport_unittest.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/libjingle/talk/p2p/base/relayport_unittest.cc
 
1
/*
 
2
 * libjingle
 
3
 * Copyright 2009 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/basicpacketsocketfactory.h"
 
29
#include "talk/base/logging.h"
 
30
#include "talk/base/gunit.h"
 
31
#include "talk/base/helpers.h"
 
32
#include "talk/base/physicalsocketserver.h"
 
33
#include "talk/base/scoped_ptr.h"
 
34
#include "talk/base/socketadapters.h"
 
35
#include "talk/base/socketaddress.h"
 
36
#include "talk/base/thread.h"
 
37
#include "talk/base/virtualsocketserver.h"
 
38
#include "talk/p2p/base/relayport.h"
 
39
#include "talk/p2p/base/relayserver.h"
 
40
 
 
41
using talk_base::SocketAddress;
 
42
 
 
43
static const SocketAddress kLocalAddress = SocketAddress("192.168.1.2", 0);
 
44
static const SocketAddress kRelayUdpAddr = SocketAddress("99.99.99.1", 5000);
 
45
static const SocketAddress kRelayTcpAddr = SocketAddress("99.99.99.2", 5001);
 
46
static const SocketAddress kRelaySslAddr = SocketAddress("99.99.99.3", 443);
 
47
static const SocketAddress kRelayExtAddr = SocketAddress("99.99.99.3", 5002);
 
48
 
 
49
static const int kTimeoutMs = 1000;
 
50
static const int kMaxTimeoutMs = 5000;
 
51
 
 
52
// Tests connecting a RelayPort to a fake relay server
 
53
// (cricket::RelayServer) using all currently available protocols. The
 
54
// network layer is faked out by using a VirtualSocketServer for
 
55
// creating sockets. The test will monitor the current state of the
 
56
// RelayPort and created sockets by listening for signals such as,
 
57
// SignalConnectFailure, SignalConnectTimeout, SignalSocketClosed and
 
58
// SignalReadPacket.
 
59
class RelayPortTest : public testing::Test,
 
60
                      public sigslot::has_slots<> {
 
61
 public:
 
62
  RelayPortTest()
 
63
      : main_(talk_base::Thread::Current()),
 
64
        physical_socket_server_(new talk_base::PhysicalSocketServer),
 
65
        virtual_socket_server_(new talk_base::VirtualSocketServer(
 
66
            physical_socket_server_.get())),
 
67
        ss_scope_(virtual_socket_server_.get()),
 
68
        network_("unittest", "unittest", talk_base::IPAddress(INADDR_ANY), 32),
 
69
        socket_factory_(talk_base::Thread::Current()),
 
70
        username_(talk_base::CreateRandomString(16)),
 
71
        password_(talk_base::CreateRandomString(16)),
 
72
        relay_port_(cricket::RelayPort::Create(main_, &socket_factory_,
 
73
                                               &network_,
 
74
                                               kLocalAddress.ipaddr(),
 
75
                                               0, 0, username_, password_, "")),
 
76
        relay_server_(new cricket::RelayServer(main_)) {
 
77
  }
 
78
 
 
79
  void OnReadPacket(talk_base::AsyncPacketSocket* socket,
 
80
                    const char* data, size_t size,
 
81
                    const talk_base::SocketAddress& remote_addr) {
 
82
    received_packet_count_[socket]++;
 
83
  }
 
84
 
 
85
  void OnConnectFailure(const cricket::ProtocolAddress* addr) {
 
86
    failed_connections_.push_back(*addr);
 
87
  }
 
88
 
 
89
  void OnSoftTimeout(const cricket::ProtocolAddress* addr) {
 
90
    soft_timedout_connections_.push_back(*addr);
 
91
  }
 
92
 
 
93
 protected:
 
94
  static void SetUpTestCase() {
 
95
    // Ensure the RNG is inited.
 
96
    talk_base::InitRandom(NULL, 0);
 
97
  }
 
98
 
 
99
  virtual void SetUp() {
 
100
    // The relay server needs an external socket to work properly.
 
101
    talk_base::AsyncUDPSocket* ext_socket =
 
102
        CreateAsyncUdpSocket(kRelayExtAddr);
 
103
    relay_server_->AddExternalSocket(ext_socket);
 
104
 
 
105
    // Listen for failures.
 
106
    relay_port_->SignalConnectFailure.
 
107
        connect(this, &RelayPortTest::OnConnectFailure);
 
108
 
 
109
    // Listen for soft timeouts.
 
110
    relay_port_->SignalSoftTimeout.
 
111
        connect(this, &RelayPortTest::OnSoftTimeout);
 
112
  }
 
113
 
 
114
  // Udp has the highest 'goodness' value of the three different
 
115
  // protocols used for connecting to the relay server. As soon as
 
116
  // PrepareAddress is called, the RelayPort will start trying to
 
117
  // connect to the given UDP address. As soon as a response to the
 
118
  // sent STUN allocate request message has been received, the
 
119
  // RelayPort will consider the connection to be complete and will
 
120
  // abort any other connection attempts.
 
121
  void TestConnectUdp() {
 
122
    // Add a UDP socket to the relay server.
 
123
    talk_base::AsyncUDPSocket* internal_udp_socket =
 
124
        CreateAsyncUdpSocket(kRelayUdpAddr);
 
125
    talk_base::AsyncSocket* server_socket = CreateServerSocket(kRelayTcpAddr);
 
126
 
 
127
    relay_server_->AddInternalSocket(internal_udp_socket);
 
128
    relay_server_->AddInternalServerSocket(server_socket, cricket::PROTO_TCP);
 
129
 
 
130
    // Now add our relay addresses to the relay port and let it start.
 
131
    relay_port_->AddServerAddress(
 
132
        cricket::ProtocolAddress(kRelayUdpAddr, cricket::PROTO_UDP));
 
133
    relay_port_->AddServerAddress(
 
134
        cricket::ProtocolAddress(kRelayTcpAddr, cricket::PROTO_TCP));
 
135
    relay_port_->PrepareAddress();
 
136
 
 
137
    // Should be connected.
 
138
    EXPECT_TRUE_WAIT(relay_port_->IsReady(), kTimeoutMs);
 
139
 
 
140
    // Make sure that we are happy with UDP, ie. not continuing with
 
141
    // TCP, SSLTCP, etc.
 
142
    WAIT(relay_server_->HasConnection(kRelayTcpAddr), kTimeoutMs);
 
143
 
 
144
    // Should have only one connection.
 
145
    EXPECT_EQ(1, relay_server_->GetConnectionCount());
 
146
 
 
147
    // Should be the UDP address.
 
148
    EXPECT_TRUE(relay_server_->HasConnection(kRelayUdpAddr));
 
149
  }
 
150
 
 
151
  // TCP has the second best 'goodness' value, and as soon as UDP
 
152
  // connection has failed, the RelayPort will attempt to connect via
 
153
  // TCP. Here we add a fake UDP address together with a real TCP
 
154
  // address to simulate an UDP failure. As soon as UDP has failed the
 
155
  // RelayPort will try the TCP adress and succed.
 
156
  void TestConnectTcp() {
 
157
    // Create a fake UDP address for relay port to simulate a failure.
 
158
    cricket::ProtocolAddress fake_protocol_address =
 
159
        cricket::ProtocolAddress(kRelayUdpAddr, cricket::PROTO_UDP);
 
160
 
 
161
    // Create a server socket for the RelayServer.
 
162
    talk_base::AsyncSocket* server_socket = CreateServerSocket(kRelayTcpAddr);
 
163
    relay_server_->AddInternalServerSocket(server_socket, cricket::PROTO_TCP);
 
164
 
 
165
    // Add server addresses to the relay port and let it start.
 
166
    relay_port_->AddServerAddress(
 
167
        cricket::ProtocolAddress(fake_protocol_address));
 
168
    relay_port_->AddServerAddress(
 
169
        cricket::ProtocolAddress(kRelayTcpAddr, cricket::PROTO_TCP));
 
170
    relay_port_->PrepareAddress();
 
171
 
 
172
    EXPECT_FALSE(relay_port_->IsReady());
 
173
 
 
174
    // Should have timed out in 200 + 200 + 400 + 800 + 1600 ms.
 
175
    EXPECT_TRUE_WAIT(HasFailed(&fake_protocol_address), 3600);
 
176
 
 
177
    // Wait until relayport is ready.
 
178
    EXPECT_TRUE_WAIT(relay_port_->IsReady(), kMaxTimeoutMs);
 
179
 
 
180
    // Should have only one connection.
 
181
    EXPECT_EQ(1, relay_server_->GetConnectionCount());
 
182
 
 
183
    // Should be the TCP address.
 
184
    EXPECT_TRUE(relay_server_->HasConnection(kRelayTcpAddr));
 
185
  }
 
186
 
 
187
  void TestConnectSslTcp() {
 
188
    // Create a fake TCP address for relay port to simulate a failure.
 
189
    // We skip UDP here since transition from UDP to TCP has been
 
190
    // tested above.
 
191
    cricket::ProtocolAddress fake_protocol_address =
 
192
        cricket::ProtocolAddress(kRelayTcpAddr, cricket::PROTO_TCP);
 
193
 
 
194
    // Create a ssl server socket for the RelayServer.
 
195
    talk_base::AsyncSocket* ssl_server_socket =
 
196
        CreateServerSocket(kRelaySslAddr);
 
197
    relay_server_->AddInternalServerSocket(ssl_server_socket,
 
198
                                           cricket::PROTO_SSLTCP);
 
199
 
 
200
    // Create a tcp server socket that listens on the fake address so
 
201
    // the relay port can attempt to connect to it.
 
202
    talk_base::scoped_ptr<talk_base::AsyncSocket> tcp_server_socket(
 
203
        CreateServerSocket(kRelayTcpAddr));
 
204
 
 
205
    // Add server addresses to the relay port and let it start.
 
206
    relay_port_->AddServerAddress(fake_protocol_address);
 
207
    relay_port_->AddServerAddress(
 
208
        cricket::ProtocolAddress(kRelaySslAddr, cricket::PROTO_SSLTCP));
 
209
    relay_port_->PrepareAddress();
 
210
    EXPECT_FALSE(relay_port_->IsReady());
 
211
 
 
212
    // Should have timed out in 3000 ms(relayport.cc, kSoftConnectTimeoutMs).
 
213
    EXPECT_TRUE_WAIT_MARGIN(HasTimedOut(&fake_protocol_address), 3000, 100);
 
214
 
 
215
    // Wait until relayport is ready.
 
216
    EXPECT_TRUE_WAIT(relay_port_->IsReady(), kMaxTimeoutMs);
 
217
 
 
218
    // Should have only one connection.
 
219
    EXPECT_EQ(1, relay_server_->GetConnectionCount());
 
220
 
 
221
    // Should be the SSLTCP address.
 
222
    EXPECT_TRUE(relay_server_->HasConnection(kRelaySslAddr));
 
223
  }
 
224
 
 
225
 private:
 
226
  talk_base::AsyncUDPSocket* CreateAsyncUdpSocket(const SocketAddress addr) {
 
227
    talk_base::AsyncSocket* socket =
 
228
        virtual_socket_server_->CreateAsyncSocket(SOCK_DGRAM);
 
229
    talk_base::AsyncUDPSocket* packet_socket =
 
230
        talk_base::AsyncUDPSocket::Create(socket, addr);
 
231
    EXPECT_TRUE(packet_socket != NULL);
 
232
    packet_socket->SignalReadPacket.connect(this, &RelayPortTest::OnReadPacket);
 
233
    return packet_socket;
 
234
  }
 
235
 
 
236
  talk_base::AsyncSocket* CreateServerSocket(const SocketAddress addr) {
 
237
    talk_base::AsyncSocket* socket =
 
238
        virtual_socket_server_->CreateAsyncSocket(SOCK_STREAM);
 
239
    EXPECT_GE(socket->Bind(addr), 0);
 
240
    EXPECT_GE(socket->Listen(5), 0);
 
241
    return socket;
 
242
  }
 
243
 
 
244
  bool HasFailed(cricket::ProtocolAddress* addr) {
 
245
    for (size_t i = 0; i < failed_connections_.size(); i++) {
 
246
      if (failed_connections_[i].address == addr->address &&
 
247
          failed_connections_[i].proto == addr->proto) {
 
248
        return true;
 
249
      }
 
250
    }
 
251
    return false;
 
252
  }
 
253
 
 
254
  bool HasTimedOut(cricket::ProtocolAddress* addr) {
 
255
    for (size_t i = 0; i < soft_timedout_connections_.size(); i++) {
 
256
      if (soft_timedout_connections_[i].address == addr->address &&
 
257
          soft_timedout_connections_[i].proto == addr->proto) {
 
258
        return true;
 
259
      }
 
260
    }
 
261
    return false;
 
262
  }
 
263
 
 
264
  typedef std::map<talk_base::AsyncPacketSocket*, int> PacketMap;
 
265
 
 
266
  talk_base::Thread* main_;
 
267
  talk_base::scoped_ptr<talk_base::PhysicalSocketServer>
 
268
      physical_socket_server_;
 
269
  talk_base::scoped_ptr<talk_base::VirtualSocketServer> virtual_socket_server_;
 
270
  talk_base::SocketServerScope ss_scope_;
 
271
  talk_base::Network network_;
 
272
  talk_base::BasicPacketSocketFactory socket_factory_;
 
273
  std::string username_;
 
274
  std::string password_;
 
275
  talk_base::scoped_ptr<cricket::RelayPort> relay_port_;
 
276
  talk_base::scoped_ptr<cricket::RelayServer> relay_server_;
 
277
  std::vector<cricket::ProtocolAddress> failed_connections_;
 
278
  std::vector<cricket::ProtocolAddress> soft_timedout_connections_;
 
279
  PacketMap received_packet_count_;
 
280
};
 
281
 
 
282
TEST_F(RelayPortTest, ConnectUdp) {
 
283
  TestConnectUdp();
 
284
}
 
285
 
 
286
TEST_F(RelayPortTest, ConnectTcp) {
 
287
  TestConnectTcp();
 
288
}
 
289
 
 
290
TEST_F(RelayPortTest, ConnectSslTcp) {
 
291
  TestConnectSslTcp();
 
292
}