2 * Asterisk -- An open source telephony toolkit.
4 * Copyright (C) 2010, Digium, Inc.
6 * See http://www.asterisk.org for more information about
7 * the Asterisk project. Please do not directly contact
8 * any of the maintainers of this project for assistance;
9 * the project provides a web site, mailing lists and IRC
10 * channels for your use.
12 * This program is free software, distributed under the terms of
13 * the GNU General Public License Version 2. See the LICENSE file
14 * at the top of the source tree.
19 * \brief sip request parsing functions and unit tests
24 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
26 #include "include/sip.h"
27 #include "include/sip_utils.h"
28 #include "include/reqresp_parser.h"
34 /*! \brief * parses a URI in its components.*/
35 int parse_uri_full(char *uri, const char *scheme, char **user, char **pass,
36 char **hostport, struct uriparams *params, char **headers,
39 char *userinfo = NULL;
40 char *parameters = NULL;
41 char *endparams = NULL;
46 * Initialize requested strings - some functions don't care if parse_uri fails
47 * and will attempt to use string pointers passed into parse_uri even after a
66 /* check for valid input */
67 if (ast_strlen_zero(uri)) {
73 char *scheme2 = ast_strdupa(scheme);
74 char *cur = strsep(&scheme2, ",");
75 for (; !ast_strlen_zero(cur); cur = strsep(&scheme2, ",")) {
77 if (!strncasecmp(uri, cur, l)) {
82 if (ast_strlen_zero(cur)) {
83 ast_debug(1, "No supported scheme found in '%s' using the scheme[s] %s\n", uri, scheme);
89 /* if we don't want to split around hostport, keep everything as a
90 * userinfo - cos thats how old parse_uri operated*/
94 if ((c = strchr(uri, '@'))) {
98 uri = c; /* userinfo can contain ? and ; chars so step forward before looking for params and headers */
100 /* domain-only URI, according to the SIP RFC. */
108 if (pass && (c = strchr(userinfo, ':'))) { /* user:password */
120 /* strip [?headers] from end of uri - even if no header pointer exists*/
121 if ((c = strrchr(uri, '?'))) {
127 if ((c = strrchr(uri, ';'))) {
130 c = strrchr(uri, '\0');
132 uri = c; /* residue */
135 } else if (headers) {
139 /* parse parameters */
140 endparams = strchr(parameters,'\0');
141 if ((c = strchr(parameters, ';'))) {
145 parameters = endparams;
149 char *rem = parameters; /* unparsed or unrecognised remainder */
154 params->transport = "";
163 while ((value = strchr(parameters, '=')) || (lr = !strncmp(parameters, "lr", 2))) {
164 /* The while condition will not continue evaluation to set lr if it matches "lr=" */
171 if ((c = strchr(value, ';'))) {
175 parameters = endparams;
178 if (!strcmp(label, "transport")) {
179 params->transport = value;
181 } else if (!strcmp(label, "user")) {
182 params->user = value;
184 } else if (!strcmp(label, "method")) {
185 params->method = value;
187 } else if (!strcmp(label, "ttl")) {
190 } else if (!strcmp(label, "maddr")) {
191 params->maddr = value;
193 /* Treat "lr", "lr=yes", "lr=on", "lr=1", "lr=almostanything" as lr enabled and "", "lr=no", "lr=off", "lr=0", "lr=" and "lranything" as lr disabled */
194 } else if ((!strcmp(label, "lr") && strcmp(value, "no") && strcmp(value, "off") && strcmp(value, "0") && strcmp(value, "")) || ((lr) && strcmp(value, "lr"))) {
206 if (rem > uri) { /* no headers */
220 AST_TEST_DEFINE(sip_parse_uri_full_test)
222 int res = AST_TEST_PASS;
224 char *user, *pass, *hostport, *headers, *residue;
225 struct uriparams params;
235 struct uriparams params;
236 AST_LIST_ENTRY(testdata) list;
240 struct testdata *testdataptr;
242 static AST_LIST_HEAD_NOLOCK(testdataliststruct, testdata) testdatalist;
244 struct testdata td1 = {
245 .desc = "no headers",
246 .uri = "sip:user:secret@host:5060;param=discard;transport=tcp;param2=residue",
249 .hostport = "host:5060",
251 .residue = "param2=residue",
252 .params.transport = "tcp",
257 struct testdata td2 = {
258 .desc = "with headers",
259 .uri = "sip:user:secret@host:5060;param=discard;transport=tcp;param2=discard2?header=blah&header2=blah2;param3=residue",
262 .hostport = "host:5060",
263 .headers = "header=blah&header2=blah2",
264 .residue = "param3=residue",
265 .params.transport = "tcp",
270 struct testdata td3 = {
271 .desc = "difficult user",
272 .uri = "sip:-_.!~*'()&=+$,;?/:secret@host:5060;transport=tcp",
273 .user = "-_.!~*'()&=+$,;?/",
275 .hostport = "host:5060",
278 .params.transport = "tcp",
283 struct testdata td4 = {
284 .desc = "difficult pass",
285 .uri = "sip:user:-_.!~*'()&=+$,@host:5060;transport=tcp",
287 .pass = "-_.!~*'()&=+$,",
288 .hostport = "host:5060",
291 .params.transport = "tcp",
296 struct testdata td5 = {
297 .desc = "difficult host",
298 .uri = "sip:user:secret@1-1.a-1.:5060;transport=tcp",
301 .hostport = "1-1.a-1.:5060",
304 .params.transport = "tcp",
309 struct testdata td6 = {
310 .desc = "difficult params near transport",
311 .uri = "sip:user:secret@host:5060;-_.!~*'()[]/:&+$=-_.!~*'()[]/:&+$;transport=tcp",
314 .hostport = "host:5060",
317 .params.transport = "tcp",
322 struct testdata td7 = {
323 .desc = "difficult params near headers",
324 .uri = "sip:user:secret@host:5060;-_.!~*'()[]/:&+$=-_.!~*'()[]/:&+$?header=blah&header2=blah2;-_.!~*'()[]/:&+$=residue",
327 .hostport = "host:5060",
328 .headers = "header=blah&header2=blah2",
329 .residue = "-_.!~*'()[]/:&+$=residue",
330 .params.transport = "",
335 struct testdata td8 = {
336 .desc = "lr parameter",
337 .uri = "sip:user:secret@host:5060;param=discard;lr?header=blah",
340 .hostport = "host:5060",
341 .headers = "header=blah",
343 .params.transport = "",
348 struct testdata td9 = {
349 .desc = "alternative lr parameter",
350 .uri = "sip:user:secret@host:5060;param=discard;lr=yes?header=blah",
353 .hostport = "host:5060",
354 .headers = "header=blah",
356 .params.transport = "",
361 struct testdata td10 = {
362 .desc = "no lr parameter",
363 .uri = "sip:user:secret@host:5060;paramlr=lr;lr=no;lr=off;lr=0;lr=;=lr;lrextra;lrparam2=lr?header=blah",
366 .hostport = "host:5060",
367 .headers = "header=blah",
369 .params.transport = "",
375 AST_LIST_HEAD_SET_NOLOCK(&testdatalist, &td1);
376 AST_LIST_INSERT_TAIL(&testdatalist, &td2, list);
377 AST_LIST_INSERT_TAIL(&testdatalist, &td3, list);
378 AST_LIST_INSERT_TAIL(&testdatalist, &td4, list);
379 AST_LIST_INSERT_TAIL(&testdatalist, &td5, list);
380 AST_LIST_INSERT_TAIL(&testdatalist, &td6, list);
381 AST_LIST_INSERT_TAIL(&testdatalist, &td7, list);
382 AST_LIST_INSERT_TAIL(&testdatalist, &td8, list);
383 AST_LIST_INSERT_TAIL(&testdatalist, &td9, list);
384 AST_LIST_INSERT_TAIL(&testdatalist, &td10, list);
389 info->name = "sip_uri_full_parse_test";
390 info->category = "/channels/chan_sip/";
391 info->summary = "tests sip full uri parsing";
393 "Tests full parsing of various URIs "
394 "Verifies output matches expected behavior.";
395 return AST_TEST_NOT_RUN;
400 AST_LIST_TRAVERSE(&testdatalist, testdataptr, list) {
401 user = pass = hostport = headers = residue = NULL;
402 params.transport = params.user = params.method = params.ttl = params.maddr = NULL;
405 ast_copy_string(uri,testdataptr->uri,sizeof(uri));
406 if (parse_uri_full(uri, "sip:,sips:", &user,
411 (user && strcmp(testdataptr->user, user)) ||
412 (pass && strcmp(testdataptr->pass, pass)) ||
413 (hostport && strcmp(testdataptr->hostport, hostport)) ||
414 (headers && strcmp(testdataptr->headers, headers)) ||
415 (residue && strcmp(testdataptr->residue, residue)) ||
416 (strcmp(testdataptr->params.transport,params.transport)) ||
417 (testdataptr->params.lr != params.lr) ||
418 (strcmp(testdataptr->params.user,params.user))
420 ast_test_status_update(test, "Sub-Test: %s, failed.\n", testdataptr->desc);
430 int parse_uri(char *uri, const char *scheme, char **user, char **pass,
431 char **hostport, char **transport) {
434 struct uriparams params;
437 ret = parse_uri_full(uri, scheme, user, pass, hostport, ¶ms, &headers, NULL);
439 *transport=params.transport;
444 AST_TEST_DEFINE(sip_parse_uri_test)
446 int res = AST_TEST_PASS;
447 char *name, *pass, *hostport, *transport;
448 char uri1[] = "sip:name@host";
449 char uri2[] = "sip:name@host;transport=tcp";
450 char uri3[] = "sip:name:secret@host;transport=tcp";
451 char uri4[] = "sip:name:secret@host:port;transport=tcp?headers=%40%40testblah&headers2=blah%20blah";
452 /* test 5 is for NULL input */
453 char uri6[] = "sip:name:secret@host:port;transport=tcp?headers=%40%40testblah&headers2=blah%20blah";
454 char uri7[] = "sip:name:secret@host:port;transport=tcp?headers=%40%40testblah&headers2=blah%20blah";
455 char uri8[] = "sip:host";
456 char uri9[] = "sip:host:port;transport=tcp?headers=%40%40testblah&headers2=blah%20blah";
457 char uri10[] = "host:port;transport=tcp?headers=%40%40testblah&headers2=blah%20blah";
458 char uri11[] = "host";
462 info->name = "sip_uri_parse_test";
463 info->category = "/channels/chan_sip/";
464 info->summary = "tests sip uri parsing";
466 "Tests parsing of various URIs "
467 "Verifies output matches expected behavior.";
468 return AST_TEST_NOT_RUN;
473 /* Test 1, simple URI */
474 name = pass = hostport = transport = NULL;
475 if (parse_uri(uri1, "sip:,sips:", &name, &pass, &hostport, &transport) ||
476 strcmp(name, "name") ||
477 !ast_strlen_zero(pass) ||
478 strcmp(hostport, "host") ||
479 !ast_strlen_zero(transport)) {
480 ast_test_status_update(test, "Test 1: simple uri failed. \n");
484 /* Test 2, add tcp transport */
485 name = pass = hostport = transport = NULL;
486 if (parse_uri(uri2, "sip:,sips:", &name, &pass, &hostport, &transport) ||
487 strcmp(name, "name") ||
488 !ast_strlen_zero(pass) ||
489 strcmp(hostport, "host") ||
490 strcmp(transport, "tcp")) {
491 ast_test_status_update(test, "Test 2: uri with addtion of tcp transport failed. \n");
495 /* Test 3, add secret */
496 name = pass = hostport = transport = NULL;
497 if (parse_uri(uri3, "sip:,sips:", &name, &pass, &hostport, &transport) ||
498 strcmp(name, "name") ||
499 strcmp(pass, "secret") ||
500 strcmp(hostport, "host") ||
501 strcmp(transport, "tcp")) {
502 ast_test_status_update(test, "Test 3: uri with addition of secret failed.\n");
506 /* Test 4, add port and unparsed header field*/
507 name = pass = hostport = transport = NULL;
508 if (parse_uri(uri4, "sip:,sips:", &name, &pass, &hostport, &transport) ||
509 strcmp(name, "name") ||
510 strcmp(pass, "secret") ||
511 strcmp(hostport, "host:port") ||
512 strcmp(transport, "tcp")) {
513 ast_test_status_update(test, "Test 4: add port and unparsed header field failed.\n");
517 /* Test 5, verify parse_uri does not crash when given a NULL uri */
518 name = pass = hostport = transport = NULL;
519 if (!parse_uri(NULL, "sip:,sips:", &name, &pass, &hostport, &transport)) {
520 ast_test_status_update(test, "Test 5: passing a NULL uri failed.\n");
524 /* Test 6, verify parse_uri does not crash when given a NULL output parameters */
525 name = pass = hostport = transport = NULL;
526 if (parse_uri(uri6, "sip:,sips:", NULL, NULL, NULL, NULL)) {
527 ast_test_status_update(test, "Test 6: passing NULL output parameters failed.\n");
531 /* Test 7, verify parse_uri returns user:secret and hostport when no port or secret output parameters are supplied. */
532 name = pass = hostport = transport = NULL;
533 if (parse_uri(uri7, "sip:,sips:", &name, NULL, &hostport, NULL) ||
534 strcmp(name, "name:secret") ||
535 strcmp(hostport, "host:port")) {
537 ast_test_status_update(test, "Test 7: providing no port and secret output parameters failed.\n");
541 /* Test 8, verify parse_uri can handle a hostport only uri */
542 name = pass = hostport = transport = NULL;
543 if (parse_uri(uri8, "sip:,sips:", &name, &pass, &hostport, &transport) ||
544 strcmp(hostport, "host") ||
545 !ast_strlen_zero(name)) {
546 ast_test_status_update(test, "Test 8: add port and unparsed header field failed.\n");
550 /* Test 9, add port and unparsed header field with hostport only uri*/
551 name = pass = hostport = transport = NULL;
552 if (parse_uri(uri9, "sip:,sips:", &name, &pass, &hostport, &transport) ||
553 !ast_strlen_zero(name) ||
554 !ast_strlen_zero(pass) ||
555 strcmp(hostport, "host:port") ||
556 strcmp(transport, "tcp")) {
557 ast_test_status_update(test, "Test 9: hostport only uri failed \n");
561 /* Test 10, handle invalid/missing "sip:,sips:" scheme
562 * we expect parse_uri to return an error, but still parse
563 * the results correctly here */
564 name = pass = hostport = transport = NULL;
565 if (!parse_uri(uri10, "sip:,sips:", &name, &pass, &hostport, &transport) ||
566 !ast_strlen_zero(name) ||
567 !ast_strlen_zero(pass) ||
568 strcmp(hostport, "host:port") ||
569 strcmp(transport, "tcp")) {
570 ast_test_status_update(test, "Test 10: missing \"sip:sips:\" scheme failed\n");
574 /* Test 11, simple hostport only URI with missing scheme
575 * we expect parse_uri to return an error, but still parse
576 * the results correctly here */
577 name = pass = hostport = transport = NULL;
578 if (!parse_uri(uri11, "sip:,sips:", &name, &pass, &hostport, &transport) ||
579 !ast_strlen_zero(name) ||
580 !ast_strlen_zero(pass) ||
581 strcmp(hostport, "host") ||
582 !ast_strlen_zero(transport)) {
583 ast_test_status_update(test, "Test 11: simple uri with missing scheme failed. \n");
590 /*! \brief Get caller id name from SIP headers, copy into output buffer
592 * \retval input string pointer placed after display-name field if possible
594 const char *get_calleridname(const char *input, char *output, size_t outputsize)
598 * From = ( "From" / "f" ) HCOLON from-spec
599 * from-spec = ( name-addr / addr-spec ) *( SEMI from-param )
600 * name-addr = [ display-name ] LAQUOT addr-spec RAQUOT
601 * display-name = *(token LWS)/ quoted-string
602 * token = 1*(alphanum / "-" / "." / "!" / "%" / "*"
603 * / "_" / "+" / "`" / "'" / "~" )
604 * quoted-string = SWS DQUOTE *(qdtext / quoted-pair ) DQUOTE
605 * qdtext = LWS / %x21 / %x23-5B / %x5D-7E
607 * quoted-pair = "\" (%x00-09 / %x0B-0C / %x0E-7F)
609 * HCOLON = *WSP ":" SWS
611 * LWS = *[*WSP CRLF] 1*WSP
614 * Deviations from it:
615 * - following CRLF's in LWS is not done (here at least)
616 * - ascii NUL is never legal as it terminates the C-string
617 * - utf8-nonascii is not checked for validity
619 char *orig_output = output;
620 const char *orig_input = input;
622 if (!output || !outputsize) {
623 /* Bad output parameters. Should never happen. */
627 /* clear any empty characters in the beginning */
628 input = ast_skip_blanks(input);
630 /* make sure the output buffer is initilized */
633 /* make room for '\0' at the end of the output buffer */
636 /* no data at all or no display name? */
637 if (!input || *input == '<') {
641 /* quoted-string rules */
642 if (input[0] == '"') {
643 input++; /* skip the first " */
645 for (; *input; ++input) {
646 if (*input == '"') { /* end of quoted-string */
648 } else if (*input == 0x5c) { /* quoted-pair = "\" (%x00-09 / %x0B-0C / %x0E-7F) */
653 if ((unsigned char) *input > 0x7f || *input == 0xa || *input == 0xd) {
654 continue; /* not a valid quoted-pair, so skip it */
656 } else if ((*input != 0x9 && (unsigned char) *input < 0x20)
658 continue; /* skip this invalid character. */
661 if (0 < outputsize) {
662 /* We still have room for the output display-name. */
668 /* if this is successful, input should be at the ending quote */
670 ast_log(LOG_WARNING, "No ending quote for display-name was found\n");
675 /* make sure input is past the last quote */
678 /* terminate output */
680 } else { /* either an addr-spec or tokenLWS-combo */
681 for (; *input; ++input) {
682 /* token or WSP (without LWS) */
683 if ((*input >= '0' && *input <= '9') || (*input >= 'A' && *input <= 'Z')
684 || (*input >= 'a' && *input <= 'z') || *input == '-' || *input == '.'
685 || *input == '!' || *input == '%' || *input == '*' || *input == '_'
686 || *input == '+' || *input == '`' || *input == '\'' || *input == '~'
687 || *input == 0x9 || *input == ' ') {
688 if (0 < outputsize) {
689 /* We still have room for the output display-name. */
693 } else if (*input == '<') { /* end of tokenLWS-combo */
694 /* we could assert that the previous char is LWS, but we don't care */
696 } else if (*input == ':') {
697 /* This invalid character which indicates this is addr-spec rather than display-name. */
700 } else { /* else, invalid character we can skip. */
701 continue; /* skip this character */
705 if (*input != '<') { /* if we never found the start of addr-spec then this is invalid */
710 /* terminate output while trimming any trailing whitespace */
713 } while (orig_output <= output && (*output == 0x9 || *output == ' '));
719 AST_TEST_DEFINE(get_calleridname_test)
721 int res = AST_TEST_PASS;
722 const char *in1 = " \" quoted-text internal \\\" quote \"<stuff>";
723 const char *in2 = " token text with no quotes <stuff>";
724 const char *overflow1 = " \"quoted-text overflow 1234567890123456789012345678901234567890\" <stuff>";
725 const char *overflow2 = " non-quoted text overflow 1234567890123456789012345678901234567890 <stuff>";
726 const char *noendquote = " \"quoted-text no end <stuff>";
727 const char *addrspec = " sip:blah@blah";
728 const char *no_quotes_no_brackets = "blah@blah";
729 const char *after_dname;
734 info->name = "sip_get_calleridname_test";
735 info->category = "/channels/chan_sip/";
736 info->summary = "decodes callerid name from sip header";
737 info->description = "Decodes display-name field of sip header. Checks for valid output and expected failure cases.";
738 return AST_TEST_NOT_RUN;
743 /* quoted-text with backslash escaped quote */
744 after_dname = get_calleridname(in1, dname, sizeof(dname));
745 ast_test_status_update(test, "display-name1: %s\nafter: %s\n", dname, after_dname);
746 if (strcmp(dname, " quoted-text internal \" quote ")) {
747 ast_test_status_update(test, "display-name1 test failed\n");
752 after_dname = get_calleridname(in2, dname, sizeof(dname));
753 ast_test_status_update(test, "display-name2: %s\nafter: %s\n", dname, after_dname);
754 if (strcmp(dname, "token text with no quotes")) {
755 ast_test_status_update(test, "display-name2 test failed\n");
759 /* quoted-text buffer overflow */
760 after_dname = get_calleridname(overflow1, dname, sizeof(dname));
761 ast_test_status_update(test, "overflow display-name1: %s\nafter: %s\n", dname, after_dname);
762 if (strcmp(dname, "quoted-text overflow 123456789012345678")) {
763 ast_test_status_update(test, "overflow display-name1 test failed\n");
767 /* non-quoted-text buffer overflow */
768 after_dname = get_calleridname(overflow2, dname, sizeof(dname));
769 ast_test_status_update(test, "overflow display-name2: %s\nafter: %s\n", dname, after_dname);
770 if (strcmp(dname, "non-quoted text overflow 12345678901234")) {
771 ast_test_status_update(test, "overflow display-name2 test failed\n");
775 /* quoted-text buffer with no terminating end quote */
776 after_dname = get_calleridname(noendquote, dname, sizeof(dname));
777 ast_test_status_update(test, "noendquote display-name1: %s\nafter: %s\n", dname, after_dname);
778 if (*dname != '\0' && after_dname != noendquote) {
779 ast_test_status_update(test, "no end quote for quoted-text display-name failed\n");
783 /* addr-spec rather than display-name. */
784 after_dname = get_calleridname(addrspec, dname, sizeof(dname));
785 ast_test_status_update(test, "addr-spec display-name1: %s\nafter: %s\n", dname, after_dname);
786 if (*dname != '\0' && after_dname != addrspec) {
787 ast_test_status_update(test, "detection of addr-spec failed\n");
791 /* no quotes, no brackets */
792 after_dname = get_calleridname(no_quotes_no_brackets, dname, sizeof(dname));
793 ast_test_status_update(test, "no_quotes_no_brackets display-name1: %s\nafter: %s\n", dname, after_dname);
794 if (*dname != '\0' && after_dname != no_quotes_no_brackets) {
795 ast_test_status_update(test, "detection of addr-spec failed\n");
802 int get_name_and_number(const char *hdr, char **name, char **number)
806 char *tmp_number = NULL;
807 char *hostport = NULL;
810 if (!name || !number || ast_strlen_zero(hdr)) {
816 ast_copy_string(header, hdr, sizeof(header));
818 /* strip the display-name portion off the beginning of the header. */
819 get_calleridname(header, tmp_name, sizeof(tmp_name));
821 /* get uri within < > brackets */
822 tmp_number = get_in_brackets(header);
824 /* parse out the number here */
825 if (parse_uri(tmp_number, "sip:,sips:", &tmp_number, &dummy, &hostport, NULL) || ast_strlen_zero(tmp_number)) {
826 ast_log(LOG_ERROR, "can not parse name and number from sip header.\n");
830 /* number is not option, and must be present at this point */
831 *number = ast_strdup(tmp_number);
832 ast_uri_decode(*number, ast_uri_sip_user);
834 /* name is optional and may not be present at this point */
835 if (!ast_strlen_zero(tmp_name)) {
836 *name = ast_strdup(tmp_name);
842 AST_TEST_DEFINE(get_name_and_number_test)
844 int res = AST_TEST_PASS;
847 const char *in1 = "NAME <sip:NUMBER@place>";
848 const char *in2 = "\"NA><ME\" <sip:NUMBER@place>";
849 const char *in3 = "NAME";
850 const char *in4 = "<sip:NUMBER@place>";
851 const char *in5 = "This is a screwed up string <sip:LOLCLOWNS<sip:>@place>";
855 info->name = "sip_get_name_and_number_test";
856 info->category = "/channels/chan_sip/";
857 info->summary = "Tests getting name and number from sip header";
859 "Runs through various test situations in which a name and "
860 "and number can be retrieved from a sip header.";
861 return AST_TEST_NOT_RUN;
866 /* Test 1. get name and number */
867 number = name = NULL;
868 if ((get_name_and_number(in1, &name, &number)) ||
869 strcmp(name, "NAME") ||
870 strcmp(number, "NUMBER")) {
872 ast_test_status_update(test, "Test 1, simple get name and number failed.\n");
878 /* Test 2. get quoted name and number */
879 number = name = NULL;
880 if ((get_name_and_number(in2, &name, &number)) ||
881 strcmp(name, "NA><ME") ||
882 strcmp(number, "NUMBER")) {
884 ast_test_status_update(test, "Test 2, get quoted name and number failed.\n");
890 /* Test 3. name only */
891 number = name = NULL;
892 if (!(get_name_and_number(in3, &name, &number))) {
894 ast_test_status_update(test, "Test 3, get name only was expected to fail but did not.\n");
900 /* Test 4. number only */
901 number = name = NULL;
902 if ((get_name_and_number(in4, &name, &number)) ||
903 !ast_strlen_zero(name) ||
904 strcmp(number, "NUMBER")) {
906 ast_test_status_update(test, "Test 4, get number with no name present failed.\n");
912 /* Test 5. malformed string, since number can not be parsed, this should return an error. */
913 number = name = NULL;
914 if (!(get_name_and_number(in5, &name, &number)) ||
915 !ast_strlen_zero(name) ||
916 !ast_strlen_zero(number)) {
918 ast_test_status_update(test, "Test 5, processing malformed string failed.\n");
924 /* Test 6. NULL output parameters */
925 number = name = NULL;
926 if (!(get_name_and_number(in5, NULL, NULL))) {
928 ast_test_status_update(test, "Test 6, NULL output parameters failed.\n");
932 /* Test 7. NULL input parameter */
933 number = name = NULL;
934 if (!(get_name_and_number(NULL, &name, &number)) ||
935 !ast_strlen_zero(name) ||
936 !ast_strlen_zero(number)) {
938 ast_test_status_update(test, "Test 7, NULL input parameter failed.\n");
947 int get_in_brackets_full(char *tmp,char **out,char **residue)
949 const char *parse = tmp;
951 char *second_bracket;
960 if (ast_strlen_zero(tmp)) {
965 * Skip any quoted text until we find the part in brackets.
966 * On any error give up and return -1
968 while ( (first_bracket = strchr(parse, '<')) ) {
969 char *first_quote = strchr(parse, '"');
971 if (!first_quote || first_quote >= first_bracket) {
972 break; /* no need to look at quoted part */
974 /* the bracket is within quotes, so ignore it */
975 parse = find_closing_quote(first_quote + 1, NULL);
977 ast_log(LOG_WARNING, "No closing quote found in '%s'\n", tmp);
983 /* If no first bracket then still look for a second bracket as some other parsing functions
984 may overwrite first bracket with NULL when terminating a token based display-name. As this
985 only affects token based display-names there is no danger of brackets being in quotes */
987 parse = first_bracket;
992 if ((second_bracket = strchr(parse, '>'))) {
993 *second_bracket++ = '\0';
995 *out = (char *) parse;
998 *residue = second_bracket;
1003 if ((first_bracket)) {
1004 ast_log(LOG_WARNING, "No closing bracket found in '%s'\n", tmp);
1015 char *get_in_brackets(char *tmp)
1019 if ((get_in_brackets_full(tmp, &out, NULL))) {
1025 AST_TEST_DEFINE(get_in_brackets_test)
1027 int res = AST_TEST_PASS;
1028 char in_brackets[] = "sip:name:secret@host:port;transport=tcp?headers=testblah&headers2=blahblah";
1029 char no_name[] = "<sip:name:secret@host:port;transport=tcp?headers=testblah&headers2=blahblah>";
1030 char quoted_string[] = "\"I'm a quote stri><ng\" <sip:name:secret@host:port;transport=tcp?headers=testblah&headers2=blahblah>";
1031 char missing_end_quote[] = "\"I'm a quote string <sip:name:secret@host:port;transport=tcp?headers=testblah&headers2=blahblah>";
1032 char name_no_quotes[] = "name not in quotes <sip:name:secret@host:port;transport=tcp?headers=testblah&headers2=blahblah>";
1033 char no_end_bracket[] = "name not in quotes <sip:name:secret@host:port;transport=tcp?headers=testblah&headers2=blahblah";
1034 char no_name_no_brackets[] = "sip:name@host";
1035 char missing_start_bracket[] = "sip:name:secret@host:port;transport=tcp?headers=testblah&headers2=blahblah>";
1040 info->name = "sip_get_in_brackets_test";
1041 info->category = "/channels/chan_sip/";
1042 info->summary = "Tests getting a sip uri in <> brackets within a sip header.";
1044 "Runs through various test situations in which a sip uri "
1045 "in angle brackets needs to be retrieved";
1046 return AST_TEST_NOT_RUN;
1051 /* Test 1, simple get in brackets */
1052 if (!(uri = get_in_brackets(no_name)) || strcmp(uri, in_brackets)) {
1053 ast_test_status_update(test, "Test 1, simple get in brackets failed. %s\n", uri);
1054 res = AST_TEST_FAIL;
1057 /* Test 2, starts with quoted string */
1058 if (!(uri = get_in_brackets(quoted_string)) || strcmp(uri, in_brackets)) {
1059 ast_test_status_update(test, "Test 2, get in brackets with quoted string in front failed. %s\n", uri);
1060 res = AST_TEST_FAIL;
1063 /* Test 3, missing end quote */
1064 if (!(uri = get_in_brackets(missing_end_quote)) || !strcmp(uri, in_brackets)) {
1065 ast_test_status_update(test, "Test 3, missing end quote failed. %s\n", uri);
1066 res = AST_TEST_FAIL;
1069 /* Test 4, starts with a name not in quotes */
1070 if (!(uri = get_in_brackets(name_no_quotes)) || strcmp(uri, in_brackets)) {
1071 ast_test_status_update(test, "Test 4, passing name not in quotes failed. %s\n", uri);
1072 res = AST_TEST_FAIL;
1075 /* Test 5, no end bracket, should just return everything after the first '<' */
1076 if (!(uri = get_in_brackets(no_end_bracket)) || !strcmp(uri, in_brackets)) {
1077 ast_test_status_update(test, "Test 5, no end bracket failed. %s\n", uri);
1078 res = AST_TEST_FAIL;
1081 /* Test 6, NULL input */
1082 if (get_in_brackets(NULL)) {
1083 ast_test_status_update(test, "Test 6, NULL input failed.\n");
1084 res = AST_TEST_FAIL;
1087 /* Test 7, no name, and no brackets. */
1088 if (!(uri = get_in_brackets(no_name_no_brackets)) || strcmp(uri, "sip:name@host")) {
1089 ast_test_status_update(test, "Test 7 failed. %s\n", uri);
1090 res = AST_TEST_FAIL;
1093 /* Test 8, no start bracket, but with ending bracket. */
1094 if (!(uri = get_in_brackets(missing_start_bracket)) || strcmp(uri, in_brackets)) {
1095 ast_test_status_update(test, "Test 8 failed. %s\n", uri);
1096 res = AST_TEST_FAIL;
1103 int parse_name_andor_addr(char *uri, const char *scheme, char **name,
1104 char **user, char **pass, char **hostport,
1105 struct uriparams *params, char **headers,
1109 char **residue2 = residue;
1110 char *orig_uri = uri;
1115 uri = (char *) get_calleridname(uri, buf, sizeof(buf));
1117 ret = get_in_brackets_full(uri, &uri, residue);
1120 * The uri is in brackets so do not treat unknown trailing uri
1121 * parameters as potential message header parameters.
1123 if (residue && **residue) {
1124 /* step over the first semicolon as per parse_uri_full residue */
1125 *residue = *residue + 1;
1133 * There is always room at orig_uri for the display-name because
1134 * at least one character has always been removed. A '"' or '<'
1137 strcpy(orig_uri, buf);
1144 return parse_uri_full(uri, scheme, user, pass, hostport, params, headers, residue2);
1147 AST_TEST_DEFINE(parse_name_andor_addr_test)
1149 int res = AST_TEST_PASS;
1151 char *name, *user, *pass, *hostport, *headers, *residue;
1152 struct uriparams params;
1163 struct uriparams params;
1164 AST_LIST_ENTRY(testdata) list;
1167 struct testdata *testdataptr;
1169 static AST_LIST_HEAD_NOLOCK(testdataliststruct, testdata) testdatalist;
1171 struct testdata td1 = {
1172 .desc = "quotes and brackets",
1173 .uri = "\"name :@ \" <sip:user:secret@host:5060;param=discard;transport=tcp>;tag=tag",
1177 .hostport = "host:5060",
1179 .residue = "tag=tag",
1180 .params.transport = "tcp",
1185 struct testdata td2 = {
1186 .desc = "no quotes",
1187 .uri = "givenname familyname <sip:user:secret@host:5060;param=discard;transport=tcp>;expires=3600",
1188 .name = "givenname familyname",
1191 .hostport = "host:5060",
1193 .residue = "expires=3600",
1194 .params.transport = "tcp",
1199 struct testdata td3 = {
1200 .desc = "no brackets",
1201 .uri = "sip:user:secret@host:5060;param=discard;transport=tcp;q=1",
1205 .hostport = "host:5060",
1208 .params.transport = "tcp",
1213 struct testdata td4 = {
1214 .desc = "just host",
1222 .params.transport = "",
1228 AST_LIST_HEAD_SET_NOLOCK(&testdatalist, &td1);
1229 AST_LIST_INSERT_TAIL(&testdatalist, &td2, list);
1230 AST_LIST_INSERT_TAIL(&testdatalist, &td3, list);
1231 AST_LIST_INSERT_TAIL(&testdatalist, &td4, list);
1236 info->name = "parse_name_andor_addr_test";
1237 info->category = "/channels/chan_sip/";
1238 info->summary = "tests parsing of name_andor_addr abnf structure";
1240 "Tests parsing of abnf name-andor-addr = name-addr / addr-spec "
1241 "Verifies output matches expected behavior.";
1242 return AST_TEST_NOT_RUN;
1247 AST_LIST_TRAVERSE(&testdatalist, testdataptr, list) {
1248 name = user = pass = hostport = headers = residue = NULL;
1249 params.transport = params.user = params.method = params.ttl = params.maddr = NULL;
1251 ast_copy_string(uri,testdataptr->uri,sizeof(uri));
1252 if (parse_name_andor_addr(uri, "sip:,sips:",
1260 (name && strcmp(testdataptr->name, name)) ||
1261 (user && strcmp(testdataptr->user, user)) ||
1262 (pass && strcmp(testdataptr->pass, pass)) ||
1263 (hostport && strcmp(testdataptr->hostport, hostport)) ||
1264 (headers && strcmp(testdataptr->headers, headers)) ||
1265 (residue && strcmp(testdataptr->residue, residue)) ||
1266 (strcmp(testdataptr->params.transport,params.transport)) ||
1267 (strcmp(testdataptr->params.user,params.user))
1269 ast_test_status_update(test, "Sub-Test: %s,failed.\n", testdataptr->desc);
1270 res = AST_TEST_FAIL;
1277 int get_comma(char *in, char **out)
1285 /* Skip any quoted text */
1287 if ((c = strchr(parse, '"'))) {
1288 in = (char *)find_closing_quote((const char *)c + 1, NULL);
1290 ast_log(LOG_WARNING, "No closing quote found in '%s'\n", c);
1302 /* Skip any userinfo components of a uri as they may contain commas */
1303 if ((c = strchr(parse,'@'))) {
1306 if ((out) && (c = strchr(parse,','))) {
1314 int parse_contact_header(char *contactheader, struct contactliststruct *contactlist)
1322 struct contact *split_contact = NULL;
1324 if (*contactheader == '*') {
1328 split_contact = ast_calloc(1, sizeof(*split_contact));
1330 AST_LIST_HEAD_SET_NOLOCK(contactlist, split_contact);
1331 while ((last = get_comma(contactheader, &comma)) != -1) {
1332 res = parse_name_andor_addr(contactheader, "sip:,sips:",
1333 &split_contact->name, &split_contact->user,
1334 &split_contact->pass, &split_contact->hostport,
1335 &split_contact->params, &split_contact->headers,
1341 /* parse contact params */
1342 split_contact->expires = split_contact->q = "";
1344 while ((value = strchr(residue,'='))) {
1348 if ((residue = strchr(value,';'))) {
1354 if (!strcmp(param,"expires")) {
1355 split_contact->expires = value;
1356 } else if (!strcmp(param,"q")) {
1357 split_contact->q = value;
1364 contactheader = comma;
1366 split_contact = ast_calloc(1, sizeof(*split_contact));
1367 AST_LIST_INSERT_TAIL(contactlist, split_contact, list);
1372 AST_TEST_DEFINE(parse_contact_header_test)
1374 int res = AST_TEST_PASS;
1375 char contactheader[1024];
1377 struct contactliststruct contactlist;
1378 struct contactliststruct *contactlistptr=&contactlist;
1382 char *contactheader;
1384 struct contactliststruct *contactlist;
1386 AST_LIST_ENTRY(testdata) list;
1389 struct testdata *testdataptr;
1390 struct contact *tdcontactptr;
1391 struct contact *contactptr;
1393 static AST_LIST_HEAD_NOLOCK(testdataliststruct, testdata) testdatalist;
1394 struct contactliststruct contactlist1, contactlist2;
1396 struct testdata td1 = {
1397 .desc = "single contact",
1398 .contactheader = "\"name :@;?&,\" <sip:user:secret@host:5082;param=discard;transport=tcp>;expires=3600",
1399 .contactlist = &contactlist1,
1402 struct contact contact11 = {
1403 .name = "name :@;?&,",
1406 .hostport = "host:5082",
1407 .params.transport = "tcp",
1415 struct testdata td2 = {
1416 .desc = "multiple contacts",
1417 .contactheader = "sip:,user1,:,secret1,@host1;ttl=7;q=1;expires=3600,sips:host2",
1418 .contactlist = &contactlist2,
1421 struct contact contact21 = {
1424 .pass = ",secret1,",
1425 .hostport = "host1",
1426 .params.transport = "",
1433 struct contact contact22 = {
1437 .hostport = "host2",
1438 .params.transport = "",
1446 struct testdata td3 = {
1447 .desc = "star - all contacts",
1448 .contactheader = "*",
1453 AST_LIST_HEAD_SET_NOLOCK(&testdatalist, &td1);
1454 AST_LIST_INSERT_TAIL(&testdatalist, &td2, list);
1455 AST_LIST_INSERT_TAIL(&testdatalist, &td3, list);
1457 AST_LIST_HEAD_SET_NOLOCK(&contactlist1, &contact11);
1459 AST_LIST_HEAD_SET_NOLOCK(&contactlist2, &contact21);
1460 AST_LIST_INSERT_TAIL(&contactlist2, &contact22, list);
1465 info->name = "parse_contact_header_test";
1466 info->category = "/channels/chan_sip/";
1467 info->summary = "tests parsing of sip contact header";
1469 "Tests parsing of a contact header including those with multiple contacts "
1470 "Verifies output matches expected behavior.";
1471 return AST_TEST_NOT_RUN;
1476 AST_LIST_TRAVERSE(&testdatalist, testdataptr, list) {
1477 ast_copy_string(contactheader,testdataptr->contactheader,sizeof(contactheader));
1478 star = parse_contact_header(contactheader,contactlistptr);
1479 if (testdataptr->star) {
1480 /* expecting star rather than list of contacts */
1482 ast_test_status_update(test, "Sub-Test: %s,failed.\n", testdataptr->desc);
1483 res = AST_TEST_FAIL;
1487 contactptr = AST_LIST_FIRST(contactlistptr);
1488 AST_LIST_TRAVERSE(testdataptr->contactlist, tdcontactptr, list) {
1490 strcmp(tdcontactptr->name, contactptr->name) ||
1491 strcmp(tdcontactptr->user, contactptr->user) ||
1492 strcmp(tdcontactptr->pass, contactptr->pass) ||
1493 strcmp(tdcontactptr->hostport, contactptr->hostport) ||
1494 strcmp(tdcontactptr->headers, contactptr->headers) ||
1495 strcmp(tdcontactptr->expires, contactptr->expires) ||
1496 strcmp(tdcontactptr->q, contactptr->q) ||
1497 strcmp(tdcontactptr->params.transport, contactptr->params.transport) ||
1498 strcmp(tdcontactptr->params.ttl, contactptr->params.ttl) ||
1499 (tdcontactptr->params.lr != contactptr->params.lr)
1501 ast_test_status_update(test, "Sub-Test: %s,failed.\n", testdataptr->desc);
1502 res = AST_TEST_FAIL;
1506 contactptr = AST_LIST_NEXT(contactptr,list);
1515 * \brief Parse supported header in incoming packet
1517 * \details This function parses through the options parameters and
1518 * builds a bit field representing all the SIP options in that field. When an
1519 * item is found that is not supported, it is copied to the unsupported
1522 * \param option list
1523 * \param unsupported out buffer (optional)
1524 * \param unsupported out buffer length (optional)
1526 unsigned int parse_sip_options(const char *options, char *unsupported, size_t unsupported_len)
1530 int i, found, supported;
1531 unsigned int profile = 0;
1533 char *out = unsupported;
1534 size_t outlen = unsupported_len;
1535 char *cur_out = out;
1537 if (out && (outlen > 0)) {
1538 memset(out, 0, outlen);
1541 if (ast_strlen_zero(options) )
1544 temp = ast_strdupa(options);
1546 ast_debug(3, "Begin: parsing SIP \"Supported: %s\"\n", options);
1548 for (next = temp; next; next = sep) {
1551 if ((sep = strchr(next, ',')) != NULL) {
1555 /* trim leading and trailing whitespace */
1556 next = ast_strip(next);
1558 if (ast_strlen_zero(next)) {
1559 continue; /* if there is a blank argument in there just skip it */
1562 ast_debug(3, "Found SIP option: -%s-\n", next);
1563 for (i = 0; i < ARRAY_LEN(sip_options); i++) {
1564 if (!strcasecmp(next, sip_options[i].text)) {
1565 profile |= sip_options[i].id;
1566 if (sip_options[i].supported == SUPPORTED) {
1570 ast_debug(3, "Matched SIP option: %s\n", next);
1575 /* If option is not supported, add to unsupported out buffer */
1576 if (!supported && out && outlen) {
1577 size_t copylen = strlen(next);
1578 size_t cur_outlen = strlen(out);
1579 /* Check to see if there is enough room to store this option.
1580 * Copy length is string length plus 2 for the ',' and '\0' */
1581 if ((cur_outlen + copylen + 2) < outlen) {
1582 /* if this isn't the first item, add the ',' */
1588 ast_copy_string(cur_out, next, (outlen - cur_outlen));
1594 profile |= SIP_OPT_UNKNOWN;
1595 if (!strncasecmp(next, "x-", 2))
1596 ast_debug(3, "Found private SIP option, not supported: %s\n", next);
1598 ast_debug(3, "Found no match for SIP option: %s (Please file bug report!)\n", next);
1605 AST_TEST_DEFINE(sip_parse_options_test)
1607 int res = AST_TEST_PASS;
1608 char unsupported[64];
1609 unsigned int option_profile = 0;
1612 char *input_options;
1613 char *expected_unsupported;
1614 unsigned int expected_profile;
1615 AST_LIST_ENTRY(testdata) list;
1618 struct testdata *testdataptr;
1619 static AST_LIST_HEAD_NOLOCK(testdataliststruct, testdata) testdatalist;
1621 struct testdata test1 = {
1622 .name = "test_all_unsupported",
1623 .input_options = "unsupported1,,, ,unsupported2,unsupported3,unsupported4",
1624 .expected_unsupported = "unsupported1,unsupported2,unsupported3,unsupported4",
1625 .expected_profile = SIP_OPT_UNKNOWN,
1627 struct testdata test2 = {
1628 .name = "test_all_unsupported_one_supported",
1629 .input_options = " unsupported1, replaces, unsupported3 , , , ,unsupported4",
1630 .expected_unsupported = "unsupported1,unsupported3,unsupported4",
1631 .expected_profile = SIP_OPT_UNKNOWN | SIP_OPT_REPLACES
1633 struct testdata test3 = {
1634 .name = "test_two_supported_two_unsupported",
1635 .input_options = ",, timer ,replaces ,unsupported3,unsupported4",
1636 .expected_unsupported = "unsupported3,unsupported4",
1637 .expected_profile = SIP_OPT_UNKNOWN | SIP_OPT_REPLACES | SIP_OPT_TIMER,
1640 struct testdata test4 = {
1641 .name = "test_all_supported",
1642 .input_options = "timer,replaces",
1643 .expected_unsupported = "",
1644 .expected_profile = SIP_OPT_REPLACES | SIP_OPT_TIMER,
1647 struct testdata test5 = {
1648 .name = "test_all_supported_redundant",
1649 .input_options = "timer,replaces,timer,replace,timer,replaces",
1650 .expected_unsupported = "",
1651 .expected_profile = SIP_OPT_REPLACES | SIP_OPT_TIMER,
1653 struct testdata test6 = {
1654 .name = "test_buffer_overflow",
1655 .input_options = "unsupported1,replaces,timer,unsupported4,unsupported_huge____"
1656 "____________________________________,__________________________________________"
1657 "________________________________________________",
1658 .expected_unsupported = "unsupported1,unsupported4",
1659 .expected_profile = SIP_OPT_UNKNOWN | SIP_OPT_REPLACES | SIP_OPT_TIMER,
1661 struct testdata test7 = {
1662 .name = "test_null_input",
1663 .input_options = NULL,
1664 .expected_unsupported = "",
1665 .expected_profile = 0,
1667 struct testdata test8 = {
1668 .name = "test_whitespace_input",
1669 .input_options = " ",
1670 .expected_unsupported = "",
1671 .expected_profile = 0,
1673 struct testdata test9 = {
1674 .name = "test_whitespace_plus_option_input",
1675 .input_options = " , , ,timer , , , , , ",
1676 .expected_unsupported = "",
1677 .expected_profile = SIP_OPT_TIMER,
1682 info->name = "sip_parse_options_test";
1683 info->category = "/channels/chan_sip/";
1684 info->summary = "Tests parsing of sip options";
1686 "Tests parsing of SIP options from supported and required "
1687 "header fields. Verifies when unsupported options are encountered "
1688 "that they are appended to the unsupported out buffer and that the "
1689 "correct bit field representnig the option profile is returned.";
1690 return AST_TEST_NOT_RUN;
1695 AST_LIST_HEAD_SET_NOLOCK(&testdatalist, &test1);
1696 AST_LIST_INSERT_TAIL(&testdatalist, &test2, list);
1697 AST_LIST_INSERT_TAIL(&testdatalist, &test3, list);
1698 AST_LIST_INSERT_TAIL(&testdatalist, &test4, list);
1699 AST_LIST_INSERT_TAIL(&testdatalist, &test5, list);
1700 AST_LIST_INSERT_TAIL(&testdatalist, &test6, list);
1701 AST_LIST_INSERT_TAIL(&testdatalist, &test7, list);
1702 AST_LIST_INSERT_TAIL(&testdatalist, &test8, list);
1703 AST_LIST_INSERT_TAIL(&testdatalist, &test9, list);
1705 /* Test with unsupported char buffer */
1706 AST_LIST_TRAVERSE(&testdatalist, testdataptr, list) {
1707 option_profile = parse_sip_options(testdataptr->input_options, unsupported, ARRAY_LEN(unsupported));
1708 if (option_profile != testdataptr->expected_profile ||
1709 strcmp(unsupported, testdataptr->expected_unsupported)) {
1710 ast_test_status_update(test, "Test with output buffer \"%s\", expected unsupported: %s actual unsupported:"
1711 "%s expected bit profile: %x actual bit profile: %x\n",
1713 testdataptr->expected_unsupported,
1715 testdataptr->expected_profile,
1717 res = AST_TEST_FAIL;
1719 ast_test_status_update(test, "\"%s\" passed got expected unsupported: %s and bit profile: %x\n",
1725 option_profile = parse_sip_options(testdataptr->input_options, NULL, 0);
1726 if (option_profile != testdataptr->expected_profile) {
1727 ast_test_status_update(test, "NULL output test \"%s\", expected bit profile: %x actual bit profile: %x\n",
1729 testdataptr->expected_profile,
1731 res = AST_TEST_FAIL;
1733 ast_test_status_update(test, "\"%s\" with NULL output buf passed, bit profile: %x\n",
1742 /*! \brief helper routine for sip_uri_cmp to compare URI parameters
1744 * This takes the parameters from two SIP URIs and determines
1745 * if the URIs match. The rules for parameters *suck*. Here's a breakdown
1746 * 1. If a parameter appears in both URIs, then they must have the same value
1747 * in order for the URIs to match
1748 * 2. If one URI has a user, maddr, ttl, or method parameter, then the other
1749 * URI must also have that parameter and must have the same value
1750 * in order for the URIs to match
1751 * 3. All other headers appearing in only one URI are not considered when
1752 * determining if URIs match
1754 * \param input1 Parameters from URI 1
1755 * \param input2 Parameters from URI 2
1756 * \retval 0 URIs' parameters match
1757 * \retval nonzero URIs' parameters do not match
1759 static int sip_uri_params_cmp(const char *input1, const char *input2)
1761 char *params1 = NULL;
1762 char *params2 = NULL;
1765 int zerolength1 = 0;
1766 int zerolength2 = 0;
1770 int methodmatch = 0;
1772 if (ast_strlen_zero(input1)) {
1775 params1 = ast_strdupa(input1);
1777 if (ast_strlen_zero(input2)) {
1780 params2 = ast_strdupa(input2);
1783 /* Quick optimization. If both params are zero-length, then
1786 if (zerolength1 && zerolength2) {
1790 for (pos1 = strsep(¶ms1, ";"); pos1; pos1 = strsep(¶ms1, ";")) {
1791 char *value1 = pos1;
1792 char *name1 = strsep(&value1, "=");
1793 char *params2dup = NULL;
1798 /* Checkpoint reached. We have the name and value parsed for param1
1799 * We have to duplicate params2 each time through this loop
1800 * or else the inner loop below will not work properly.
1803 params2dup = ast_strdupa(params2);
1805 for (pos2 = strsep(¶ms2dup, ";"); pos2; pos2 = strsep(¶ms2dup, ";")) {
1807 char *value2 = strchr(pos2, '=');
1813 if (!strcasecmp(name1, name2)) {
1814 if (strcasecmp(value1, value2)) {
1822 /* Check to see if the parameter is one of the 'must-match' parameters */
1823 if (!strcasecmp(name1, "maddr")) {
1829 } else if (!strcasecmp(name1, "ttl")) {
1835 } else if (!strcasecmp(name1, "user")) {
1841 } else if (!strcasecmp(name1, "method")) {
1850 /* We've made it out of that horrible O(m*n) construct and there are no
1851 * failures yet. We're not done yet, though, because params2 could have
1852 * an maddr, ttl, user, or method header and params1 did not.
1854 for (pos2 = strsep(¶ms2, ";"); pos2; pos2 = strsep(¶ms2, ";")) {
1855 char *value2 = pos2;
1856 char *name2 = strsep(&value2, "=");
1860 if ((!strcasecmp(name2, "maddr") && !maddrmatch) ||
1861 (!strcasecmp(name2, "ttl") && !ttlmatch) ||
1862 (!strcasecmp(name2, "user") && !usermatch) ||
1863 (!strcasecmp(name2, "method") && !methodmatch)) {
1873 /*! \brief helper routine for sip_uri_cmp to compare URI headers
1875 * This takes the headers from two SIP URIs and determines
1876 * if the URIs match. The rules for headers is simple. If a header
1877 * appears in one URI, then it must also appear in the other URI. The
1878 * order in which the headers appear does not matter.
1880 * \param input1 Headers from URI 1
1881 * \param input2 Headers from URI 2
1882 * \retval 0 URI headers match
1883 * \retval nonzero URI headers do not match
1885 static int sip_uri_headers_cmp(const char *input1, const char *input2)
1887 char *headers1 = NULL;
1888 char *headers2 = NULL;
1889 int zerolength1 = 0;
1890 int zerolength2 = 0;
1894 if (ast_strlen_zero(input1)) {
1897 headers1 = ast_strdupa(input1);
1900 if (ast_strlen_zero(input2)) {
1903 headers2 = ast_strdupa(input2);
1906 /* If one URI contains no headers and the other
1907 * does, then they cannot possibly match
1909 if (zerolength1 != zerolength2) {
1913 if (zerolength1 && zerolength2)
1916 /* At this point, we can definitively state that both inputs are
1917 * not zero-length. First, one more optimization. If the length
1918 * of the headers is not equal, then we definitely have no match
1920 if (strlen(headers1) != strlen(headers2)) {
1924 for (header1 = strsep(&headers1, "&"); header1; header1 = strsep(&headers1, "&")) {
1925 if (!strcasestr(headers2, header1)) {
1935 * \brief Compare domain sections of SIP URIs
1937 * For hostnames, a case insensitive string comparison is
1938 * used. For IP addresses, a binary comparison is used. This
1939 * is mainly because IPv6 addresses have many ways of writing
1942 * For specifics about IP address comparison, see the following
1943 * document: http://tools.ietf.org/html/draft-ietf-sip-ipv6-abnf-fix-05
1945 * \param host1 The domain from the first URI
1946 * \param host2 THe domain from the second URI
1947 * \retval 0 The domains match
1948 * \retval nonzero The domains do not match
1950 static int sip_uri_domain_cmp(const char *host1, const char *host2)
1952 struct ast_sockaddr addr1;
1953 struct ast_sockaddr addr2;
1957 addr1_parsed = ast_sockaddr_parse(&addr1, host1, 0);
1958 addr2_parsed = ast_sockaddr_parse(&addr2, host2, 0);
1960 if (addr1_parsed != addr2_parsed) {
1961 /* One domain was an IP address and the other had
1962 * a host name. FAIL!
1967 /* Both are host names. A string comparison will work
1968 * perfectly here. Specifying the "C" locale ensures that
1969 * The LC_CTYPE conventions use those defined in ANSI C,
1972 if (!addr1_parsed) {
1973 #ifdef HAVE_XLOCALE_H
1975 return strcasecmp(host1, host2);
1977 return strcasecmp_l(host1, host2, c_locale);
1980 return strcasecmp(host1, host2);
1984 /* Both contain IP addresses */
1985 return ast_sockaddr_cmp(&addr1, &addr2);
1988 int sip_uri_cmp(const char *input1, const char *input2)
2001 /* XXX It would be really nice if we could just use parse_uri_full() here
2002 * to separate the components of the URI, but unfortunately it is written
2003 * in a way that can cause URI parameters to be discarded.
2006 if (!input1 || !input2) {
2010 uri1 = ast_strdupa(input1);
2011 uri2 = ast_strdupa(input2);
2013 ast_uri_decode(uri1, ast_uri_sip_user);
2014 ast_uri_decode(uri2, ast_uri_sip_user);
2016 uri_scheme1 = strsep(&uri1, ":");
2017 uri_scheme2 = strsep(&uri2, ":");
2019 if (strcmp(uri_scheme1, uri_scheme2)) {
2023 /* This function is tailored for SIP and SIPS URIs. There's no
2024 * need to check uri_scheme2 since we have determined uri_scheme1
2025 * and uri_scheme2 are equivalent already.
2027 if (strcmp(uri_scheme1, "sip") && strcmp(uri_scheme1, "sips")) {
2031 if (ast_strlen_zero(uri1) || ast_strlen_zero(uri2)) {
2035 if ((host1 = strchr(uri1, '@'))) {
2038 if ((host2 = strchr(uri2, '@'))) {
2042 /* Check for mismatched username and passwords. This is the
2043 * only case-sensitive comparison of a SIP URI
2045 if ((host1 && !host2) ||
2046 (host2 && !host1) ||
2047 (host1 && host2 && strcmp(uri1, uri2))) {
2058 /* Strip off the parameters and headers so we can compare
2062 if ((params1 = strchr(host1, ';'))) {
2065 if ((params2 = strchr(host2, ';'))) {
2069 /* Headers come after parameters, but there may be headers without
2070 * parameters, thus the S_OR
2072 if ((headers1 = strchr(S_OR(params1, host1), '?'))) {
2075 if ((headers2 = strchr(S_OR(params2, host2), '?'))) {
2079 if (sip_uri_domain_cmp(host1, host2)) {
2083 /* Headers have easier rules to follow, so do those first */
2084 if (sip_uri_headers_cmp(headers1, headers2)) {
2088 /* And now the parameters. Ugh */
2089 return sip_uri_params_cmp(params1, params2);
2092 #define URI_CMP_MATCH 0
2093 #define URI_CMP_NOMATCH 1
2095 AST_TEST_DEFINE(sip_uri_cmp_test)
2097 static const struct {
2100 int expected_result;
2101 } uri_cmp_tests [] = {
2102 /* These are identical, so they match */
2103 { "sip:bob@example.com", "sip:bob@example.com", URI_CMP_MATCH },
2104 /* Different usernames. No match */
2105 { "sip:alice@example.com", "sip:bob@example.com", URI_CMP_NOMATCH },
2106 /* Different hosts. No match */
2107 { "sip:bob@example.com", "sip:bob@examplez.com", URI_CMP_NOMATCH },
2108 /* Now start using IP addresses. Identical, so they match */
2109 { "sip:bob@1.2.3.4", "sip:bob@1.2.3.4", URI_CMP_MATCH },
2110 /* Two identical IPv4 addresses represented differently. Match */
2111 { "sip:bob@1.2.3.4", "sip:bob@001.002.003.004", URI_CMP_MATCH },
2112 /* Logically equivalent IPv4 Address and hostname. No Match */
2113 { "sip:bob@127.0.0.1", "sip:bob@localhost", URI_CMP_NOMATCH },
2114 /* Logically equivalent IPv6 address and hostname. No Match */
2115 { "sip:bob@[::1]", "sip:bob@localhost", URI_CMP_NOMATCH },
2116 /* Try an IPv6 one as well */
2117 { "sip:bob@[2001:db8::1234]", "sip:bob@[2001:db8::1234]", URI_CMP_MATCH },
2118 /* Two identical IPv6 addresses represented differently. Match */
2119 { "sip:bob@[2001:db8::1234]", "sip:bob@[2001:0db8::1234]", URI_CMP_MATCH },
2120 /* Different ports. No match */
2121 { "sip:bob@1.2.3.4:5060", "sip:bob@1.2.3.4:5061", URI_CMP_NOMATCH },
2122 /* Same port logically, but only one address specifies it. No match */
2123 { "sip:bob@1.2.3.4:5060", "sip:bob@1.2.3.4", URI_CMP_NOMATCH },
2124 /* And for safety, try with IPv6 */
2125 { "sip:bob@[2001:db8:1234]:5060", "sip:bob@[2001:db8:1234]", URI_CMP_NOMATCH },
2126 /* User comparison is case sensitive. No match */
2127 { "sip:bob@example.com", "sip:BOB@example.com", URI_CMP_NOMATCH },
2128 /* Host comparison is case insensitive. Match */
2129 { "sip:bob@example.com", "sip:bob@EXAMPLE.COM", URI_CMP_MATCH },
2130 /* Add headers to the URI. Identical, so they match */
2131 { "sip:bob@example.com?header1=value1&header2=value2", "sip:bob@example.com?header1=value1&header2=value2", URI_CMP_MATCH },
2132 /* Headers in URI 1 are not in URI 2. No Match */
2133 { "sip:bob@example.com?header1=value1&header2=value2", "sip:bob@example.com", URI_CMP_NOMATCH },
2134 /* Header present in both URIs does not have matching values. No match */
2135 { "sip:bob@example.com?header1=value1&header2=value2", "sip:bob@example.com?header1=value1&header2=value3", URI_CMP_NOMATCH },
2136 /* Add parameters to the URI. Identical so they match */
2137 { "sip:bob@example.com;param1=value1;param2=value2", "sip:bob@example.com;param1=value1;param2=value2", URI_CMP_MATCH },
2138 /* Same parameters in both URIs but appear in different order. Match */
2139 { "sip:bob@example.com;param2=value2;param1=value1", "sip:bob@example.com;param1=value1;param2=value2", URI_CMP_MATCH },
2140 /* params in URI 1 are not in URI 2. Match */
2141 { "sip:bob@example.com;param1=value1;param2=value2", "sip:bob@example.com", URI_CMP_MATCH },
2142 /* param present in both URIs does not have matching values. No match */
2143 { "sip:bob@example.com;param1=value1;param2=value2", "sip:bob@example.com;param1=value1;param2=value3", URI_CMP_NOMATCH },
2144 /* URI 1 has a maddr param but URI 2 does not. No match */
2145 { "sip:bob@example.com;param1=value1;maddr=192.168.0.1", "sip:bob@example.com;param1=value1", URI_CMP_NOMATCH },
2146 /* URI 1 and URI 2 both have identical maddr params. Match */
2147 { "sip:bob@example.com;param1=value1;maddr=192.168.0.1", "sip:bob@example.com;param1=value1;maddr=192.168.0.1", URI_CMP_MATCH },
2148 /* URI 1 is a SIPS URI and URI 2 is a SIP URI. No Match */
2149 { "sips:bob@example.com", "sip:bob@example.com", URI_CMP_NOMATCH },
2150 /* No URI schemes. No match */
2151 { "bob@example.com", "bob@example.com", URI_CMP_NOMATCH },
2152 /* Crashiness tests. Just an address scheme. No match */
2153 { "sip", "sips", URI_CMP_NOMATCH },
2154 /* Still just an address scheme. Even though they're the same, No match */
2155 { "sip", "sip", URI_CMP_NOMATCH },
2156 /* Empty strings. No match */
2157 { "", "", URI_CMP_NOMATCH },
2158 /* An empty string and a NULL. No match */
2159 { "", NULL, URI_CMP_NOMATCH },
2162 int test_res = AST_TEST_PASS;
2165 info->name = "sip_uri_cmp_test";
2166 info->category = "/channels/chan_sip/";
2167 info->summary = "Tests comparison of SIP URIs";
2168 info->description = "Several would-be tricky URI comparisons are performed";
2169 return AST_TEST_NOT_RUN;
2174 for (i = 0; i < ARRAY_LEN(uri_cmp_tests); ++i) {
2177 if ((cmp_res1 = sip_uri_cmp(uri_cmp_tests[i].uri1, uri_cmp_tests[i].uri2))) {
2178 /* URI comparison may return -1 or +1 depending on the failure. Standardize
2179 * the return value to be URI_CMP_NOMATCH on any failure
2181 cmp_res1 = URI_CMP_NOMATCH;
2183 if (cmp_res1 != uri_cmp_tests[i].expected_result) {
2184 ast_test_status_update(test, "Unexpected comparison result for URIs %s and %s. "
2185 "Expected %s but got %s\n", uri_cmp_tests[i].uri1, uri_cmp_tests[i].uri2,
2186 uri_cmp_tests[i].expected_result == URI_CMP_MATCH ? "Match" : "No Match",
2187 cmp_res1 == URI_CMP_MATCH ? "Match" : "No Match");
2188 test_res = AST_TEST_FAIL;
2191 /* All URI comparisons are commutative, so for the sake of being thorough, we'll
2192 * rerun the comparison with the parameters reversed
2194 if ((cmp_res2 = sip_uri_cmp(uri_cmp_tests[i].uri2, uri_cmp_tests[i].uri1))) {
2195 /* URI comparison may return -1 or +1 depending on the failure. Standardize
2196 * the return value to be URI_CMP_NOMATCH on any failure
2198 cmp_res2 = URI_CMP_NOMATCH;
2200 if (cmp_res2 != uri_cmp_tests[i].expected_result) {
2201 ast_test_status_update(test, "Unexpected comparison result for URIs %s and %s. "
2202 "Expected %s but got %s\n", uri_cmp_tests[i].uri2, uri_cmp_tests[i].uri1,
2203 uri_cmp_tests[i].expected_result == URI_CMP_MATCH ? "Match" : "No Match",
2204 cmp_res2 == URI_CMP_MATCH ? "Match" : "No Match");
2205 test_res = AST_TEST_FAIL;
2212 void free_via(struct sip_via *v)
2222 struct sip_via *parse_via(const char *header)
2224 struct sip_via *v = ast_calloc(1, sizeof(*v));
2231 v->via = ast_strdup(header);
2236 if (ast_strlen_zero(via)) {
2237 ast_log(LOG_ERROR, "received request without a Via header\n");
2242 /* seperate the first via-parm */
2243 via = strsep(&via, ",");
2245 /* chop off sent-protocol */
2246 v->protocol = strsep(&via, " \t\r\n");
2247 if (ast_strlen_zero(v->protocol)) {
2248 ast_log(LOG_ERROR, "missing sent-protocol in Via header\n");
2252 v->protocol = ast_skip_blanks(v->protocol);
2255 via = ast_skip_blanks(via);
2258 /* chop off sent-by */
2259 v->sent_by = strsep(&via, "; \t\r\n");
2260 if (ast_strlen_zero(v->sent_by)) {
2261 ast_log(LOG_ERROR, "missing sent-by in Via header\n");
2265 v->sent_by = ast_skip_blanks(v->sent_by);
2267 /* store the port, we have to handle ipv6 addresses containing ':'
2268 * characters gracefully */
2269 if (((parm = strchr(v->sent_by, ']')) && *(++parm) == ':') || (parm = strchr(v->sent_by, ':'))) {
2272 v->port = strtol(++parm, &endptr, 10);
2275 /* evaluate any via-parms */
2276 while ((parm = strsep(&via, "; \t\r\n"))) {
2278 if ((c = strstr(parm, "maddr="))) {
2279 v->maddr = ast_skip_blanks(c + sizeof("maddr=") - 1);
2280 } else if ((c = strstr(parm, "branch="))) {
2281 v->branch = ast_skip_blanks(c + sizeof("branch=") - 1);
2282 } else if ((c = strstr(parm, "ttl="))) {
2284 c = ast_skip_blanks(c + sizeof("ttl=") - 1);
2285 v->ttl = strtol(c, &endptr, 10);
2287 /* make sure we got a valid ttl value */
2297 AST_TEST_DEFINE(parse_via_test)
2299 int res = AST_TEST_PASS;
2301 struct sip_via *via;
2304 char *expected_protocol;
2305 char *expected_branch;
2306 char *expected_sent_by;
2307 char *expected_maddr;
2308 unsigned int expected_port;
2309 unsigned char expected_ttl;
2311 AST_LIST_ENTRY(testdata) list;
2313 struct testdata *testdataptr;
2314 static AST_LIST_HEAD_NOLOCK(testdataliststruct, testdata) testdatalist;
2315 struct testdata t1 = {
2316 .in = "SIP/2.0/UDP host:port;branch=thebranch",
2317 .expected_protocol = "SIP/2.0/UDP",
2318 .expected_sent_by = "host:port",
2319 .expected_branch = "thebranch",
2321 struct testdata t2 = {
2322 .in = "SIP/2.0/UDP host:port",
2323 .expected_protocol = "SIP/2.0/UDP",
2324 .expected_sent_by = "host:port",
2325 .expected_branch = "",
2327 struct testdata t3 = {
2328 .in = "SIP/2.0/UDP",
2331 struct testdata t4 = {
2332 .in = "BLAH/BLAH/BLAH host:port;branch=",
2333 .expected_protocol = "BLAH/BLAH/BLAH",
2334 .expected_sent_by = "host:port",
2335 .expected_branch = "",
2337 struct testdata t5 = {
2338 .in = "SIP/2.0/UDP host:5060;branch=thebranch;maddr=224.0.0.1;ttl=1",
2339 .expected_protocol = "SIP/2.0/UDP",
2340 .expected_sent_by = "host:5060",
2341 .expected_port = 5060,
2342 .expected_branch = "thebranch",
2343 .expected_maddr = "224.0.0.1",
2346 struct testdata t6 = {
2347 .in = "SIP/2.0/UDP host:5060;\n branch=thebranch;\r\n maddr=224.0.0.1; ttl=1",
2348 .expected_protocol = "SIP/2.0/UDP",
2349 .expected_sent_by = "host:5060",
2350 .expected_port = 5060,
2351 .expected_branch = "thebranch",
2352 .expected_maddr = "224.0.0.1",
2355 struct testdata t7 = {
2356 .in = "SIP/2.0/UDP [::1]:5060",
2357 .expected_protocol = "SIP/2.0/UDP",
2358 .expected_sent_by = "[::1]:5060",
2359 .expected_port = 5060,
2360 .expected_branch = "",
2364 info->name = "parse_via_test";
2365 info->category = "/channels/chan_sip/";
2366 info->summary = "Tests parsing the Via header";
2368 "Runs through various test situations in which various "
2369 " parameters parameter must be extracted from a VIA header";
2370 return AST_TEST_NOT_RUN;
2375 AST_LIST_HEAD_SET_NOLOCK(&testdatalist, &t1);
2376 AST_LIST_INSERT_TAIL(&testdatalist, &t2, list);
2377 AST_LIST_INSERT_TAIL(&testdatalist, &t3, list);
2378 AST_LIST_INSERT_TAIL(&testdatalist, &t4, list);
2379 AST_LIST_INSERT_TAIL(&testdatalist, &t5, list);
2380 AST_LIST_INSERT_TAIL(&testdatalist, &t6, list);
2381 AST_LIST_INSERT_TAIL(&testdatalist, &t7, list);
2384 AST_LIST_TRAVERSE(&testdatalist, testdataptr, list) {
2385 via = parse_via(testdataptr->in);
2387 if (!testdataptr->expected_null) {
2388 ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
2389 "failed to parse header\n",
2390 i, testdataptr->in);
2391 res = AST_TEST_FAIL;
2397 if (testdataptr->expected_null) {
2398 ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
2399 "successfully parased invalid via header\n",
2400 i, testdataptr->in);
2401 res = AST_TEST_FAIL;
2407 if ((ast_strlen_zero(via->protocol) && !ast_strlen_zero(testdataptr->expected_protocol))
2408 || (!ast_strlen_zero(via->protocol) && strcmp(via->protocol, testdataptr->expected_protocol))) {
2410 ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
2411 "parsed protocol = \"%s\"\n"
2412 "expected = \"%s\"\n"
2413 "failed to parse protocol\n",
2414 i, testdataptr->in, via->protocol, testdataptr->expected_protocol);
2415 res = AST_TEST_FAIL;
2418 if ((ast_strlen_zero(via->sent_by) && !ast_strlen_zero(testdataptr->expected_sent_by))
2419 || (!ast_strlen_zero(via->sent_by) && strcmp(via->sent_by, testdataptr->expected_sent_by))) {
2421 ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
2422 "parsed sent_by = \"%s\"\n"
2423 "expected = \"%s\"\n"
2424 "failed to parse sent-by\n",
2425 i, testdataptr->in, via->sent_by, testdataptr->expected_sent_by);
2426 res = AST_TEST_FAIL;
2429 if (testdataptr->expected_port && testdataptr->expected_port != via->port) {
2430 ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
2431 "parsed port = \"%d\"\n"
2432 "expected = \"%d\"\n"
2433 "failed to parse port\n",
2434 i, testdataptr->in, via->port, testdataptr->expected_port);
2435 res = AST_TEST_FAIL;
2438 if ((ast_strlen_zero(via->branch) && !ast_strlen_zero(testdataptr->expected_branch))
2439 || (!ast_strlen_zero(via->branch) && strcmp(via->branch, testdataptr->expected_branch))) {
2441 ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
2442 "parsed branch = \"%s\"\n"
2443 "expected = \"%s\"\n"
2444 "failed to parse branch\n",
2445 i, testdataptr->in, via->branch, testdataptr->expected_branch);
2446 res = AST_TEST_FAIL;
2449 if ((ast_strlen_zero(via->maddr) && !ast_strlen_zero(testdataptr->expected_maddr))
2450 || (!ast_strlen_zero(via->maddr) && strcmp(via->maddr, testdataptr->expected_maddr))) {
2452 ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
2453 "parsed maddr = \"%s\"\n"
2454 "expected = \"%s\"\n"
2455 "failed to parse maddr\n",
2456 i, testdataptr->in, via->maddr, testdataptr->expected_maddr);
2457 res = AST_TEST_FAIL;
2460 if (testdataptr->expected_ttl && testdataptr->expected_ttl != via->ttl) {
2461 ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
2462 "parsed ttl = \"%d\"\n"
2463 "expected = \"%d\"\n"
2464 "failed to parse ttl\n",
2465 i, testdataptr->in, via->ttl, testdataptr->expected_ttl);
2466 res = AST_TEST_FAIL;
2475 void sip_request_parser_register_tests(void)
2477 AST_TEST_REGISTER(get_calleridname_test);
2478 AST_TEST_REGISTER(sip_parse_uri_test);
2479 AST_TEST_REGISTER(get_in_brackets_test);
2480 AST_TEST_REGISTER(get_name_and_number_test);
2481 AST_TEST_REGISTER(sip_parse_uri_full_test);
2482 AST_TEST_REGISTER(parse_name_andor_addr_test);
2483 AST_TEST_REGISTER(parse_contact_header_test);
2484 AST_TEST_REGISTER(sip_parse_options_test);
2485 AST_TEST_REGISTER(sip_uri_cmp_test);
2486 AST_TEST_REGISTER(parse_via_test);
2488 void sip_request_parser_unregister_tests(void)
2490 AST_TEST_UNREGISTER(sip_parse_uri_test);
2491 AST_TEST_UNREGISTER(get_calleridname_test);
2492 AST_TEST_UNREGISTER(get_in_brackets_test);
2493 AST_TEST_UNREGISTER(get_name_and_number_test);
2494 AST_TEST_UNREGISTER(sip_parse_uri_full_test);
2495 AST_TEST_UNREGISTER(parse_name_andor_addr_test);
2496 AST_TEST_UNREGISTER(parse_contact_header_test);
2497 AST_TEST_UNREGISTER(sip_parse_options_test);
2498 AST_TEST_UNREGISTER(sip_uri_cmp_test);
2499 AST_TEST_UNREGISTER(parse_via_test);
2502 int sip_reqresp_parser_init(void)
2504 #ifdef HAVE_XLOCALE_H
2505 c_locale = newlocale(LC_CTYPE_MASK, "C", NULL);
2513 void sip_reqresp_parser_exit(void)
2515 #ifdef HAVE_XLOCALE_H
2517 freelocale(c_locale);