1 /**
2 * @file test/ua.c Baresip selftest -- User-Agent (UA)
3 *
4 * Copyright (C) 2010 Creytiv.com
5 */
6 #include <string.h>
7 #include <re.h>
8 #include <baresip.h>
9 #include "test.h"
10 #include "sip/sipsrv.h"
11
12
13 #define MAGIC 0x9044bbfc
14
15
16 struct test {
17 struct sip_server *srvv[16];
18 size_t srvc;
19 struct ua *ua;
20 int err;
21 unsigned got_register_ok;
22 unsigned n_resp;
23 uint32_t magic;
24 };
25
26
test_init(struct test * t)27 static void test_init(struct test *t)
28 {
29 memset(t, 0, sizeof(*t));
30 t->magic = MAGIC;
31 }
32
33
test_reset(struct test * t)34 static void test_reset(struct test *t)
35 {
36 size_t i;
37
38 for (i=0; i<ARRAY_SIZE(t->srvv); i++)
39 mem_deref(t->srvv[i]);
40 mem_deref(t->ua);
41
42 memset(t, 0, sizeof(*t));
43 }
44
45
test_abort(struct test * t,int err)46 static void test_abort(struct test *t, int err)
47 {
48 t->err = err;
49 re_cancel();
50 }
51
52
ua_event_handler(struct ua * ua,enum ua_event ev,struct call * call,const char * prm,void * arg)53 static void ua_event_handler(struct ua *ua, enum ua_event ev,
54 struct call *call, const char *prm, void *arg)
55 {
56 struct test *t = arg;
57 size_t i;
58 int err = 0;
59 (void)call;
60 (void)prm;
61
62 ASSERT_TRUE(t != NULL);
63
64 if (ua != t->ua)
65 return;
66
67 if (ev == UA_EVENT_REGISTER_OK) {
68
69 info("event: Register OK!\n");
70
71 ++t->got_register_ok;
72
73 /* verify register success */
74 ASSERT_TRUE(ua_isregistered(t->ua));
75
76 /* Terminate SIP Server, then De-REGISTER */
77 for (i=0; i<t->srvc; i++)
78 t->srvv[i]->terminate = true;
79
80 t->ua = mem_deref(t->ua);
81 }
82 else if (ev == UA_EVENT_REGISTER_FAIL) {
83
84 err = EAUTH;
85 re_cancel();
86 }
87
88 out:
89 if (err) {
90 warning("selftest: event handler error: %m\n", err);
91 t->err = err;
92 }
93 }
94
95
reg(enum sip_transp tp)96 static int reg(enum sip_transp tp)
97 {
98 struct test t;
99 char aor[256];
100 int err;
101
102 memset(&t, 0, sizeof t);
103
104 err = sip_server_alloc(&t.srvv[0]);
105 if (err) {
106 warning("failed to create sip server (%d/%m)\n", err, err);
107 goto out;
108 }
109
110 err = sip_server_uri(t.srvv[0], aor, sizeof(aor), tp);
111 TEST_ERR(err);
112
113 err = ua_alloc(&t.ua, aor);
114 TEST_ERR(err);
115
116 err = uag_event_register(ua_event_handler, &t);
117 if (err)
118 goto out;
119
120 /* run main-loop with timeout, wait for events */
121 err = re_main_timeout(5000);
122 if (err)
123 goto out;
124
125 if (t.err)
126 err = t.err;
127
128 ASSERT_TRUE(t.srvv[0]->n_register_req > 0);
129 ASSERT_EQ(tp, t.srvv[0]->tp_last);
130 ASSERT_TRUE(t.got_register_ok > 0);
131
132 out:
133 if (err) {
134 warning("selftest: ua_register test failed (%m)\n", err);
135 }
136 uag_event_unregister(ua_event_handler);
137 test_reset(&t);
138
139 return err;
140 }
141
142
test_ua_register(void)143 int test_ua_register(void)
144 {
145 int err = 0;
146
147 err = ua_init("test", true, true, true, false);
148 TEST_ERR(err);
149
150 err |= reg(SIP_TRANSP_UDP);
151 err |= reg(SIP_TRANSP_TCP);
152 #ifdef USE_TLS
153 err |= reg(SIP_TRANSP_TLS);
154 #endif
155
156 ua_close();
157
158 out:
159 return err;
160 }
161
162
test_ua_alloc(void)163 int test_ua_alloc(void)
164 {
165 struct ua *ua;
166 uint32_t n_uas = list_count(uag_list());
167 int err = 0;
168
169 /* make sure we dont have that UA already */
170 ASSERT_TRUE(NULL == uag_find_aor("sip:user@127.0.0.1"));
171
172 err = ua_alloc(&ua, "Foo <sip:user@127.0.0.1>;regint=0");
173 if (err)
174 return err;
175
176 /* verify this UA-instance */
177 ASSERT_TRUE(!ua_isregistered(ua));
178 ASSERT_STREQ("sip:user@127.0.0.1", ua_aor(ua));
179 ASSERT_TRUE(NULL == ua_call(ua));
180
181 /* verify global UA keeper */
182 ASSERT_EQ((n_uas + 1), list_count(uag_list()));
183 ASSERT_TRUE(ua == uag_find_aor("sip:user@127.0.0.1"));
184
185 mem_deref(ua);
186
187 ASSERT_EQ((n_uas), list_count(uag_list()));
188
189 out:
190 return err;
191 }
192
193
test_uag_find_param(void)194 int test_uag_find_param(void)
195 {
196 struct ua *ua1 = NULL, *ua2 = NULL;
197 int err = 0;
198
199 ASSERT_TRUE(NULL == uag_find_param("not", "found"));
200
201 err = ua_alloc(&ua1, "<sip:x@127.0.0.1>;regint=0;abc");
202 err |= ua_alloc(&ua2, "<sip:x@127.0.0.1>;regint=0;def=123");
203 if (err)
204 goto out;
205
206 ASSERT_TRUE(ua1 == uag_find_param("abc", NULL));
207 ASSERT_TRUE(NULL == uag_find_param("abc", "123"));
208 ASSERT_TRUE(ua2 == uag_find_param("def", NULL));
209 ASSERT_TRUE(ua2 == uag_find_param("def", "123"));
210
211 ASSERT_TRUE(NULL == uag_find_param("not", "found"));
212
213 out:
214 mem_deref(ua2);
215 mem_deref(ua1);
216
217 return err;
218 }
219
220
_sip_transp_srvid(enum sip_transp tp)221 static const char *_sip_transp_srvid(enum sip_transp tp)
222 {
223 switch (tp) {
224
225 case SIP_TRANSP_UDP: return "_sip._udp";
226 case SIP_TRANSP_TCP: return "_sip._tcp";
227 case SIP_TRANSP_TLS: return "_sips._tcp";
228 default: return "???";
229 }
230 }
231
232
reg_dns(enum sip_transp tp)233 static int reg_dns(enum sip_transp tp)
234 {
235 struct dns_server *dnssrv = NULL;
236 struct test t;
237 const char *domain = "test.invalid";
238 struct network *net = baresip_network();
239 unsigned server_count = 1;
240 char aor[256];
241 char srv[256];
242 size_t i;
243 int err;
244
245 memset(&t, 0, sizeof t);
246
247 /*
248 * Setup server-side mocks:
249 */
250
251 err = dns_server_alloc(&dnssrv, true);
252 TEST_ERR(err);
253
254 info("| DNS-server on %J\n", &dnssrv->addr);
255
256 /* NOTE: must be done before ua_init() */
257 err = net_use_nameserver(net, &dnssrv->addr);
258 TEST_ERR(err);
259
260 for (i=0; i<server_count; i++) {
261 struct sa sip_addr;
262 char arec[256];
263
264 err = sip_server_alloc(&t.srvv[i]);
265 if (err) {
266 warning("failed to create sip server (%d/%m)\n",
267 err, err);
268 goto out;
269 }
270
271 err = domain_add(t.srvv[0], domain);
272 if (err)
273 goto out;
274
275 err = sip_transp_laddr(t.srvv[i]->sip, &sip_addr, tp, NULL);
276 TEST_ERR(err);
277
278 info("| SIP-server on %J\n", &sip_addr);
279
280 re_snprintf(arec, sizeof(arec),
281 "alpha%u.%s", i+1, domain);
282
283 re_snprintf(srv, sizeof(srv),
284 "%s.%s", _sip_transp_srvid(tp), domain);
285 err = dns_server_add_srv(dnssrv, srv,
286 20, 0, sa_port(&sip_addr),
287 arec);
288 TEST_ERR(err);
289
290 err = dns_server_add_a(dnssrv, arec, sa_in(&sip_addr));
291 TEST_ERR(err);
292 }
293 t.srvc = server_count;
294
295 /* NOTE: angel brackets needed to parse ;transport parameter */
296 if (re_snprintf(aor, sizeof(aor), "<sip:x@%s;transport=%s>",
297 domain, sip_transp_name(tp)) < 0)
298 return ENOMEM;
299
300 /*
301 * Start SIP client:
302 */
303
304 err = ua_init("test", true, true, true, false);
305 TEST_ERR(err);
306
307 err = ua_alloc(&t.ua, aor);
308 TEST_ERR(err);
309
310 err = uag_event_register(ua_event_handler, &t);
311 if (err)
312 goto out;
313
314 /* run main-loop with timeout, wait for events */
315 err = re_main_timeout(5000);
316 if (err)
317 goto out;
318
319 if (t.err)
320 err = t.err;
321
322 /* verify that all SIP requests was sent to the first
323 * SIP-server.
324 */
325 ASSERT_TRUE(t.srvv[0]->n_register_req > 0);
326 ASSERT_EQ(tp, t.srvv[0]->tp_last);
327 ASSERT_TRUE(t.got_register_ok > 0);
328
329 out:
330 if (err) {
331 warning("selftest: ua_register test failed (%m)\n", err);
332 }
333 uag_event_unregister(ua_event_handler);
334
335 test_reset(&t);
336
337 ua_stop_all(true);
338 ua_close();
339
340 mem_deref(dnssrv);
341
342 return err;
343 }
344
345
test_ua_register_dns(void)346 int test_ua_register_dns(void)
347 {
348 int err = 0;
349
350 err |= reg_dns(SIP_TRANSP_UDP);
351 TEST_ERR(err);
352 err |= reg_dns(SIP_TRANSP_TCP);
353 TEST_ERR(err);
354 #ifdef USE_TLS
355 err |= reg_dns(SIP_TRANSP_TLS);
356 TEST_ERR(err);
357 #endif
358
359 out:
360 return err;
361 }
362
363
364 #define USER "alfredh"
365 #define PASS "pass@word"
366 #define DOMAIN "localhost"
367
reg_auth(enum sip_transp tp)368 static int reg_auth(enum sip_transp tp)
369 {
370 struct sa laddr;
371 struct test t;
372 char aor[256];
373 int err;
374
375 memset(&t, 0, sizeof t);
376
377 err = sip_server_alloc(&t.srvv[0]);
378 if (err) {
379 warning("failed to create sip server (%d/%m)\n", err, err);
380 goto out;
381 }
382
383 err = domain_add(t.srvv[0], DOMAIN);
384 TEST_ERR(err);
385
386 err = user_add(domain_lookup(t.srvv[0], DOMAIN)->ht_usr,
387 USER, PASS, DOMAIN);
388 TEST_ERR(err);
389
390 t.srvv[0]->auth_enabled = true;
391
392 err = sip_transp_laddr(t.srvv[0]->sip, &laddr, tp, NULL);
393 if (err)
394 return err;
395
396 /* NOTE: angel brackets needed to parse ;transport parameter */
397 if (re_snprintf(aor, sizeof(aor),
398 "<sip:%s@%s>"
399 ";auth_pass=%s"
400 ";outbound=\"sip:%J;transport=%s\"",
401 USER,
402 DOMAIN,
403 PASS,
404 &laddr,
405 sip_transp_name(tp)) < 0)
406 return ENOMEM;
407
408 err = ua_alloc(&t.ua, aor);
409 TEST_ERR(err);
410
411 err = uag_event_register(ua_event_handler, &t);
412 if (err)
413 goto out;
414
415 /* run main-loop with timeout, wait for events */
416 err = re_main_timeout(5000);
417 if (err)
418 goto out;
419
420 if (t.err) {
421 err = t.err;
422 goto out;
423 }
424
425 ASSERT_TRUE(t.srvv[0]->n_register_req > 0);
426 ASSERT_EQ(tp, t.srvv[0]->tp_last);
427 ASSERT_TRUE(t.got_register_ok > 0);
428
429 out:
430 if (err) {
431 warning("selftest: ua_register test failed (%m)\n", err);
432 }
433 uag_event_unregister(ua_event_handler);
434 test_reset(&t);
435
436
437 return err;
438 }
439
440
test_ua_register_auth(void)441 int test_ua_register_auth(void)
442 {
443 int err;
444
445 err = ua_init("test", true, true, true, false);
446 TEST_ERR(err);
447
448 err |= reg_auth(SIP_TRANSP_UDP);
449 TEST_ERR(err);
450 err |= reg_auth(SIP_TRANSP_TCP);
451 TEST_ERR(err);
452 #ifdef USE_TLS
453 err |= reg_auth(SIP_TRANSP_TLS);
454 TEST_ERR(err);
455 #endif
456
457 out:
458 ua_stop_all(true);
459 ua_close();
460
461 return err;
462 }
463
464
reg_auth_dns(enum sip_transp tp)465 static int reg_auth_dns(enum sip_transp tp)
466 {
467 struct network *net = baresip_network();
468 struct dns_server *dnssrv = NULL;
469 struct test t;
470 const char *username = "alfredh";
471 const char *password = "password";
472 const char *domain = "test.invalid";
473 unsigned server_count = 2;
474 char aor[256];
475 char srv[256];
476 unsigned i;
477 unsigned total_req = 0;
478 int err;
479
480 memset(&t, 0, sizeof t);
481
482 /*
483 * Setup server-side mocks:
484 */
485
486 err = dns_server_alloc(&dnssrv, true);
487 TEST_ERR(err);
488
489 info("| DNS-server on %J\n", &dnssrv->addr);
490
491 /* NOTE: must be done before ua_init() */
492 err = net_use_nameserver(net, &dnssrv->addr);
493 TEST_ERR(err);
494
495 for (i=0; i<server_count; i++) {
496 struct sa sip_addr;
497 char arec[256];
498
499 err = sip_server_alloc(&t.srvv[i]);
500 if (err) {
501 warning("failed to create sip server (%d/%m)\n",
502 err, err);
503 goto out;
504 }
505
506 t.srvv[i]->instance = i;
507
508 #if 1
509 /* Comment this out to have different random secrets
510 * on each SIP-Server instance */
511 t.srvv[i]->secret = 42;
512 #endif
513
514 err = domain_add(t.srvv[i], domain);
515 if (err)
516 goto out;
517
518 err = user_add(domain_lookup(t.srvv[i], domain)->ht_usr,
519 username, password, domain);
520 TEST_ERR(err);
521
522 t.srvv[i]->auth_enabled = true;
523
524 err = sip_transp_laddr(t.srvv[i]->sip, &sip_addr, tp, NULL);
525 TEST_ERR(err);
526
527 info("| SIP-server on %J\n", &sip_addr);
528
529 re_snprintf(arec, sizeof(arec),
530 "alpha%u.%s", i+1, domain);
531
532 re_snprintf(srv, sizeof(srv),
533 "%s.%s", _sip_transp_srvid(tp), domain);
534 err = dns_server_add_srv(dnssrv, srv,
535 20, 0, sa_port(&sip_addr),
536 arec);
537 TEST_ERR(err);
538
539 err = dns_server_add_a(dnssrv, arec, sa_in(&sip_addr));
540 TEST_ERR(err);
541 }
542 t.srvc = server_count;
543
544 /* NOTE: angel brackets needed to parse ;transport parameter */
545 if (re_snprintf(aor, sizeof(aor),
546 "<sip:%s@%s;transport=%s>;auth_pass=%s",
547 username, domain, sip_transp_name(tp),
548 password) < 0)
549 return ENOMEM;
550
551 /*
552 * Start SIP client:
553 */
554
555 err = ua_init("test", true, true, true, false);
556 TEST_ERR(err);
557
558 err = ua_alloc(&t.ua, aor);
559 TEST_ERR(err);
560
561 err = uag_event_register(ua_event_handler, &t);
562 if (err)
563 goto out;
564
565 /* run main-loop with timeout, wait for events */
566 err = re_main_timeout(5000);
567 if (err)
568 goto out;
569
570 if (t.err) {
571 err = t.err;
572 goto out;
573 }
574
575 /* verify that all SIP requests was sent to the
576 * SIP-servers.
577 */
578 for (i=0; i<server_count; i++) {
579
580 total_req += t.srvv[i]->n_register_req;
581
582 if (t.srvv[i]->n_register_req) {
583 ASSERT_EQ(tp, t.srvv[i]->tp_last);
584 }
585 }
586 ASSERT_TRUE(total_req >= 2);
587 ASSERT_TRUE(t.got_register_ok > 0);
588
589 out:
590 if (err) {
591 warning("selftest: ua_register test failed (%m)\n", err);
592 }
593 uag_event_unregister(ua_event_handler);
594
595 test_reset(&t);
596
597 ua_stop_all(true);
598 ua_close();
599
600 mem_deref(dnssrv);
601
602 return err;
603 }
604
605
test_ua_register_auth_dns(void)606 int test_ua_register_auth_dns(void)
607 {
608 int err = 0;
609
610 err |= reg_auth_dns(SIP_TRANSP_UDP);
611 TEST_ERR(err);
612 err |= reg_auth_dns(SIP_TRANSP_TCP);
613 TEST_ERR(err);
614 #ifdef USE_TLS
615 err |= reg_auth_dns(SIP_TRANSP_TLS);
616 TEST_ERR(err);
617 #endif
618
619 out:
620 return err;
621 }
622
623
options_resp_handler(int err,const struct sip_msg * msg,void * arg)624 static void options_resp_handler(int err, const struct sip_msg *msg, void *arg)
625 {
626 struct test *t = arg;
627 const struct sip_hdr *hdr;
628 struct pl content;
629 uint32_t clen;
630
631 ASSERT_EQ(MAGIC, t->magic);
632
633 if (err) {
634 test_abort(t, err);
635 return;
636 }
637 if (msg->scode != 200) {
638 test_abort(t, EPROTO);
639 return;
640 }
641
642 ++t->n_resp;
643
644 /* Verify SIP headers */
645
646 ASSERT_TRUE(sip_msg_hdr_has_value(msg, SIP_HDR_ALLOW, "INVITE"));
647 ASSERT_TRUE(sip_msg_hdr_has_value(msg, SIP_HDR_ALLOW, "ACK"));
648 ASSERT_TRUE(sip_msg_hdr_has_value(msg, SIP_HDR_ALLOW, "BYE"));
649 ASSERT_TRUE(sip_msg_hdr_has_value(msg, SIP_HDR_ALLOW, "CANCEL"));
650
651 hdr = sip_msg_hdr(msg, SIP_HDR_CONTACT);
652 ASSERT_TRUE(hdr != NULL);
653 ASSERT_TRUE(hdr->val.l != 0);
654
655 ASSERT_EQ(0, pl_strcasecmp(&msg->ctyp.type, "application"));
656 ASSERT_EQ(0, pl_strcasecmp(&msg->ctyp.subtype, "sdp"));
657
658 clen = pl_u32(&msg->clen);
659 ASSERT_TRUE(clen > 0);
660
661 /* Verify the SDP content */
662
663 pl_set_mbuf(&content, msg->mb);
664
665 ASSERT_EQ(0, re_regex(content.p, content.l, "v=0"));
666 ASSERT_EQ(0, re_regex(content.p, content.l, "a=tool:baresip"));
667 ASSERT_EQ(0, re_regex(content.p, content.l, "m=audio"));
668
669 out:
670 if (err)
671 t->err = err;
672 re_cancel();
673 }
674
675
test_ua_options(void)676 int test_ua_options(void)
677 {
678 struct test t;
679 struct sa laddr;
680 char uri[256];
681 int n, err = 0;
682
683 test_init(&t);
684
685 err = ua_init("test", true, false, false, false);
686 TEST_ERR(err);
687
688 err = sip_transp_laddr(uag_sip(), &laddr, SIP_TRANSP_UDP, NULL);
689 TEST_ERR(err);
690
691 err = ua_alloc(&t.ua, "Foo <sip:user@127.0.0.1>;regint=0");
692 TEST_ERR(err);
693
694 n = re_snprintf(uri, sizeof(uri),
695 "sip:user@127.0.0.1:%u", sa_port(&laddr));
696 ASSERT_TRUE(n > 0);
697
698 err = ua_options_send(t.ua, uri, options_resp_handler, &t);
699 TEST_ERR(err);
700
701 /* run main-loop with timeout, wait for events */
702 err = re_main_timeout(5000);
703 if (err)
704 goto out;
705
706 TEST_ERR(t.err);
707
708 /* verify after test is complete */
709 ASSERT_EQ(1, t.n_resp);
710
711 out:
712 test_reset(&t);
713
714 ua_stop_all(true);
715 ua_close();
716
717 return err;
718 }
719