/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <ctype.h>
#include <stdlib.h>
#include <string.h>

#include "sip_parse_uri.h"

/*
 * SIP-URI          =  "sip:" [ userinfo ] hostport uri-parameters [ headers ]
 * SIPS-URI         =  "sips:" [ userinfo ] hostport uri-parameters [ headers ]
 * userinfo         =  ( user / telephone-subscriber ) [ ":" password ] "@"
 * user             =  1*( unreserved / escaped / user-unreserved )
 * user-unreserved  =  "&" / "=" / "+" / "$" / "," / ";" / "?" / "/"
 * password         =  *( unreserved / escaped / "&" / "=" / "+" / "$" / "," )
 * hostport         =  host [ ":" port ]
 * host             =  hostname / IPv4address / IPv6reference
 * hostname         =  *( domainlabel "." ) toplabel [ "." ]
 * domainlabel      =  alphanum / alphanum *( alphanum / "-" ) alphanum
 * toplabel         =  ALPHA / ALPHA *( alphanum / "-" ) alphanum
 * IPv4address    =  1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT
 * IPv6reference  =  "[" IPv6address "]"
 * IPv6address    =  hexpart [ ":" IPv4address ]
 * hexpart        =  hexseq / hexseq "::" [ hexseq ] / "::" [ hexseq ]
 * hexseq         =  hex4 *( ":" hex4)
 * hex4           =  1*4HEXDIG
 * port           =  1*DIGIT
 *
 * The BNF for telephone-subscriber can be found in RFC 2806 [9].  Note,
 * however, that any characters allowed there that are not allowed in
 * the user part of the SIP URI MUST be escaped.
 *
 * uri-parameters    =  *( ";" uri-parameter)
 * uri-parameter     =  transport-param / user-param / method-param
 *                      / ttl-param / maddr-param / lr-param / other-param
 * transport-param   =  "transport="( "udp" / "tcp" / "sctp" / "tls"
 *                     / other-transport)
 * other-transport   =  token
 * user-param        =  "user=" ( "phone" / "ip" / other-user)
 * other-user        =  token
 * method-param      =  "method=" Method
 * ttl-param         =  "ttl=" ttl
 * maddr-param       =  "maddr=" host
 * lr-param          =  "lr"
 * other-param       =  pname [ "=" pvalue ]
 * pname             =  1*paramchar
 * pvalue            =  1*paramchar
 * paramchar         =  param-unreserved / unreserved / escaped
 * param-unreserved  =  "[" / "]" / "/" / ":" / "&" / "+" / "$"
 * headers         =  "?" header *( "&" header )
 * header          =  hname "=" hvalue
 * hname           =  1*( hnv-unreserved / unreserved / escaped )
 * hvalue          =  *( hnv-unreserved / unreserved / escaped )
 * hnv-unreserved  =  "[" / "]" / "/" / "?" / ":" / "+" / "$"
 *
 */

#define SIP_URI_MSG_BUF_SZ      100

#define SIP_URI_ISHEX(c)                                        \
        (((int)(c) >= 0x30 && (int)(c) <= 0x39) ||      \
        ((int)(c) >= 0x41 && (int)(c) <= 0x46) ||       \
        ((int)(c) >= 0x61 && (int)(c) <= 0x66))

#define SIP_URI_ISURLESCAPE(scan, end)                  \
        ((scan) + 2 < (end) && (scan)[0] == '%' &&      \
        SIP_URI_ISHEX((scan)[1]) && SIP_URI_ISHEX((scan[2])))

/*
 * URL character classes
 *  mark        - _ . ! ~ * ' ()
 *  reserved    ; / ? : @ & = + $ ,    also [] for IPv6
 *  unreserved  alphanum mark
 *  pchar       : @ & = + $ , unreserved
 *  userinfo    ; : & = + $ , unreserved escaped
 *  relsegment  ; @ & = + $ , unreserved escaped
 *  reg_name    ; : @ & = + $ , unreserved escaped
 *  token       - _ . ! ~ * ' %  + `
 *  param-unreserved  [ ] / : + $ &
 *  hnv-unreserved    [ ] / : + $ ?
 */
#define SIP_URI_ALPHA_BIT               0x0001
#define SIP_URI_DIGIT_BIT               0x0002
#define SIP_URI_ALNUM_BITS              0x0003
#define SIP_URI_SCHEME_BIT              0x0004  /* for - + . */
#define SIP_URI_TOKEN_BIT               0x0008  /* for - _ . ! ~ * ' % + ` */
#define SIP_URI_QUEST_BIT               0x0010  /* for ? */
#define SIP_URI_AT_BIT                  0x0020  /* for @ */
#define SIP_URI_COLON_BIT               0x0040  /* for : */
#define SIP_URI_SEMI_BIT                0x0080  /* for ; */
#define SIP_URI_DASH_BIT                0x0100  /* for - */
#define SIP_URI_MARK_BIT                0x0200  /* for - _ . ! ~ * ' ( ) */
#define SIP_URI_AND_BIT                 0x0400  /* for & */
#define SIP_URI_PHCOMM_BIT              0x0800  /* for [ ] / : + $ */
#define SIP_URI_OTHER_BIT               0x1000  /* for = + $ , */
#define SIP_URI_SLASH_BIT               0x2000  /* for / */
#define SIP_URI_VISUALSEP_BIT           0x4000  /* for -.() */
#define SIP_URI_DTMFURI_DIGIT_BIT       0x8000  /* for *ABCD */

#define a                       SIP_URI_ALPHA_BIT
#define d                       SIP_URI_DIGIT_BIT
#define s                       SIP_URI_SCHEME_BIT
#define t                       SIP_URI_TOKEN_BIT
#define q                       SIP_URI_QUEST_BIT
#define m                       SIP_URI_AT_BIT
#define c                       SIP_URI_COLON_BIT
#define i                       SIP_URI_SEMI_BIT
#define h                       SIP_URI_DASH_BIT
#define k                       SIP_URI_MARK_BIT
#define n                       SIP_URI_AND_BIT
#define o                       SIP_URI_PHCOMM_BIT
#define r                       SIP_URI_OTHER_BIT
#define l                       SIP_URI_SLASH_BIT
#define v                       SIP_URI_VISUALSEP_BIT
#define f                       SIP_URI_DTMFURI_DIGIT_BIT

static const unsigned short sip_uri_table[256] = {
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      t|k,    0,      0,      o|r,    t,      n,      t|k,
        k|v,    k|v,    t|k|f, s|t|r|o, r,  h|s|t|k|v, s|t|k|v, o|l,
        d,      d,      d,      d,      d,      d,      d,      d,
        d,      d,      c|o,    i,      0,      r,      0,      q,
        m,      a|f,    a|f,    a|f,    a|f,    a,      a,      a,
        a,      a,      a,      a,      a,      a,      a,      a,
        a,      a,      a,      a,      a,      a,      a,      a,
        a,      a,      a,      o,      0,      o,      0,      t|k,
        t,      a,      a,      a,      a,      a,      a,      a,
        a,      a,      a,      a,      a,      a,      a,      a,
        a,      a,      a,      a,      a,      a,      a,      a,
        a,      a,      a,      0,      0,      0,      t|k,    0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
        0,      0,      0,      0,      0,      0,      0,      0,
};

#undef  a
#undef  d
#undef  s
#undef  t
#undef  q
#undef  m
#undef  c
#undef  i
#undef  h
#undef  k
#undef  n
#undef  o
#undef  r
#undef  l
#undef  v
#undef  f

#define SIP_URI_UT(c)                   sip_uri_table[(unsigned char)(c)]
#define SIP_URI_ISALPHA(c)              (SIP_URI_UT(c) & SIP_URI_ALPHA_BIT)
#define SIP_URI_ISDIGIT(c)              (SIP_URI_UT(c) & SIP_URI_DIGIT_BIT)
#define SIP_URI_ISALNUM(c)              (SIP_URI_UT(c) & SIP_URI_ALNUM_BITS)
#define SIP_URI_ISSCHEME(c)             \
                (SIP_URI_UT(c) & (SIP_URI_ALNUM_BITS|SIP_URI_SCHEME_BIT))
#define SIP_URI_ISTOKEN(c)              \
                (SIP_URI_UT(c) & (SIP_URI_ALNUM_BITS|SIP_URI_TOKEN_BIT))
#define SIP_URI_ISSIPDELIM(c)           \
                (SIP_URI_UT(c) & (SIP_URI_SEMI_BIT|SIP_URI_QUEST_BIT))
#define SIP_URI_ISSIPHDELIM(c)                                  \
        (SIP_URI_UT(c) & (SIP_URI_COLON_BIT|SIP_URI_SEMI_BIT|SIP_URI_QUEST_BIT))
#define SIP_URI_ISHOST(c)               \
                (SIP_URI_UT(c) & (SIP_URI_ALNUM_BITS|SIP_URI_DASH_BIT))
#define SIP_URI_ISUSER(c)                                               \
        (SIP_URI_UT(c) & (SIP_URI_OTHER_BIT|SIP_URI_SEMI_BIT|           \
        SIP_URI_QUEST_BIT|SIP_URI_SLASH_BIT|SIP_URI_AND_BIT))

#define SIP_URI_ISABSHDELIM(c)                                  \
        (SIP_URI_UT(c) & \
        (SIP_URI_SLASH_BIT|SIP_URI_COLON_BIT|SIP_URI_QUEST_BIT))
#define SIP_URI_ISABSDELIM(c)   \
        (SIP_URI_UT(c) & (SIP_URI_SLASH_BIT|SIP_URI_QUEST_BIT))
#define SIP_URI_ISUNRESERVED(c) \
        (SIP_URI_UT(c) & (SIP_URI_ALNUM_BITS|SIP_URI_MARK_BIT))
#define SIP_URI_ISPARAM(c)                                              \
        (SIP_URI_UT(c) & (SIP_URI_PHCOMM_BIT|SIP_URI_AND_BIT|\
        SIP_URI_ALNUM_BITS|SIP_URI_MARK_BIT))
#define SIP_URI_ISHEADER(c)                                             \
        (SIP_URI_UT(c) & (SIP_URI_PHCOMM_BIT|SIP_URI_QUEST_BIT|\
        SIP_URI_ALNUM_BITS|SIP_URI_MARK_BIT))
#define SIP_URI_ISOTHER(c)              (SIP_URI_UT(c) & SIP_URI_OTHER_BIT)
#define SIP_URI_ISRESERVED(c)                                   \
        (SIP_URI_UT(c) & (SIP_URI_SEMI_BIT|SIP_URI_SLASH_BIT|   \
        SIP_URI_QUEST_BIT| SIP_URI_COLON_BIT|SIP_URI_AT_BIT|    \
        SIP_URI_AND_BIT|SIP_URI_OTHER_BIT))
#define SIP_URI_ISPCHAR(c)      \
        (SIP_URI_UT(c) & (SIP_URI_COLON_BIT|SIP_URI_AT_BIT|     \
        SIP_URI_AND_BIT|SIP_URI_OTHER_BIT))
#define SIP_URI_ISREGNAME(c)                                    \
        (SIP_URI_UT(c) &        \
        (SIP_URI_OTHER_BIT|SIP_URI_SEMI_BIT|SIP_URI_COLON_BIT|  \
        SIP_URI_AT_BIT|SIP_URI_AND_BIT))
#define SIP_URI_ISPHONEDIGIT(c) \
        (SIP_URI_UT(c) & (SIP_URI_DIGIT_BIT|SIP_URI_VISUALSEP_BIT))
#define SIP_URI_ISDTMFDIGIT(c)  (SIP_URI_UT(c) & SIP_URI_DTMFURI_DIGIT_BIT)

static int  sip_uri_url_casecmp(const char *, const char *, unsigned);
static void sip_uri_parse_params(_sip_uri_t *, char *, char *);
static void sip_uri_parse_headers(_sip_uri_t *, char *, char *);
static void sip_uri_parse_abs_opaque(_sip_uri_t *, char *, char *);
static void sip_uri_parse_abs_query(_sip_uri_t *, char *, char *);
static void sip_uri_parse_abs_path(_sip_uri_t *, char *, char *);
static void sip_uri_parse_abs_regname(_sip_uri_t *, char *, char *);
static int  sip_uri_parse_scheme(_sip_uri_t *, char *, char *);
static void sip_uri_parse_password(_sip_uri_t *, char *, char *);
static void sip_uri_parse_user(_sip_uri_t *, char *, char *);
static void sip_uri_parse_port(_sip_uri_t *, char *, char *);
static void sip_uri_parse_netpath(_sip_uri_t *, char **, char *, boolean_t);
static int  sip_uri_parse_ipv6(char *, char *);
static int  sip_uri_parse_ipv4(char *, char *);
static int  sip_uri_parse_hostname(char *, char *);
static int sip_uri_parse_tel(char *, char *);
static int sip_uri_parse_tel_areaspe(char *, char *);
static int sip_uri_parse_tel_servicepro(char *, char *);
static int sip_uri_parse_tel_futureext(char *, char *);
static int sip_uri_isTokenchar(char **, char *);
static int sip_uri_isEscapedPound(char **, char *);
static int sip_uri_hexVal(char *, char *);
static int SIP_URI_HEXVAL(int);

/*
 * get the hex value of a char
 */
static int
SIP_URI_HEXVAL(int c)
{
        if (c >= 0x30 && c <= 0x39)
                return (c - '0');
        if (c >= 0x41 && c <= 0x46)
                return (c - 'A' + 10);
        if (c >= 0x61 && c <= 0x66)
                return (c - 'a' + 10);
        return (c);
}

/*
 * basic ASCII case-insensitive comparison
 */
static int
sip_uri_url_casecmp(const char *str1, const char *str2, unsigned len)
{
        unsigned        j;

        for (j = 0; j < len && tolower(str1[j]) == tolower(str2[j]) &&
            str1[j] != '\0'; ++j) {
                ;
        }
        return (j == len ? 0 : tolower(str2[j]) - tolower(str1[j]));
}

/*
 * telephone-subscriber  = global-phone-number / local-phone-number
 * Please refer to RFC 2806
 */
static int
sip_uri_parse_tel(char *scan, char *uend)
{
        char    *mark = (char *)0;
        int     ret = 0;
        int     isGlobal = 0;
        int     quote = 0;

        if (scan == uend)
                return (0);
        if (*scan == '+') {
                ++scan;
                isGlobal = 1;
        }
        mark = scan;
        if (isGlobal) {
                while (scan < uend && SIP_URI_ISPHONEDIGIT(*scan))
                        ++scan;
        } else {
                while (scan < uend &&
                    (SIP_URI_ISPHONEDIGIT(*scan) ||
                    SIP_URI_ISDTMFDIGIT(*scan) ||
                    sip_uri_isEscapedPound(&scan, uend) ||
                    *scan == 'p' || *scan == 'w')) {
                        ++scan;
                }
        }
        if (mark == scan || (scan < uend && *scan != ';'))
                return (0);

        /*
         * parse isdn-subaddress
         */
        if (uend - scan > 6 && !sip_uri_url_casecmp(scan, ";isub=", 6)) {
                scan += 6;
                mark = scan;
                while (scan < uend && SIP_URI_ISPHONEDIGIT(*scan))
                        ++scan;
                if (mark == scan || (scan < uend && *scan != ';'))
                        return (0);
        }

        /*
         * parse post-dial
         */
        if (uend - scan > 7 && !sip_uri_url_casecmp(scan, ";postd=", 7)) {
                scan += 7;
                mark = scan;
                while (scan < uend &&
                    (SIP_URI_ISPHONEDIGIT(*scan) ||
                    SIP_URI_ISDTMFDIGIT(*scan) ||
                    sip_uri_isEscapedPound(&scan, uend) ||
                    *scan == 'p' || *scan == 'w')) {
                        ++scan;
                }
                if (mark == scan || (scan < uend && *scan != ';'))
                        return (0);
        }

        if (!isGlobal) {
                /*
                 * parse area-specifier
                 */
                if (uend - scan > 15 &&
                    !sip_uri_url_casecmp(scan, ";phone-context=", 15)) {
                        scan += 15;
                        mark = scan;
                        while (scan < uend && *scan != ';')
                                ++scan;
                        ret = sip_uri_parse_tel_areaspe(mark, scan);
                }
        } else {
                ret = 1;
        }

        /*
         * parse area-specifier, service-provider, future-extension
         */
        while (scan < uend && ret) {
                if (uend - scan > 15 &&
                        !sip_uri_url_casecmp(scan, ";phone-context=", 15)) {
                        scan += 15;
                        mark = scan;
                        while (scan < uend && *scan != ';')
                                ++scan;
                        ret = sip_uri_parse_tel_areaspe(mark, scan);
                } else if (uend - scan > 5 &&
                    !sip_uri_url_casecmp(scan, ";tsp=", 5)) {
                        scan += 5;
                        mark = scan;
                        while (scan < uend && *scan != ';')
                                ++scan;
                        ret = sip_uri_parse_tel_servicepro(mark, scan);
                } else {
                        ++scan;
                        mark = scan;
                        while (scan < uend && (*scan != ';' || quote)) {
                                if (sip_uri_hexVal(scan, uend) == 0x22) {
                                        quote = !quote;
                                        scan += 3;
                                } else {
                                        ++scan;
                                }
                        }
                        ret = sip_uri_parse_tel_futureext(mark, scan);
                }
        }
        return (ret && scan == uend);
}

/*
 * area-specifier        = ";" phone-context-tag "=" phone-context-ident
 * phone-context-tag     = "phone-context"
 * phone-context-ident   = network-prefix / private-prefix
 * network-prefix        = global-network-prefix / local-network-prefix
 * global-network-prefix = "+" 1*phonedigit
 * local-network-prefix  = 1*(phonedigit / dtmf-digit / pause-character)
 * private-prefix        = (%x21-22 / %x24-27 / %x2C / %x2F / %x3A /
 *                          %x3C-40 / %x45-4F / %x51-56 / %x58-60 /
 *                          %x65-6F / %x71-76 / %x78-7E)
 *                          *(%x21-3A / %x3C-7E)
 * phonedigit            = DIGIT / visual-separator
 * visual-separator      = "-" / "." / "(" / ")"
 * pause-character       = one-second-pause / wait-for-dial-tone
 * one-second-pause      = "p"
 * wait-for-dial-tone    = "w"
 * dtmf-digit            = "*" / "#" / "A" / "B" / "C" / "D"
 */
static int
sip_uri_parse_tel_areaspe(char *scan, char *uend)
{
        int     uri_hexValue;

        if (scan == uend)
                return (0);

        /*
         * parse global-network-prefix
         */
        if (*scan == '+') {
                ++scan;
                if (scan == uend)
                        return (0);
                while (scan < uend && SIP_URI_ISPHONEDIGIT(*scan))
                        ++scan;
        /*
         * parse local-network-prefix
         */
        } else if (SIP_URI_ISPHONEDIGIT(*scan) || SIP_URI_ISDTMFDIGIT(*scan) ||
            sip_uri_isEscapedPound(&scan, uend) ||
            *scan == 'p' || *scan == 'w') {
                ++scan;
                while (scan < uend &&
                    (SIP_URI_ISPHONEDIGIT(*scan) ||
                    SIP_URI_ISDTMFDIGIT(*scan) ||
                    sip_uri_isEscapedPound(&scan, uend) ||
                    *scan == 'p' || *scan == 'w')) {
                        ++scan;
                }
        } else {
        /*
         * parse private-prefix
         *
         * any characters allowed in RFC 2806 that are not allowed in
         * the user part of the SIP URI MUST be escaped
         *
         * private-prefix       = (! $ & ', / = ? _
         *                      EFGHIJKLMNOQRSTUVXYZ efghijklmnoqrstuvxyz
         *                      { } | ~ [ ] \ ^  ` " % : < > @)
         *                      *(%x21-3A / %x3C-7E)
         *
         * following characters are allowed in RFC 2806 and
         * the user part of SIP URI
         *  ! $ & ', / = ? _ EFGHIJKLMNOQRSTUVXYZ efghijklmnoqrstuvxyz
         */
                if (*scan == '!' || *scan == '$' || *scan == '&' ||
                    *scan == '\'' || *scan == ',' || *scan == '/' ||
                    *scan == '=' || *scan == '?' || *scan == '_' ||
                    (*scan >= 'E' && *scan <= 'Z' &&
                    *scan != 'P' && *scan != 'W') ||
                    (*scan >= 'e' && *scan <= 'z' &&
                    *scan != 'p' && *scan != 'w')) {
                        ++scan;
                } else {
                        uri_hexValue = sip_uri_hexVal(scan, uend);
                        if (uri_hexValue == 0x21 || uri_hexValue == 0x22 ||
                            (uri_hexValue >= 0x24 && uri_hexValue <= 0x27) ||
                            uri_hexValue == 0x2c || uri_hexValue == 0x2f ||
                            uri_hexValue == 0x3a ||
                            (uri_hexValue >= 0x3c && uri_hexValue <= 0x40) ||
                            (uri_hexValue >= 0x45 && uri_hexValue <= 0x4f) ||
                            (uri_hexValue >= 0x51 && uri_hexValue <= 0x56) ||
                            (uri_hexValue >= 0x58 && uri_hexValue <= 0x60) ||
                            (uri_hexValue >= 0x65 && uri_hexValue <= 0x6f) ||
                            (uri_hexValue >= 0x71 && uri_hexValue <= 0x76) ||
                            (uri_hexValue >= 0x78 && uri_hexValue <= 0x7e)) {
                                scan += 3;
                        } else {
                                return (0);
                        }
                }
                /*
                 * parse *(%x21-3A / %x3C-7E)
                 */
                while (scan < uend) {
                        if (SIP_URI_ISUNRESERVED(*scan) ||
                            (SIP_URI_ISUSER(*scan) && *scan != ';')) {
                                ++scan;
                        } else {
                                uri_hexValue = sip_uri_hexVal(scan, uend);
                                if (uri_hexValue >= 0x21 &&
                                    uri_hexValue <= 0x7e &&
                                    uri_hexValue != 0x3b) {
                                        scan += 3;
                                } else {
                                        return (0);
                                }
                        }
                }
        }
        if (scan < uend)
                return (0);
        return (1);
}

static int
sip_uri_hexVal(char *scan, char *uend)
{
        int     ret = -1;

        if (SIP_URI_ISURLESCAPE(scan, uend)) {
                ret = (SIP_URI_ISDIGIT(scan[1]) ? (scan[1] - '0') :
                    (tolower(scan[1]) - 'a' + 10)) * 16 +
                    (SIP_URI_ISDIGIT(scan[2]) ? (scan[2] - '0') :
                    (tolower(scan[2]) - 'a' + 10));
        }
        return (ret);
}

/*
 * service-provider  = ";" provider-tag "=" provider-hostname
 * provider-tag      = "tsp"
 * provider-hostname = domain
 */
static int
sip_uri_parse_tel_servicepro(char *scan, char *uend)
{
        char    *mark = (char *)0;

        if (scan == uend)
                return (0);

        /*
         * parse domain=" "
         */
        if (sip_uri_hexVal(scan, uend) == 0x20 && scan + 3 == uend)
                return (1);
        while (scan < uend) {
                mark = scan;
                while (scan < uend && (*scan == '-'|| SIP_URI_ISALNUM(*scan)))
                        ++scan;
                if ((scan < uend && *scan != '.') ||
                    !SIP_URI_ISALPHA(*mark) || !SIP_URI_ISALNUM(*(scan - 1))) {
                        return (0);
                }
                if (scan < uend)
                        ++scan;
        }

        if (scan < uend)
                return (0);
        return (1);
}

/*
 * future-extension = ";" 1*(token-char) ["=" ((1*(token-char)
 *                    ["?" 1*(token-char)]) / quoted-string )]
 * token-char       = (%x21 / %x23-27 / %x2A-2B / %x2D-2E / %x30-39
 *                     / %x41-5A / %x5E-7A / %x7C / %x7E)
 */
static int
sip_uri_parse_tel_futureext(char *scan, char *uend)
{
        char    *mark;
        int     uri_hexValue = 0;

        if (scan == uend)
                return (0);

        /*
         * parse 1*(token-char)
         */
        mark = scan;
        while (scan < uend && sip_uri_isTokenchar(&scan, uend))
                ;
        if (mark == scan ||
            (scan < uend && (*scan != '=' || scan + 1 == uend))) {
                return (0);
        }
        if (scan == uend)
                return (1);
        ++scan;

        /*
         * parse 1*token-char ["?" 1*token-char]
         */
        if (sip_uri_isTokenchar(&scan, uend)) {
                while (sip_uri_isTokenchar(&scan, uend))
                        ;
                if (scan < uend) {
                        if (*scan != '?')
                                return (0);
                        ++scan;
                        mark = scan;
                        while (sip_uri_isTokenchar(&scan, uend))
                                ;
                        if (mark == scan)
                                return (0);
                }
        } else { /* parse quoted-string */
                uri_hexValue = sip_uri_hexVal(scan, uend);
                if (uri_hexValue != 0x22)
                        return (0);
                scan += 3;
                while (scan < uend && sip_uri_hexVal(scan, uend) != 0x22) {
                        /*
                         * parse "\" CHAR
                         */
                        if (sip_uri_hexVal(scan, uend) == 0x5c) {
                                scan += 3;
                                if (scan < uend) {
                                        if (SIP_URI_ISUNRESERVED(*scan) ||
                                            SIP_URI_ISUSER(*scan)) {
                                                ++scan;
                                        } else if (sip_uri_hexVal(scan, uend) >=
                                            0x00 &&
                                            sip_uri_hexVal(scan, uend) <=
                                            0x7f) {
                                                scan += 3;
                                        } else {
                                                return (0);
                                        }
                                } else {
                                        return (0);
                                }
                        } else {
                                if (SIP_URI_ISUNRESERVED(*scan) ||
                                    SIP_URI_ISUSER(*scan)) {
                                        ++scan;
                                } else {
                                        uri_hexValue =
                                            sip_uri_hexVal(scan, uend);
                                        if ((uri_hexValue >= 0x20 &&
                                                uri_hexValue <= 0x21) ||
                                                (uri_hexValue >= 0x23 &&
                                                uri_hexValue <= 0x7e) ||
                                                (uri_hexValue >= 0x80 &&
                                                uri_hexValue <= 0xff)) {
                                                scan += 3;
                                        } else {
                                                return (0);
                                        }
                                }
                        }
                }
                if (scan == uend ||
                    (scan < uend && sip_uri_hexVal(scan, uend) != 0x22)) {
                        return (0);
                }
                scan += 3;
        }

        if (scan < uend)
                return (0);
        return (1);
}

/*
 * Any characters allowed in RFC2806 tel URL that are not allowed in
 * the user part of the SIP URI MUST be escaped.
 * token-char = - _ . ! ~ * ' $ &  + DIGIT ALPHA #  % ^ ` |
 */
static int
sip_uri_isTokenchar(char **pscan, char *uend)
{
        char    *scan = *pscan;
        int     uri_hexValue = 0;

        if (scan == uend)
                return (0);

        /*
         * for ALPAH DIGIT - _ . ! ~ * ' $ & +
         */
        if ((SIP_URI_ISUNRESERVED(*scan) && *scan != '(' && *scan != ')') ||
            *scan == '$' || *scan == '&' || *scan == '+') {
                ++scan;
                *pscan = scan;
                return (1);
        }

        uri_hexValue = sip_uri_hexVal(scan, uend);
        if (uri_hexValue == 0x21 || uri_hexValue == 0x7c ||
            uri_hexValue == 0x7e ||
            (uri_hexValue >= 0x23 && uri_hexValue <= 0x27) ||
            (uri_hexValue >= 0x2a && uri_hexValue <= 0x2b) ||
            (uri_hexValue >= 0x2d && uri_hexValue <= 0x2e) ||
            (uri_hexValue >= 0x30 && uri_hexValue <= 0x39) ||
            (uri_hexValue >= 0x41 && uri_hexValue <= 0x5a) ||
            (uri_hexValue >= 0x5e && uri_hexValue <= 0x7a)) {
                scan += 3;
                *pscan = scan;
                return (1);
        }
        return (0);
}

/*
 * '#' is not allowed in the telephone-subscriber part of SIP URI
 * it must be escaped
 */
static int
sip_uri_isEscapedPound(char **pscan, char *uend)
{
        char    *scan = *pscan;

        if (scan == uend)
                return (0);
        if (*scan == '%' && scan + 2 < uend && scan[1] == '2' &&
            scan[2] == '3') {
                scan += 2;
                *pscan = scan;
                return (1);
        }
        return (0);
}

/*
 * scheme =  ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
 */
static int
sip_uri_parse_scheme(_sip_uri_t *outurl, char *scan, char *uend)
{
        if (scan == uend) {
                outurl->sip_uri_errflags |= SIP_URIERR_SCHEME;
                return (0);
        }
        outurl->sip_uri_scheme.sip_str_ptr = scan;
        outurl->sip_uri_scheme.sip_str_len = uend - scan;

        if (scan < uend && SIP_URI_ISALPHA(*scan)) {
                ++scan;
                while (scan < uend && SIP_URI_ISSCHEME(*scan))
                        ++scan;
        }
        if (scan < uend)
                outurl->sip_uri_errflags |= SIP_URIERR_SCHEME;
        return (1);
}

/*
 * The format of params is supposed to be;XXX;XXX;XXX
 * uri-parameters       = *(";" uri-parameter)
 * uri-parameter        = transport-param / user-param / method-param
 *                      / ttl-param / maddr-param / lr-param / other-param
 * transport-param      =  "transport="
 *                      ("udp" / "tcp" / "sctp" / "tls" / other-transport)
 * other-transport              =  token
 * user-param           =  "user=" ("phone" / "ip" / other-user)
 * other-user           =  token
 * method-param         =  "method=" Method
 * ttl-param            =  "ttl=" ttl
 * maddr-param          =  "maddr=" host
 * lr-param             =  "lr"
 * other-param          =  pname [ "=" pvalue ]
 * pname                =  1*paramchar
 * pvalue               =  1*paramchar
 * paramchar            =  param-unreserved / unreserved / escaped
 * param-unreserved     =  "[" / "]" / "/" / ":" / "&" / "+" / "$"
 */
static void
sip_uri_parse_params(_sip_uri_t *outurl, char *scan, char *uend)
{
        char            *mark = (char *)0;
        char            *equal = (char *)0;
        int             i = 0;
        int             ttl = 0;
        int             paramleftlen = 0;
        int             gothost = 0;
        sip_param_t     *param = NULL;
        sip_param_t     *new_param = NULL;

        if (scan == uend || *scan != ';' || scan + 1 == uend) {
                outurl->sip_uri_errflags |= SIP_URIERR_PARAM;
                return;
        }

        while (scan < uend) {
                mark = ++scan;
                while (scan < uend && *scan != ';')
                        ++scan;
                if (scan == mark) {
                        outurl->sip_uri_errflags |= SIP_URIERR_PARAM;
                        return;
                }

                new_param = calloc(1, sizeof (sip_param_t));
                if (new_param == NULL) {
                        outurl->sip_uri_errflags |= SIP_URIERR_MEMORY;
                        return;
                }

                if (param == NULL)
                        outurl->sip_uri_params = new_param;
                else
                        param->param_next = new_param;

                param = new_param;

                param->param_name.sip_str_ptr = mark;
                equal = memchr(mark, '=', scan - mark);
                if (equal == (char *)0) {
                        param->param_name.sip_str_len = scan - mark;
                        param->param_value.sip_str_ptr = NULL;
                        param->param_value.sip_str_len = 0;
                        while (mark < scan && (SIP_URI_ISPARAM(*mark) ||
                            SIP_URI_ISURLESCAPE(mark, scan))) {
                                ++mark;
                        }
                } else {
                        param->param_name.sip_str_len = equal - mark;
                        param->param_value.sip_str_ptr = equal + 1;
                        param->param_value.sip_str_len = scan - equal - 1;

                        if (mark == equal || equal + 1 == scan) {
                                outurl->sip_uri_errflags |= SIP_URIERR_PARAM;
                                return;
                        }
                        paramleftlen = equal - mark + 1;
                        if ((paramleftlen == 10 &&
                            !sip_uri_url_casecmp(mark, "transport=", 10)) ||
                            (paramleftlen == 5 &&
                            !sip_uri_url_casecmp(mark, "user=", 5)) ||
                            (paramleftlen == 7 &&
                            !sip_uri_url_casecmp(mark, "method=", 7))) {
                                if (scan - equal == 1) {
                                        outurl->sip_uri_errflags |=
                                            SIP_URIERR_PARAM;
                                        return;
                                }
                                mark = equal + 1;
                                while (mark < scan && SIP_URI_ISTOKEN(*mark))
                                        ++mark;
                        } else if (paramleftlen == 4 &&
                            !sip_uri_url_casecmp(mark, "ttl=", 4)) {
                                if (scan - equal == 1) {
                                        outurl->sip_uri_errflags |=
                                            SIP_URIERR_PARAM;
                                        return;
                                }
                                mark = equal;
                                for (i = 0; i < 3; ++i) {
                                        ++mark;
                                        if (mark < scan &&
                                            SIP_URI_ISDIGIT(*mark)) {
                                                ttl = ttl * 10 + (*mark - '0');
                                        }
                                        if (ttl > 255) {
                                                outurl->sip_uri_errflags |=
                                                        SIP_URIERR_PARAM;
                                                return;
                                        }
                                }
                        } else if (paramleftlen == 6 &&
                            !sip_uri_url_casecmp(mark, "maddr=", 6)) {
                                gothost = 0;
                                mark = equal + 1;
                                if (mark < scan && SIP_URI_ISDIGIT(*mark)) {
                                        gothost = sip_uri_parse_ipv4(mark,
                                            scan);
                                }
                                /*
                                 * not valid syntax for a host or user name,
                                 * try IPv6 literal
                                 */
                                if (!gothost && mark < scan && *mark == '[') {
                                        gothost = sip_uri_parse_ipv6(mark,
                                            scan);
                                }
                                /*
                                 * look for a valid host name:
                                 * *(domainlabel ".") toplabel ["."]
                                 */
                                if (!gothost && mark < scan) {
                                        if (!(gothost =
                                            sip_uri_parse_hostname(mark,
                                            scan))) {
                                                outurl->sip_uri_errflags |=
                                                        SIP_URIERR_PARAM;
                                        }
                                }
                                if (gothost)
                                        mark = scan;
                        } else if (paramleftlen == 3 &&
                            !sip_uri_url_casecmp(mark, "lr=", 3)) {
                                outurl->sip_uri_errflags |= SIP_URIERR_PARAM;
                                return;
                        } else {
                                while (mark < scan && (SIP_URI_ISPARAM(*mark) ||
                                    SIP_URI_ISURLESCAPE(mark, scan) ||
                                    mark == equal)) {
                                        ++mark;
                                }
                        }
                }
                if (mark < scan) {
                        outurl->sip_uri_errflags |= SIP_URIERR_PARAM;
                        return;
                }
        }
}

/*
 * The format of headers is supposed to be ?XXX&XXX&XXX
 * headers         =  "?" header *("&" header
 * header          =  hname "=" hvalue
 * hname           =  1*(hnv-unreserved / unreserved / escaped
 * hvalue          =  *(hnv-unreserved / unreserved / escaped
 * hnv-unreserved  =  "[" / "]" / "/" / "?" / ":" / "+" / "$"
 */
static void
sip_uri_parse_headers(_sip_uri_t *outurl, char *scan, char *uend)
{
        char    *mark = NULL;
        char    *equal = NULL;

        if (scan == uend || *scan != '?' || scan + 1 == uend) {
                outurl->sip_uri_errflags |= SIP_URIERR_HEADER;
                return;
        }
        outurl->sip_uri_headers.sip_str_ptr = scan + 1;
        outurl->sip_uri_headers.sip_str_len = uend - (scan + 1);

        while (scan < uend) {
                mark = ++scan;
                while (scan < uend && *scan != '&')
                        ++scan;
                if (scan == mark) {
                        outurl->sip_uri_errflags |= SIP_URIERR_HEADER;
                        return;
                }
                equal = memchr(mark, '=', scan - mark);
                if (equal == mark || equal == (char *)0) {
                        outurl->sip_uri_errflags |= SIP_URIERR_HEADER;
                        return;
                }
                while (mark < scan &&
                    (SIP_URI_ISHEADER(*mark) ||
                    SIP_URI_ISURLESCAPE(mark, scan) || mark == equal)) {
                        ++mark;
                }
                if (mark < scan) {
                        outurl->sip_uri_errflags |= SIP_URIERR_HEADER;
                        return;
                }
        }
}

/*
 * opaque-part   =  uric-no-slash *uric
 * uric          =  reserved / unreserved / escaped
 * uric-no-slash =  unreserved / escaped / ";" / "?" / ":" / "@"
 *                  / "&" / "=" / "+" / "$" / ","
 */
static void
sip_uri_parse_abs_opaque(_sip_uri_t *outurl, char *scan, char *uend)
{
        if (scan == uend) {
                outurl->sip_uri_errflags |= SIP_URIERR_OPAQUE;
                return;
        }
        outurl->sip_uri_opaque.sip_str_ptr = scan;
        outurl->sip_uri_opaque.sip_str_len = uend - scan;

        if (SIP_URI_ISUNRESERVED(*scan) || SIP_URI_ISURLESCAPE(scan, uend) ||
            SIP_URI_ISOTHER(*scan) || *scan == ';' || *scan == '?' ||
            *scan == ':' || *scan == '@' || *scan == '&') {
                ++scan;
        } else {
                outurl->sip_uri_errflags |= SIP_URIERR_OPAQUE;
                return;
        }
        while (scan < uend && (SIP_URI_ISRESERVED(*scan) ||
            SIP_URI_ISUNRESERVED(*scan) || SIP_URI_ISURLESCAPE(scan, uend))) {
                ++scan;
        }
        if (scan < uend)
                outurl->sip_uri_errflags |= SIP_URIERR_OPAQUE;
}

/*
 * format of query is supposed to be ?XXX
 * query =  *uric
 * uric  =  reserved / unreserved / escaped
 */
static void
sip_uri_parse_abs_query(_sip_uri_t *outurl, char *scan, char *uend)
{
        if (uend == scan || *scan != '?' || scan + 1 == uend)
                return;
        ++scan;
        outurl->sip_uri_query.sip_str_ptr = scan;
        outurl->sip_uri_query.sip_str_len = uend - scan;

        while (scan < uend && (SIP_URI_ISRESERVED(*scan) ||
            SIP_URI_ISUNRESERVED(*scan) || SIP_URI_ISURLESCAPE(scan, uend))) {
                ++scan;
        }
        if (scan < uend)
                outurl->sip_uri_errflags |= SIP_URIERR_QUERY;
}

/*
 * the format of path is supposed to be /XXX;XXX/XXX;
 * abs-path       =  "/" path-segments
 * path-segments  =  segment *( "/" segment )
 * segment        =  *pchar *( ";" param )
 * param          =  *pchar
 * pchar          =  unreserved / escaped /
 *                   ":" / "@" / "&" / "=" / "+" / "$" / ","
 */
static void
sip_uri_parse_abs_path(_sip_uri_t *outurl, char *scan, char *uend)
{
        if (scan == uend || *scan != '/')
                return;
        outurl->sip_uri_path.sip_str_ptr = scan;
        outurl->sip_uri_path.sip_str_len = uend - scan;

        ++scan;
        while (scan < uend && (SIP_URI_ISPCHAR(*scan) ||
            SIP_URI_ISUNRESERVED(*scan) || SIP_URI_ISURLESCAPE(scan, uend) ||
            *scan == '/' || *scan == ';')) {
                ++scan;
        }
        if (scan < uend)
                outurl->sip_uri_errflags |= SIP_URIERR_PATH;
}
/*
 * reg-name =  1*( unreserved / escaped / "$" / "," / ";"
 *             / ":" / "@" / "&" / "=" / "+" )
 */
static void
sip_uri_parse_abs_regname(_sip_uri_t *outurl, char *scan, char *uend)
{
        if (scan == uend)
                return;
        outurl->sip_uri_regname.sip_str_ptr = scan;
        outurl->sip_uri_regname.sip_str_len = uend - scan;

        while (scan < uend && (SIP_URI_ISUNRESERVED(*scan) ||
            SIP_URI_ISURLESCAPE(scan, uend) || SIP_URI_ISREGNAME(*scan))) {
                ++scan;
        }
        if (scan < uend)
                outurl->sip_uri_errflags |= SIP_URIERR_REGNAME;
}

/*
 * The format of the password is supposed to be :XXX
 * password =  *( unreserved / escaped / "&" / "=" / "+" / "$" / "," )
 */
static void
sip_uri_parse_password(_sip_uri_t *outurl, char *scan, char *uend)
{
        if (scan == uend || *scan != ':' || scan + 1 == uend)
                return;
        ++scan;
        outurl->sip_uri_password.sip_str_ptr = scan;
        outurl->sip_uri_password.sip_str_len = uend - scan;

        while (scan < uend && (SIP_URI_ISUNRESERVED(*scan) ||
            SIP_URI_ISURLESCAPE(scan, uend) || SIP_URI_ISOTHER(*scan) ||
            *scan == '&')) {
                ++scan;
        }
        if (scan < uend)
                outurl->sip_uri_errflags |= SIP_URIERR_PASS;
}

/*
 * user =  1*( unreserved / escaped / user-unreserved )
 * user-unreserved  =  "&" / "=" / "+" / "$" / "," / ";" / "?" / "/"
 */
static void
sip_uri_parse_user(_sip_uri_t *outurl, char *scan, char *uend)
{
        if (scan == uend) {
                outurl->sip_uri_errflags |= SIP_URIERR_USER;
                return;
        }
        outurl->sip_uri_user.sip_str_ptr = scan;
        outurl->sip_uri_user.sip_str_len = uend - scan;

        if (sip_uri_parse_tel(scan, uend)) {
                outurl->sip_uri_isteluser = B_TRUE;
        } else {
                while (scan < uend && (SIP_URI_ISUNRESERVED(*scan) ||
                    SIP_URI_ISURLESCAPE(scan, uend) || SIP_URI_ISUSER(*scan))) {
                        ++scan;
                }
                if (scan < uend)
                        outurl->sip_uri_errflags |= SIP_URIERR_USER;
        }
}

/*
 * the format of port is supposed to be :XXX
 * port =  1*DIGIT
 */
static void
sip_uri_parse_port(_sip_uri_t *outurl, char *scan, char *uend)
{
        if (scan == uend || *scan != ':' || scan + 1 == uend) {
                outurl->sip_uri_errflags |= SIP_URIERR_PORT;
                return;
        }
        ++scan;
        /*
         * parse numeric port number
         */
        if (SIP_URI_ISDIGIT(*scan)) {
                outurl->sip_uri_port = *scan - '0';
                while (++scan < uend && SIP_URI_ISDIGIT(*scan)) {
                    outurl->sip_uri_port =
                        outurl->sip_uri_port * 10 + (*scan - '0');
                        if (outurl->sip_uri_port > 0xffff) {
                                outurl->sip_uri_errflags |= SIP_URIERR_PORT;
                                outurl->sip_uri_port = 0;
                                break;
                        }
                }
        }
        if (scan < uend) {
                outurl->sip_uri_errflags |= SIP_URIERR_PORT;
                outurl->sip_uri_port = 0;
        }
}

/*
 * parse an IPv4 address
 *    1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT
 *  advances pscan to end of IPv4 address, or after last "." that was
 *  a valid IPv4 or domain name.
 * returns 1 if ipv4 found, 0 otherwise
 */
static int
sip_uri_parse_ipv4(char *scan, char *uend)
{
        int     j = 0;
        int     val = 0;

        for (j = 0; j < 4; ++j) {
                if (!SIP_URI_ISDIGIT(*scan))
                        break;
                val = *scan - '0';
                while (++scan < uend && SIP_URI_ISDIGIT(*scan)) {
                        val = val * 10 + (*scan - '0');
                        if (val > 255)
                                return (0);
                }
                if (j < 3) {
                        if (*scan != '.')
                                break;
                        ++scan;
                }
        }

        if (j == 4 && scan == uend)
                return (1);

        return (0);
}

/*
 * parse an IPv6 address
 *  IPv6address = hexpart [ ":" IPv4address ]
 *  IPv4address = 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT
 *  hexpart = hexseq | hexseq "::" [ hexseq ] | "::" [ hexseq ]
 *  hexseq  = hex4 *( ":" hex4)
 *  hex4    = 1*4HEXDIG
 *  if not found, leaves pscan unchanged, otherwise advances to end
 *  returns 1 if valid,
 *  0 if invalid
 */
static int
sip_uri_parse_ipv6(char *scan, char *uend)
{
        char            *mark;
        unsigned        j = 0;                  /* index for addr */
        unsigned        val = 0;                /* hex value */
        int             zpad = 0;               /* index of :: delimiter */

        if (*scan != '[')
                return (0);
        ++scan;
        j = 0;

        /*
         * check for leading "::", set zpad to the position of the "::"
         */
        if (scan + 1 < uend && scan[0] == ':' && scan[1] == ':') {
                zpad = 0;
                scan += 2;
        } else {
                zpad = -1;
        }

        /*
         * loop through up to 16 bytes of IPv6 address
         */
        while (scan < uend && j < 15) {
                if (!SIP_URI_ISHEX(*scan))
                        break;
                mark = scan;
                val = SIP_URI_HEXVAL(*scan);
                while (++scan < uend && SIP_URI_ISHEX(*scan)) {
                        val = val * 16 + SIP_URI_HEXVAL(*scan);
                        if (val > 0xffff)
                                return (0);
                }

                /*
                 * always require a delimiter or ]
                 */
                if (scan == uend)
                        return (0);

                if (*scan == '.' && (j == 12 || (zpad != -1 && j < 12)) &&
                    mark < uend && sip_uri_parse_ipv4(mark, uend - 1) &&
                    *(uend - 1) == ']') {
                        mark = uend - 1;
                        j += 4;
                        scan = mark + 1;
                        break;
                }

                /*
                 * set address
                 */
                j += 2;

                /*
                 * check for delimiter or ]
                 */
                if (*scan == ':') {
                        /*
                         * found ":" delimiter, check for "::"
                         */
                        if (++scan < uend && *scan == ':') {
                                if (zpad != -1)
                                        return (0);
                                zpad = j;
                                if (++scan < uend && *scan == ']') {
                                        ++scan;
                                        break;
                                }
                        }
                } else if (*scan == ']' && (j == 16 || zpad != -1)) {
                        ++scan;
                        break;
                } else {
                        /*
                         * not a valid delimiter
                         */
                        return (0);
                }
        }
        if (zpad == -1 && j < 16)
                return (0);
        if (zpad != -1) {
                if (j > 15)
                        return (0);
        }

        if (scan == uend)
                return (1);

        return (0);
}

/*
 * hostname         =  *( domainlabel "." ) toplabel [ "." ]
 * domainlabel      =  alphanum / alphanum *( alphanum / "-" ) alphanum
 * toplabel         =  ALPHA / ALPHA *( alphanum / "-" ) alphanum
 */
static int
sip_uri_parse_hostname(char *scan, char *uend)
{
        int     sawalpha = 0;

        if (scan < uend && SIP_URI_ISALNUM(*scan)) {
                do {
                        sawalpha = SIP_URI_ISALPHA(*scan);
                        while (SIP_URI_ISHOST(*scan))
                                ++scan;
                        if (*scan != '.')
                                break;
                        ++scan;
                } while (scan < uend && SIP_URI_ISALNUM(*scan));
        }

        if (sawalpha && scan == uend)
                return (1);
        return (0);
}


/*
 * parse the network path portion of a full URL
 */
static void
sip_uri_parse_netpath(_sip_uri_t *outurl, char **pscan, char *uend,
    boolean_t issip)
{
        char    *mark = (char *)0;
        char    *mark2 = (char *)0;
        char    *scan = *pscan;
        int     gothost = 0;

        /*
         * look for the first high-level delimiter
         */
        mark = scan;
        while (scan < uend && *scan != '@')
                ++scan;
        /*
         * handle userinfo section of URL
         */
        if (scan < uend && *scan == '@') {
                /*
                 * parse user
                 */
                mark2 = mark;
                while (mark < scan && *mark != ':')
                        ++mark;
                sip_uri_parse_user(outurl, mark2, mark);
                /*
                 * parse password
                 */
                if (*mark == ':')
                        sip_uri_parse_password(outurl, mark, scan);
                mark = ++scan;
        }

        scan = mark;
        if (scan < uend && *scan == '[') {      /* look for an IPv6 address */
                while (scan < uend && *scan != ']')
                        ++scan;
                if (scan < uend) {
                        ++scan;
                        if (sip_uri_parse_ipv6(mark, scan))
                                gothost = 1;
                }
        } else {
                while (scan < uend && ((issip && !SIP_URI_ISSIPHDELIM(*scan)) ||
                    (!issip && !SIP_URI_ISABSHDELIM(*scan)))) {
                        ++scan;
                }

                /*
                 * look for an IPv4 address
                 */
                if (mark < scan && SIP_URI_ISDIGIT(*mark) &&
                    sip_uri_parse_ipv4(mark, scan)) {
                        gothost = 1;
                }

                /*
                 * look for a valid host name
                 */
                if (!gothost && mark < scan &&
                    sip_uri_parse_hostname(mark, scan)) {
                        gothost = 1;
                }
        }
        /*
         * handle invalid host name
         */
        if (!gothost)
                outurl->sip_uri_errflags |= SIP_URIERR_HOST;
        /*
         * save host name
         */
        outurl->sip_uri_host.sip_str_ptr = mark;
        outurl->sip_uri_host.sip_str_len = scan - mark;

        mark = scan;
        /*
         * parse the port number
         */
        if (scan < uend && *scan == ':') {
                while (scan < uend && ((issip && !SIP_URI_ISSIPDELIM(*scan)) ||
                    (!issip && !SIP_URI_ISABSDELIM(*scan)))) {
                        ++scan;
                }
                sip_uri_parse_port(outurl, mark, scan);
        }

        /*
         * set return pointer
         */
        *pscan = scan;
}

/*
 * parse a URL
 * URL = SIP-URI / SIPS-URI / absoluteURI
 */
void
sip_uri_parse_it(_sip_uri_t *outurl, sip_str_t *uri_str)
{
        char            *mark;
        char            *scan;
        char            *uend;
        char            *str = uri_str->sip_str_ptr;
        unsigned        urlen = uri_str->sip_str_len;

        /*
         * reset output parameters
         */
        (void) memset(outurl, 0, sizeof (sip_uri_t));

        /*
         * strip enclosing angle brackets
         */
        if (urlen > 1 && str[0] == '<' && str[urlen-1] == '>') {
                urlen -= 2;
                ++str;
        }
        uend = str + urlen;

        /*
         * strip off space prefix and trailing spaces
         */
        while (str < uend && isspace(*str)) {
                ++str;
                --urlen;
        }
        while (str < uend && isspace(*(uend - 1))) {
                --uend;
                --urlen;
        }

        /*
         * strip off "URL:" prefix
         */
        if (urlen > 4 && sip_uri_url_casecmp(str, "URL:", 4) == 0) {
                str += 4;
                urlen -= 4;
        }

        /*
         * parse the scheme name
         */
        mark = scan = str;
        while (scan < uend && *scan != ':')
                ++scan;
        if (scan == uend || !sip_uri_parse_scheme(outurl, mark, scan)) {
                outurl->sip_uri_errflags |= SIP_URIERR_SCHEME;
                return;
        }

        if ((outurl->sip_uri_scheme.sip_str_len == SIP_SCHEME_LEN &&
            !memcmp(outurl->sip_uri_scheme.sip_str_ptr, SIP_SCHEME,
            SIP_SCHEME_LEN)) ||
            (outurl->sip_uri_scheme.sip_str_len == SIPS_SCHEME_LEN &&
            !memcmp(outurl->sip_uri_scheme.sip_str_ptr, SIPS_SCHEME,
            SIPS_SCHEME_LEN))) {
                outurl->sip_uri_issip = B_TRUE;
        } else {
                outurl->sip_uri_issip = B_FALSE;
        }
        ++scan; /* skip ':' */

        if (outurl->sip_uri_issip) {
                /*
                 * parse SIP URL
                 */
                sip_uri_parse_netpath(outurl, &scan, uend, B_TRUE);

                /*
                 * parse parameters
                 */
                if (scan < uend && *scan == ';') {
                        mark = scan;
                        while (scan < uend && *scan != '?')
                                ++scan;
                        sip_uri_parse_params(outurl, mark, scan);
                }

                /*
                 * parse headers
                 */
                if (scan < uend && *scan == '?')
                        sip_uri_parse_headers(outurl, scan, uend);
        } else if (scan < uend && scan[0] == '/') {      /* parse absoluteURL */
                ++scan;
                /*
                 * parse authority
                 * authority    = srvr / reg-name
                 * srvr         = [ [ userinfo "@" ] hostport ]
                 * reg-name     = 1*(unreserved / escaped / "$" / ","
                 *                      / ";" / ":" / "@" / "&" / "=" / "+")
                 */
                if (scan < uend && *scan == '/') {
                        ++scan;
                        mark = scan;
                        /*
                         * take authority as srvr
                         */
                        sip_uri_parse_netpath(outurl, &scan, uend, B_FALSE);

                        /*
                         * if srvr failed, take it as reg-name
                         * parse reg-name
                         */
                        if (outurl->sip_uri_errflags & SIP_URIERR_USER ||
                            outurl->sip_uri_errflags & SIP_URIERR_PASS ||
                            outurl->sip_uri_errflags & SIP_URIERR_HOST ||
                            outurl->sip_uri_errflags & SIP_URIERR_PORT) {
                                scan = mark;
                                while (scan < uend && *scan != '/' &&
                                        *scan != '?') {
                                        ++scan;
                                }
                                sip_uri_parse_abs_regname(outurl, mark, scan);
                                if (!(outurl->sip_uri_errflags &
                                    SIP_URIERR_REGNAME)) {
                                        /*
                                         * remove error info of user,
                                         * password, host, port
                                         */
                                        outurl->sip_uri_user.sip_str_ptr = NULL;
                                        outurl->sip_uri_user.sip_str_len = 0;
                                        outurl->sip_uri_errflags &=
                                            ~SIP_URIERR_USER;
                                        outurl->sip_uri_password.sip_str_ptr =
                                            NULL;
                                        outurl->sip_uri_password.sip_str_len =
                                            0;
                                        outurl->sip_uri_errflags &=
                                            ~SIP_URIERR_PASS;
                                        outurl->sip_uri_host.sip_str_ptr = NULL;
                                        outurl->sip_uri_host.sip_str_len = 0;
                                        outurl->sip_uri_errflags &=
                                            ~SIP_URIERR_HOST;
                                        outurl->sip_uri_port = 0;
                                        outurl->sip_uri_errflags &=
                                            ~SIP_URIERR_PORT;
                                }
                        }
                } else {
                        /*
                         * there is no net-path
                         */
                        --scan;
                }
                /*
                 * parse abs-path
                 */
                if (scan < uend && *scan == '/') {
                        mark = scan;
                        while (scan < uend && *scan != '?')
                                ++scan;
                        sip_uri_parse_abs_path(outurl, mark, scan);
                }

                /*
                 * parse query
                 */
                if (scan < uend && *scan == '?')
                        sip_uri_parse_abs_query(outurl, scan, uend);
        } else {
                /*
                 * parse opaque-part
                 */
                sip_uri_parse_abs_opaque(outurl, scan, uend);
        }
}