media formats: re-architect handling of media for performance improvements
[asterisk/asterisk.git] / channels / sip / reqresp_parser.c
index 6fec362..88aea07 100644 (file)
  * \brief sip request parsing functions and unit tests
  */
 
+/*** MODULEINFO
+       <support_level>core</support_level>
+ ***/
+
 #include "asterisk.h"
 
 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 
 #include "include/sip.h"
+#include "include/sip_utils.h"
 #include "include/reqresp_parser.h"
 
+#ifdef HAVE_XLOCALE_H
+locale_t c_locale;
+#endif
+
 /*! \brief * parses a URI in its components.*/
-int parse_uri(char *uri, const char *scheme, char **ret_name, char **pass, char **domain, char **port, char **transport)
+int parse_uri_full(char *uri, const char *scheme, char **user, char **pass,
+                  char **hostport, struct uriparams *params, char **headers,
+                  char **residue)
 {
-       char *name = NULL;
-       char *tmp; /* used as temporary place holder */
+       char *userinfo = NULL;
+       char *parameters = NULL;
+       char *endparams = NULL;
+       char *c = NULL;
        int error = 0;
+       int teluri_scheme = 0;
+
+       /*
+        * Initialize requested strings - some functions don't care if parse_uri fails
+        * and will attempt to use string pointers passed into parse_uri even after a
+        * parse_uri failure
+        */
+       if (user) {
+               *user = "";
+       }
+       if (pass) {
+               *pass = "";
+       }
+       if (hostport) {
+               *hostport = "";
+       }
+       if (headers) {
+               *headers = "";
+       }
+       if (residue) {
+               *residue = "";
+       }
 
        /* check for valid input */
        if (ast_strlen_zero(uri)) {
                return -1;
        }
 
-       /* strip [?headers] from end of uri */
-       if ((tmp = strrchr(uri, '?'))) {
-               *tmp = '\0';
-       }
-
-       /* init field as required */
-       if (pass)
-               *pass = "";
-       if (port)
-               *port = "";
        if (scheme) {
                int l;
                char *scheme2 = ast_strdupa(scheme);
@@ -55,6 +80,7 @@ int parse_uri(char *uri, const char *scheme, char **ret_name, char **pass, char
                for (; !ast_strlen_zero(cur); cur = strsep(&scheme2, ",")) {
                        l = strlen(cur);
                        if (!strncasecmp(uri, cur, l)) {
+                               teluri_scheme = !strncasecmp(uri, "tel:", 4);   /* TEL URI */
                                uri += l;
                                break;
                        }
@@ -64,141 +90,598 @@ int parse_uri(char *uri, const char *scheme, char **ret_name, char **pass, char
                        error = -1;
                }
        }
-       if (transport) {
-               char *t, *type = "";
-               *transport = "";
-               if ((t = strstr(uri, "transport="))) {
-                       strsep(&t, "=");
-                       if ((type = strsep(&t, ";"))) {
-                               *transport = type;
-                       }
-               }
-       }
 
-       if (!domain) {
-               /* if we don't want to split around domain, keep everything as a name,
-                * so we need to do nothing here, except remember why.
-                */
-       } else {
-               /* store the result in a temp. variable to avoid it being
-                * overwritten if arguments point to the same place.
+       if (!hostport) {
+               /* if we don't want to split around hostport, keep everything as a
+                * userinfo - cos thats how old parse_uri operated*/
+               userinfo = uri;
+       } else if (teluri_scheme) {
+               /*
+                * tel: TEL URI INVITE RFC 3966 patch
+                * See http://www.ietf.org/rfc/rfc3966.txt
+                *
+                * Once the full RFC 3966 parsing is implemented,
+                * the ext= or isub= parameters would be extracted from userinfo.
+                * When this kind of subaddressing would be implemented, the userinfo must be further parsed.
+                * Those parameters would be used for ISDN or PSTN local extensions.
+                *
+                * Current restrictions:
+                * We currently consider the ";isub=" or the ";ext=" as part of the userinfo (unparsed).
                 */
-               char *c, *dom = "";
 
-               if ((c = strchr(uri, '@')) == NULL) {
-                       /* domain-only URI, according to the SIP RFC. */
-                       dom = uri;
-                       name = "";
+               if ((c = strstr(uri, ";phone-context="))) {
+                       /*
+                        * Local number with context or domain.
+                        * ext= or isub= TEL URI parameters should be upfront.
+                        * All other parameters should come after the ";phone-context=" parameter.
+                        * If other parameters would occur before ";phone-context=" they will be ignored.
+                        */
+
+                        *c = '\0';
+                        userinfo = uri;
+                        uri = c + 15;
+                       *hostport = uri;
+                } else if ('+' == uri[0]) {
+                       /* Global number without context or domain; possibly followed by RFC 3966 and optional other parameters. */
+
+                        userinfo = uri;
+                       *hostport = uri;
                } else {
+                       ast_debug(1, "No RFC 3966 global number or context found in '%s'; returning local number anyway\n", uri);
+                        userinfo = uri;                /* Return local number anyway */
+                       error = -1;
+               }
+       } else {
+               char *dom = "";
+               if ((c = strchr(uri, '@'))) {
                        *c++ = '\0';
                        dom = c;
-                       name = uri;
+                       userinfo = uri;
+                       uri = c; /* userinfo can contain ? and ; chars so step forward before looking for params and headers */
+               } else {
+                       /* domain-only URI, according to the SIP RFC. */
+                       dom = uri;
+                       userinfo = "";
                }
 
-               /* Remove parameters in domain and name */
-               dom = strsep(&dom, ";");
-               name = strsep(&name, ";");
+               *hostport = dom;
+       }
 
-               if (port && (c = strchr(dom, ':'))) { /* Remove :port */
-                       *c++ = '\0';
-                       *port = c;
+       if (pass && (c = strchr(userinfo, ':'))) {        /* user:password */
+               *c++ = '\0';
+               *pass = c;
+       } else if (pass) {
+               *pass = "";
+       }
+
+       if (user) {
+               *user = userinfo;
+       }
+
+       parameters = uri;
+       /* strip [?headers] from end of uri  - even if no header pointer exists*/
+       if ((c = strrchr(uri, '?'))) {
+               *c++ = '\0';
+               uri = c;
+               if (headers) {
+                       *headers = c;
                }
-               if (pass && (c = strchr(name, ':'))) {  /* user:password */
+               if ((c = strrchr(uri, ';'))) {
                        *c++ = '\0';
-                       *pass = c;
+               } else {
+                       c = strrchr(uri, '\0');
+               }
+               uri = c; /* residue */
+
+
+       } else if (headers) {
+               *headers = "";
+       }
+
+       /* parse parameters */
+       endparams = strchr(parameters,'\0');
+       if ((c = strchr(parameters, ';'))) {
+               *c++ = '\0';
+               parameters = c;
+       } else {
+               parameters = endparams;
+       }
+
+       if (params) {
+               char *rem = parameters; /* unparsed or unrecognised remainder */
+               char *label;
+               char *value;
+               int lr = 0;
+
+               params->transport = "";
+               params->user = "";
+               params->method = "";
+               params->ttl = "";
+               params->maddr = "";
+               params->lr = 0;
+
+               rem = parameters;
+
+               while ((value = strchr(parameters, '=')) || (lr = !strncmp(parameters, "lr", 2))) {
+                       /* The while condition will not continue evaluation to set lr if it matches "lr=" */
+                       if (lr) {
+                               value = parameters;
+                       } else {
+                               *value++ = '\0';
+                       }
+                       label = parameters;
+                       if ((c = strchr(value, ';'))) {
+                               *c++ = '\0';
+                               parameters = c;
+                       } else {
+                               parameters = endparams;
+                       }
+
+                       if (!strcmp(label, "transport")) {
+                               params->transport = value;
+                               rem = parameters;
+                       } else if (!strcmp(label, "user")) {
+                               params->user = value;
+                               rem = parameters;
+                       } else if (!strcmp(label, "method")) {
+                               params->method = value;
+                               rem = parameters;
+                       } else if (!strcmp(label, "ttl")) {
+                               params->ttl = value;
+                               rem = parameters;
+                       } else if (!strcmp(label, "maddr")) {
+                               params->maddr = value;
+                               rem = parameters;
+                       /* 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 */
+                       } else if ((!strcmp(label, "lr") && strcmp(value, "no") && strcmp(value, "off") && strcmp(value, "0") && strcmp(value, "")) || ((lr) && strcmp(value, "lr"))) {
+                               params->lr = 1;
+                               rem = parameters;
+                       } else {
+                               value--;
+                               *value = '=';
+                               if (c) {
+                                       c--;
+                                       *c = ';';
+                               }
+                       }
                }
-               *domain = dom;
+               if (rem > uri) { /* no headers */
+                       uri = rem;
+               }
+
+       }
+
+       if (residue) {
+               *residue = uri;
        }
-       if (ret_name)   /* same as for domain, store the result only at the end */
-               *ret_name = name;
 
        return error;
 }
 
+
+AST_TEST_DEFINE(sip_parse_uri_full_test)
+{
+       int res = AST_TEST_PASS;
+       char uri[1024];
+       char *user, *pass, *hostport, *headers, *residue;
+       struct uriparams params;
+
+       struct testdata {
+               char *desc;
+               char *uri;
+               char *user;
+               char *pass;
+               char *hostport;
+               char *headers;
+               char *residue;
+               struct uriparams params;
+               AST_LIST_ENTRY(testdata) list;
+       };
+
+
+       struct testdata *testdataptr;
+
+       static AST_LIST_HEAD_NOLOCK(testdataliststruct, testdata) testdatalist;
+
+       struct testdata td1 = {
+               .desc = "no headers",
+               .uri = "sip:user:secret@host:5060;param=discard;transport=tcp;param2=residue",
+               .user = "user",
+               .pass = "secret",
+               .hostport = "host:5060",
+               .headers = "",
+               .residue = "param2=residue",
+               .params.transport = "tcp",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+       struct testdata td2 = {
+               .desc = "with headers",
+               .uri = "sip:user:secret@host:5060;param=discard;transport=tcp;param2=discard2?header=blah&header2=blah2;param3=residue",
+               .user = "user",
+               .pass = "secret",
+               .hostport = "host:5060",
+               .headers = "header=blah&header2=blah2",
+               .residue = "param3=residue",
+               .params.transport = "tcp",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+       struct testdata td3 = {
+               .desc = "difficult user",
+               .uri = "sip:-_.!~*'()&=+$,;?/:secret@host:5060;transport=tcp",
+               .user = "-_.!~*'()&=+$,;?/",
+               .pass = "secret",
+               .hostport = "host:5060",
+               .headers = "",
+               .residue = "",
+               .params.transport = "tcp",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+       struct testdata td4 = {
+               .desc = "difficult pass",
+               .uri = "sip:user:-_.!~*'()&=+$,@host:5060;transport=tcp",
+               .user = "user",
+               .pass = "-_.!~*'()&=+$,",
+               .hostport = "host:5060",
+               .headers = "",
+               .residue = "",
+               .params.transport = "tcp",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+       struct testdata td5 = {
+               .desc = "difficult host",
+               .uri = "sip:user:secret@1-1.a-1.:5060;transport=tcp",
+               .user = "user",
+               .pass = "secret",
+               .hostport = "1-1.a-1.:5060",
+               .headers = "",
+               .residue = "",
+               .params.transport = "tcp",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+       struct testdata td6 = {
+               .desc = "difficult params near transport",
+               .uri = "sip:user:secret@host:5060;-_.!~*'()[]/:&+$=-_.!~*'()[]/:&+$;transport=tcp",
+               .user = "user",
+               .pass = "secret",
+               .hostport = "host:5060",
+               .headers = "",
+               .residue = "",
+               .params.transport = "tcp",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+       struct testdata td7 = {
+               .desc = "difficult params near headers",
+               .uri = "sip:user:secret@host:5060;-_.!~*'()[]/:&+$=-_.!~*'()[]/:&+$?header=blah&header2=blah2;-_.!~*'()[]/:&+$=residue",
+               .user = "user",
+               .pass = "secret",
+               .hostport = "host:5060",
+               .headers = "header=blah&header2=blah2",
+               .residue = "-_.!~*'()[]/:&+$=residue",
+               .params.transport = "",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+       struct testdata td8 = {
+               .desc = "lr parameter",
+               .uri = "sip:user:secret@host:5060;param=discard;lr?header=blah",
+               .user = "user",
+               .pass = "secret",
+               .hostport = "host:5060",
+               .headers = "header=blah",
+               .residue = "",
+               .params.transport = "",
+               .params.lr = 1,
+               .params.user = ""
+       };
+
+       struct testdata td9 = {
+               .desc = "alternative lr parameter",
+               .uri = "sip:user:secret@host:5060;param=discard;lr=yes?header=blah",
+               .user = "user",
+               .pass = "secret",
+               .hostport = "host:5060",
+               .headers = "header=blah",
+               .residue = "",
+               .params.transport = "",
+               .params.lr = 1,
+               .params.user = ""
+       };
+
+       struct testdata td10 = {
+               .desc = "no lr parameter",
+               .uri = "sip:user:secret@host:5060;paramlr=lr;lr=no;lr=off;lr=0;lr=;=lr;lrextra;lrparam2=lr?header=blah",
+               .user = "user",
+               .pass = "secret",
+               .hostport = "host:5060",
+               .headers = "header=blah",
+               .residue = "",
+               .params.transport = "",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+       /* RFC 3966 TEL URI INVITE */
+       struct testdata td11 = {
+               .desc = "tel local number",
+               .uri = "tel:0987654321;phone-context=+32987654321",
+               .user = "0987654321",
+               .pass = "",
+               .hostport = "+32987654321",
+               .headers = "",
+               .residue = "",
+               .params.transport = "",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+       struct testdata td12 = {
+               .desc = "tel global number",
+               .uri = "tel:+32987654321",
+               .user = "+32987654321",
+               .pass = "",
+               .hostport = "+32987654321",
+               .headers = "",
+               .residue = "",
+               .params.transport = "",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+       /*
+        * Once the full RFC 3966 parsing is implemented,
+        * only the ext= or isub= parameters would be extracted from .user
+        * Then the ;param=discard would be ignored,
+        * and the .user would only contain "0987654321"
+        */
+       struct testdata td13 = {
+               .desc = "tel local number",
+               .uri = "tel:0987654321;ext=1234;param=discard;phone-context=+32987654321;transport=udp;param2=discard2?header=blah&header2=blah2;param3=residue",
+               .user = "0987654321;ext=1234;param=discard",
+               .pass = "",
+               .hostport = "+32987654321",
+               .headers = "header=blah&header2=blah2",
+               .residue = "param3=residue",
+               .params.transport = "udp",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+       AST_LIST_HEAD_SET_NOLOCK(&testdatalist, &td1);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td2, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td3, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td4, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td5, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td6, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td7, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td8, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td9, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td10, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td11, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td12, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td13, list);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "sip_uri_full_parse_test";
+               info->category = "/channels/chan_sip/";
+               info->summary = "tests sip full uri parsing";
+               info->description =
+                       "Tests full parsing of various URIs "
+                       "Verifies output matches expected behavior.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       AST_LIST_TRAVERSE(&testdatalist, testdataptr, list) {
+               user = pass = hostport = headers = residue = NULL;
+               params.transport = params.user = params.method = params.ttl = params.maddr = NULL;
+               params.lr = 0;
+
+               ast_copy_string(uri,testdataptr->uri,sizeof(uri));
+               if (parse_uri_full(uri, "sip:,sips:,tel:", &user,
+                                  &pass, &hostport,
+                                  &params,
+                                  &headers,
+                                  &residue) ||
+                       (user && strcmp(testdataptr->user, user)) ||
+                       (pass && strcmp(testdataptr->pass, pass)) ||
+                       (hostport && strcmp(testdataptr->hostport, hostport)) ||
+                       (headers && strcmp(testdataptr->headers, headers)) ||
+                       (residue && strcmp(testdataptr->residue, residue)) ||
+                       (strcmp(testdataptr->params.transport,params.transport)) ||
+                       (testdataptr->params.lr != params.lr) ||
+                       (strcmp(testdataptr->params.user,params.user))
+               ) {
+                               ast_test_status_update(test, "Sub-Test: %s, failed.\n", testdataptr->desc);
+                               res = AST_TEST_FAIL;
+               }
+       }
+
+
+       return res;
+}
+
+
+int parse_uri(char *uri, const char *scheme, char **user, char **pass,
+             char **hostport, char **transport) {
+       int ret;
+       char *headers;
+       struct uriparams params;
+
+       headers = NULL;
+       ret = parse_uri_full(uri, scheme, user, pass, hostport, &params, &headers, NULL);
+       if (transport) {
+               *transport=params.transport;
+       }
+       return ret;
+}
+
 AST_TEST_DEFINE(sip_parse_uri_test)
 {
        int res = AST_TEST_PASS;
-       char *name, *pass, *domain, *port, *transport;
+       char *name, *pass, *hostport, *transport;
        char uri1[] = "sip:name@host";
        char uri2[] = "sip:name@host;transport=tcp";
        char uri3[] = "sip:name:secret@host;transport=tcp";
        char uri4[] = "sip:name:secret@host:port;transport=tcp?headers=%40%40testblah&headers2=blah%20blah";
+       /* test 5 is for NULL input */
+       char uri6[] = "sip:name:secret@host:port;transport=tcp?headers=%40%40testblah&headers2=blah%20blah";
+       char uri7[] = "sip:name:secret@host:port;transport=tcp?headers=%40%40testblah&headers2=blah%20blah";
+       char uri8[] = "sip:host";
+       char uri9[] = "sip:host:port;transport=tcp?headers=%40%40testblah&headers2=blah%20blah";
+       char uri10[] = "host:port;transport=tcp?headers=%40%40testblah&headers2=blah%20blah";
+       char uri11[] = "host";
+       char uri12[] = "tel:911";       /* TEL URI Local number without context or global number */
+
        switch (cmd) {
        case TEST_INIT:
                info->name = "sip_uri_parse_test";
-               info->category = "channels/chan_sip/";
+               info->category = "/channels/chan_sip/";
                info->summary = "tests sip uri parsing";
                info->description =
-                                                       " Tests parsing of various URIs"
-                                                       " Verifies output matches expected behavior.";
+                                                       "Tests parsing of various URIs "
+                                                       "Verifies output matches expected behavior.";
                return AST_TEST_NOT_RUN;
        case TEST_EXECUTE:
                break;
        }
 
        /* Test 1, simple URI */
-       name = pass = domain = port = transport = NULL;
-       if (parse_uri(uri1, "sip:,sips:", &name, &pass, &domain, &port, &transport) ||
-               strcmp(name, "name")        ||
-               !ast_strlen_zero(pass)      ||
-               strcmp(domain, "host")      ||
-               !ast_strlen_zero(port)      ||
-               !ast_strlen_zero(transport)) {
-
-               ast_str_append(&args->ast_test_error_str, 0, "Test 1: simple uri failed. \n");
+       name = pass = hostport = transport = NULL;
+       if (parse_uri(uri1, "sip:,sips:", &name, &pass, &hostport, &transport) ||
+                       strcmp(name, "name")        ||
+                       !ast_strlen_zero(pass)      ||
+                       strcmp(hostport, "host")      ||
+                       !ast_strlen_zero(transport)) {
+               ast_test_status_update(test, "Test 1: simple uri failed. \n");
                res = AST_TEST_FAIL;
        }
 
        /* Test 2, add tcp transport */
-       name = pass = domain = port = transport = NULL;
-       if (parse_uri(uri2, "sip:,sips:", &name, &pass, &domain, &port, &transport) ||
-               strcmp(name, "name")        ||
-               !ast_strlen_zero(pass)      ||
-               strcmp(domain, "host")    ||
-               !ast_strlen_zero(port)      ||
-               strcmp(transport, "tcp")) {
-
-               ast_str_append(&args->ast_test_error_str, 0, "Test 2: uri with addtion of tcp transport failed. \n");
+       name = pass = hostport = transport = NULL;
+       if (parse_uri(uri2, "sip:,sips:", &name, &pass, &hostport, &transport) ||
+                       strcmp(name, "name")        ||
+                       !ast_strlen_zero(pass)      ||
+                       strcmp(hostport, "host")    ||
+                       strcmp(transport, "tcp")) {
+               ast_test_status_update(test, "Test 2: uri with addtion of tcp transport failed. \n");
                res = AST_TEST_FAIL;
        }
 
        /* Test 3, add secret */
-       name = pass = domain = port = transport = NULL;
-       if (parse_uri(uri3, "sip:,sips:", &name, &pass, &domain, &port, &transport) ||
-           strcmp(name, "name")        ||
-               strcmp(pass, "secret")      ||
-               strcmp(domain, "host")    ||
-               !ast_strlen_zero(port)      ||
-               strcmp(transport, "tcp")) {
-
-               ast_str_append(&args->ast_test_error_str, 0, "Test 3: uri with addition of secret failed.\n");
+       name = pass = hostport = transport = NULL;
+       if (parse_uri(uri3, "sip:,sips:", &name, &pass, &hostport, &transport) ||
+                       strcmp(name, "name")        ||
+                       strcmp(pass, "secret")      ||
+                       strcmp(hostport, "host")    ||
+                       strcmp(transport, "tcp")) {
+               ast_test_status_update(test, "Test 3: uri with addition of secret failed.\n");
                res = AST_TEST_FAIL;
        }
 
        /* Test 4, add port and unparsed header field*/
-       name = pass = domain = port = transport = NULL;
-       if (parse_uri(uri4, "sip:,sips:", &name, &pass, &domain, &port, &transport) ||
-           strcmp(name, "name")        ||
-               strcmp(pass, "secret")      ||
-               strcmp(domain, "host")    ||
-               strcmp(port, "port")      ||
-               strcmp(transport, "tcp")) {
-
-               ast_str_append(&args->ast_test_error_str, 0, "Test 4: add port and unparsed header field failed.\n");
+       name = pass = hostport = transport = NULL;
+       if (parse_uri(uri4, "sip:,sips:", &name, &pass, &hostport, &transport) ||
+                       strcmp(name, "name")        ||
+                       strcmp(pass, "secret")      ||
+                       strcmp(hostport, "host:port") ||
+                       strcmp(transport, "tcp")) {
+               ast_test_status_update(test, "Test 4: add port and unparsed header field failed.\n");
                res = AST_TEST_FAIL;
        }
 
        /* Test 5, verify parse_uri does not crash when given a NULL uri */
-       name = pass = domain = port = transport = NULL;
-       if (!parse_uri(NULL, "sip:,sips:", &name, &pass, &domain, &port, &transport)) {
-               ast_str_append(&args->ast_test_error_str, 0, "Test 5: passing a NULL uri failed.\n");
+       name = pass = hostport = transport = NULL;
+       if (!parse_uri(NULL, "sip:,sips:", &name, &pass, &hostport, &transport)) {
+               ast_test_status_update(test, "Test 5: passing a NULL uri failed.\n");
                res = AST_TEST_FAIL;
        }
 
        /* Test 6, verify parse_uri does not crash when given a NULL output parameters */
-       name = pass = domain = port = transport = NULL;
-       if (parse_uri(uri4, "sip:,sips:", NULL, NULL, NULL, NULL, NULL)) {
-               ast_str_append(&args->ast_test_error_str, 0, "Test 6: passing NULL output parameters failed.\n");
+       name = pass = hostport = transport = NULL;
+       if (parse_uri(uri6, "sip:,sips:", NULL, NULL, NULL, NULL)) {
+               ast_test_status_update(test, "Test 6: passing NULL output parameters failed.\n");
+               res = AST_TEST_FAIL;
+       }
+
+       /* Test 7, verify parse_uri returns user:secret and hostport when no port or secret output parameters are supplied. */
+       name = pass = hostport = transport = NULL;
+       if (parse_uri(uri7, "sip:,sips:", &name, NULL, &hostport, NULL) ||
+                       strcmp(name, "name:secret")        ||
+                       strcmp(hostport, "host:port")) {
+
+               ast_test_status_update(test, "Test 7: providing no port and secret output parameters failed.\n");
+               res = AST_TEST_FAIL;
+       }
+
+       /* Test 8, verify parse_uri can handle a hostport only uri */
+       name = pass = hostport = transport = NULL;
+       if (parse_uri(uri8, "sip:,sips:", &name, &pass, &hostport, &transport) ||
+                       strcmp(hostport, "host") ||
+                       !ast_strlen_zero(name)) {
+               ast_test_status_update(test, "Test 8: add port and unparsed header field failed.\n");
+               res = AST_TEST_FAIL;
+       }
+
+       /* Test 9, add port and unparsed header field with hostport only uri*/
+       name = pass = hostport = transport = NULL;
+       if (parse_uri(uri9, "sip:,sips:", &name, &pass, &hostport, &transport) ||
+                       !ast_strlen_zero(name)        ||
+                       !ast_strlen_zero(pass)      ||
+                       strcmp(hostport, "host:port")    ||
+                       strcmp(transport, "tcp")) {
+               ast_test_status_update(test, "Test 9: hostport only uri failed \n");
+               res = AST_TEST_FAIL;
+       }
+
+       /* Test 10, handle invalid/missing "sip:,sips:" scheme
+        * we expect parse_uri to return an error, but still parse
+        * the results correctly here */
+       name = pass = hostport = transport = NULL;
+       if (!parse_uri(uri10, "sip:,sips:", &name, &pass, &hostport, &transport) ||
+                       !ast_strlen_zero(name)        ||
+                       !ast_strlen_zero(pass)      ||
+                       strcmp(hostport, "host:port")    ||
+                       strcmp(transport, "tcp")) {
+               ast_test_status_update(test, "Test 10: missing \"sip:sips:\" scheme failed\n");
+               res = AST_TEST_FAIL;
+       }
+
+       /* Test 11, simple hostport only URI with missing scheme
+        * we expect parse_uri to return an error, but still parse
+        * the results correctly here */
+       name = pass = hostport = transport = NULL;
+       if (!parse_uri(uri11, "sip:,sips:", &name, &pass, &hostport, &transport) ||
+                       !ast_strlen_zero(name)      ||
+                       !ast_strlen_zero(pass)      ||
+                       strcmp(hostport, "host")      ||
+                       !ast_strlen_zero(transport)) {
+               ast_test_status_update(test, "Test 11: simple uri with missing scheme failed. \n");
+               res = AST_TEST_FAIL;
+       }
+
+       /* Test 12, simple URI */
+       name = pass = hostport = transport = NULL;
+       if (!parse_uri(uri12, "sip:,sips:,tel:", &name, &pass, &hostport, &transport) ||
+                       strcmp(name, "911")      ||     /* We return local number anyway */
+                       !ast_strlen_zero(pass)      ||
+                       !ast_strlen_zero(hostport)      ||      /* No global number nor context */
+                       !ast_strlen_zero(transport)) {
+               ast_test_status_update(test, "Test 12: TEL URI INVITE failed.\n");
                res = AST_TEST_FAIL;
        }
 
@@ -212,7 +695,7 @@ AST_TEST_DEFINE(sip_parse_uri_test)
 const char *get_calleridname(const char *input, char *output, size_t outputsize)
 {
        /* From RFC3261:
-        * 
+        *
         * From           =  ( "From" / "f" ) HCOLON from-spec
         * from-spec      =  ( name-addr / addr-spec ) *( SEMI from-param )
         * name-addr      =  [ display-name ] LAQUOT addr-spec RAQUOT
@@ -237,63 +720,77 @@ const char *get_calleridname(const char *input, char *output, size_t outputsize)
        char *orig_output = output;
        const char *orig_input = input;
 
+       if (!output || !outputsize) {
+               /* Bad output parameters.  Should never happen. */
+               return input;
+       }
+
        /* clear any empty characters in the beginning */
        input = ast_skip_blanks(input);
 
-       /* no data at all or no storage room? */
-       if (!input || *input == '<' || !outputsize || !output) {
-               return orig_input;
-       }
-
        /* make sure the output buffer is initilized */
        *orig_output = '\0';
 
        /* make room for '\0' at the end of the output buffer */
-       outputsize--;
+       --outputsize;
+
+       /* no data at all or no display name? */
+       if (!input || *input == '<') {
+               return input;
+       }
 
        /* quoted-string rules */
        if (input[0] == '"') {
                input++; /* skip the first " */
 
-               for (;((outputsize > 0) && *input); input++) {
+               for (; *input; ++input) {
                        if (*input == '"') {  /* end of quoted-string */
                                break;
                        } else if (*input == 0x5c) { /* quoted-pair = "\" (%x00-09 / %x0B-0C / %x0E-7F) */
-                               input++;
-                               if (!*input || (unsigned char)*input > 0x7f || *input == 0xa || *input == 0xd) {
+                               ++input;
+                               if (!*input) {
+                                       break;
+                               }
+                               if ((unsigned char) *input > 0x7f || *input == 0xa || *input == 0xd) {
                                        continue;  /* not a valid quoted-pair, so skip it */
                                }
-                       } else if (((*input != 0x9) && ((unsigned char) *input < 0x20)) ||
-                                   (*input == 0x7f)) {
+                       } else if ((*input != 0x9 && (unsigned char) *input < 0x20)
+                               || *input == 0x7f) {
                                continue; /* skip this invalid character. */
                        }
 
-                       *output++ = *input;
-                       outputsize--;
+                       if (0 < outputsize) {
+                               /* We still have room for the output display-name. */
+                               *output++ = *input;
+                               --outputsize;
+                       }
                }
 
                /* if this is successful, input should be at the ending quote */
-               if (!input || *input != '"') {
+               if (*input != '"') {
                        ast_log(LOG_WARNING, "No ending quote for display-name was found\n");
                        *orig_output = '\0';
                        return orig_input;
                }
 
                /* make sure input is past the last quote */
-               input++;
+               ++input;
 
-               /* terminate outbuf */
+               /* terminate output */
                *output = '\0';
        } else {  /* either an addr-spec or tokenLWS-combo */
-               for (;((outputsize > 0) && *input); input++) {
+               for (; *input; ++input) {
                        /* token or WSP (without LWS) */
                        if ((*input >= '0' && *input <= '9') || (*input >= 'A' && *input <= 'Z')
                                || (*input >= 'a' && *input <= 'z') || *input == '-' || *input == '.'
                                || *input == '!' || *input == '%' || *input == '*' || *input == '_'
                                || *input == '+' || *input == '`' || *input == '\'' || *input == '~'
                                || *input == 0x9 || *input == ' ') {
-                               *output++ = *input;
-                               outputsize -= 1;
+                               if (0 < outputsize) {
+                                       /* We still have room for the output display-name. */
+                                       *output++ = *input;
+                                       --outputsize;
+                               }
                        } else if (*input == '<') {   /* end of tokenLWS-combo */
                                /* we could assert that the previous char is LWS, but we don't care */
                                break;
@@ -306,10 +803,15 @@ const char *get_calleridname(const char *input, char *output, size_t outputsize)
                        }
                }
 
-               /* set NULL while trimming trailing whitespace */
+               if (*input != '<') {   /* if we never found the start of addr-spec then this is invalid */
+                       *orig_output = '\0';
+                       return orig_input;
+               }
+
+               /* terminate output while trimming any trailing whitespace */
                do {
                        *output-- = '\0';
-               } while (*output == 0x9 || *output == ' '); /* we won't go past orig_output as first was a non-space */
+               } while (orig_output <= output && (*output == 0x9 || *output == ' '));
        }
 
        return input;
@@ -318,18 +820,20 @@ const char *get_calleridname(const char *input, char *output, size_t outputsize)
 AST_TEST_DEFINE(get_calleridname_test)
 {
        int res = AST_TEST_PASS;
-       const char *in1 = "\" quoted-text internal \\\" quote \"<stuff>";
+       const char *in1 = " \" quoted-text internal \\\" quote \"<stuff>";
        const char *in2 = " token text with no quotes <stuff>";
        const char *overflow1 = " \"quoted-text overflow 1234567890123456789012345678901234567890\" <stuff>";
+       const char *overflow2 = " non-quoted text overflow 1234567890123456789012345678901234567890 <stuff>";
        const char *noendquote = " \"quoted-text no end <stuff>";
-       const char *addrspec = " \"sip:blah@blah <stuff>";
+       const char *addrspec = " sip:blah@blah";
+       const char *no_quotes_no_brackets = "blah@blah";
        const char *after_dname;
        char dname[40];
 
        switch (cmd) {
        case TEST_INIT:
                info->name = "sip_get_calleridname_test";
-               info->category = "channels/chan_sip/";
+               info->category = "/channels/chan_sip/";
                info->summary = "decodes callerid name from sip header";
                info->description = "Decodes display-name field of sip header.  Checks for valid output and expected failure cases.";
                return AST_TEST_NOT_RUN;
@@ -339,60 +843,1837 @@ AST_TEST_DEFINE(get_calleridname_test)
 
        /* quoted-text with backslash escaped quote */
        after_dname = get_calleridname(in1, dname, sizeof(dname));
-       ast_test_status_update(&args->status_update, "display-name1: %s\nafter: %s\n", dname, after_dname);
+       ast_test_status_update(test, "display-name1: %s\nafter: %s\n", dname, after_dname);
        if (strcmp(dname, " quoted-text internal \" quote ")) {
-               ast_test_status_update(&args->status_update, "display-name1 test failed\n");
-               ast_str_append(&args->ast_test_error_str, 0, "quoted-text with internal backslash decode failed. \n");
+               ast_test_status_update(test, "display-name1 test failed\n");
                res = AST_TEST_FAIL;
        }
 
        /* token text */
        after_dname = get_calleridname(in2, dname, sizeof(dname));
-       ast_test_status_update(&args->status_update, "display-name2: %s\nafter: %s\n", dname, after_dname);
+       ast_test_status_update(test, "display-name2: %s\nafter: %s\n", dname, after_dname);
        if (strcmp(dname, "token text with no quotes")) {
-               ast_test_status_update(&args->status_update, "display-name2 test failed\n");
-               ast_str_append(&args->ast_test_error_str, 0, "token text with decode failed. \n");
+               ast_test_status_update(test, "display-name2 test failed\n");
                res = AST_TEST_FAIL;
        }
 
        /* quoted-text buffer overflow */
        after_dname = get_calleridname(overflow1, dname, sizeof(dname));
-       ast_test_status_update(&args->status_update, "overflow display-name1: %s\nafter: %s\n", dname, after_dname);
-       if (*dname != '\0' && after_dname != overflow1) {
-               ast_test_status_update(&args->status_update, "overflow display-name1 test failed\n");
-               ast_str_append(&args->ast_test_error_str, 0, "quoted-text buffer overflow check failed. \n");
+       ast_test_status_update(test, "overflow display-name1: %s\nafter: %s\n", dname, after_dname);
+       if (strcmp(dname, "quoted-text overflow 123456789012345678")) {
+               ast_test_status_update(test, "overflow display-name1 test failed\n");
+               res = AST_TEST_FAIL;
+       }
+
+       /* non-quoted-text buffer overflow */
+       after_dname = get_calleridname(overflow2, dname, sizeof(dname));
+       ast_test_status_update(test, "overflow display-name2: %s\nafter: %s\n", dname, after_dname);
+       if (strcmp(dname, "non-quoted text overflow 12345678901234")) {
+               ast_test_status_update(test, "overflow display-name2 test failed\n");
                res = AST_TEST_FAIL;
        }
 
        /* quoted-text buffer with no terminating end quote */
        after_dname = get_calleridname(noendquote, dname, sizeof(dname));
-       ast_test_status_update(&args->status_update, "noendquote display-name1: %s\nafter: %s\n", dname, after_dname);
+       ast_test_status_update(test, "noendquote display-name1: %s\nafter: %s\n", dname, after_dname);
        if (*dname != '\0' && after_dname != noendquote) {
-               ast_test_status_update(&args->status_update, "no end quote for quoted-text display-name failed\n");
-               ast_str_append(&args->ast_test_error_str, 0, "quoted-text buffer check no terminating end quote failed. \n");
+               ast_test_status_update(test, "no end quote for quoted-text display-name failed\n");
                res = AST_TEST_FAIL;
        }
 
        /* addr-spec rather than display-name. */
        after_dname = get_calleridname(addrspec, dname, sizeof(dname));
-       ast_test_status_update(&args->status_update, "noendquote display-name1: %s\nafter: %s\n", dname, after_dname);
+       ast_test_status_update(test, "addr-spec display-name1: %s\nafter: %s\n", dname, after_dname);
        if (*dname != '\0' && after_dname != addrspec) {
-               ast_test_status_update(&args->status_update, "detection of addr-spec failed\n");
-               ast_str_append(&args->ast_test_error_str, 0, "detection of addr-spec failed. \n");
+               ast_test_status_update(test, "detection of addr-spec failed\n");
+               res = AST_TEST_FAIL;
+       }
+
+       /* no quotes, no brackets */
+       after_dname = get_calleridname(no_quotes_no_brackets, dname, sizeof(dname));
+       ast_test_status_update(test, "no_quotes_no_brackets display-name1: %s\nafter: %s\n", dname, after_dname);
+       if (*dname != '\0' && after_dname != no_quotes_no_brackets) {
+               ast_test_status_update(test, "detection of addr-spec failed\n");
                res = AST_TEST_FAIL;
        }
 
        return res;
 }
 
+int get_name_and_number(const char *hdr, char **name, char **number)
+{
+       char header[256];
+       char tmp_name[256];
+       char *tmp_number = NULL;
+       char *hostport = NULL;
+       char *dummy = NULL;
 
-void sip_request_parser_register_tests(void)
+       if (!name || !number || ast_strlen_zero(hdr)) {
+               return -1;
+       }
+
+       *number = NULL;
+       *name = NULL;
+       ast_copy_string(header, hdr, sizeof(header));
+
+       /* strip the display-name portion off the beginning of the header. */
+       get_calleridname(header, tmp_name, sizeof(tmp_name));
+
+       /* get uri within < > brackets */
+       tmp_number = get_in_brackets(header);
+
+       /* parse out the number here */
+       if (parse_uri(tmp_number, "sip:,sips:", &tmp_number, &dummy, &hostport, NULL) || ast_strlen_zero(tmp_number)) {
+               ast_log(LOG_ERROR, "can not parse name and number from sip header.\n");
+               return -1;
+       }
+
+       /* number is not option, and must be present at this point */
+       *number = ast_strdup(tmp_number);
+       ast_uri_decode(*number, ast_uri_sip_user);
+
+       /* name is optional and may not be present at this point */
+       if (!ast_strlen_zero(tmp_name)) {
+               *name = ast_strdup(tmp_name);
+       }
+
+       return 0;
+}
+
+AST_TEST_DEFINE(get_name_and_number_test)
 {
-       AST_TEST_REGISTER(get_calleridname_test);
-       AST_TEST_REGISTER(sip_parse_uri_test);
+       int res = AST_TEST_PASS;
+       char *name = NULL;
+       char *number = NULL;
+       const char *in1 = "NAME <sip:NUMBER@place>";
+       const char *in2 = "\"NA><ME\" <sip:NUMBER@place>";
+       const char *in3 = "NAME";
+       const char *in4 = "<sip:NUMBER@place>";
+       const char *in5 = "This is a screwed up string <sip:LOLCLOWNS<sip:>@place>";
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "sip_get_name_and_number_test";
+               info->category = "/channels/chan_sip/";
+               info->summary = "Tests getting name and number from sip header";
+               info->description =
+                               "Runs through various test situations in which a name and "
+                               "and number can be retrieved from a sip header.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* Test 1. get name and number */
+       number = name = NULL;
+       if ((get_name_and_number(in1, &name, &number)) ||
+               strcmp(name, "NAME") ||
+               strcmp(number, "NUMBER")) {
+
+               ast_test_status_update(test, "Test 1, simple get name and number failed.\n");
+               res = AST_TEST_FAIL;
+       }
+       ast_free(name);
+       ast_free(number);
+
+       /* Test 2. get quoted name and number */
+       number = name = NULL;
+       if ((get_name_and_number(in2, &name, &number)) ||
+               strcmp(name, "NA><ME") ||
+               strcmp(number, "NUMBER")) {
+
+               ast_test_status_update(test, "Test 2, get quoted name and number failed.\n");
+               res = AST_TEST_FAIL;
+       }
+       ast_free(name);
+       ast_free(number);
+
+       /* Test 3. name only */
+       number = name = NULL;
+       if (!(get_name_and_number(in3, &name, &number))) {
+
+               ast_test_status_update(test, "Test 3, get name only was expected to fail but did not.\n");
+               res = AST_TEST_FAIL;
+       }
+       ast_free(name);
+       ast_free(number);
+
+       /* Test 4. number only */
+       number = name = NULL;
+       if ((get_name_and_number(in4, &name, &number)) ||
+               !ast_strlen_zero(name) ||
+               strcmp(number, "NUMBER")) {
+
+               ast_test_status_update(test, "Test 4, get number with no name present failed.\n");
+               res = AST_TEST_FAIL;
+       }
+       ast_free(name);
+       ast_free(number);
+
+       /* Test 5. malformed string, since number can not be parsed, this should return an error.  */
+       number = name = NULL;
+       if (!(get_name_and_number(in5, &name, &number)) ||
+               !ast_strlen_zero(name) ||
+               !ast_strlen_zero(number)) {
+
+               ast_test_status_update(test, "Test 5, processing malformed string failed.\n");
+               res = AST_TEST_FAIL;
+       }
+       ast_free(name);
+       ast_free(number);
+
+       /* Test 6. NULL output parameters */
+       number = name = NULL;
+       if (!(get_name_and_number(in5, NULL, NULL))) {
+
+               ast_test_status_update(test, "Test 6, NULL output parameters failed.\n");
+               res = AST_TEST_FAIL;
+       }
+
+       /* Test 7. NULL input parameter */
+       number = name = NULL;
+       if (!(get_name_and_number(NULL, &name, &number)) ||
+               !ast_strlen_zero(name) ||
+               !ast_strlen_zero(number)) {
+
+               ast_test_status_update(test, "Test 7, NULL input parameter failed.\n");
+               res = AST_TEST_FAIL;
+       }
+       ast_free(name);
+       ast_free(number);
+
+       return res;
 }
-void sip_request_parser_unregister_tests(void)
+
+int get_in_brackets_const(const char *src,const char **start,int *length)
 {
-       AST_TEST_UNREGISTER(sip_parse_uri_test);
-       AST_TEST_UNREGISTER(get_calleridname_test);
+       const char *parse = src;
+       const char *first_bracket;
+       const char *second_bracket;
+
+       if (start == NULL) {
+               return -1;
+       }
+       if (length == NULL) {
+               return -1;
+       }
+       *start = NULL;
+       *length = -1;
+       if (ast_strlen_zero(src)) {
+               return 1;
+       }
+
+       /*
+        * Skip any quoted text until we find the part in brackets.
+        * On any error give up and return -1
+        */
+       while ( (first_bracket = strchr(parse, '<')) ) {
+               const char *first_quote = strchr(parse, '"');
+               first_bracket++;
+               if (!first_quote || first_quote >= first_bracket) {
+                       break; /* no need to look at quoted part */
+               }
+               /* the bracket is within quotes, so ignore it */
+               parse = find_closing_quote(first_quote + 1, NULL);
+               if (!*parse) {
+                       ast_log(LOG_WARNING, "No closing quote found in '%s'\n", src);
+                       return  -1;
+               }
+               parse++;
+       }
+
+       /* Require a first bracket.  Unlike get_in_brackets_full, this procedure is passed a const,
+        * so it can expect a pointer to an original value */
+       if (!first_bracket) {
+               ast_log(LOG_WARNING, "No opening bracket found in '%s'\n", src);
+               return 1;
+       }
+
+       if ((second_bracket = strchr(first_bracket, '>'))) {
+               *start = first_bracket;
+               *length = second_bracket - first_bracket;
+               return 0;
+       }
+       ast_log(LOG_WARNING, "No closing bracket found in '%s'\n", src);
+       return -1;
+}
+
+int get_in_brackets_full(char *tmp,char **out,char **residue)
+{
+       const char *parse = tmp;
+       char *first_bracket;
+       char *second_bracket;
+
+       if (out) {
+               *out = "";
+       }
+       if (residue) {
+               *residue = "";
+       }
+
+       if (ast_strlen_zero(tmp)) {
+               return 1;
+       }
+
+       /*
+        * Skip any quoted text until we find the part in brackets.
+       * On any error give up and return -1
+       */
+       while ( (first_bracket = strchr(parse, '<')) ) {
+               char *first_quote = strchr(parse, '"');
+               first_bracket++;
+               if (!first_quote || first_quote >= first_bracket) {
+                       break; /* no need to look at quoted part */
+               }
+               /* the bracket is within quotes, so ignore it */
+               parse = find_closing_quote(first_quote + 1, NULL);
+               if (!*parse) {
+                       ast_log(LOG_WARNING, "No closing quote found in '%s'\n", tmp);
+                       return  -1;
+               }
+               parse++;
+       }
+
+       /* If no first bracket then still look for a second bracket as some other parsing functions
+       may overwrite first bracket with NULL when terminating a token based display-name. As this
+       only affects token based display-names there is no danger of brackets being in quotes */
+       if (first_bracket) {
+               parse = first_bracket;
+       } else {
+               parse = tmp;
+       }
+
+       if ((second_bracket = strchr(parse, '>'))) {
+               *second_bracket++ = '\0';
+               if (out) {
+                       *out = (char *) parse;
+               }
+               if (residue) {
+                       *residue = second_bracket;
+               }
+               return 0;
+       }
+
+       if ((first_bracket)) {
+               ast_log(LOG_WARNING, "No closing bracket found in '%s'\n", tmp);
+               return -1;
+       }
+
+       if (out) {
+               *out = tmp;
+       }
+
+       return 1;
+}
+
+char *get_in_brackets(char *tmp)
+{
+       char *out;
+
+       if ((get_in_brackets_full(tmp, &out, NULL))) {
+               return tmp;
+       }
+       return out;
+}
+
+AST_TEST_DEFINE(get_in_brackets_test)
+{
+       int res = AST_TEST_PASS;
+       char in_brackets[] = "sip:name:secret@host:port;transport=tcp?headers=testblah&headers2=blahblah";
+       char no_name[] = "<sip:name:secret@host:port;transport=tcp?headers=testblah&headers2=blahblah>";
+       char quoted_string[] = "\"I'm a quote stri><ng\" <sip:name:secret@host:port;transport=tcp?headers=testblah&headers2=blahblah>";
+       char missing_end_quote[] = "\"I'm a quote string <sip:name:secret@host:port;transport=tcp?headers=testblah&headers2=blahblah>";
+       char name_no_quotes[] = "name not in quotes <sip:name:secret@host:port;transport=tcp?headers=testblah&headers2=blahblah>";
+       char no_end_bracket[] = "name not in quotes <sip:name:secret@host:port;transport=tcp?headers=testblah&headers2=blahblah";
+       char no_name_no_brackets[] = "sip:name@host";
+       char missing_start_bracket[] = "sip:name:secret@host:port;transport=tcp?headers=testblah&headers2=blahblah>";
+       char *uri = NULL;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "sip_get_in_brackets_test";
+               info->category = "/channels/chan_sip/";
+               info->summary = "Tests getting a sip uri in <> brackets within a sip header.";
+               info->description =
+                               "Runs through various test situations in which a sip uri "
+                               "in angle brackets needs to be retrieved";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* Test 1, simple get in brackets */
+       if (!(uri = get_in_brackets(no_name)) || strcmp(uri, in_brackets)) {
+               ast_test_status_update(test, "Test 1, simple get in brackets failed. %s\n", uri);
+               res = AST_TEST_FAIL;
+       }
+
+       /* Test 2, starts with quoted string */
+       if (!(uri = get_in_brackets(quoted_string)) || strcmp(uri, in_brackets)) {
+               ast_test_status_update(test, "Test 2, get in brackets with quoted string in front failed. %s\n", uri);
+               res = AST_TEST_FAIL;
+       }
+
+       /* Test 3, missing end quote */
+       if (!(uri = get_in_brackets(missing_end_quote)) || !strcmp(uri, in_brackets)) {
+               ast_test_status_update(test, "Test 3, missing end quote failed. %s\n", uri);
+               res = AST_TEST_FAIL;
+       }
+
+       /* Test 4, starts with a name not in quotes */
+       if (!(uri = get_in_brackets(name_no_quotes)) || strcmp(uri, in_brackets)) {
+               ast_test_status_update(test, "Test 4, passing name not in quotes failed. %s\n", uri);
+               res = AST_TEST_FAIL;
+       }
+
+       /* Test 5, no end bracket, should just return everything after the first '<'  */
+       if (!(uri = get_in_brackets(no_end_bracket)) || !strcmp(uri, in_brackets)) {
+               ast_test_status_update(test, "Test 5, no end bracket failed. %s\n", uri);
+               res = AST_TEST_FAIL;
+       }
+
+       /* Test 6, NULL input  */
+       if (get_in_brackets(NULL)) {
+               ast_test_status_update(test, "Test 6, NULL input failed.\n");
+               res = AST_TEST_FAIL;
+       }
+
+       /* Test 7, no name, and no brackets. */
+       if (!(uri = get_in_brackets(no_name_no_brackets)) || strcmp(uri, "sip:name@host")) {
+               ast_test_status_update(test, "Test 7 failed. %s\n", uri);
+               res = AST_TEST_FAIL;
+       }
+
+       /* Test 8, no start bracket, but with ending bracket. */
+       if (!(uri = get_in_brackets(missing_start_bracket)) || strcmp(uri, in_brackets)) {
+               ast_test_status_update(test, "Test 8 failed. %s\n", uri);
+               res = AST_TEST_FAIL;
+       }
+
+       return res;
+}
+
+
+int parse_name_andor_addr(char *uri, const char *scheme, char **name,
+                         char **user, char **pass, char **hostport,
+                         struct uriparams *params, char **headers,
+                         char **residue)
+{
+       char buf[1024];
+       char **residue2 = residue;
+       char *orig_uri = uri;
+       int ret;
+
+       buf[0] = '\0';
+       if (name) {
+               uri = (char *) get_calleridname(uri, buf, sizeof(buf));
+       }
+       ret = get_in_brackets_full(uri, &uri, residue);
+       if (ret == 0) {
+               /*
+                * The uri is in brackets so do not treat unknown trailing uri
+                * parameters as potential message header parameters.
+                */
+               if (residue && **residue) {
+                       /* step over the first semicolon as per parse_uri_full residue */
+                       *residue = *residue + 1;
+               }
+               residue2 = NULL;
+       }
+
+       if (name) {
+               if (buf[0]) {
+                       /*
+                        * There is always room at orig_uri for the display-name because
+                        * at least one character has always been removed.  A '"' or '<'
+                        * has been removed.
+                        */
+                       strcpy(orig_uri, buf);
+                       *name = orig_uri;
+               } else {
+                       *name = "";
+               }
+       }
+
+       return parse_uri_full(uri, scheme, user, pass, hostport, params, headers, residue2);
+}
+
+AST_TEST_DEFINE(parse_name_andor_addr_test)
+{
+       int res = AST_TEST_PASS;
+       char uri[1024];
+       char *name, *user, *pass, *hostport, *headers, *residue;
+       struct uriparams params;
+
+       struct testdata {
+               char *desc;
+               char *uri;
+               char *name;
+               char *user;
+               char *pass;
+               char *hostport;
+               char *headers;
+               char *residue;
+               struct uriparams params;
+               AST_LIST_ENTRY(testdata) list;
+       };
+
+       struct testdata *testdataptr;
+
+       static AST_LIST_HEAD_NOLOCK(testdataliststruct, testdata) testdatalist;
+
+       struct testdata td1 = {
+               .desc = "quotes and brackets",
+               .uri = "\"name :@ \" <sip:user:secret@host:5060;param=discard;transport=tcp>;tag=tag",
+               .name =  "name :@ ",
+               .user = "user",
+               .pass = "secret",
+               .hostport = "host:5060",
+               .headers = "",
+               .residue = "tag=tag",
+               .params.transport = "tcp",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+       struct testdata td2 = {
+               .desc = "no quotes",
+               .uri = "givenname familyname <sip:user:secret@host:5060;param=discard;transport=tcp>;expires=3600",
+               .name = "givenname familyname",
+               .user = "user",
+               .pass = "secret",
+               .hostport = "host:5060",
+               .headers = "",
+               .residue = "expires=3600",
+               .params.transport = "tcp",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+       struct testdata td3 = {
+               .desc = "no brackets",
+               .uri = "sip:user:secret@host:5060;param=discard;transport=tcp;q=1",
+               .name = "",
+               .user = "user",
+               .pass = "secret",
+               .hostport = "host:5060",
+               .headers = "",
+               .residue = "q=1",
+               .params.transport = "tcp",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+       struct testdata td4 = {
+               .desc = "just host",
+               .uri = "sips:host",
+               .name = "",
+               .user = "",
+               .pass = "",
+               .hostport = "host",
+               .headers = "",
+               .residue = "",
+               .params.transport = "",
+               .params.lr = 0,
+               .params.user = ""
+       };
+
+
+       AST_LIST_HEAD_SET_NOLOCK(&testdatalist, &td1);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td2, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td3, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td4, list);
+
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "parse_name_andor_addr_test";
+               info->category = "/channels/chan_sip/";
+               info->summary = "tests parsing of name_andor_addr abnf structure";
+               info->description =
+                       "Tests parsing of abnf name-andor-addr = name-addr / addr-spec "
+                       "Verifies output matches expected behavior.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       AST_LIST_TRAVERSE(&testdatalist, testdataptr, list) {
+               name = user = pass = hostport = headers = residue = NULL;
+               params.transport = params.user = params.method = params.ttl = params.maddr = NULL;
+               params.lr = 0;
+               ast_copy_string(uri,testdataptr->uri,sizeof(uri));
+               if (parse_name_andor_addr(uri, "sip:,sips:",
+                                         &name,
+                                         &user,
+                                         &pass,
+                                         &hostport,
+                                         &params,
+                                         &headers,
+                                         &residue) ||
+                       (name && strcmp(testdataptr->name, name)) ||
+                       (user && strcmp(testdataptr->user, user)) ||
+                       (pass && strcmp(testdataptr->pass, pass)) ||
+                       (hostport && strcmp(testdataptr->hostport, hostport)) ||
+                       (headers && strcmp(testdataptr->headers, headers)) ||
+                       (residue && strcmp(testdataptr->residue, residue)) ||
+                       (strcmp(testdataptr->params.transport,params.transport)) ||
+                       (strcmp(testdataptr->params.user,params.user))
+                       ) {
+                       ast_test_status_update(test, "Sub-Test: %s,failed.\n", testdataptr->desc);
+                       res = AST_TEST_FAIL;
+               }
+       }
+
+       return res;
+}
+
+int get_comma(char *in, char **out)
+{
+       char *c;
+       char *parse = in;
+       if (out) {
+               *out = in;
+       }
+
+       /* Skip any quoted text */
+       while (*parse) {
+               if ((c = strchr(parse, '"'))) {
+                       in = (char *)find_closing_quote((const char *)c + 1, NULL);
+                       if (!*in) {
+                               ast_log(LOG_WARNING, "No closing quote found in '%s'\n", c);
+                               return -1;
+                       } else {
+                               break;
+                       }
+               } else {
+                       break;
+               }
+               parse++;
+       }
+       parse = in;
+
+       /* Skip any userinfo components of a uri as they may contain commas */
+       if ((c = strchr(parse,'@'))) {
+               parse = c+1;
+       }
+       if ((out) && (c = strchr(parse,','))) {
+               *c++ = '\0';
+               *out = c;
+               return 0;
+       }
+       return 1;
+}
+
+int parse_contact_header(char *contactheader, struct contactliststruct *contactlist)
+{
+       int res;
+       int last;
+       char *comma;
+       char *residue;
+       char *param;
+       char *value;
+       struct contact *split_contact = NULL;
+
+       if (*contactheader == '*') {
+               return 1;
+       }
+
+       split_contact = ast_calloc(1, sizeof(*split_contact));
+
+       AST_LIST_HEAD_SET_NOLOCK(contactlist, split_contact);
+       while ((last = get_comma(contactheader, &comma)) != -1) {
+               res = parse_name_andor_addr(contactheader, "sip:,sips:",
+                       &split_contact->name, &split_contact->user,
+                       &split_contact->pass, &split_contact->hostport,
+                       &split_contact->params, &split_contact->headers,
+                       &residue);
+               if (res == -1) {
+                       return res;
+               }
+
+               /* parse contact params */
+               split_contact->expires = split_contact->q = "";
+
+               while ((value = strchr(residue,'='))) {
+                       *value++ = '\0';
+
+                       param = residue;
+                       if ((residue = strchr(value,';'))) {
+                               *residue++ = '\0';
+                       } else {
+                               residue = "";
+                       }
+
+                       if (!strcmp(param,"expires")) {
+                               split_contact->expires = value;
+                       } else if (!strcmp(param,"q")) {
+                               split_contact->q = value;
+                       }
+               }
+
+               if (last) {
+                       return 0;
+               }
+               contactheader = comma;
+
+               split_contact = ast_calloc(1, sizeof(*split_contact));
+               AST_LIST_INSERT_TAIL(contactlist, split_contact, list);
+       }
+       return last;
+}
+
+AST_TEST_DEFINE(parse_contact_header_test)
+{
+       int res = AST_TEST_PASS;
+       char contactheader[1024];
+       int star;
+       struct contactliststruct contactlist;
+       struct contactliststruct *contactlistptr=&contactlist;
+
+       struct testdata {
+               char *desc;
+               char *contactheader;
+               int star;
+               struct contactliststruct *contactlist;
+
+               AST_LIST_ENTRY(testdata) list;
+       };
+
+       struct testdata *testdataptr;
+       struct contact *tdcontactptr;
+       struct contact *contactptr;
+
+       static AST_LIST_HEAD_NOLOCK(testdataliststruct, testdata) testdatalist;
+       struct contactliststruct contactlist1, contactlist2;
+
+       struct testdata td1 = {
+               .desc = "single contact",
+               .contactheader = "\"name :@;?&,\" <sip:user:secret@host:5082;param=discard;transport=tcp>;expires=3600",
+               .contactlist = &contactlist1,
+               .star = 0
+       };
+       struct contact contact11 = {
+               .name = "name :@;?&,",
+               .user = "user",
+               .pass = "secret",
+               .hostport = "host:5082",
+               .params.transport = "tcp",
+               .params.ttl = "",
+               .params.lr = 0,
+               .headers = "",
+               .expires = "3600",
+               .q = ""
+       };
+
+       struct testdata td2 = {
+               .desc = "multiple contacts",
+               .contactheader = "sip:,user1,:,secret1,@host1;ttl=7;q=1;expires=3600,sips:host2",
+               .contactlist = &contactlist2,
+               .star = 0,
+       };
+       struct contact contact21 = {
+               .name = "",
+               .user = ",user1,",
+               .pass = ",secret1,",
+               .hostport = "host1",
+               .params.transport = "",
+               .params.ttl = "7",
+               .params.lr = 0,
+               .headers = "",
+               .expires = "3600",
+               .q = "1"
+       };
+       struct contact contact22 = {
+               .name = "",
+               .user = "",
+               .pass = "",
+               .hostport = "host2",
+               .params.transport = "",
+               .params.ttl = "",
+               .params.lr = 0,
+               .headers = "",
+               .expires = "",
+               .q = ""
+       };
+
+       struct testdata td3 = {
+               .desc = "star - all contacts",
+               .contactheader = "*",
+               .star = 1,
+               .contactlist = NULL
+       };
+
+       AST_LIST_HEAD_SET_NOLOCK(&testdatalist, &td1);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td2, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &td3, list);
+
+       AST_LIST_HEAD_SET_NOLOCK(&contactlist1, &contact11);
+
+       AST_LIST_HEAD_SET_NOLOCK(&contactlist2, &contact21);
+       AST_LIST_INSERT_TAIL(&contactlist2, &contact22, list);
+
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "parse_contact_header_test";
+               info->category = "/channels/chan_sip/";
+               info->summary = "tests parsing of sip contact header";
+               info->description =
+                       "Tests parsing of a contact header including those with multiple contacts "
+                       "Verifies output matches expected behavior.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       AST_LIST_TRAVERSE(&testdatalist, testdataptr, list) {
+               ast_copy_string(contactheader,testdataptr->contactheader,sizeof(contactheader));
+               star = parse_contact_header(contactheader,contactlistptr);
+               if (testdataptr->star) {
+                       /* expecting star rather than list of contacts */
+                       if (!star) {
+                               ast_test_status_update(test, "Sub-Test: %s,failed.\n", testdataptr->desc);
+                               res = AST_TEST_FAIL;
+                               break;
+                       }
+               } else {
+                       contactptr = AST_LIST_FIRST(contactlistptr);
+                       AST_LIST_TRAVERSE(testdataptr->contactlist, tdcontactptr, list) {
+                               if (!contactptr ||
+                                       strcmp(tdcontactptr->name, contactptr->name) ||
+                                       strcmp(tdcontactptr->user, contactptr->user) ||
+                                       strcmp(tdcontactptr->pass, contactptr->pass) ||
+                                       strcmp(tdcontactptr->hostport, contactptr->hostport) ||
+                                       strcmp(tdcontactptr->headers, contactptr->headers) ||
+                                       strcmp(tdcontactptr->expires, contactptr->expires) ||
+                                       strcmp(tdcontactptr->q, contactptr->q) ||
+                                       strcmp(tdcontactptr->params.transport, contactptr->params.transport) ||
+                                       strcmp(tdcontactptr->params.ttl, contactptr->params.ttl) ||
+                                       (tdcontactptr->params.lr != contactptr->params.lr)
+                                       ) {
+                                       ast_test_status_update(test, "Sub-Test: %s,failed.\n", testdataptr->desc);
+                                       res = AST_TEST_FAIL;
+                                       break;
+                               }
+
+                               contactptr = AST_LIST_NEXT(contactptr,list);
+                       }
+
+                       while ((contactptr = AST_LIST_REMOVE_HEAD(contactlistptr,list))) {
+                               ast_free(contactptr);
+                       }
+               }
+       }
+
+       return res;
+}
+
+/*!
+ * \brief Parse supported header in incoming packet
+ *
+ * \details This function parses through the options parameters and
+ * builds a bit field representing all the SIP options in that field. When an
+ * item is found that is not supported, it is copied to the unsupported
+ * out buffer.
+ *
+ * \param options list
+ * \param unsupported out buffer (optional)
+ * \param unsupported_len out buffer length (optional)
+ */
+unsigned int parse_sip_options(const char *options, char *unsupported, size_t unsupported_len)
+{
+       char *next, *sep;
+       char *temp;
+       int i, found, supported;
+       unsigned int profile = 0;
+
+       char *out = unsupported;
+       size_t outlen = unsupported_len;
+       char *cur_out = out;
+
+       if (out && (outlen > 0)) {
+               memset(out, 0, outlen);
+       }
+
+       if (ast_strlen_zero(options) )
+               return 0;
+
+       temp = ast_strdupa(options);
+
+       ast_debug(3, "Begin: parsing SIP \"Supported: %s\"\n", options);
+
+       for (next = temp; next; next = sep) {
+               found = FALSE;
+               supported = FALSE;
+               if ((sep = strchr(next, ',')) != NULL) {
+                       *sep++ = '\0';
+               }
+
+               /* trim leading and trailing whitespace */
+               next = ast_strip(next);
+
+               if (ast_strlen_zero(next)) {
+                       continue; /* if there is a blank argument in there just skip it */
+               }
+
+               ast_debug(3, "Found SIP option: -%s-\n", next);
+               for (i = 0; i < ARRAY_LEN(sip_options); i++) {
+                       if (!strcasecmp(next, sip_options[i].text)) {
+                               profile |= sip_options[i].id;
+                               if (sip_options[i].supported == SUPPORTED) {
+                                       supported = TRUE;
+                               }
+                               found = TRUE;
+                               ast_debug(3, "Matched SIP option: %s\n", next);
+                               break;
+                       }
+               }
+
+               /* If option is not supported, add to unsupported out buffer */
+               if (!supported && out && outlen) {
+                       size_t copylen = strlen(next);
+                       size_t cur_outlen = strlen(out);
+                       /* Check to see if there is enough room to store this option.
+                        * Copy length is string length plus 2 for the ',' and '\0' */
+                       if ((cur_outlen + copylen + 2) < outlen) {
+                               /* if this isn't the first item, add the ',' */
+                               if (cur_outlen) {
+                                       *cur_out = ',';
+                                       cur_out++;
+                                       cur_outlen++;
+                               }
+                               ast_copy_string(cur_out, next, (outlen - cur_outlen));
+                               cur_out += copylen;
+                       }
+               }
+
+               if (!found) {
+                       profile |= SIP_OPT_UNKNOWN;
+                       if (!strncasecmp(next, "x-", 2))
+                               ast_debug(3, "Found private SIP option, not supported: %s\n", next);
+                       else
+                               ast_debug(3, "Found no match for SIP option: %s (Please file bug report!)\n", next);
+               }
+       }
+
+       return profile;
+}
+
+AST_TEST_DEFINE(sip_parse_options_test)
+{
+       int res = AST_TEST_PASS;
+       char unsupported[64];
+       unsigned int option_profile = 0;
+       struct testdata {
+               char *name;
+               char *input_options;
+               char *expected_unsupported;
+               unsigned int expected_profile;
+               AST_LIST_ENTRY(testdata) list;
+       };
+
+       struct testdata *testdataptr;
+       static AST_LIST_HEAD_NOLOCK(testdataliststruct, testdata) testdatalist;
+
+       struct testdata test1 = {
+               .name = "test_all_unsupported",
+               .input_options = "unsupported1,,, ,unsupported2,unsupported3,unsupported4",
+               .expected_unsupported = "unsupported1,unsupported2,unsupported3,unsupported4",
+               .expected_profile = SIP_OPT_UNKNOWN,
+       };
+       struct testdata test2 = {
+               .name = "test_all_unsupported_one_supported",
+               .input_options = "  unsupported1, replaces,   unsupported3  , , , ,unsupported4",
+               .expected_unsupported = "unsupported1,unsupported3,unsupported4",
+               .expected_profile = SIP_OPT_UNKNOWN | SIP_OPT_REPLACES
+       };
+       struct testdata test3 = {
+               .name = "test_two_supported_two_unsupported",
+               .input_options = ",,  timer  ,replaces     ,unsupported3,unsupported4",
+               .expected_unsupported = "unsupported3,unsupported4",
+               .expected_profile = SIP_OPT_UNKNOWN | SIP_OPT_REPLACES | SIP_OPT_TIMER,
+       };
+
+       struct testdata test4 = {
+               .name = "test_all_supported",
+               .input_options = "timer,replaces",
+               .expected_unsupported = "",
+               .expected_profile = SIP_OPT_REPLACES | SIP_OPT_TIMER,
+       };
+
+       struct testdata test5 = {
+               .name = "test_all_supported_redundant",
+               .input_options = "timer,replaces,timer,replace,timer,replaces",
+               .expected_unsupported = "",
+               .expected_profile = SIP_OPT_REPLACES | SIP_OPT_TIMER,
+       };
+       struct testdata test6 = {
+               .name = "test_buffer_overflow",
+               .input_options = "unsupported1,replaces,timer,unsupported4,unsupported_huge____"
+               "____________________________________,__________________________________________"
+               "________________________________________________",
+               .expected_unsupported = "unsupported1,unsupported4",
+               .expected_profile = SIP_OPT_UNKNOWN | SIP_OPT_REPLACES | SIP_OPT_TIMER,
+       };
+       struct testdata test7 = {
+               .name = "test_null_input",
+               .input_options = NULL,
+               .expected_unsupported = "",
+               .expected_profile = 0,
+       };
+       struct testdata test8 = {
+               .name = "test_whitespace_input",
+               .input_options = "         ",
+               .expected_unsupported = "",
+               .expected_profile = 0,
+       };
+       struct testdata test9 = {
+               .name = "test_whitespace_plus_option_input",
+               .input_options = " , , ,timer , ,  , ,        ,    ",
+               .expected_unsupported = "",
+               .expected_profile = SIP_OPT_TIMER,
+       };
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "sip_parse_options_test";
+               info->category = "/channels/chan_sip/";
+               info->summary = "Tests parsing of sip options";
+               info->description =
+                                                       "Tests parsing of SIP options from supported and required "
+                                                       "header fields.  Verifies when unsupported options are encountered "
+                                                       "that they are appended to the unsupported out buffer and that the "
+                                                       "correct bit field representnig the option profile is returned.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       AST_LIST_HEAD_SET_NOLOCK(&testdatalist, &test1);
+       AST_LIST_INSERT_TAIL(&testdatalist, &test2, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &test3, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &test4, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &test5, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &test6, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &test7, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &test8, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &test9, list);
+
+       /* Test with unsupported char buffer */
+       AST_LIST_TRAVERSE(&testdatalist, testdataptr, list) {
+               option_profile = parse_sip_options(testdataptr->input_options, unsupported, ARRAY_LEN(unsupported));
+               if (option_profile != testdataptr->expected_profile ||
+                       strcmp(unsupported, testdataptr->expected_unsupported)) {
+                       ast_test_status_update(test, "Test with output buffer \"%s\", expected unsupported: %s actual unsupported:"
+                               "%s expected bit profile: %x actual bit profile: %x\n",
+                               testdataptr->name,
+                               testdataptr->expected_unsupported,
+                               unsupported,
+                               testdataptr->expected_profile,
+                               option_profile);
+                       res = AST_TEST_FAIL;
+               } else {
+                       ast_test_status_update(test, "\"%s\" passed got expected unsupported: %s and bit profile: %x\n",
+                               testdataptr->name,
+                               unsupported,
+                               option_profile);
+               }
+
+               option_profile = parse_sip_options(testdataptr->input_options, NULL, 0);
+               if (option_profile != testdataptr->expected_profile) {
+                       ast_test_status_update(test, "NULL output test \"%s\", expected bit profile: %x actual bit profile: %x\n",
+                               testdataptr->name,
+                               testdataptr->expected_profile,
+                               option_profile);
+                       res = AST_TEST_FAIL;
+               } else {
+                       ast_test_status_update(test, "\"%s\" with NULL output buf passed, bit profile: %x\n",
+                               testdataptr->name,
+                               option_profile);
+               }
+       }
+
+       return res;
+}
+
+/*! \brief helper routine for sip_uri_cmp to compare URI parameters
+ *
+ * This takes the parameters from two SIP URIs and determines
+ * if the URIs match. The rules for parameters *suck*. Here's a breakdown
+ * 1. If a parameter appears in both URIs, then they must have the same value
+ *    in order for the URIs to match
+ * 2. If one URI has a user, maddr, ttl, or method parameter, then the other
+ *    URI must also have that parameter and must have the same value
+ *    in order for the URIs to match
+ * 3. All other headers appearing in only one URI are not considered when
+ *    determining if URIs match
+ *
+ * \param input1 Parameters from URI 1
+ * \param input2 Parameters from URI 2
+ * \retval 0 URIs' parameters match
+ * \retval nonzero URIs' parameters do not match
+ */
+static int sip_uri_params_cmp(const char *input1, const char *input2)
+{
+       char *params1 = NULL;
+       char *params2 = NULL;
+       char *pos1;
+       char *pos2;
+       int zerolength1 = 0;
+       int zerolength2 = 0;
+       int maddrmatch = 0;
+       int ttlmatch = 0;
+       int usermatch = 0;
+       int methodmatch = 0;
+
+       if (ast_strlen_zero(input1)) {
+               zerolength1 = 1;
+       } else {
+               params1 = ast_strdupa(input1);
+       }
+       if (ast_strlen_zero(input2)) {
+               zerolength2 = 1;
+       } else {
+               params2 = ast_strdupa(input2);
+       }
+
+       /* Quick optimization. If both params are zero-length, then
+        * they match
+        */
+       if (zerolength1 && zerolength2) {
+               return 0;
+       }
+
+       for (pos1 = strsep(&params1, ";"); pos1; pos1 = strsep(&params1, ";")) {
+               char *value1 = pos1;
+               char *name1 = strsep(&value1, "=");
+               char *params2dup = NULL;
+               int matched = 0;
+               if (!value1) {
+                       value1 = "";
+               }
+               /* Checkpoint reached. We have the name and value parsed for param1
+                * We have to duplicate params2 each time through this loop
+                * or else the inner loop below will not work properly.
+                */
+               if (!zerolength2) {
+                       params2dup = ast_strdupa(params2);
+               }
+               for (pos2 = strsep(&params2dup, ";"); pos2; pos2 = strsep(&params2dup, ";")) {
+                       char *name2 = pos2;
+                       char *value2 = strchr(pos2, '=');
+                       if (!value2) {
+                               value2 = "";
+                       } else {
+                               *value2++ = '\0';
+                       }
+                       if (!strcasecmp(name1, name2)) {
+                               if (strcasecmp(value1, value2)) {
+                                       goto fail;
+                               } else {
+                                       matched = 1;
+                                       break;
+                               }
+                       }
+               }
+               /* Check to see if the parameter is one of the 'must-match' parameters */
+               if (!strcasecmp(name1, "maddr")) {
+                       if (matched) {
+                               maddrmatch = 1;
+                       } else {
+                               goto fail;
+                       }
+               } else if (!strcasecmp(name1, "ttl")) {
+                       if (matched) {
+                               ttlmatch = 1;
+                       } else {
+                               goto fail;
+                       }
+               } else if (!strcasecmp(name1, "user")) {
+                       if (matched) {
+                               usermatch = 1;
+                       } else {
+                               goto fail;
+                       }
+               } else if (!strcasecmp(name1, "method")) {
+                       if (matched) {
+                               methodmatch = 1;
+                       } else {
+                               goto fail;
+                       }
+               }
+       }
+
+       /* We've made it out of that horrible O(m*n) construct and there are no
+        * failures yet. We're not done yet, though, because params2 could have
+        * an maddr, ttl, user, or method header and params1 did not.
+        */
+       for (pos2 = strsep(&params2, ";"); pos2; pos2 = strsep(&params2, ";")) {
+               char *value2 = pos2;
+               char *name2 = strsep(&value2, "=");
+               if (!value2) {
+                       value2 = "";
+               }
+               if ((!strcasecmp(name2, "maddr") && !maddrmatch) ||
+                               (!strcasecmp(name2, "ttl") && !ttlmatch) ||
+                               (!strcasecmp(name2, "user") && !usermatch) ||
+                               (!strcasecmp(name2, "method") && !methodmatch)) {
+                       goto fail;
+               }
+       }
+       return 0;
+
+fail:
+       return 1;
+}
+
+/*! \brief helper routine for sip_uri_cmp to compare URI headers
+ *
+ * This takes the headers from two SIP URIs and determines
+ * if the URIs match. The rules for headers is simple. If a header
+ * appears in one URI, then it must also appear in the other URI. The
+ * order in which the headers appear does not matter.
+ *
+ * \param input1 Headers from URI 1
+ * \param input2 Headers from URI 2
+ * \retval 0 URI headers match
+ * \retval nonzero URI headers do not match
+ */
+static int sip_uri_headers_cmp(const char *input1, const char *input2)
+{
+       char *headers1 = NULL;
+       char *headers2 = NULL;
+       int zerolength1 = 0;
+       int zerolength2 = 0;
+       int different = 0;
+       char *header1;
+
+       if (ast_strlen_zero(input1)) {
+               zerolength1 = 1;
+       } else {
+               headers1 = ast_strdupa(input1);
+       }
+
+       if (ast_strlen_zero(input2)) {
+               zerolength2 = 1;
+       } else {
+               headers2 = ast_strdupa(input2);
+       }
+
+       /* If one URI contains no headers and the other
+        * does, then they cannot possibly match
+        */
+       if (zerolength1 != zerolength2) {
+               return 1;
+       }
+
+       if (zerolength1 && zerolength2)
+               return 0;
+
+       /* At this point, we can definitively state that both inputs are
+        * not zero-length. First, one more optimization. If the length
+        * of the headers is not equal, then we definitely have no match
+        */
+       if (strlen(headers1) != strlen(headers2)) {
+               return 1;
+       }
+
+       for (header1 = strsep(&headers1, "&"); header1; header1 = strsep(&headers1, "&")) {
+               if (!strcasestr(headers2, header1)) {
+                       different = 1;
+                       break;
+               }
+       }
+
+       return different;
+}
+
+/*!
+ * \brief Compare domain sections of SIP URIs
+ *
+ * For hostnames, a case insensitive string comparison is
+ * used. For IP addresses, a binary comparison is used. This
+ * is mainly because IPv6 addresses have many ways of writing
+ * the same address.
+ *
+ * For specifics about IP address comparison, see the following
+ * document: http://tools.ietf.org/html/draft-ietf-sip-ipv6-abnf-fix-05
+ *
+ * \param host1 The domain from the first URI
+ * \param host2 THe domain from the second URI
+ * \retval 0 The domains match
+ * \retval nonzero The domains do not match
+ */
+static int sip_uri_domain_cmp(const char *host1, const char *host2)
+{
+       struct ast_sockaddr addr1;
+       struct ast_sockaddr addr2;
+       int addr1_parsed;
+       int addr2_parsed;
+
+       addr1_parsed = ast_sockaddr_parse(&addr1, host1, 0);
+       addr2_parsed = ast_sockaddr_parse(&addr2, host2, 0);
+
+       if (addr1_parsed != addr2_parsed) {
+               /* One domain was an IP address and the other had
+                * a host name. FAIL!
+                */
+               return 1;
+       }
+
+       /* Both are host names. A string comparison will work
+        * perfectly here. Specifying the "C" locale ensures that
+        * The LC_CTYPE conventions use those defined in ANSI C,
+        * i.e. ASCII.
+        */
+       if (!addr1_parsed) {
+#ifdef HAVE_XLOCALE_H
+               if(!c_locale) {
+                       return strcasecmp(host1, host2);
+               } else {
+                       return strcasecmp_l(host1, host2, c_locale);
+               }
+#else
+               return strcasecmp(host1, host2);
+#endif
+       }
+
+       /* Both contain IP addresses */
+       return ast_sockaddr_cmp(&addr1, &addr2);
+}
+
+int sip_uri_cmp(const char *input1, const char *input2)
+{
+       char *uri1;
+       char *uri2;
+       char *uri_scheme1;
+       char *uri_scheme2;
+       char *host1;
+       char *host2;
+       char *params1;
+       char *params2;
+       char *headers1;
+       char *headers2;
+
+       /* XXX It would be really nice if we could just use parse_uri_full() here
+        * to separate the components of the URI, but unfortunately it is written
+        * in a way that can cause URI parameters to be discarded.
+        */
+
+       if (!input1 || !input2) {
+               return 1;
+       }
+
+       uri1 = ast_strdupa(input1);
+       uri2 = ast_strdupa(input2);
+
+       ast_uri_decode(uri1, ast_uri_sip_user);
+       ast_uri_decode(uri2, ast_uri_sip_user);
+
+       uri_scheme1 = strsep(&uri1, ":");
+       uri_scheme2 = strsep(&uri2, ":");
+
+       if (strcmp(uri_scheme1, uri_scheme2)) {
+               return 1;
+       }
+
+       /* This function is tailored for SIP and SIPS URIs. There's no
+        * need to check uri_scheme2 since we have determined uri_scheme1
+        * and uri_scheme2 are equivalent already.
+        */
+       if (strcmp(uri_scheme1, "sip") && strcmp(uri_scheme1, "sips")) {
+               return 1;
+       }
+
+       if (ast_strlen_zero(uri1) || ast_strlen_zero(uri2)) {
+               return 1;
+       }
+
+       if ((host1 = strchr(uri1, '@'))) {
+               *host1++ = '\0';
+       }
+       if ((host2 = strchr(uri2, '@'))) {
+               *host2++ = '\0';
+       }
+
+       /* Check for mismatched username and passwords. This is the
+        * only case-sensitive comparison of a SIP URI
+        */
+       if ((host1 && !host2) ||
+                       (host2 && !host1) ||
+                       (host1 && host2 && strcmp(uri1, uri2))) {
+               return 1;
+       }
+
+       if (!host1) {
+               host1 = uri1;
+       }
+       if (!host2) {
+               host2 = uri2;
+       }
+
+       /* Strip off the parameters and headers so we can compare
+        * host and port
+        */
+
+       if ((params1 = strchr(host1, ';'))) {
+               *params1++ = '\0';
+       }
+       if ((params2 = strchr(host2, ';'))) {
+               *params2++ = '\0';
+       }
+
+       /* Headers come after parameters, but there may be headers without
+        * parameters, thus the S_OR
+        */
+       if ((headers1 = strchr(S_OR(params1, host1), '?'))) {
+               *headers1++ = '\0';
+       }
+       if ((headers2 = strchr(S_OR(params2, host2), '?'))) {
+               *headers2++ = '\0';
+       }
+
+       if (sip_uri_domain_cmp(host1, host2)) {
+               return 1;
+       }
+
+       /* Headers have easier rules to follow, so do those first */
+       if (sip_uri_headers_cmp(headers1, headers2)) {
+               return 1;
+       }
+
+       /* And now the parameters. Ugh */
+       return sip_uri_params_cmp(params1, params2);
+}
+
+#define URI_CMP_MATCH 0
+#define URI_CMP_NOMATCH 1
+
+AST_TEST_DEFINE(sip_uri_cmp_test)
+{
+       static const struct {
+               const char *uri1;
+               const char *uri2;
+               int expected_result;
+       } uri_cmp_tests [] = {
+               /* These are identical, so they match */
+               { "sip:bob@example.com", "sip:bob@example.com", URI_CMP_MATCH },
+               /* Different usernames. No match */
+               { "sip:alice@example.com", "sip:bob@example.com", URI_CMP_NOMATCH },
+               /* Different hosts. No match */
+               { "sip:bob@example.com", "sip:bob@examplez.com", URI_CMP_NOMATCH },
+               /* Now start using IP addresses. Identical, so they match */
+               { "sip:bob@1.2.3.4", "sip:bob@1.2.3.4", URI_CMP_MATCH },
+               /* Two identical IPv4 addresses represented differently. Match */
+               { "sip:bob@1.2.3.4", "sip:bob@001.002.003.004", URI_CMP_MATCH },
+               /* Logically equivalent IPv4 Address and hostname. No Match */
+               { "sip:bob@127.0.0.1", "sip:bob@localhost", URI_CMP_NOMATCH },
+               /* Logically equivalent IPv6 address and hostname. No Match */
+               { "sip:bob@[::1]", "sip:bob@localhost", URI_CMP_NOMATCH },
+               /* Try an IPv6 one as well */
+               { "sip:bob@[2001:db8::1234]", "sip:bob@[2001:db8::1234]", URI_CMP_MATCH },
+               /* Two identical IPv6 addresses represented differently. Match */
+               { "sip:bob@[2001:db8::1234]", "sip:bob@[2001:0db8::1234]", URI_CMP_MATCH },
+               /* Different ports. No match */
+               { "sip:bob@1.2.3.4:5060", "sip:bob@1.2.3.4:5061", URI_CMP_NOMATCH },
+               /* Same port logically, but only one address specifies it. No match */
+               { "sip:bob@1.2.3.4:5060", "sip:bob@1.2.3.4", URI_CMP_NOMATCH },
+               /* And for safety, try with IPv6 */
+               { "sip:bob@[2001:db8:1234]:5060", "sip:bob@[2001:db8:1234]", URI_CMP_NOMATCH },
+               /* User comparison is case sensitive. No match */
+               { "sip:bob@example.com", "sip:BOB@example.com", URI_CMP_NOMATCH },
+               /* Host comparison is case insensitive. Match */
+               { "sip:bob@example.com", "sip:bob@EXAMPLE.COM", URI_CMP_MATCH },
+               /* Add headers to the URI. Identical, so they match */
+               { "sip:bob@example.com?header1=value1&header2=value2", "sip:bob@example.com?header1=value1&header2=value2", URI_CMP_MATCH },
+               /* Headers in URI 1 are not in URI 2. No Match */
+               { "sip:bob@example.com?header1=value1&header2=value2", "sip:bob@example.com", URI_CMP_NOMATCH },
+               /* Header present in both URIs does not have matching values. No match */
+               { "sip:bob@example.com?header1=value1&header2=value2", "sip:bob@example.com?header1=value1&header2=value3", URI_CMP_NOMATCH },
+               /* Add parameters to the URI. Identical so they match */
+               { "sip:bob@example.com;param1=value1;param2=value2", "sip:bob@example.com;param1=value1;param2=value2", URI_CMP_MATCH },
+               /* Same parameters in both URIs but appear in different order. Match */
+               { "sip:bob@example.com;param2=value2;param1=value1", "sip:bob@example.com;param1=value1;param2=value2", URI_CMP_MATCH },
+               /* params in URI 1 are not in URI 2. Match */
+               { "sip:bob@example.com;param1=value1;param2=value2", "sip:bob@example.com", URI_CMP_MATCH },
+               /* param present in both URIs does not have matching values. No match */
+               { "sip:bob@example.com;param1=value1;param2=value2", "sip:bob@example.com;param1=value1;param2=value3", URI_CMP_NOMATCH },
+               /* URI 1 has a maddr param but URI 2 does not. No match */
+               { "sip:bob@example.com;param1=value1;maddr=192.168.0.1", "sip:bob@example.com;param1=value1", URI_CMP_NOMATCH },
+               /* URI 1 and URI 2 both have identical maddr params. Match */
+               { "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 },
+               /* URI 1 is a SIPS URI and URI 2 is a SIP URI. No Match */
+               { "sips:bob@example.com", "sip:bob@example.com", URI_CMP_NOMATCH },
+               /* No URI schemes. No match */
+               { "bob@example.com", "bob@example.com", URI_CMP_NOMATCH },
+               /* Crashiness tests. Just an address scheme. No match */
+               { "sip", "sips", URI_CMP_NOMATCH },
+               /* Still just an address scheme. Even though they're the same, No match */
+               { "sip", "sip", URI_CMP_NOMATCH },
+               /* Empty strings. No match */
+               { "", "", URI_CMP_NOMATCH },
+               /* An empty string and a NULL. No match */
+               { "", NULL, URI_CMP_NOMATCH },
+       };
+       int i;
+       int test_res = AST_TEST_PASS;
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "sip_uri_cmp_test";
+               info->category = "/channels/chan_sip/";
+               info->summary = "Tests comparison of SIP URIs";
+               info->description = "Several would-be tricky URI comparisons are performed";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       for (i = 0; i < ARRAY_LEN(uri_cmp_tests); ++i) {
+               int cmp_res1;
+               int cmp_res2;
+               if ((cmp_res1 = sip_uri_cmp(uri_cmp_tests[i].uri1, uri_cmp_tests[i].uri2))) {
+                       /* URI comparison may return -1 or +1 depending on the failure. Standardize
+                        * the return value to be URI_CMP_NOMATCH on any failure
+                        */
+                       cmp_res1 = URI_CMP_NOMATCH;
+               }
+               if (cmp_res1 != uri_cmp_tests[i].expected_result) {
+                       ast_test_status_update(test, "Unexpected comparison result for URIs %s and %s. "
+                                       "Expected %s but got %s\n", uri_cmp_tests[i].uri1, uri_cmp_tests[i].uri2,
+                                       uri_cmp_tests[i].expected_result == URI_CMP_MATCH ? "Match" : "No Match",
+                                       cmp_res1 == URI_CMP_MATCH ? "Match" : "No Match");
+                       test_res = AST_TEST_FAIL;
+               }
+
+               /* All URI comparisons are commutative, so for the sake of being thorough, we'll
+                * rerun the comparison with the parameters reversed
+                */
+               if ((cmp_res2 = sip_uri_cmp(uri_cmp_tests[i].uri2, uri_cmp_tests[i].uri1))) {
+                       /* URI comparison may return -1 or +1 depending on the failure. Standardize
+                        * the return value to be URI_CMP_NOMATCH on any failure
+                        */
+                       cmp_res2 = URI_CMP_NOMATCH;
+               }
+               if (cmp_res2 != uri_cmp_tests[i].expected_result) {
+                       ast_test_status_update(test, "Unexpected comparison result for URIs %s and %s. "
+                                       "Expected %s but got %s\n", uri_cmp_tests[i].uri2, uri_cmp_tests[i].uri1,
+                                       uri_cmp_tests[i].expected_result == URI_CMP_MATCH ? "Match" : "No Match",
+                                       cmp_res2 == URI_CMP_MATCH ? "Match" : "No Match");
+                       test_res = AST_TEST_FAIL;
+               }
+       }
+
+       return test_res;
+}
+
+void free_via(struct sip_via *v)
+{
+       if (!v) {
+               return;
+       }
+
+       ast_free(v->via);
+       ast_free(v);
+}
+
+struct sip_via *parse_via(const char *header)
+{
+       struct sip_via *v = ast_calloc(1, sizeof(*v));
+       char *via, *parm;
+
+       if (!v) {
+               return NULL;
+       }
+
+       v->via = ast_strdup(header);
+       v->ttl = 1;
+
+       via = v->via;
+
+       if (ast_strlen_zero(via)) {
+               ast_log(LOG_ERROR, "received request without a Via header\n");
+               free_via(v);
+               return NULL;
+       }
+
+       /* seperate the first via-parm */
+       via = strsep(&via, ",");
+
+       /* chop off sent-protocol */
+       v->protocol = strsep(&via, " \t\r\n");
+       if (ast_strlen_zero(v->protocol)) {
+               ast_log(LOG_ERROR, "missing sent-protocol in Via header\n");
+               free_via(v);
+               return NULL;
+       }
+       v->protocol = ast_skip_blanks(v->protocol);
+
+       if (via) {
+               via = ast_skip_blanks(via);
+       }
+
+       /* chop off sent-by */
+       v->sent_by = strsep(&via, "; \t\r\n");
+       if (ast_strlen_zero(v->sent_by)) {
+               ast_log(LOG_ERROR, "missing sent-by in Via header\n");
+               free_via(v);
+               return NULL;
+       }
+       v->sent_by = ast_skip_blanks(v->sent_by);
+
+       /* store the port, we have to handle ipv6 addresses containing ':'
+        * characters gracefully */
+       if (((parm = strchr(v->sent_by, ']')) && *(++parm) == ':') || (parm = strchr(v->sent_by, ':'))) {
+               char *endptr;
+
+               v->port = strtol(++parm, &endptr, 10);
+       }
+
+       /* evaluate any via-parms */
+       while ((parm = strsep(&via, "; \t\r\n"))) {
+               char *c;
+               if ((c = strstr(parm, "maddr="))) {
+                       v->maddr = ast_skip_blanks(c + sizeof("maddr=") - 1);
+               } else if ((c = strstr(parm, "branch="))) {
+                       v->branch = ast_skip_blanks(c + sizeof("branch=") - 1);
+               } else if ((c = strstr(parm, "ttl="))) {
+                       char *endptr;
+                       c = ast_skip_blanks(c + sizeof("ttl=") - 1);
+                       v->ttl = strtol(c, &endptr, 10);
+
+                       /* make sure we got a valid ttl value */
+                       if (c == endptr) {
+                               v->ttl = 1;
+                       }
+               }
+       }
+
+       return v;
+}
+
+AST_TEST_DEFINE(parse_via_test)
+{
+       int res = AST_TEST_PASS;
+       int i = 1;
+       struct sip_via *via;
+       struct testdata {
+               char *in;
+               char *expected_protocol;
+               char *expected_branch;
+               char *expected_sent_by;
+               char *expected_maddr;
+               unsigned int expected_port;
+               unsigned char expected_ttl;
+               int expected_null;
+               AST_LIST_ENTRY(testdata) list;
+       };
+       struct testdata *testdataptr;
+       static AST_LIST_HEAD_NOLOCK(testdataliststruct, testdata) testdatalist;
+       struct testdata t1 = {
+               .in = "SIP/2.0/UDP host:port;branch=thebranch",
+               .expected_protocol = "SIP/2.0/UDP",
+               .expected_sent_by = "host:port",
+               .expected_branch = "thebranch",
+       };
+       struct testdata t2 = {
+               .in = "SIP/2.0/UDP host:port",
+               .expected_protocol = "SIP/2.0/UDP",
+               .expected_sent_by = "host:port",
+               .expected_branch = "",
+       };
+       struct testdata t3 = {
+               .in = "SIP/2.0/UDP",
+               .expected_null = 1,
+       };
+       struct testdata t4 = {
+               .in = "BLAH/BLAH/BLAH host:port;branch=",
+               .expected_protocol = "BLAH/BLAH/BLAH",
+               .expected_sent_by = "host:port",
+               .expected_branch = "",
+       };
+       struct testdata t5 = {
+               .in = "SIP/2.0/UDP host:5060;branch=thebranch;maddr=224.0.0.1;ttl=1",
+               .expected_protocol = "SIP/2.0/UDP",
+               .expected_sent_by = "host:5060",
+               .expected_port = 5060,
+               .expected_branch = "thebranch",
+               .expected_maddr = "224.0.0.1",
+               .expected_ttl = 1,
+       };
+       struct testdata t6 = {
+               .in = "SIP/2.0/UDP      host:5060;\n   branch=thebranch;\r\n  maddr=224.0.0.1;   ttl=1",
+               .expected_protocol = "SIP/2.0/UDP",
+               .expected_sent_by = "host:5060",
+               .expected_port = 5060,
+               .expected_branch = "thebranch",
+               .expected_maddr = "224.0.0.1",
+               .expected_ttl = 1,
+       };
+       struct testdata t7 = {
+               .in = "SIP/2.0/UDP [::1]:5060",
+               .expected_protocol = "SIP/2.0/UDP",
+               .expected_sent_by = "[::1]:5060",
+               .expected_port = 5060,
+               .expected_branch = "",
+       };
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "parse_via_test";
+               info->category = "/channels/chan_sip/";
+               info->summary = "Tests parsing the Via header";
+               info->description =
+                               "Runs through various test situations in which various "
+                               " parameters parameter must be extracted from a VIA header";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       AST_LIST_HEAD_SET_NOLOCK(&testdatalist, &t1);
+       AST_LIST_INSERT_TAIL(&testdatalist, &t2, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &t3, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &t4, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &t5, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &t6, list);
+       AST_LIST_INSERT_TAIL(&testdatalist, &t7, list);
+
+
+       AST_LIST_TRAVERSE(&testdatalist, testdataptr, list) {
+               via = parse_via(testdataptr->in);
+               if (!via) {
+                       if (!testdataptr->expected_null) {
+                               ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
+                                       "failed to parse header\n",
+                               i, testdataptr->in);
+                               res = AST_TEST_FAIL;
+                       }
+                       i++;
+                       continue;
+               }
+
+               if (testdataptr->expected_null) {
+                       ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
+                               "successfully parased invalid via header\n",
+                       i, testdataptr->in);
+                       res = AST_TEST_FAIL;
+                       free_via(via);
+                       i++;
+                       continue;
+               }
+
+               if ((ast_strlen_zero(via->protocol) && !ast_strlen_zero(testdataptr->expected_protocol))
+                       || (!ast_strlen_zero(via->protocol) && strcmp(via->protocol, testdataptr->expected_protocol))) {
+
+                       ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
+                               "parsed protocol = \"%s\"\n"
+                               "expected = \"%s\"\n"
+                               "failed to parse protocol\n",
+                       i, testdataptr->in, via->protocol, testdataptr->expected_protocol);
+                       res = AST_TEST_FAIL;
+               }
+
+               if ((ast_strlen_zero(via->sent_by) && !ast_strlen_zero(testdataptr->expected_sent_by))
+                       || (!ast_strlen_zero(via->sent_by) && strcmp(via->sent_by, testdataptr->expected_sent_by))) {
+
+                       ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
+                               "parsed sent_by = \"%s\"\n"
+                               "expected = \"%s\"\n"
+                               "failed to parse sent-by\n",
+                       i, testdataptr->in, via->sent_by, testdataptr->expected_sent_by);
+                       res = AST_TEST_FAIL;
+               }
+
+               if (testdataptr->expected_port && testdataptr->expected_port != via->port) {
+                       ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
+                               "parsed port = \"%u\"\n"
+                               "expected = \"%u\"\n"
+                               "failed to parse port\n",
+                       i, testdataptr->in, via->port, testdataptr->expected_port);
+                       res = AST_TEST_FAIL;
+               }
+
+               if ((ast_strlen_zero(via->branch) && !ast_strlen_zero(testdataptr->expected_branch))
+                       || (!ast_strlen_zero(via->branch) && strcmp(via->branch, testdataptr->expected_branch))) {
+
+                       ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
+                               "parsed branch = \"%s\"\n"
+                               "expected = \"%s\"\n"
+                               "failed to parse branch\n",
+                       i, testdataptr->in, via->branch, testdataptr->expected_branch);
+                       res = AST_TEST_FAIL;
+               }
+
+               if ((ast_strlen_zero(via->maddr) && !ast_strlen_zero(testdataptr->expected_maddr))
+                       || (!ast_strlen_zero(via->maddr) && strcmp(via->maddr, testdataptr->expected_maddr))) {
+
+                       ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
+                               "parsed maddr = \"%s\"\n"
+                               "expected = \"%s\"\n"
+                               "failed to parse maddr\n",
+                       i, testdataptr->in, via->maddr, testdataptr->expected_maddr);
+                       res = AST_TEST_FAIL;
+               }
+
+               if (testdataptr->expected_ttl && testdataptr->expected_ttl != via->ttl) {
+                       ast_test_status_update(test, "TEST#%d FAILED: VIA = \"%s\"\n"
+                               "parsed ttl = \"%d\"\n"
+                               "expected = \"%d\"\n"
+                               "failed to parse ttl\n",
+                       i, testdataptr->in, via->ttl, testdataptr->expected_ttl);
+                       res = AST_TEST_FAIL;
+               }
+
+               free_via(via);
+               i++;
+       }
+       return res;
+}
+
+void sip_request_parser_register_tests(void)
+{
+       AST_TEST_REGISTER(get_calleridname_test);
+       AST_TEST_REGISTER(sip_parse_uri_test);
+       AST_TEST_REGISTER(get_in_brackets_test);
+       AST_TEST_REGISTER(get_name_and_number_test);
+       AST_TEST_REGISTER(sip_parse_uri_full_test);
+       AST_TEST_REGISTER(parse_name_andor_addr_test);
+       AST_TEST_REGISTER(parse_contact_header_test);
+       AST_TEST_REGISTER(sip_parse_options_test);
+       AST_TEST_REGISTER(sip_uri_cmp_test);
+       AST_TEST_REGISTER(parse_via_test);
+}
+void sip_request_parser_unregister_tests(void)
+{
+       AST_TEST_UNREGISTER(sip_parse_uri_test);
+       AST_TEST_UNREGISTER(get_calleridname_test);
+       AST_TEST_UNREGISTER(get_in_brackets_test);
+       AST_TEST_UNREGISTER(get_name_and_number_test);
+       AST_TEST_UNREGISTER(sip_parse_uri_full_test);
+       AST_TEST_UNREGISTER(parse_name_andor_addr_test);
+       AST_TEST_UNREGISTER(parse_contact_header_test);
+       AST_TEST_UNREGISTER(sip_parse_options_test);
+       AST_TEST_UNREGISTER(sip_uri_cmp_test);
+       AST_TEST_UNREGISTER(parse_via_test);
+}
+
+int sip_reqresp_parser_init(void)
+{
+#ifdef HAVE_XLOCALE_H
+       c_locale = newlocale(LC_CTYPE_MASK, "C", NULL);
+       if (!c_locale) {
+               return -1;
+       }
+#endif
+       return 0;
+}
+
+void sip_reqresp_parser_exit(void)
+{
+#ifdef HAVE_XLOCALE_H
+       if (c_locale) {
+               freelocale(c_locale);
+               c_locale = NULL;
+       }
+#endif
 }