xref: /titanic_51/usr/src/lib/libsip/common/sip_parse_uri.c (revision 2c2c41837e330b002c4220a39638150db504fe0e)

/*
 * 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.
 */
#pragma ident	"%Z%%M%	%I%	%E% SMI"

#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);
	}
}