/* * Conditions Of Use * * This software was developed by employees of the National Institute of * Standards and Technology (NIST), an agency of the Federal Government. * Pursuant to title 15 Untied States Code Section 105, works of NIST * employees are not subject to copyright protection in the United States * and are considered to be in the public domain. As a result, a formal * license is not needed to use the software. * * This software is provided by NIST as a service and is expressly * provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED * OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT * AND DATA ACCURACY. NIST does not warrant or make any representations * regarding the use of the software or the results thereof, including but * not limited to the correctness, accuracy, reliability or usefulness of * the software. * * Permission to use this software is contingent upon your acceptance * of the terms of this agreement * * . * */ package gov.nist.javax.sip.parser; import gov.nist.core.HostNameParser; import gov.nist.core.HostPort; import gov.nist.core.NameValue; import gov.nist.core.NameValueList; import gov.nist.core.Token; import gov.nist.javax.sip.address.GenericURI; import gov.nist.javax.sip.address.SipUri; import gov.nist.javax.sip.address.TelURLImpl; import gov.nist.javax.sip.address.TelephoneNumber; import java.text.ParseException; /** * Parser For SIP and Tel URLs. Other kinds of URL's are handled by the * J2SE 1.4 URL class. * @version 1.2 $Revision: 1.27 $ $Date: 2009/10/22 10:27:39 $ * * @author M. Ranganathan <br/> * * */ public class URLParser extends Parser { public URLParser(String url) { this.lexer = new Lexer("sip_urlLexer", url); } // public tag added - issued by Miguel Freitas public URLParser(Lexer lexer) { this.lexer = lexer; this.lexer.selectLexer("sip_urlLexer"); } protected static boolean isMark(char next) { switch (next) { case '-': case '_': case '.': case '!': case '~': case '*': case '\'': case '(': case ')': return true; default: return false; } } protected static boolean isUnreserved(char next) { return Lexer.isAlphaDigit(next) || isMark(next); } protected static boolean isReservedNoSlash(char next) { switch (next) { case ';': case '?': case ':': case '@': case '&': case '+': case '$': case ',': return true; default: return false; } } // Missing '=' bug in character set - discovered by interop testing // at SIPIT 13 by Bob Johnson and Scott Holben. // change . to ; by Bruno Konik protected static boolean isUserUnreserved(char la) { switch (la) { case '&': case '?': case '+': case '$': case '#': case '/': case ',': case ';': case '=': return true; default: return false; } } protected String unreserved() throws ParseException { char next = lexer.lookAhead(0); if (isUnreserved(next)) { lexer.consume(1); return String.valueOf(next); } else throw createParseException("unreserved"); } /** Name or value of a parameter. */ protected String paramNameOrValue() throws ParseException { int startIdx = lexer.getPtr(); while (lexer.hasMoreChars()) { char next = lexer.lookAhead(0); boolean isValidChar = false; switch (next) { case '[': case ']':// JvB: fixed this one case '/': case ':': case '&': case '+': case '$': isValidChar = true; } if (isValidChar || isUnreserved(next)) { lexer.consume(1); } else if (isEscaped()) { lexer.consume(3); } else break; } return lexer.getBuffer().substring(startIdx, lexer.getPtr()); } private NameValue uriParam() throws ParseException { if (debug) dbg_enter("uriParam"); try { String pvalue = ""; String pname = paramNameOrValue(); char next = lexer.lookAhead(0); boolean isFlagParam = true; if (next == '=') { lexer.consume(1); pvalue = paramNameOrValue(); isFlagParam = false; } if (pname.length() == 0 && ( pvalue == null || pvalue.length() == 0)) return null; else return new NameValue(pname, pvalue, isFlagParam); } finally { if (debug) dbg_leave("uriParam"); } } protected static boolean isReserved(char next) { switch (next) { case ';': case '/': case '?': case ':': case '=': // Bug fix by Bruno Konik case '@': case '&': case '+': case '$': case ',': return true; default: return false; } } protected String reserved() throws ParseException { char next = lexer.lookAhead(0); if (isReserved(next)) { lexer.consume(1); return new StringBuffer().append(next).toString(); } else throw createParseException("reserved"); } protected boolean isEscaped() { try { return lexer.lookAhead(0) == '%' && Lexer.isHexDigit(lexer.lookAhead(1)) && Lexer.isHexDigit(lexer.lookAhead(2)); } catch (Exception ex) { return false; } } protected String escaped() throws ParseException { if (debug) dbg_enter("escaped"); try { StringBuffer retval = new StringBuffer(); char next = lexer.lookAhead(0); char next1 = lexer.lookAhead(1); char next2 = lexer.lookAhead(2); if (next == '%' && Lexer.isHexDigit(next1) && Lexer.isHexDigit(next2)) { lexer.consume(3); retval.append(next); retval.append(next1); retval.append(next2); } else throw createParseException("escaped"); return retval.toString(); } finally { if (debug) dbg_leave("escaped"); } } protected String mark() throws ParseException { if (debug) dbg_enter("mark"); try { char next = lexer.lookAhead(0); if (isMark(next)) { lexer.consume(1); return new String( new char[]{next} ); } else throw createParseException("mark"); } finally { if (debug) dbg_leave("mark"); } } protected String uric() { if (debug) dbg_enter("uric"); try { try { char la = lexer.lookAhead(0); if (isUnreserved(la)) { lexer.consume(1); return Lexer.charAsString(la); } else if (isReserved(la)) { lexer.consume(1); return Lexer.charAsString(la); } else if (isEscaped()) { String retval = lexer.charAsString(3); lexer.consume(3); return retval; } else return null; } catch (Exception ex) { return null; } } finally { if (debug) dbg_leave("uric"); } } protected String uricNoSlash() { if (debug) dbg_enter("uricNoSlash"); try { try { char la = lexer.lookAhead(0); if (isEscaped()) { String retval = lexer.charAsString(3); lexer.consume(3); return retval; } else if (isUnreserved(la)) { lexer.consume(1); return Lexer.charAsString(la); } else if (isReservedNoSlash(la)) { lexer.consume(1); return Lexer.charAsString(la); } else return null; } catch (ParseException ex) { return null; } } finally { if (debug) dbg_leave("uricNoSlash"); } } protected String uricString() throws ParseException { StringBuffer retval = new StringBuffer(); while (true) { String next = uric(); if (next == null) { char la = lexer.lookAhead(0); // JvB: allow IPv6 addresses in generic URI strings // e.g. http://[::1] if ( la == '[' ) { HostNameParser hnp = new HostNameParser(this.getLexer()); HostPort hp = hnp.hostPort( false ); retval.append(hp.toString()); continue; } break; } retval.append(next); } return retval.toString(); } /** * Parse and return a structure for a generic URL. * Note that non SIP URLs are just stored as a string (not parsed). * @return URI is a URL structure for a SIP url. * @throws ParseException if there was a problem parsing. */ public GenericURI uriReference( boolean inBrackets ) throws ParseException { if (debug) dbg_enter("uriReference"); GenericURI retval = null; Token[] tokens = lexer.peekNextToken(2); Token t1 = (Token) tokens[0]; Token t2 = (Token) tokens[1]; try { if (t1.getTokenType() == TokenTypes.SIP || t1.getTokenType() == TokenTypes.SIPS) { if (t2.getTokenType() == ':') retval = sipURL( inBrackets ); else throw createParseException("Expecting \':\'"); } else if (t1.getTokenType() == TokenTypes.TEL) { if (t2.getTokenType() == ':') { retval = telURL( inBrackets ); } else throw createParseException("Expecting \':\'"); } else { String urlString = uricString(); try { retval = new GenericURI(urlString); } catch (ParseException ex) { throw createParseException(ex.getMessage()); } } } finally { if (debug) dbg_leave("uriReference"); } return retval; } /** * Parser for the base phone number. */ private String base_phone_number() throws ParseException { StringBuffer s = new StringBuffer(); if (debug) dbg_enter("base_phone_number"); try { int lc = 0; while (lexer.hasMoreChars()) { char w = lexer.lookAhead(0); if (Lexer.isDigit(w) || w == '-' || w == '.' || w == '(' || w == ')') { lexer.consume(1); s.append(w); lc++; } else if (lc > 0) break; else throw createParseException("unexpected " + w); } return s.toString(); } finally { if (debug) dbg_leave("base_phone_number"); } } /** * Parser for the local phone #. */ private String local_number() throws ParseException { StringBuffer s = new StringBuffer(); if (debug) dbg_enter("local_number"); try { int lc = 0; while (lexer.hasMoreChars()) { char la = lexer.lookAhead(0); if (la == '*' || la == '#' || la == '-' || la == '.' || la == '(' || la == ')' // JvB: allow 'A'..'F', should be uppercase || Lexer.isHexDigit(la)) { lexer.consume(1); s.append(la); lc++; } else if (lc > 0) break; else throw createParseException("unexepcted " + la); } return s.toString(); } finally { if (debug) dbg_leave("local_number"); } } /** * Parser for telephone subscriber. * * @return the parsed telephone number. */ public final TelephoneNumber parseTelephoneNumber( boolean inBrackets ) throws ParseException { TelephoneNumber tn; if (debug) dbg_enter("telephone_subscriber"); lexer.selectLexer("charLexer"); try { char c = lexer.lookAhead(0); if (c == '+') tn = global_phone_number( inBrackets ); else if ( Lexer.isHexDigit(c)// see RFC3966 || c == '#' || c == '*' || c == '-' || c == '.' || c == '(' || c == ')' ) { tn = local_phone_number( inBrackets ); } else throw createParseException("unexpected char " + c); return tn; } finally { if (debug) dbg_leave("telephone_subscriber"); } } private final TelephoneNumber global_phone_number( boolean inBrackets ) throws ParseException { if (debug) dbg_enter("global_phone_number"); try { TelephoneNumber tn = new TelephoneNumber(); tn.setGlobal(true); NameValueList nv = null; this.lexer.match(PLUS); String b = base_phone_number(); tn.setPhoneNumber(b); if (lexer.hasMoreChars()) { char tok = lexer.lookAhead(0); if (tok == ';' && inBrackets) { this.lexer.consume(1); nv = tel_parameters(); tn.setParameters(nv); } } return tn; } finally { if (debug) dbg_leave("global_phone_number"); } } private TelephoneNumber local_phone_number( boolean inBrackets ) throws ParseException { if (debug) dbg_enter("local_phone_number"); TelephoneNumber tn = new TelephoneNumber(); tn.setGlobal(false); NameValueList nv = null; String b = null; try { b = local_number(); tn.setPhoneNumber(b); if (lexer.hasMoreChars()) { Token tok = this.lexer.peekNextToken(); switch (tok.getTokenType()) { case SEMICOLON: { if (inBrackets) { this.lexer.consume(1); nv = tel_parameters(); tn.setParameters(nv); } break; } default : { break; } } } } finally { if (debug) dbg_leave("local_phone_number"); } return tn; } private NameValueList tel_parameters() throws ParseException { NameValueList nvList = new NameValueList(); // JvB: Need to handle 'phone-context' specially // 'isub' (or 'ext') MUST appear first, but we accept any order here NameValue nv; while ( true ) { String pname = paramNameOrValue(); // Handle 'phone-context' specially, it may start with '+' if ( pname.equalsIgnoreCase("phone-context")) { nv = phone_context(); } else { if (lexer.lookAhead(0) == '=') { lexer.consume(1); String value = paramNameOrValue(); nv = new NameValue( pname, value, false ); } else { nv = new NameValue( pname, "", true );// flag param } } nvList.set( nv ); if ( lexer.lookAhead(0) == ';' ) { lexer.consume(1); } else { return nvList; } } } /** * Parses the 'phone-context' parameter in tel: URLs * @throws ParseException */ private NameValue phone_context() throws ParseException { lexer.match('='); char la = lexer.lookAhead(0); Object value; if (la=='+') {// global-number-digits lexer.consume(1);// skip '+' value = "+" + base_phone_number(); } else if ( Lexer.isAlphaDigit(la) ) { Token t = lexer.match( Lexer.ID );// more broad than allowed value = t.getTokenValue(); } else { throw new ParseException( "Invalid phone-context:" + la , -1 ); } return new NameValue( "phone-context", value, false ); } /** * Parse and return a structure for a Tel URL. * @return a parsed tel url structure. */ public TelURLImpl telURL( boolean inBrackets ) throws ParseException { lexer.match(TokenTypes.TEL); lexer.match(':'); TelephoneNumber tn = this.parseTelephoneNumber(inBrackets); TelURLImpl telUrl = new TelURLImpl(); telUrl.setTelephoneNumber(tn); return telUrl; } /** * Parse and return a structure for a SIP URL. * @return a URL structure for a SIP url. * @throws ParseException if there was a problem parsing. */ public SipUri sipURL( boolean inBrackets ) throws ParseException { if (debug) dbg_enter("sipURL"); SipUri retval = new SipUri(); // pmusgrave - handle sips case Token nextToken = lexer.peekNextToken(); int sipOrSips = TokenTypes.SIP; String scheme = TokenNames.SIP; if ( nextToken.getTokenType() == TokenTypes.SIPS) { sipOrSips = TokenTypes.SIPS; scheme = TokenNames.SIPS; } try { lexer.match(sipOrSips); lexer.match(':'); retval.setScheme(scheme); int startOfUser = lexer.markInputPosition(); String userOrHost = user();// Note: user may contain ';', host may not... String passOrPort = null; // name:password or host:port if ( lexer.lookAhead() == ':' ) { lexer.consume(1); passOrPort = password(); } // name@hostPort if ( lexer.lookAhead() == '@' ) { lexer.consume(1); retval.setUser( userOrHost ); if (passOrPort!=null) retval.setUserPassword( passOrPort ); } else { // then userOrHost was a host, backtrack just in case a ';' was eaten... lexer.rewindInputPosition( startOfUser ); } HostNameParser hnp = new HostNameParser(this.getLexer()); HostPort hp = hnp.hostPort( false ); retval.setHostPort(hp); lexer.selectLexer("charLexer"); while (lexer.hasMoreChars()) { // If the URI is not enclosed in brackets, parameters belong to header if (lexer.lookAhead(0) != ';' || !inBrackets) break; lexer.consume(1); NameValue parms = uriParam(); if (parms != null) retval.setUriParameter(parms); } if (lexer.hasMoreChars() && lexer.lookAhead(0) == '?') { lexer.consume(1); while (lexer.hasMoreChars()) { NameValue parms = qheader(); retval.setQHeader(parms); if (lexer.hasMoreChars() && lexer.lookAhead(0) != '&') break; else lexer.consume(1); } } return retval; } finally { if (debug) dbg_leave("sipURL"); } } public String peekScheme() throws ParseException { Token[] tokens = lexer.peekNextToken(1); if (tokens.length == 0) return null; String scheme = ((Token) tokens[0]).getTokenValue(); return scheme; } /** * Get a name value for a given query header (ie one that comes * after the ?). */ protected NameValue qheader() throws ParseException { String name = lexer.getNextToken('='); lexer.consume(1); String value = hvalue(); return new NameValue(name, value, false); } protected String hvalue() throws ParseException { StringBuffer retval = new StringBuffer(); while (lexer.hasMoreChars()) { char la = lexer.lookAhead(0); // Look for a character that can terminate a URL. boolean isValidChar = false; switch (la) { case '+': case '?': case ':': case '[': case ']': case '/': case '$': case '_': case '-': case '"': case '!': case '~': case '*': case '.': case '(': case ')': isValidChar = true; } if (isValidChar || Lexer.isAlphaDigit(la)) { lexer.consume(1); retval.append(la); } else if (la == '%') { retval.append(escaped()); } else break; } return retval.toString(); } /** * Scan forward until you hit a terminating character for a URL. * We do not handle non sip urls in this implementation. * @return the string that takes us to the end of this URL (i.e. to * the next delimiter). */ protected String urlString() throws ParseException { StringBuffer retval = new StringBuffer(); lexer.selectLexer("charLexer"); while (lexer.hasMoreChars()) { char la = lexer.lookAhead(0); // Look for a character that can terminate a URL. if (la == ' ' || la == '\t' || la == '\n' || la == '>' || la == '<') break; lexer.consume(0); retval.append(la); } return retval.toString(); } protected String user() throws ParseException { if (debug) dbg_enter("user"); try { int startIdx = lexer.getPtr(); while (lexer.hasMoreChars()) { char la = lexer.lookAhead(0); if (isUnreserved(la) || isUserUnreserved(la)) { lexer.consume(1); } else if (isEscaped()) { lexer.consume(3); } else break; } return lexer.getBuffer().substring(startIdx, lexer.getPtr()); } finally { if (debug) dbg_leave("user"); } } protected String password() throws ParseException { int startIdx = lexer.getPtr(); while (true) { char la = lexer.lookAhead(0); boolean isValidChar = false; switch (la) { case '&': case '=': case '+': case '$': case ',': isValidChar = true; } if (isValidChar || isUnreserved(la)) { lexer.consume(1); } else if (isEscaped()) { lexer.consume(3); // bug reported by // Jeff Haynie } else break; } return lexer.getBuffer().substring(startIdx, lexer.getPtr()); } /** * Default parse method. This method just calls uriReference. */ public GenericURI parse() throws ParseException { return uriReference( true ); } // quick test routine for debugging type assignment public static void main(String[] args) throws ParseException { // quick test for sips parsing String[] test = { "sip:alice@example.com", "sips:alice@examples.com" , "sip:3Zqkv5dajqaaas0tCjCxT0xH2ZEuEMsFl0xoasip%3A%2B3519116786244%40siplab.domain.com@213.0.115.163:7070"}; for ( int i = 0; i < test.length; i++) { URLParser p = new URLParser(test[i]); GenericURI uri = p.parse(); System.out.println("uri type returned " + uri.getClass().getName()); System.out.println(test[i] + " is SipUri? " + uri.isSipURI() + ">" + uri.encode()); } } /** **/ }