« back to all changes in this revision
Viewing changes to agent/test-fullmode.c
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Laurent Bigonville
- Date: 2009-01-04 17:45:34 UTC
- Revision ID: james.westby@ubuntu.com-20090104174534-dh5u1pfonumqa99c
Tags: upstream-0.0.4
Import upstream version 0.0.4
- files added:
- agent
- docs
- docs/reference
- docs/reference/libnice
- docs/reference/libnice/html
- docs/reference/libnice/tmpl
- docs/reference/libnice/xml
- gst
- nice
- random
- scripts
- socket
- stun
- stun/tests
- stun/tools
- stun/usages
added
removed
agent/test-fullmode.c
1
/*
2
* This file is part of the Nice GLib ICE library.
3
*
4
* Unit test for ICE full-mode related features.
5
*
6
* (C) 2007 Nokia Corporation. All rights reserved.
7
* Contact: Kai Vehmanen
8
*
9
* The contents of this file are subject to the Mozilla Public License Version
10
* 1.1 (the "License"); you may not use this file except in compliance with
11
* the License. You may obtain a copy of the License at
12
* http://www.mozilla.org/MPL/
13
*
14
* Software distributed under the License is distributed on an "AS IS" basis,
15
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
16
* for the specific language governing rights and limitations under the
17
* License.
18
*
19
* The Original Code is the Nice GLib ICE library.
20
*
21
* The Initial Developers of the Original Code are Collabora Ltd and Nokia
22
* Corporation. All Rights Reserved.
23
*
24
* Contributors:
25
* Kai Vehmanen, Nokia
26
*
27
* Alternatively, the contents of this file may be used under the terms of the
28
* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
29
* case the provisions of LGPL are applicable instead of those above. If you
30
* wish to allow use of your version of this file only under the terms of the
31
* LGPL and not to allow others to use your version of this file under the
32
* MPL, indicate your decision by deleting the provisions above and replace
33
* them with the notice and other provisions required by the LGPL. If you do
34
* not delete the provisions above, a recipient may use your version of this
35
* file under either the MPL or the LGPL.
36
*/
37
#ifdef HAVE_CONFIG_H
38
# include <config.h>
39
#endif
40
41
#include "agent.h"
42
43
#include <stdlib.h>
44
#include <string.h>
45
46
47
#define USE_TURN 0
48
#define USE_LOOPBACK 1
49
#define TEST_GOOGLE 0
50
51
#define PROXY_IP "127.0.0.1"
52
#define PROXY_PORT 1080
53
#define PROXY_TYPE NICE_PROXY_TYPE_SOCKS5
54
#define PROXY_USERNAME NULL
55
#define PROXY_PASSWORD NULL
56
57
58
#if TEST_GOOGLE
59
#define NICE_COMPATIBILITY NICE_COMPATIBILITY_GOOGLE
60
61
#if USE_TURN
62
#undef USE_LOOPBACK
63
#define USE_LOOPBACK 0
64
65
#define TURN_IP "209.85.163.126"
66
#define TURN_PORT 443
67
#define TURN_USER "ih9ppiM0P6vN34DB"
68
#define TURN_PASS ""
69
#define TURN_USER2 TURN_USER
70
#define TURN_PASS2 TURN_PASS
71
#define TURN_TYPE NICE_RELAY_TYPE_TURN_TLS
72
73
#endif
74
75
#else
76
#define NICE_COMPATIBILITY NICE_COMPATIBILITY_DRAFT19
77
#if USE_LOOPBACK
78
#define USE_TURN_SERVER_ORG 1
79
#else
80
#define USE_TURN_SERVER_ORG 0
81
#endif
82
83
#define NUMB_IP "64.251.22.149"
84
#define NUMB_PORT 3478
85
#define NUMB_USER "youness.alaoui@collabora.co.uk"
86
#define NUMB_PASS "badger"
87
88
#define TSORG_IP "127.0.0.1"
89
#define TSORG_PORT 3478
90
#define TSORG_USER "toto"
91
#define TSORG_PASS "password"
92
93
94
#if USE_TURN_SERVER_ORG
95
#define TURN_IP TSORG_IP
96
#define TURN_PORT TSORG_PORT
97
#define TURN_USER TSORG_USER
98
#define TURN_PASS TSORG_PASS
99
#define TURN_USER2 TSORG_USER
100
#define TURN_PASS2 TSORG_PASS
101
#define TURN_TYPE NICE_RELAY_TYPE_TURN_TCP
102
#else
103
#define TURN_IP NUMB_IP
104
#define TURN_PORT NUMB_PORT
105
#define TURN_USER NUMB_USER
106
#define TURN_PASS NUMB_PASS
107
#define TURN_USER2 NUMB_USER
108
#define TURN_PASS2 NUMB_PASS
109
#define TURN_TYPE NICE_RELAY_TYPE_TURN_UDP
110
#endif
111
112
#endif
113
114
115
static NiceComponentState global_lagent_state[2] = { NICE_COMPONENT_STATE_LAST, NICE_COMPONENT_STATE_LAST };
116
static NiceComponentState global_ragent_state[2] = { NICE_COMPONENT_STATE_LAST, NICE_COMPONENT_STATE_LAST };
117
static guint global_components_ready = 0;
118
static guint global_components_ready_exit = 0;
119
static guint global_components_failed = 0;
120
static guint global_components_failed_exit = 0;
121
static GMainLoop *global_mainloop = NULL;
122
static gboolean global_lagent_gathering_done = FALSE;
123
static gboolean global_ragent_gathering_done = FALSE;
124
static gboolean global_lagent_ibr_received = FALSE;
125
static gboolean global_ragent_ibr_received = FALSE;
126
static int global_lagent_cands = 0;
127
static int global_ragent_cands = 0;
128
static gint global_ragent_read = 0;
129
static guint global_exit_when_ibr_received = 0;
130
131
static void priv_print_global_status (void)
132
{
133
g_debug ("\tgathering_done=%d", global_lagent_gathering_done && global_ragent_gathering_done);
134
g_debug ("\tlstate[rtp]=%d [rtcp]=%d", global_lagent_state[0], global_lagent_state[1]);
135
g_debug ("\trstate[rtp]=%d [rtcp]=%d", global_ragent_state[0], global_ragent_state[1]);
136
g_debug ("\tL cands=%d R cands=%d", global_lagent_cands, global_ragent_cands);
137
}
138
139
static gboolean timer_cb (gpointer pointer)
140
{
141
g_debug ("test-fullmode:%s: %p", G_STRFUNC, pointer);
142
143
/* signal status via a global variable */
144
145
/* note: should not be reached, abort */
146
g_error ("ERROR: test has got stuck, aborting...");
147
}
148
149
static void cb_nice_recv (NiceAgent *agent, guint stream_id, guint component_id, guint len, gchar *buf, gpointer user_data)
150
{
151
g_debug ("test-fullmode:%s: %p", G_STRFUNC, user_data);
152
153
/* XXX: dear compiler, these are for you: */
154
(void)agent; (void)stream_id; (void)component_id; (void)buf;
155
156
/*
157
* Lets ignore stun packets that got through
158
*/
159
if (len < 8)
160
return;
161
if (strncmp ("12345678", buf, 8))
162
return;
163
164
if (GPOINTER_TO_UINT (user_data) == 2) {
165
global_ragent_read = len;
166
g_main_loop_quit (global_mainloop);
167
}
168
}
169
170
static void cb_candidate_gathering_done(NiceAgent *agent, guint stream_id, gpointer data)
171
{
172
g_debug ("test-fullmode:%s: %p", G_STRFUNC, data);
173
174
if (GPOINTER_TO_UINT (data) == 1)
175
global_lagent_gathering_done = TRUE;
176
else if (GPOINTER_TO_UINT (data) == 2)
177
global_ragent_gathering_done = TRUE;
178
179
if (global_lagent_gathering_done &&
180
global_ragent_gathering_done)
181
g_main_loop_quit (global_mainloop);
182
183
/* XXX: dear compiler, these are for you: */
184
(void)agent;
185
}
186
187
static void cb_component_state_changed (NiceAgent *agent, guint stream_id, guint component_id, guint state, gpointer data)
188
{
189
g_debug ("test-fullmode:%s: %p", __func__, data);
190
191
if (GPOINTER_TO_UINT (data) == 1)
192
global_lagent_state[component_id - 1] = state;
193
else if (GPOINTER_TO_UINT (data) == 2)
194
global_ragent_state[component_id - 1] = state;
195
196
if (state == NICE_COMPONENT_STATE_READY)
197
global_components_ready++;
198
if (state == NICE_COMPONENT_STATE_FAILED)
199
global_components_failed++;
200
201
g_debug ("test-fullmode: checks READY/EXIT-AT %u/%u.", global_components_ready, global_components_ready_exit);
202
g_debug ("test-fullmode: checks FAILED/EXIT-AT %u/%u.", global_components_failed, global_components_failed_exit);
203
204
/* signal status via a global variable */
205
if (global_components_ready == global_components_ready_exit &&
206
global_components_failed == global_components_failed_exit) {
207
g_main_loop_quit (global_mainloop);
208
return;
209
}
210
211
#if 0
212
/* signal status via a global variable */
213
if (global_components_failed == global_components_failed_exit) {
214
g_main_loop_quit (global_mainloop);
215
return;
216
}
217
#endif
218
219
/* XXX: dear compiler, these are for you: */
220
(void)agent; (void)stream_id; (void)data; (void)component_id;
221
}
222
223
static void cb_new_selected_pair(NiceAgent *agent, guint stream_id, guint component_id,
224
gchar *lfoundation, gchar* rfoundation, gpointer data)
225
{
226
g_debug ("test-fullmode:%s: %p", __func__, data);
227
228
if (GPOINTER_TO_UINT (data) == 1)
229
++global_lagent_cands;
230
else if (GPOINTER_TO_UINT (data) == 2)
231
++global_ragent_cands;
232
233
/* XXX: dear compiler, these are for you: */
234
(void)agent; (void)stream_id; (void)component_id; (void)lfoundation; (void)rfoundation;
235
}
236
237
static void cb_new_candidate(NiceAgent *agent, guint stream_id, guint component_id,
238
gchar *foundation, gpointer data)
239
{
240
g_debug ("test-fullmode:%s: %p", __func__, data);
241
242
/* XXX: dear compiler, these are for you: */
243
(void)agent; (void)stream_id; (void)data; (void)component_id; (void)foundation;
244
}
245
246
static void cb_initial_binding_request_received(NiceAgent *agent, guint stream_id, gpointer data)
247
{
248
g_debug ("test-fullmode:%s: %p", __func__, data);
249
250
if (GPOINTER_TO_UINT (data) == 1)
251
global_lagent_ibr_received = TRUE;
252
else if (GPOINTER_TO_UINT (data) == 2)
253
global_ragent_ibr_received = TRUE;
254
255
if (global_exit_when_ibr_received)
256
g_main_loop_quit (global_mainloop);
257
258
/* XXX: dear compiler, these are for you: */
259
(void)agent; (void)stream_id; (void)data;
260
}
261
262
static void priv_get_local_addr (NiceAgent *agent, guint stream_id, guint component_id, NiceAddress *dstaddr)
263
{
264
GSList *cands, *i;
265
cands = nice_agent_get_local_candidates(agent, stream_id, component_id);
266
for (i = cands; i; i = i->next) {
267
NiceCandidate *cand = i->data;
268
if (cand) {
269
g_assert (dstaddr);
270
*dstaddr = cand->addr;
271
}
272
}
273
for (i = cands; i; i = i->next)
274
nice_candidate_free ((NiceCandidate *) i->data);
275
g_slist_free (cands);
276
}
277
278
279
static GSList *priv_get_local_candidate (NiceAgent *agent, guint stream_id, guint component_id)
280
{
281
GSList *cands, *i;
282
GSList *result = NULL;
283
NiceCandidate *out_cand = NULL;
284
cands = nice_agent_get_local_candidates(agent, stream_id, component_id);
285
for (i = cands; i; i = i->next) {
286
NiceCandidate *cand = i->data;
287
if (cand) {
288
out_cand = cand;
289
}
290
}
291
result = g_slist_append (result, nice_candidate_copy (out_cand));
292
293
for (i = cands; i; i = i->next)
294
nice_candidate_free ((NiceCandidate *) i->data);
295
g_slist_free (cands);
296
return result;
297
}
298
299
300
301
static void init_candidate (NiceCandidate *cand)
302
{
303
memset (cand, 0, sizeof(NiceCandidate));
304
305
cand->priority = 10000;
306
strcpy (cand->foundation, "1");
307
cand->type = NICE_CANDIDATE_TYPE_HOST;
308
cand->transport = NICE_CANDIDATE_TRANSPORT_UDP;
309
}
310
311
static int run_full_test (NiceAgent *lagent, NiceAgent *ragent, NiceAddress *baseaddr, guint ready, guint failed)
312
{
313
// NiceAddress laddr, raddr, laddr_rtcp, raddr_rtcp;
314
NiceCandidate cdes;
315
GSList *cands, *i;
316
guint ls_id, rs_id;
317
318
init_candidate (&cdes);
319
320
/* XXX: dear compiler, this is for you */
321
(void)baseaddr;
322
323
/* step: initialize variables modified by the callbacks */
324
global_components_ready = 0;
325
global_components_ready_exit = ready;
326
global_components_failed = 0;
327
global_components_failed_exit = failed;
328
global_lagent_gathering_done = FALSE;
329
global_ragent_gathering_done = FALSE;
330
global_lagent_ibr_received =
331
global_ragent_ibr_received = FALSE;
332
global_lagent_cands =
333
global_ragent_cands = 0;
334
335
g_object_set (G_OBJECT (lagent), "controlling-mode", TRUE, NULL);
336
g_object_set (G_OBJECT (ragent), "controlling-mode", FALSE, NULL);
337
338
/* step: add one stream, with RTP+RTCP components, to each agent */
339
ls_id = nice_agent_add_stream (lagent, 2);
340
341
rs_id = nice_agent_add_stream (ragent, 2);
342
g_assert (ls_id > 0);
343
g_assert (rs_id > 0);
344
#if USE_TURN
345
nice_agent_set_relay_info(lagent, ls_id, 1,
346
TURN_IP, TURN_PORT, TURN_USER, TURN_PASS, TURN_TYPE);
347
nice_agent_set_relay_info(lagent, ls_id, 2,
348
TURN_IP, TURN_PORT, TURN_USER, TURN_PASS, TURN_TYPE);
349
nice_agent_set_relay_info(ragent, rs_id, 1,
350
TURN_IP, TURN_PORT, TURN_USER2, TURN_PASS2, TURN_TYPE);
351
nice_agent_set_relay_info(ragent, rs_id, 2,
352
TURN_IP, TURN_PORT, TURN_USER2, TURN_PASS2, TURN_TYPE);
353
#endif
354
355
356
nice_agent_gather_candidates (lagent, ls_id);
357
nice_agent_gather_candidates (ragent, rs_id);
358
359
/* step: attach to mainloop (needed to register the fds) */
360
nice_agent_attach_recv (lagent, ls_id, NICE_COMPONENT_TYPE_RTP,
361
g_main_loop_get_context (global_mainloop), cb_nice_recv,
362
GUINT_TO_POINTER (1));
363
nice_agent_attach_recv (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP,
364
g_main_loop_get_context (global_mainloop), cb_nice_recv,
365
GUINT_TO_POINTER (1));
366
nice_agent_attach_recv (ragent, rs_id, NICE_COMPONENT_TYPE_RTP,
367
g_main_loop_get_context (global_mainloop), cb_nice_recv,
368
GUINT_TO_POINTER (2));
369
nice_agent_attach_recv (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP,
370
g_main_loop_get_context (global_mainloop), cb_nice_recv,
371
GUINT_TO_POINTER (2));
372
373
/* step: run mainloop until local candidates are ready
374
* (see timer_cb() above) */
375
if (global_lagent_gathering_done != TRUE ||
376
global_ragent_gathering_done != TRUE) {
377
g_debug ("test-fullmode: Added streams, running mainloop until 'candidate-gathering-done'...");
378
g_main_loop_run (global_mainloop);
379
g_assert (global_lagent_gathering_done == TRUE);
380
g_assert (global_ragent_gathering_done == TRUE);
381
}
382
383
/* step: find out the local candidates of each agent */
384
385
/* priv_get_local_addr (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, &raddr);
386
g_debug ("test-fullmode: local RTP port R %u",
387
nice_address_get_port (&raddr));
388
389
priv_get_local_addr (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, &laddr);
390
g_debug ("test-fullmode: local RTP port L %u",
391
nice_address_get_port (&laddr));
392
393
priv_get_local_addr (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP, &raddr_rtcp);
394
g_debug ("test-fullmode: local RTCP port R %u",
395
nice_address_get_port (&raddr_rtcp));
396
397
priv_get_local_addr (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP, &laddr_rtcp);
398
g_debug ("test-fullmode: local RTCP port L %u",
399
nice_address_get_port (&laddr_rtcp));*/
400
401
/* step: pass the remote candidates to agents */
402
//cands = g_slist_append (NULL, &cdes);
403
{
404
gchar *ufrag = NULL, *password = NULL;
405
nice_agent_get_local_credentials(lagent, ls_id, &ufrag, &password);
406
nice_agent_set_remote_credentials (ragent,
407
rs_id, ufrag, password);
408
g_free (ufrag);
409
g_free (password);
410
nice_agent_get_local_credentials(ragent, rs_id, &ufrag, &password);
411
nice_agent_set_remote_credentials (lagent,
412
ls_id, ufrag, password);
413
g_free (ufrag);
414
g_free (password);
415
}
416
/* cdes.component_id = NICE_COMPONENT_TYPE_RTP;
417
cdes.addr = raddr;
418
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, cands);
419
cdes.addr = laddr;
420
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, cands);
421
cdes.component_id = NICE_COMPONENT_TYPE_RTCP;
422
cdes.addr = raddr_rtcp;
423
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP, cands);
424
cdes.addr = laddr_rtcp;
425
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP, cands);
426
427
g_slist_free (cands);*/
428
cands = priv_get_local_candidate (ragent, rs_id, NICE_COMPONENT_TYPE_RTP);
429
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, cands);
430
for (i = cands; i; i = i->next)
431
nice_candidate_free ((NiceCandidate *) i->data);
432
g_slist_free (cands);
433
cands = priv_get_local_candidate (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP);
434
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP, cands);
435
for (i = cands; i; i = i->next)
436
nice_candidate_free ((NiceCandidate *) i->data);
437
g_slist_free (cands);
438
cands = priv_get_local_candidate (lagent, ls_id, NICE_COMPONENT_TYPE_RTP);
439
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, cands);
440
for (i = cands; i; i = i->next)
441
nice_candidate_free ((NiceCandidate *) i->data);
442
g_slist_free (cands);
443
cands = priv_get_local_candidate (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP);
444
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP, cands);
445
for (i = cands; i; i = i->next)
446
nice_candidate_free ((NiceCandidate *) i->data);
447
g_slist_free (cands);
448
449
g_debug ("test-fullmode: Set properties, next running mainloop until connectivity checks succeed...");
450
451
/* step: run the mainloop until connectivity checks succeed
452
* (see timer_cb() above) */
453
g_main_loop_run (global_mainloop);
454
455
/* note: verify that STUN binding requests were sent */
456
g_assert (global_lagent_ibr_received == TRUE);
457
g_assert (global_ragent_ibr_received == TRUE);
458
459
/* note: test payload send and receive */
460
global_ragent_read = 0;
461
g_assert (nice_agent_send (lagent, ls_id, 1, 16, "1234567812345678") == 16);
462
g_main_loop_run (global_mainloop);
463
g_assert (global_ragent_read == 16);
464
465
g_debug ("test-fullmode: Ran mainloop, removing streams...");
466
467
/* step: clean up resources and exit */
468
469
nice_agent_remove_stream (lagent, ls_id);
470
nice_agent_remove_stream (ragent, rs_id);
471
472
return 0;
473
}
474
475
/**
476
* Simulate the case where answer to the offer is delayed and
477
* some STUN connectivity checks reach the offering party
478
* before it gets the remote SDP information.
479
*/
480
static int run_full_test_delayed_answer (NiceAgent *lagent, NiceAgent *ragent, NiceAddress *baseaddr, guint ready, guint failed)
481
{
482
NiceAddress laddr, raddr, laddr_rtcp, raddr_rtcp;
483
NiceCandidate cdes;
484
GSList *cands;
485
guint ls_id, rs_id;
486
487
init_candidate (&cdes);
488
489
/* XXX: dear compiler, this is for you */
490
(void)baseaddr;
491
492
/* step: initialize variables modified by the callbacks */
493
global_components_ready = 0;
494
global_components_ready_exit = ready;
495
global_components_failed = 0;
496
global_components_failed_exit = failed;
497
global_lagent_gathering_done = FALSE;
498
global_ragent_gathering_done = FALSE;
499
global_lagent_ibr_received =
500
global_ragent_ibr_received = FALSE;
501
global_exit_when_ibr_received = 1;
502
global_lagent_cands =
503
global_ragent_cands = 0;
504
505
g_object_set (G_OBJECT (lagent), "controlling-mode", TRUE, NULL);
506
g_object_set (G_OBJECT (ragent), "controlling-mode", FALSE, NULL);
507
508
/* step: add one stream, with RTP+RTCP components, to each agent */
509
ls_id = nice_agent_add_stream (lagent, 2);
510
511
rs_id = nice_agent_add_stream (ragent, 2);
512
g_assert (ls_id > 0);
513
g_assert (rs_id > 0);
514
515
/* We don't try this with TURN because as long as both agents don't
516
have the remote candidates, they won't be able to create the
517
permission on the TURN server, so the connchecks will never go through */
518
519
nice_agent_gather_candidates (lagent, ls_id);
520
nice_agent_gather_candidates (ragent, rs_id);
521
522
/* step: attach to mainloop (needed to register the fds) */
523
nice_agent_attach_recv (lagent, ls_id, NICE_COMPONENT_TYPE_RTP,
524
g_main_loop_get_context (global_mainloop), cb_nice_recv,
525
GUINT_TO_POINTER (1));
526
nice_agent_attach_recv (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP,
527
g_main_loop_get_context (global_mainloop), cb_nice_recv,
528
GUINT_TO_POINTER (1));
529
nice_agent_attach_recv (ragent, rs_id, NICE_COMPONENT_TYPE_RTP,
530
g_main_loop_get_context (global_mainloop), cb_nice_recv,
531
GUINT_TO_POINTER (2));
532
nice_agent_attach_recv (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP,
533
g_main_loop_get_context (global_mainloop), cb_nice_recv,
534
GUINT_TO_POINTER (2));
535
536
/* step: run mainloop until local candidates are ready
537
* (see timer_cb() above) */
538
if (global_lagent_gathering_done != TRUE ||
539
global_ragent_gathering_done != TRUE) {
540
g_debug ("test-fullmode: Added streams, running mainloop until 'candidate-gathering-done'...");
541
g_main_loop_run (global_mainloop);
542
g_assert (global_lagent_gathering_done == TRUE);
543
g_assert (global_ragent_gathering_done == TRUE);
544
}
545
546
/* step: find out the local candidates of each agent */
547
548
priv_get_local_addr (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, &raddr);
549
g_debug ("test-fullmode: local RTP port R %u",
550
nice_address_get_port (&raddr));
551
552
priv_get_local_addr (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, &laddr);
553
g_debug ("test-fullmode: local RTP port L %u",
554
nice_address_get_port (&laddr));
555
556
priv_get_local_addr (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP, &raddr_rtcp);
557
g_debug ("test-fullmode: local RTCP port R %u",
558
nice_address_get_port (&raddr_rtcp));
559
560
priv_get_local_addr (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP, &laddr_rtcp);
561
g_debug ("test-fullmode: local RTCP port L %u",
562
nice_address_get_port (&laddr_rtcp));
563
564
/* step: pass the remote candidates to agent R (answering party) */
565
{
566
gchar *ufrag = NULL, *password = NULL;
567
nice_agent_get_local_credentials(lagent, ls_id, &ufrag, &password);
568
nice_agent_set_remote_credentials (ragent,
569
rs_id, ufrag, password);
570
g_free (ufrag);
571
g_free (password);
572
nice_agent_get_local_credentials(ragent, rs_id, &ufrag, &password);
573
nice_agent_set_remote_credentials (lagent,
574
ls_id, ufrag, password);
575
g_free (ufrag);
576
g_free (password);
577
}
578
/* step: set remote candidates for agent R (answering party) */
579
cands = g_slist_append (NULL, &cdes);
580
cdes.component_id = NICE_COMPONENT_TYPE_RTP;
581
cdes.addr = laddr;
582
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, cands);
583
cdes.component_id = NICE_COMPONENT_TYPE_RTCP;
584
cdes.addr = laddr_rtcp;
585
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP, cands);
586
587
g_debug ("test-fullmode: Set properties, next running mainloop until first check is received...");
588
589
/* step: run the mainloop until first connectivity check receveid */
590
g_main_loop_run (global_mainloop);
591
global_exit_when_ibr_received = 0;
592
593
/* note: verify that STUN binding requests were sent */
594
g_assert (global_lagent_ibr_received == TRUE);
595
596
g_debug ("test-fullmode: Delayed answer received, continuing processing..");
597
598
/* step: pass the remote candidates to agent L (offering party) */
599
{
600
gchar *ufrag = NULL, *password = NULL;
601
nice_agent_get_local_credentials(ragent, rs_id, &ufrag, &password);
602
nice_agent_set_remote_credentials (lagent,
603
ls_id, ufrag, password);
604
g_free (ufrag);
605
g_free (password);
606
nice_agent_get_local_credentials(ragent, rs_id, &ufrag, &password);
607
nice_agent_set_remote_credentials (lagent,
608
ls_id, ufrag, password);
609
g_free (ufrag);
610
g_free (password);
611
}
612
613
/* step: pass remove candidates to agent L (offering party) */
614
cdes.component_id = NICE_COMPONENT_TYPE_RTP;
615
cdes.addr = raddr;
616
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, cands);
617
cdes.component_id = NICE_COMPONENT_TYPE_RTCP;
618
cdes.addr = raddr_rtcp;
619
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP, cands);
620
621
g_debug ("test-fullmode: Running mainloop until connectivity checks succeeed.");
622
623
g_main_loop_run (global_mainloop);
624
g_assert (global_ragent_ibr_received == TRUE);
625
g_assert (global_components_failed == 0);
626
627
/* note: test payload send and receive */
628
global_ragent_read = 0;
629
g_assert (nice_agent_send (lagent, ls_id, 1, 16, "1234567812345678") == 16);
630
g_main_loop_run (global_mainloop);
631
g_assert (global_ragent_read == 16);
632
633
g_debug ("test-fullmode: Ran mainloop, removing streams...");
634
635
/* step: clean up resources and exit */
636
637
nice_agent_remove_stream (lagent, ls_id);
638
nice_agent_remove_stream (ragent, rs_id);
639
640
g_slist_free (cands);
641
642
return 0;
643
}
644
645
static int run_full_test_wrong_password (NiceAgent *lagent, NiceAgent *ragent, NiceAddress *baseaddr)
646
{
647
NiceAddress laddr, raddr;
648
NiceCandidate cdes;
649
GSList *cands, *i;
650
guint ls_id, rs_id;
651
652
init_candidate (&cdes);
653
654
/* XXX: dear compiler, this is for you */
655
(void)baseaddr;
656
657
global_components_ready = 0;
658
global_components_ready_exit = 0;
659
global_components_failed = 0;
660
global_components_failed_exit = 2;
661
global_lagent_state[0] = global_lagent_state[1] =
662
global_ragent_state[0] = global_ragent_state[1]
663
= NICE_COMPONENT_STATE_LAST;
664
global_lagent_gathering_done =
665
global_ragent_gathering_done = FALSE;
666
global_lagent_cands =
667
global_ragent_cands = 0;
668
669
g_object_set (G_OBJECT (lagent), "controlling-mode", TRUE, NULL);
670
g_object_set (G_OBJECT (ragent), "controlling-mode", FALSE, NULL);
671
672
/* step: add one stream, with one component, to each agent */
673
ls_id = nice_agent_add_stream (lagent, 1);
674
675
rs_id = nice_agent_add_stream (ragent, 1);
676
g_assert (ls_id > 0);
677
g_assert (rs_id > 0);
678
#if USE_TURN
679
nice_agent_set_relay_info(lagent, ls_id, 1,
680
TURN_IP, TURN_PORT, TURN_USER, TURN_PASS, TURN_TYPE);
681
nice_agent_set_relay_info(ragent, rs_id, 1,
682
TURN_IP, TURN_PORT, TURN_USER, TURN_PASS, TURN_TYPE);
683
#endif
684
685
nice_agent_gather_candidates (lagent, ls_id);
686
nice_agent_gather_candidates (ragent, rs_id);
687
688
/* step: attach to mainloop (needed to register the fds) */
689
nice_agent_attach_recv (lagent, ls_id, NICE_COMPONENT_TYPE_RTP,
690
g_main_loop_get_context (global_mainloop), cb_nice_recv,
691
GUINT_TO_POINTER (1));
692
nice_agent_attach_recv (ragent, rs_id, NICE_COMPONENT_TYPE_RTP,
693
g_main_loop_get_context (global_mainloop), cb_nice_recv,
694
GUINT_TO_POINTER (2));
695
696
/* step: run mainloop until local candidates are ready
697
* (see timer_cb() above) */
698
if (global_lagent_gathering_done != TRUE ||
699
global_ragent_gathering_done != TRUE) {
700
g_debug ("test-fullmode: Added streams, running mainloop until 'candidate-gathering-done'...");
701
g_main_loop_run (global_mainloop);
702
g_assert (global_lagent_gathering_done == TRUE);
703
g_assert (global_ragent_gathering_done == TRUE);
704
}
705
706
/* step: find out the local candidates of each agent */
707
cands = nice_agent_get_local_candidates(lagent, ls_id, NICE_COMPONENT_TYPE_RTP);
708
709
for (i = cands; i; i = i->next) {
710
NiceCandidate *cand = i->data;
711
if (cand) {
712
g_debug ("test-fullmode: local port L %u",
713
nice_address_get_port (&cand->addr));
714
laddr = cand->addr;
715
}
716
}
717
for (i = cands; i; i = i->next)
718
nice_candidate_free ((NiceCandidate *) i->data);
719
g_slist_free (cands);
720
721
cands = nice_agent_get_local_candidates(ragent, rs_id, NICE_COMPONENT_TYPE_RTP);
722
for (i = cands; i; i = i->next) {
723
NiceCandidate *cand = i->data;
724
if (cand) {
725
g_debug ("test-fullmode: local port R %u",
726
nice_address_get_port (&cand->addr));
727
raddr = cand->addr;
728
}
729
}
730
for (i = cands; i; i = i->next)
731
nice_candidate_free ((NiceCandidate *) i->data);
732
g_slist_free (cands);
733
g_debug ("test-fullmode: Got local candidates...");
734
735
/* step: pass the remote candidates to agents */
736
cands = g_slist_append (NULL, &cdes);
737
{
738
gchar *ufrag = NULL, *password = NULL;
739
nice_agent_get_local_credentials(lagent, ls_id, &ufrag, &password);
740
nice_agent_set_remote_credentials (ragent,
741
rs_id, "wrong", password);
742
g_free (ufrag);
743
g_free (password);
744
nice_agent_get_local_credentials(ragent, rs_id, &ufrag, &password);
745
nice_agent_set_remote_credentials (lagent,
746
ls_id, ufrag, "wrong2");
747
g_free (ufrag);
748
g_free (password);
749
}
750
cdes.addr = raddr;
751
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, cands);
752
cdes.addr = laddr;
753
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, cands);
754
g_slist_free (cands);
755
756
g_debug ("test-fullmode: Set properties, next running mainloop until connectivity checks succeed...");
757
758
/* step: run the mainloop until connectivity checks succeed
759
* (see timer_cb() above) */
760
g_main_loop_run (global_mainloop);
761
762
/* note: verify that correct number of local candidates were reported */
763
g_assert (global_lagent_cands == 0);
764
g_assert (global_ragent_cands == 0);
765
766
g_debug ("test-fullmode: Ran mainloop, removing streams...");
767
768
/* step: clean up resources and exit */
769
770
nice_agent_remove_stream (lagent, ls_id);
771
nice_agent_remove_stream (ragent, rs_id);
772
773
return 0;
774
}
775
776
static int run_full_test_control_conflict (NiceAgent *lagent, NiceAgent *ragent, NiceAddress *baseaddr, gboolean role)
777
{
778
NiceAddress laddr, raddr;
779
NiceCandidate cdes;
780
GSList *cands, *i;
781
guint ls_id, rs_id;
782
783
init_candidate (&cdes);
784
785
/* XXX: dear compiler, this is for you */
786
(void)baseaddr;
787
788
global_components_ready = 0;
789
global_components_ready_exit = 2;
790
global_components_failed = 0;
791
global_components_failed_exit = 0;
792
global_lagent_gathering_done =
793
global_ragent_gathering_done = FALSE;
794
global_lagent_cands =
795
global_ragent_cands = 0;
796
global_lagent_ibr_received =
797
global_ragent_ibr_received = FALSE;
798
799
g_object_set (G_OBJECT (lagent), "controlling-mode", role, NULL);
800
g_object_set (G_OBJECT (ragent), "controlling-mode", role, NULL);
801
802
/* step: add one stream, with one component, to each agent */
803
ls_id = nice_agent_add_stream (lagent, 1);
804
805
rs_id = nice_agent_add_stream (ragent, 1);
806
g_assert (ls_id > 0);
807
g_assert (rs_id > 0);
808
#if USE_TURN
809
nice_agent_set_relay_info(lagent, ls_id, 1,
810
TURN_IP, TURN_PORT, TURN_USER, TURN_PASS, TURN_TYPE);
811
nice_agent_set_relay_info(ragent, rs_id, 1,
812
TURN_IP, TURN_PORT, TURN_USER, TURN_PASS, TURN_TYPE);
813
#endif
814
815
nice_agent_gather_candidates (lagent, ls_id);
816
nice_agent_gather_candidates (ragent, rs_id);
817
818
/* step: attach to mainloop (needed to register the fds) */
819
nice_agent_attach_recv (lagent, ls_id, NICE_COMPONENT_TYPE_RTP,
820
g_main_loop_get_context (global_mainloop), cb_nice_recv,
821
GUINT_TO_POINTER (1));
822
nice_agent_attach_recv (ragent, rs_id, NICE_COMPONENT_TYPE_RTP,
823
g_main_loop_get_context (global_mainloop), cb_nice_recv,
824
GUINT_TO_POINTER (2));
825
826
/* step: run mainloop until local candidates are ready
827
* (see timer_cb() above) */
828
if (global_lagent_gathering_done != TRUE ||
829
global_ragent_gathering_done != TRUE) {
830
g_debug ("test-fullmode: Added streams, running mainloop until 'candidate-gathering-done'...");
831
g_main_loop_run (global_mainloop);
832
g_assert (global_lagent_gathering_done == TRUE);
833
g_assert (global_ragent_gathering_done == TRUE);
834
}
835
836
/* step: find out the local candidates of each agent */
837
cands = nice_agent_get_local_candidates(lagent, ls_id, NICE_COMPONENT_TYPE_RTP);
838
for (i = cands; i; i = i->next) {
839
NiceCandidate *cand = i->data;
840
if (cand) {
841
g_debug ("test-fullmode: local port L %u",
842
nice_address_get_port (&cand->addr));
843
laddr = cand->addr;
844
}
845
}
846
for (i = cands; i; i = i->next)
847
nice_candidate_free ((NiceCandidate *) i->data);
848
g_slist_free (cands);
849
850
cands = nice_agent_get_local_candidates(ragent, rs_id, NICE_COMPONENT_TYPE_RTP);
851
for (i = cands; i; i = i->next) {
852
NiceCandidate *cand = i->data;
853
if (cand) {
854
g_debug ("test-fullmode: local port R %u",
855
nice_address_get_port (&cand->addr));
856
raddr = cand->addr;
857
}
858
}
859
for (i = cands; i; i = i->next)
860
nice_candidate_free ((NiceCandidate *) i->data);
861
g_slist_free (cands);
862
g_debug ("test-fullmode: Got local candidates...");
863
864
/* step: pass the remote candidates to agents */
865
cands = g_slist_append (NULL, &cdes);
866
{
867
gchar *ufrag = NULL, *password = NULL;
868
nice_agent_get_local_credentials(lagent, ls_id, &ufrag, &password);
869
nice_agent_set_remote_credentials (ragent,
870
rs_id, ufrag, password);
871
g_free (ufrag);
872
g_free (password);
873
nice_agent_get_local_credentials(ragent, rs_id, &ufrag, &password);
874
nice_agent_set_remote_credentials (lagent,
875
ls_id, ufrag, password);
876
g_free (ufrag);
877
g_free (password);
878
}
879
cdes.addr = raddr;
880
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, cands);
881
cdes.addr = laddr;
882
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, cands);
883
g_slist_free (cands);
884
885
g_debug ("test-fullmode: Set properties, next running mainloop until connectivity checks succeed...");
886
887
/* step: run the mainloop until connectivity checks succeed
888
* (see timer_cb() above) */
889
g_main_loop_run (global_mainloop);
890
891
/* note: verify that correct number of local candidates were reported */
892
g_assert (global_lagent_cands == 1);
893
g_assert (global_ragent_cands == 1);
894
895
g_debug ("test-fullmode: Ran mainloop, removing streams...");
896
897
/* step: clean up resources and exit */
898
899
nice_agent_remove_stream (lagent, ls_id);
900
nice_agent_remove_stream (ragent, rs_id);
901
902
return 0;
903
}
904
905
int main (void)
906
{
907
NiceAgent *lagent, *ragent; /* agent's L and R */
908
NiceAddress baseaddr;
909
int result;
910
guint timer_id;
911
const char *stun_server = NULL, *stun_server_port = NULL;
912
913
g_type_init ();
914
g_thread_init (NULL);
915
global_mainloop = g_main_loop_new (NULL, FALSE);
916
917
/* Note: impl limits ...
918
* - no multi-stream support
919
* - no IPv6 support
920
*/
921
922
/* step: create the agents L and R */
923
lagent = nice_agent_new (g_main_loop_get_context (global_mainloop), NICE_COMPATIBILITY);
924
ragent = nice_agent_new (g_main_loop_get_context (global_mainloop), NICE_COMPATIBILITY);
925
926
/* step: add a timer to catch state changes triggered by signals */
927
#if USE_TURN
928
timer_id = g_timeout_add (300000, timer_cb, NULL);
929
#else
930
timer_id = g_timeout_add (30000, timer_cb, NULL);
931
#endif
932
933
/* step: specify which local interface to use */
934
#if USE_LOOPBACK
935
if (!nice_address_set_from_string (&baseaddr, "127.0.0.1"))
936
g_assert_not_reached ();
937
nice_agent_add_local_address (lagent, &baseaddr);
938
nice_agent_add_local_address (ragent, &baseaddr);
939
#else
940
if (!nice_address_set_from_string (&baseaddr, "192.168.1.110"))
941
g_assert_not_reached ();
942
nice_agent_add_local_address (lagent, &baseaddr);
943
nice_agent_add_local_address (ragent, &baseaddr);
944
#endif
945
946
g_signal_connect (G_OBJECT (lagent), "candidate-gathering-done",
947
G_CALLBACK (cb_candidate_gathering_done), GUINT_TO_POINTER(1));
948
g_signal_connect (G_OBJECT (ragent), "candidate-gathering-done",
949
G_CALLBACK (cb_candidate_gathering_done), GUINT_TO_POINTER (2));
950
g_signal_connect (G_OBJECT (lagent), "component-state-changed",
951
G_CALLBACK (cb_component_state_changed), GUINT_TO_POINTER (1));
952
g_signal_connect (G_OBJECT (ragent), "component-state-changed",
953
G_CALLBACK (cb_component_state_changed), GUINT_TO_POINTER (2));
954
g_signal_connect (G_OBJECT (lagent), "new-selected-pair",
955
G_CALLBACK (cb_new_selected_pair), GUINT_TO_POINTER(1));
956
g_signal_connect (G_OBJECT (ragent), "new-selected-pair",
957
G_CALLBACK (cb_new_selected_pair), GUINT_TO_POINTER (2));
958
g_signal_connect (G_OBJECT (lagent), "new-candidate",
959
G_CALLBACK (cb_new_candidate), GUINT_TO_POINTER (1));
960
g_signal_connect (G_OBJECT (ragent), "new-candidate",
961
G_CALLBACK (cb_new_candidate), GUINT_TO_POINTER (2));
962
g_signal_connect (G_OBJECT (lagent), "initial-binding-request-received",
963
G_CALLBACK (cb_initial_binding_request_received),
964
GUINT_TO_POINTER (1));
965
g_signal_connect (G_OBJECT (ragent), "initial-binding-request-received",
966
G_CALLBACK (cb_initial_binding_request_received),
967
GUINT_TO_POINTER (2));
968
969
stun_server = getenv ("NICE_STUN_SERVER");
970
stun_server_port = getenv ("NICE_STUN_SERVER_PORT");
971
if (stun_server) {
972
g_object_set (G_OBJECT (lagent), "stun-server", stun_server, NULL);
973
g_object_set (G_OBJECT (lagent), "stun-server-port", atoi (stun_server_port), NULL);
974
g_object_set (G_OBJECT (ragent), "stun-server", stun_server, NULL);
975
g_object_set (G_OBJECT (ragent), "stun-server-port", atoi (stun_server_port), NULL);
976
}
977
978
g_object_set (G_OBJECT (lagent), "proxy-ip", PROXY_IP, NULL);
979
g_object_set (G_OBJECT (lagent), "proxy-port", PROXY_PORT, NULL);
980
g_object_set (G_OBJECT (lagent), "proxy-type", PROXY_TYPE, NULL);
981
g_object_set (G_OBJECT (lagent), "proxy-username", PROXY_USERNAME, NULL);
982
g_object_set (G_OBJECT (lagent), "proxy-password", PROXY_PASSWORD, NULL);
983
g_object_set (G_OBJECT (ragent), "proxy-ip", PROXY_IP, NULL);
984
g_object_set (G_OBJECT (ragent), "proxy-port", PROXY_PORT, NULL);
985
g_object_set (G_OBJECT (ragent), "proxy-type", PROXY_TYPE, NULL);
986
g_object_set (G_OBJECT (ragent), "proxy-username", PROXY_USERNAME, NULL);
987
g_object_set (G_OBJECT (ragent), "proxy-password", PROXY_PASSWORD, NULL);
988
989
/* step: test setter/getter functions for properties */
990
{
991
guint max_checks = 0;
992
gchar *string = NULL;
993
guint port = 0;
994
gboolean mode = FALSE;
995
g_object_get (G_OBJECT (lagent), "stun-server", &string, NULL);
996
g_assert (stun_server == NULL || strcmp (string, stun_server) == 0);
997
g_free (string);
998
g_object_get (G_OBJECT (lagent), "stun-server-port", &port, NULL);
999
g_assert (stun_server_port == NULL || port == (guint)atoi (stun_server_port));
1000
g_object_get (G_OBJECT (lagent), "proxy-ip", &string, NULL);
1001
g_assert (strcmp (string, PROXY_IP) == 0);
1002
g_free (string);
1003
g_object_get (G_OBJECT (lagent), "proxy-port", &port, NULL);
1004
g_assert (port == PROXY_PORT);
1005
g_object_get (G_OBJECT (lagent), "controlling-mode", &mode, NULL);
1006
g_assert (mode == TRUE);
1007
g_object_set (G_OBJECT (lagent), "max-connectivity-checks", 300, NULL);
1008
g_object_get (G_OBJECT (lagent), "max-connectivity-checks", &max_checks, NULL);
1009
g_assert (max_checks == 300);
1010
}
1011
1012
/* step: run test the first time */
1013
g_debug ("test-fullmode: TEST STARTS / running test for the 1st time");
1014
result = run_full_test (lagent, ragent, &baseaddr, 4 ,0);
1015
priv_print_global_status ();
1016
g_assert (result == 0);
1017
g_assert (global_lagent_state[0] == NICE_COMPONENT_STATE_READY);
1018
g_assert (global_lagent_state[1] == NICE_COMPONENT_STATE_READY);
1019
g_assert (global_ragent_state[0] == NICE_COMPONENT_STATE_READY);
1020
g_assert (global_ragent_state[1] == NICE_COMPONENT_STATE_READY);
1021
/* note: verify that correct number of local candidates were reported */
1022
g_assert (global_lagent_cands == 2);
1023
g_assert (global_ragent_cands == 2);
1024
1025
1026
/* step: run test again without unref'ing agents */
1027
g_debug ("test-fullmode: TEST STARTS / running test for the 2nd time");
1028
result = run_full_test (lagent, ragent, &baseaddr, 4, 0);
1029
priv_print_global_status ();
1030
g_assert (result == 0);
1031
g_assert (global_lagent_state[0] == NICE_COMPONENT_STATE_READY);
1032
g_assert (global_lagent_state[1] == NICE_COMPONENT_STATE_READY);
1033
g_assert (global_ragent_state[0] == NICE_COMPONENT_STATE_READY);
1034
g_assert (global_ragent_state[1] == NICE_COMPONENT_STATE_READY);
1035
/* note: verify that correct number of local candidates were reported */
1036
g_assert (global_lagent_cands == 2);
1037
g_assert (global_ragent_cands == 2);
1038
1039
#if TEST_GOOGLE
1040
return result;
1041
#endif
1042
1043
/* step: run test simulating delayed SDP answer */
1044
g_debug ("test-fullmode: TEST STARTS / delayed SDP answer");
1045
result = run_full_test_delayed_answer (lagent, ragent, &baseaddr, 4, 0);
1046
priv_print_global_status ();
1047
g_assert (result == 0);
1048
g_assert (global_lagent_state[0] == NICE_COMPONENT_STATE_READY);
1049
g_assert (global_lagent_state[1] == NICE_COMPONENT_STATE_READY);
1050
g_assert (global_ragent_state[0] == NICE_COMPONENT_STATE_READY);
1051
g_assert (global_ragent_state[1] == NICE_COMPONENT_STATE_READY);
1052
/* note: verify that correct number of local candidates were reported */
1053
g_assert (global_lagent_cands == 2);
1054
g_assert (global_ragent_cands == 2);
1055
1056
1057
/* run test with incorrect credentials (make sure process fails) */
1058
g_debug ("test-fullmode: TEST STARTS / incorrect credentials");
1059
result = run_full_test_wrong_password (lagent, ragent, &baseaddr);
1060
priv_print_global_status ();
1061
g_assert (result == 0);
1062
g_assert (global_lagent_state[0] == NICE_COMPONENT_STATE_FAILED);
1063
g_assert (global_lagent_state[1] == NICE_COMPONENT_STATE_LAST);
1064
g_assert (global_ragent_state[0] == NICE_COMPONENT_STATE_FAILED);
1065
g_assert (global_ragent_state[1] == NICE_COMPONENT_STATE_LAST);
1066
1067
/* The max connectivity checks test can't be run with TURN because
1068
we'll have 3 local candidates instead of 1 and the checks will
1069
be random, so we can't predict how many will fail/succeed */
1070
#if USE_TURN == 0
1071
1072
/* step: run test with a hard limit for connecitivity checks */
1073
g_debug ("test-fullmode: TEST STARTS / max connectivity checks");
1074
g_object_set (G_OBJECT (lagent), "max-connectivity-checks", 1, NULL);
1075
g_object_set (G_OBJECT (ragent), "max-connectivity-checks", 1, NULL);
1076
result = run_full_test (lagent, ragent, &baseaddr, 2, 2);
1077
priv_print_global_status ();
1078
g_assert (result == 0);
1079
/* should FAIL as agent L can't send any checks: */
1080
g_assert (global_lagent_state[0] == NICE_COMPONENT_STATE_FAILED ||
1081
global_lagent_state[1] == NICE_COMPONENT_STATE_FAILED);
1082
g_assert (global_lagent_state[0] == NICE_COMPONENT_STATE_FAILED ||
1083
global_lagent_state[1] == NICE_COMPONENT_STATE_FAILED);
1084
#endif
1085
1086
g_object_set (G_OBJECT (lagent), "max-connectivity-checks", 100, NULL);
1087
g_object_set (G_OBJECT (ragent), "max-connectivity-checks", 100, NULL);
1088
result = run_full_test (lagent, ragent, &baseaddr, 4, 0);
1089
priv_print_global_status ();
1090
/* should SUCCEED as agent L can send the checks: */
1091
g_assert (result == 0);
1092
g_assert (global_lagent_state[0] == NICE_COMPONENT_STATE_READY);
1093
g_assert (global_lagent_state[1] == NICE_COMPONENT_STATE_READY);
1094
g_assert (global_ragent_state[0] == NICE_COMPONENT_STATE_READY);
1095
g_assert (global_ragent_state[1] == NICE_COMPONENT_STATE_READY);
1096
g_object_set (G_OBJECT (lagent), "max-connectivity-checks", 100, NULL);
1097
1098
/* run test with a conflict in controlling mode: controlling-controlling */
1099
g_debug ("test-fullmode: TEST STARTS / controlling mode conflict case-1");
1100
result = run_full_test_control_conflict (lagent, ragent, &baseaddr, TRUE);
1101
priv_print_global_status ();
1102
g_assert (result == 0);
1103
1104
g_assert (global_lagent_state[0] == NICE_COMPONENT_STATE_READY);
1105
g_assert (global_lagent_state[1] == NICE_COMPONENT_STATE_READY);
1106
g_assert (global_ragent_state[0] == NICE_COMPONENT_STATE_READY);
1107
g_assert (global_ragent_state[1] == NICE_COMPONENT_STATE_READY);
1108
1109
/* run test with a conflict in controlling mode: controlled-controlled */
1110
g_debug ("test-fullmode: TEST STARTS / controlling mode conflict case-2");
1111
result = run_full_test_control_conflict (lagent, ragent, &baseaddr, FALSE);
1112
priv_print_global_status ();
1113
g_assert (result == 0);
1114
g_assert (global_lagent_state[0] == NICE_COMPONENT_STATE_READY);
1115
g_assert (global_lagent_state[1] == NICE_COMPONENT_STATE_READY);
1116
g_assert (global_ragent_state[0] == NICE_COMPONENT_STATE_READY);
1117
g_assert (global_ragent_state[1] == NICE_COMPONENT_STATE_READY);
1118
1119
g_object_unref (lagent);
1120
g_object_unref (ragent);
1121
1122
g_main_loop_unref (global_mainloop);
1123
global_mainloop = NULL;
1124
1125
g_source_remove (timer_id);
1126
1127
return result;
1128
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1