1059 lines
33 KiB
Java
1059 lines
33 KiB
Java
/*
|
|
* 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
|
|
*
|
|
* .
|
|
*
|
|
*/
|
|
/*******************************************************************************
|
|
* Product of NIST/ITL Advanced Networking Technologies Division (ANTD). *
|
|
*******************************************************************************/
|
|
package gov.nist.javax.sip.address;
|
|
|
|
/*
|
|
*Bug fix contributions
|
|
*Daniel J. Martinez Manzano <dani@dif.um.es>
|
|
*Stefan Marx.
|
|
*pmusgrave@newheights.com (Additions for gruu and outbound drafts)
|
|
*Jeroen van Bemmel ( additions for SCTP transport )
|
|
*/
|
|
import gov.nist.core.*;
|
|
import java.util.*;
|
|
import java.text.ParseException;
|
|
|
|
import javax.sip.PeerUnavailableException;
|
|
import javax.sip.SipFactory;
|
|
import javax.sip.address.SipURI;
|
|
import javax.sip.header.Header;
|
|
import javax.sip.header.HeaderFactory;
|
|
|
|
|
|
/**
|
|
* Implementation of the SipURI interface.
|
|
*
|
|
*
|
|
* @author M. Ranganathan <br/>
|
|
* @version 1.2 $Revision: 1.22 $ $Date: 2009/11/15 19:50:45 $
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
public class SipUri extends GenericURI implements javax.sip.address.SipURI , SipURIExt{
|
|
|
|
|
|
private static final long serialVersionUID = 7749781076218987044L;
|
|
|
|
/** Authority for the uri.
|
|
*/
|
|
|
|
protected Authority authority;
|
|
|
|
/** uriParms list
|
|
*/
|
|
protected NameValueList uriParms;
|
|
|
|
/** qheaders list
|
|
*/
|
|
protected NameValueList qheaders;
|
|
|
|
/** telephoneSubscriber field
|
|
*/
|
|
protected TelephoneNumber telephoneSubscriber;
|
|
|
|
public SipUri() {
|
|
this.scheme = SIP;
|
|
this.uriParms = new NameValueList();
|
|
this.qheaders = new NameValueList();
|
|
this.qheaders.setSeparator("&");
|
|
}
|
|
|
|
/** Constructor given the scheme.
|
|
* The scheme must be either Sip or Sips
|
|
*/
|
|
public void setScheme(String scheme) {
|
|
if (scheme.compareToIgnoreCase(SIP) != 0
|
|
&& scheme.compareToIgnoreCase(SIPS) != 0)
|
|
throw new IllegalArgumentException("bad scheme " + scheme);
|
|
this.scheme = scheme.toLowerCase();
|
|
}
|
|
|
|
/** Get the scheme.
|
|
*/
|
|
public String getScheme() {
|
|
return scheme;
|
|
}
|
|
|
|
/**
|
|
* clear all URI Parameters.
|
|
* @since v1.0
|
|
*/
|
|
public void clearUriParms() {
|
|
uriParms = new NameValueList();
|
|
}
|
|
/**
|
|
*Clear the password from the user part if it exists.
|
|
*/
|
|
public void clearPassword() {
|
|
if (this.authority != null) {
|
|
UserInfo userInfo = authority.getUserInfo();
|
|
if (userInfo != null)
|
|
userInfo.clearPassword();
|
|
}
|
|
}
|
|
|
|
/** Get the authority.
|
|
*/
|
|
public Authority getAuthority() {
|
|
return this.authority;
|
|
}
|
|
|
|
/**
|
|
* Clear all Qheaders.
|
|
*/
|
|
public void clearQheaders() {
|
|
qheaders = new NameValueList();
|
|
}
|
|
|
|
/**
|
|
* Compare two URIs and return true if they are equal.
|
|
* @param that the object to compare to.
|
|
* @return true if the object is equal to this object.
|
|
*
|
|
* JvB: Updated to define equality in terms of API methods, according to the rules
|
|
* in RFC3261 section 19.1.4
|
|
*
|
|
* Jean Deruelle: Updated to define equality of API methods, according to the rules
|
|
* in RFC3261 section 19.1.4 convert potential ie :
|
|
* %HEX HEX encoding parts of the URI before comparing them
|
|
* transport param added in comparison
|
|
* header equality enforced in comparison
|
|
*
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public boolean equals(Object that) {
|
|
|
|
// Shortcut for same object
|
|
if (that==this) return true;
|
|
|
|
if (that instanceof SipURI) {
|
|
final SipURI a = this;
|
|
final SipURI b = (SipURI) that;
|
|
|
|
// A SIP and SIPS URI are never equivalent
|
|
if ( a.isSecure() ^ b.isSecure() ) return false;
|
|
|
|
// For two URIs to be equal, the user, password, host, and port
|
|
// components must match; comparison of userinfo is case-sensitive
|
|
if (a.getUser()==null ^ b.getUser()==null) return false;
|
|
if (a.getUserPassword()==null ^ b.getUserPassword()==null) return false;
|
|
|
|
if (a.getUser()!=null && !RFC2396UrlDecoder.decode(a.getUser()).equals(RFC2396UrlDecoder.decode(b.getUser()))) return false;
|
|
if (a.getUserPassword()!=null && !RFC2396UrlDecoder.decode(a.getUserPassword()).equals(RFC2396UrlDecoder.decode(b.getUserPassword()))) return false;
|
|
if (a.getHost() == null ^ b.getHost() == null) return false;
|
|
if (a.getHost() != null && !a.getHost().equalsIgnoreCase(b.getHost())) return false;
|
|
if (a.getPort() != b.getPort()) return false;
|
|
|
|
// URI parameters
|
|
for (Iterator i = a.getParameterNames(); i.hasNext();) {
|
|
String pname = (String) i.next();
|
|
|
|
String p1 = a.getParameter(pname);
|
|
String p2 = b.getParameter(pname);
|
|
|
|
// those present in both must match (case-insensitive)
|
|
if (p1!=null && p2!=null && !RFC2396UrlDecoder.decode(p1).equalsIgnoreCase(RFC2396UrlDecoder.decode(p2))) return false;
|
|
}
|
|
|
|
// transport, user, ttl or method must match when present in either
|
|
if (a.getTransportParam()==null ^ b.getTransportParam()==null) return false;
|
|
if (a.getUserParam()==null ^ b.getUserParam()==null) return false;
|
|
if (a.getTTLParam()==-1 ^ b.getTTLParam()==-1) return false;
|
|
if (a.getMethodParam()==null ^ b.getMethodParam()==null) return false;
|
|
if (a.getMAddrParam()==null ^ b.getMAddrParam()==null) return false;
|
|
|
|
// Headers: must match according to their definition.
|
|
if(a.getHeaderNames().hasNext() && !b.getHeaderNames().hasNext()) return false;
|
|
if(!a.getHeaderNames().hasNext() && b.getHeaderNames().hasNext()) return false;
|
|
|
|
if(a.getHeaderNames().hasNext() && b.getHeaderNames().hasNext()) {
|
|
HeaderFactory headerFactory = null;
|
|
try {
|
|
headerFactory = SipFactory.getInstance().createHeaderFactory();
|
|
} catch (PeerUnavailableException e) {
|
|
Debug.logError("Cannot get the header factory to parse the header of the sip uris to compare", e);
|
|
return false;
|
|
}
|
|
for (Iterator i = a.getHeaderNames(); i.hasNext();) {
|
|
String hname = (String) i.next();
|
|
|
|
String h1 = a.getHeader(hname);
|
|
String h2 = b.getHeader(hname);
|
|
|
|
if(h1 == null && h2 != null) return false;
|
|
if(h2 == null && h1 != null) return false;
|
|
// The following check should not be needed but we add it for findbugs.
|
|
if(h1 == null && h2 == null) continue;
|
|
try {
|
|
Header header1 = headerFactory.createHeader(hname, RFC2396UrlDecoder.decode(h1));
|
|
Header header2 = headerFactory.createHeader(hname, RFC2396UrlDecoder.decode(h2));
|
|
// those present in both must match according to the equals method of the corresponding header
|
|
if (!header1.equals(header2)) return false;
|
|
} catch (ParseException e) {
|
|
Debug.logError("Cannot parse one of the header of the sip uris to compare " + a + " " + b, e);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Finally, we can conclude that they are indeed equal
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Construct a URL from the parsed structure.
|
|
* @return String
|
|
*/
|
|
public String encode() {
|
|
return encode(new StringBuffer()).toString();
|
|
}
|
|
|
|
public StringBuffer encode(StringBuffer buffer) {
|
|
buffer.append(scheme).append(COLON);
|
|
if (authority != null)
|
|
authority.encode(buffer);
|
|
if (!uriParms.isEmpty()) {
|
|
buffer.append(SEMICOLON);
|
|
uriParms.encode(buffer);
|
|
}
|
|
if (!qheaders.isEmpty()) {
|
|
buffer.append(QUESTION);
|
|
qheaders.encode(buffer);
|
|
}
|
|
return buffer;
|
|
}
|
|
|
|
/** Return a string representation.
|
|
*
|
|
*@return the String representation of this URI.
|
|
*
|
|
*/
|
|
public String toString() {
|
|
return this.encode();
|
|
}
|
|
|
|
/**
|
|
* getUser@host
|
|
* @return user@host portion of the uri (null if none exists).
|
|
*
|
|
* Peter Musgrave - handle null user
|
|
*/
|
|
public String getUserAtHost() {
|
|
String user = "";
|
|
if (authority.getUserInfo() != null)
|
|
user = authority.getUserInfo().getUser();
|
|
|
|
String host = authority.getHost().encode();
|
|
StringBuffer s = null;
|
|
if (user.equals("")) {
|
|
s = new StringBuffer();
|
|
} else {
|
|
s = new StringBuffer(user).append(AT);
|
|
}
|
|
return s.append(host).toString();
|
|
}
|
|
|
|
/**
|
|
* getUser@host
|
|
* @return user@host portion of the uri (null if none exists).
|
|
*/
|
|
public String getUserAtHostPort() {
|
|
String user = "";
|
|
if (authority.getUserInfo() != null)
|
|
user = authority.getUserInfo().getUser();
|
|
|
|
String host = authority.getHost().encode();
|
|
int port = authority.getPort();
|
|
// If port not set assign the default.
|
|
StringBuffer s = null;
|
|
if (user.equals("")) {
|
|
s = new StringBuffer();
|
|
} else {
|
|
s = new StringBuffer(user).append(AT);
|
|
}
|
|
if (port != -1) {
|
|
return s.append(host).append(COLON).append(port).toString();
|
|
} else
|
|
return s.append(host).toString();
|
|
|
|
}
|
|
|
|
/**
|
|
* get the parameter (do a name lookup) and return null if none exists.
|
|
* @param parmname Name of the parameter to get.
|
|
* @return Parameter of the given name (null if none exists).
|
|
*/
|
|
public Object getParm(String parmname) {
|
|
Object obj = uriParms.getValue(parmname);
|
|
return obj;
|
|
}
|
|
|
|
/**
|
|
* Get the method parameter.
|
|
* @return Method parameter.
|
|
*/
|
|
public String getMethod() {
|
|
return (String) getParm(METHOD);
|
|
}
|
|
|
|
/**
|
|
* Accessor for URI parameters
|
|
* @return A name-value list containing the parameters.
|
|
*/
|
|
public NameValueList getParameters() {
|
|
return uriParms;
|
|
}
|
|
|
|
/** Remove the URI parameters.
|
|
*
|
|
*/
|
|
public void removeParameters() {
|
|
this.uriParms = new NameValueList();
|
|
}
|
|
|
|
/**
|
|
* Accessor forSIPObjects
|
|
* @return Get the query headers (that appear after the ? in
|
|
* the URL)
|
|
*/
|
|
public NameValueList getQheaders() {
|
|
return qheaders;
|
|
}
|
|
|
|
/**
|
|
* Get the urse parameter.
|
|
* @return User parameter (user= phone or user=ip).
|
|
*/
|
|
public String getUserType() {
|
|
return (String) uriParms.getValue(USER);
|
|
}
|
|
|
|
/**
|
|
* Get the password of the user.
|
|
* @return User password when it embedded as part of the uri
|
|
* ( a very bad idea).
|
|
*/
|
|
public String getUserPassword() {
|
|
if (authority == null)
|
|
return null;
|
|
return authority.getPassword();
|
|
}
|
|
|
|
/** Set the user password.
|
|
*@param password - password to set.
|
|
*/
|
|
public void setUserPassword(String password) {
|
|
if (this.authority == null)
|
|
this.authority = new Authority();
|
|
authority.setPassword(password);
|
|
}
|
|
|
|
/**
|
|
* Returns the stucture corresponding to the telephone number
|
|
* provided that the user is a telephone subscriber.
|
|
* @return TelephoneNumber part of the url (only makes sense
|
|
* when user = phone is specified)
|
|
*/
|
|
public TelephoneNumber getTelephoneSubscriber() {
|
|
if (telephoneSubscriber == null) {
|
|
|
|
telephoneSubscriber = new TelephoneNumber();
|
|
}
|
|
return telephoneSubscriber;
|
|
}
|
|
|
|
/**
|
|
* Get the host and port of the server.
|
|
* @return get the host:port part of the url parsed into a
|
|
* structure.
|
|
*/
|
|
public HostPort getHostPort() {
|
|
|
|
if (authority == null || authority.getHost() == null )
|
|
return null;
|
|
else {
|
|
return authority.getHostPort();
|
|
}
|
|
}
|
|
|
|
/** Get the port from the authority field.
|
|
*
|
|
*@return the port from the authority field.
|
|
*/
|
|
public int getPort() {
|
|
HostPort hp = this.getHostPort();
|
|
if (hp == null)
|
|
return -1;
|
|
return hp.getPort();
|
|
}
|
|
|
|
/** Get the host protion of the URI.
|
|
* @return the host portion of the url.
|
|
*/
|
|
public String getHost() {
|
|
if ( authority == null) return null;
|
|
else if (authority.getHost() == null ) return null;
|
|
else return authority.getHost().encode();
|
|
}
|
|
|
|
/**
|
|
* returns true if the user is a telephone subscriber.
|
|
* If the host is an Internet telephony
|
|
* gateway, a telephone-subscriber field MAY be used instead
|
|
* of a user field. The telephone-subscriber field uses the
|
|
* notation of RFC 2806 [19]. Any characters of the un-escaped
|
|
* "telephone-subscriber" that are not either in the set
|
|
* "unreserved" or "user-unreserved" MUST be escaped. The set
|
|
* of characters not reserved in the RFC 2806 description of
|
|
* telephone-subscriber contains a number of characters in
|
|
* various syntax elements that need to be escaped when used
|
|
* in SIP URLs, for example quotation marks (%22), hash (%23),
|
|
* colon (%3a), at-sign (%40) and the "unwise" characters,
|
|
* i.e., punctuation of %5b and above.
|
|
*
|
|
* The telephone number is a special case of a user name and
|
|
* cannot be distinguished by a BNF. Thus, a URL parameter,
|
|
* user, is added to distinguish telephone numbers from user
|
|
* names.
|
|
*
|
|
* The user parameter value "phone" indicates that the user
|
|
* part contains a telephone number. Even without this
|
|
* parameter, recipients of SIP URLs MAY interpret the pre-@
|
|
* part as a telephone number if local restrictions on the
|
|
* @return true if the user is a telephone subscriber.
|
|
*/
|
|
public boolean isUserTelephoneSubscriber() {
|
|
String usrtype = (String) uriParms.getValue(USER);
|
|
if (usrtype == null)
|
|
return false;
|
|
return usrtype.equalsIgnoreCase(PHONE);
|
|
}
|
|
|
|
/**
|
|
*remove the ttl value from the parameter list if it exists.
|
|
*/
|
|
public void removeTTL() {
|
|
if (uriParms != null)
|
|
uriParms.delete(TTL);
|
|
}
|
|
|
|
/**
|
|
*Remove the maddr param if it exists.
|
|
*/
|
|
public void removeMAddr() {
|
|
if (uriParms != null)
|
|
uriParms.delete(MADDR);
|
|
}
|
|
|
|
/**
|
|
*Delete the transport string.
|
|
*/
|
|
public void removeTransport() {
|
|
if (uriParms != null)
|
|
uriParms.delete(TRANSPORT);
|
|
}
|
|
|
|
/** Remove a header given its name (provided it exists).
|
|
* @param name name of the header to remove.
|
|
*/
|
|
public void removeHeader(String name) {
|
|
if (qheaders != null)
|
|
qheaders.delete(name);
|
|
}
|
|
|
|
/** Remove all headers.
|
|
*/
|
|
public void removeHeaders() {
|
|
qheaders = new NameValueList();
|
|
}
|
|
|
|
/**
|
|
* Set the user type.
|
|
*/
|
|
public void removeUserType() {
|
|
if (uriParms != null)
|
|
uriParms.delete(USER);
|
|
}
|
|
|
|
/**
|
|
*remove the port setting.
|
|
*/
|
|
public void removePort() {
|
|
authority.removePort();
|
|
}
|
|
|
|
/**
|
|
* remove the Method.
|
|
*/
|
|
public void removeMethod() {
|
|
if (uriParms != null)
|
|
uriParms.delete(METHOD);
|
|
}
|
|
|
|
/** Sets the user of SipURI. The identifier of a particular resource at
|
|
* the host being addressed. The user and the user password including the
|
|
* "at" sign make up the user-info.
|
|
*
|
|
* @param uname The new String value of the user.
|
|
* @throws ParseException which signals that an error has been reached
|
|
* unexpectedly while parsing the user value.
|
|
*/
|
|
public void setUser(String uname) {
|
|
if (this.authority == null) {
|
|
this.authority = new Authority();
|
|
}
|
|
|
|
this.authority.setUser(uname);
|
|
}
|
|
|
|
/** Remove the user.
|
|
*/
|
|
public void removeUser() {
|
|
this.authority.removeUserInfo();
|
|
}
|
|
|
|
/** Set the default parameters for this URI.
|
|
* Do nothing if the parameter is already set to some value.
|
|
* Otherwise set it to the given value.
|
|
* @param name Name of the parameter to set.
|
|
* @param value value of the parameter to set.
|
|
*/
|
|
public void setDefaultParm(String name, Object value) {
|
|
if (uriParms.getValue(name) == null) {
|
|
NameValue nv = new NameValue(name, value);
|
|
uriParms.set(nv);
|
|
}
|
|
}
|
|
|
|
/** Set the authority member
|
|
* @param authority Authority to set.
|
|
*/
|
|
public void setAuthority(Authority authority) {
|
|
this.authority = authority;
|
|
}
|
|
|
|
/** Set the host for this URI.
|
|
* @param h host to set.
|
|
*/
|
|
public void setHost(Host h) {
|
|
if (this.authority == null)
|
|
this.authority = new Authority();
|
|
this.authority.setHost(h);
|
|
}
|
|
|
|
/** Set the uriParms member
|
|
* @param parms URI parameters to set.
|
|
*/
|
|
public void setUriParms(NameValueList parms) {
|
|
uriParms = parms;
|
|
}
|
|
|
|
/**
|
|
* Set a given URI parameter. Note - parameter must be properly
|
|
* encoded before the function is called.
|
|
* @param name Name of the parameter to set.
|
|
* @param value value of the parameter to set.
|
|
*/
|
|
public void setUriParm(String name, Object value) {
|
|
NameValue nv = new NameValue(name, value);
|
|
uriParms.set(nv);
|
|
}
|
|
|
|
/** Set the qheaders member
|
|
* @param parms query headers to set.
|
|
*/
|
|
public void setQheaders(NameValueList parms) {
|
|
qheaders = parms;
|
|
}
|
|
|
|
/**
|
|
* Set the MADDR parameter .
|
|
* @param mAddr Host Name to set
|
|
*/
|
|
public void setMAddr(String mAddr) {
|
|
NameValue nameValue = uriParms.getNameValue(MADDR);
|
|
Host host = new Host();
|
|
host.setAddress(mAddr);
|
|
if (nameValue != null)
|
|
nameValue.setValueAsObject(host);
|
|
else {
|
|
nameValue = new NameValue(MADDR, host);
|
|
uriParms.set(nameValue);
|
|
}
|
|
}
|
|
|
|
/** Sets the value of the user parameter. The user URI parameter exists to
|
|
* distinguish telephone numbers from user names that happen to look like
|
|
* telephone numbers. This is equivalent to setParameter("user", user).
|
|
*
|
|
* @param usertype New value String value of the method parameter
|
|
*/
|
|
public void setUserParam(String usertype) {
|
|
uriParms.set(USER, usertype);
|
|
}
|
|
|
|
/**
|
|
* Set the Method
|
|
* @param method method parameter
|
|
*/
|
|
public void setMethod(String method) {
|
|
uriParms.set(METHOD, method);
|
|
}
|
|
|
|
/**
|
|
* Sets ISDN subaddress of SipURL
|
|
* @param isdnSubAddress ISDN subaddress
|
|
*/
|
|
public void setIsdnSubAddress(String isdnSubAddress) {
|
|
if (telephoneSubscriber == null)
|
|
telephoneSubscriber = new TelephoneNumber();
|
|
telephoneSubscriber.setIsdnSubaddress(isdnSubAddress);
|
|
}
|
|
|
|
/**
|
|
* Set the telephone subscriber field.
|
|
* @param tel Telephone subscriber field to set.
|
|
*/
|
|
public void setTelephoneSubscriber(TelephoneNumber tel) {
|
|
telephoneSubscriber = tel;
|
|
}
|
|
|
|
/** set the port to a given value.
|
|
* @param p Port to set.
|
|
*/
|
|
public void setPort(int p) {
|
|
if (authority == null)
|
|
authority = new Authority();
|
|
authority.setPort(p);
|
|
}
|
|
|
|
/**
|
|
* Boolean to check if a parameter of a given name exists.
|
|
* @param name Name of the parameter to check on.
|
|
* @return a boolean indicating whether the parameter exists.
|
|
*/
|
|
public boolean hasParameter(String name) {
|
|
|
|
return uriParms.getValue(name) != null;
|
|
}
|
|
|
|
/**
|
|
* Set the query header when provided as a name-value pair.
|
|
* @param nameValue qeuery header provided as a name,value pair.
|
|
*/
|
|
public void setQHeader(NameValue nameValue) {
|
|
this.qheaders.set(nameValue);
|
|
}
|
|
|
|
/** Set the parameter as given.
|
|
*@param nameValue - parameter to set.
|
|
*/
|
|
public void setUriParameter(NameValue nameValue) {
|
|
this.uriParms.set(nameValue);
|
|
}
|
|
|
|
/** Return true if the transport parameter is defined.
|
|
* @return true if transport appears as a parameter and false otherwise.
|
|
*/
|
|
public boolean hasTransport() {
|
|
return hasParameter(TRANSPORT);
|
|
}
|
|
|
|
/**
|
|
* Remove a parameter given its name
|
|
* @param name -- name of the parameter to remove.
|
|
*/
|
|
public void removeParameter(String name) {
|
|
uriParms.delete(name);
|
|
}
|
|
|
|
/** Set the hostPort field of the imbedded authority field.
|
|
*@param hostPort is the hostPort to set.
|
|
*/
|
|
public void setHostPort(HostPort hostPort) {
|
|
if (this.authority == null) {
|
|
this.authority = new Authority();
|
|
}
|
|
authority.setHostPort(hostPort);
|
|
}
|
|
|
|
/** clone this.
|
|
*/
|
|
public Object clone() {
|
|
SipUri retval = (SipUri) super.clone();
|
|
if (this.authority != null)
|
|
retval.authority = (Authority) this.authority.clone();
|
|
if (this.uriParms != null)
|
|
retval.uriParms = (NameValueList) this.uriParms.clone();
|
|
if (this.qheaders != null)
|
|
retval.qheaders = (NameValueList) this.qheaders.clone();
|
|
if (this.telephoneSubscriber != null)
|
|
retval.telephoneSubscriber = (TelephoneNumber) this.telephoneSubscriber.clone();
|
|
return retval;
|
|
}
|
|
|
|
/**
|
|
* Returns the value of the named header, or null if it is not set.
|
|
* SIP/SIPS URIs may specify headers. As an example, the URI
|
|
* sip:joe@jcp.org?priority=urgent has a header "priority" whose
|
|
* value is "urgent".
|
|
*
|
|
* @param name name of header to retrieve
|
|
* @return the value of specified header
|
|
*/
|
|
public String getHeader(String name) {
|
|
return this.qheaders.getValue(name) != null
|
|
? this.qheaders.getValue(name).toString()
|
|
: null;
|
|
|
|
}
|
|
|
|
/**
|
|
* Returns an Iterator over the names (Strings) of all headers present
|
|
* in this SipURI.
|
|
*
|
|
* @return an Iterator over all the header names
|
|
*/
|
|
public Iterator<String> getHeaderNames() {
|
|
return this.qheaders.getNames();
|
|
|
|
}
|
|
|
|
/** Returns the value of the <code>lr</code> parameter, or null if this
|
|
* is not set. This is equivalent to getParameter("lr").
|
|
*
|
|
* @return the value of the <code>lr</code> parameter
|
|
*/
|
|
public String getLrParam() {
|
|
boolean haslr = this.hasParameter(LR);
|
|
return haslr ? "true" : null;
|
|
}
|
|
|
|
/** Returns the value of the <code>maddr</code> parameter, or null if this
|
|
* is not set. This is equivalent to getParameter("maddr").
|
|
*
|
|
* @return the value of the <code>maddr</code> parameter
|
|
*/
|
|
public String getMAddrParam() {
|
|
NameValue maddr = uriParms.getNameValue(MADDR);
|
|
if (maddr == null)
|
|
return null;
|
|
String host = (String) maddr.getValueAsObject();
|
|
return host;
|
|
}
|
|
|
|
/**
|
|
* Returns the value of the <code>method</code> parameter, or null if this
|
|
* is not set. This is equivalent to getParameter("method").
|
|
*
|
|
* @return the value of the <code>method</code> parameter
|
|
*/
|
|
public String getMethodParam() {
|
|
return this.getParameter(METHOD);
|
|
}
|
|
|
|
/**
|
|
* Returns the value of the named parameter, or null if it is not set. A
|
|
* zero-length String indicates flag parameter.
|
|
*
|
|
* @param name name of parameter to retrieve
|
|
* @return the value of specified parameter
|
|
*/
|
|
public String getParameter(String name) {
|
|
Object val = uriParms.getValue(name);
|
|
if (val == null)
|
|
return null;
|
|
if (val instanceof GenericObject)
|
|
return ((GenericObject) val).encode();
|
|
else
|
|
return val.toString();
|
|
}
|
|
|
|
/**
|
|
* Returns an Iterator over the names (Strings) of all parameters present
|
|
*
|
|
* in this ParametersHeader.
|
|
*
|
|
*
|
|
*
|
|
* @return an Iterator over all the parameter names
|
|
*
|
|
*/
|
|
public Iterator<String> getParameterNames() {
|
|
return this.uriParms.getNames();
|
|
}
|
|
|
|
/** Returns the value of the "ttl" parameter, or -1 if this is not set.
|
|
* This method is equivalent to getParameter("ttl").
|
|
*
|
|
* @return the value of the <code>ttl</code> parameter
|
|
*/
|
|
public int getTTLParam() {
|
|
Integer ttl = (Integer) uriParms.getValue("ttl");
|
|
if (ttl != null)
|
|
return ttl.intValue();
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
/** Returns the value of the "transport" parameter, or null if this is not
|
|
* set. This is equivalent to getParameter("transport").
|
|
*
|
|
* @return the transport paramter of the SipURI
|
|
*/
|
|
public String getTransportParam() {
|
|
if (uriParms != null) {
|
|
return (String) uriParms.getValue(TRANSPORT);
|
|
} else
|
|
return null;
|
|
}
|
|
|
|
/** Returns the value of the <code>userParam</code>,
|
|
*or null if this is not set.
|
|
* <p>
|
|
* This is equivalent to getParameter("user").
|
|
*
|
|
* @return the value of the <code>userParam</code> of the SipURI
|
|
*/
|
|
public String getUser() {
|
|
return authority.getUser();
|
|
}
|
|
|
|
/** Returns true if this SipURI is secure i.e. if this SipURI represents a
|
|
* sips URI. A sip URI returns false.
|
|
*
|
|
* @return <code>true</code> if this SipURI represents a sips URI, and
|
|
* <code>false</code> if it represents a sip URI.
|
|
*/
|
|
public boolean isSecure() {
|
|
return this.getScheme().equalsIgnoreCase(SIPS);
|
|
}
|
|
|
|
/** This method determines if this is a URI with a scheme of "sip" or "sips".
|
|
*
|
|
* @return true if the scheme is "sip" or "sips", false otherwise.
|
|
*/
|
|
public boolean isSipURI() {
|
|
return true;
|
|
}
|
|
|
|
/** Sets the value of the specified header fields to be included in a
|
|
* request constructed from the URI. If the header already had a value it
|
|
* will be overwritten.
|
|
*
|
|
* @param name - a String specifying the header name
|
|
* @param value - a String specifying the header value
|
|
*/
|
|
public void setHeader(String name, String value) {
|
|
NameValue nv = new NameValue(name, value);
|
|
qheaders.set(nv);
|
|
|
|
}
|
|
|
|
/**
|
|
* Set the host portion of the SipURI
|
|
*
|
|
* @param host host to set.
|
|
*/
|
|
public void setHost(String host) throws ParseException {
|
|
Host h = new Host(host);
|
|
this.setHost(h);
|
|
}
|
|
|
|
/** Sets the value of the <code>lr</code> parameter of this SipURI. The lr
|
|
* parameter, when present, indicates that the element responsible for
|
|
* this resource implements the routing mechanisms specified in RFC 3261.
|
|
* This parameter will be used in the URIs proxies place in the
|
|
* Record-Route header field values, and may appear in the URIs in a
|
|
* pre-existing route set.
|
|
*/
|
|
public void setLrParam() {
|
|
this.uriParms.set("lr",null); // JvB: fixed to not add duplicates
|
|
}
|
|
|
|
/**
|
|
* Sets the value of the <code>maddr</code> parameter of this SipURI. The
|
|
* maddr parameter indicates the server address to be contacted for this
|
|
* user, overriding any address derived from the host field. This is
|
|
* equivalent to setParameter("maddr", maddr).
|
|
*
|
|
* @param maddr New value of the <code>maddr</code> parameter
|
|
*/
|
|
public void setMAddrParam(String maddr) throws ParseException {
|
|
if (maddr == null)
|
|
throw new NullPointerException("bad maddr");
|
|
setParameter("maddr", maddr);
|
|
}
|
|
|
|
/** Sets the value of the <code>method</code> parameter. This specifies
|
|
* which SIP method to use in requests directed at this URI. This is
|
|
* equivalent to setParameter("method", method).
|
|
*
|
|
* @param method - new value String value of the method parameter
|
|
*/
|
|
public void setMethodParam(String method) throws ParseException {
|
|
setParameter("method", method);
|
|
}
|
|
|
|
/**
|
|
* Sets the value of the specified parameter. If the parameter already had
|
|
*
|
|
* a value it will be overwritten. A zero-length String indicates flag
|
|
*
|
|
* parameter.
|
|
*
|
|
*
|
|
*
|
|
* @param name - a String specifying the parameter name
|
|
*
|
|
* @param value - a String specifying the parameter value
|
|
*
|
|
* @throws ParseException which signals that an error has been reached
|
|
*
|
|
* unexpectedly while parsing the parameter name or value.
|
|
*
|
|
*/
|
|
public void setParameter(String name, String value) throws ParseException {
|
|
if (name.equalsIgnoreCase("ttl")) {
|
|
try {
|
|
Integer.parseInt(value);
|
|
} catch (NumberFormatException ex) {
|
|
throw new ParseException("bad parameter " + value, 0);
|
|
}
|
|
}
|
|
uriParms.set(name,value);
|
|
}
|
|
|
|
/** Sets the scheme of this URI to sip or sips depending on whether the
|
|
* argument is true or false. The default value is false.
|
|
*
|
|
* @param secure - the boolean value indicating if the SipURI is secure.
|
|
*/
|
|
public void setSecure(boolean secure) {
|
|
if (secure)
|
|
this.scheme = SIPS;
|
|
else
|
|
this.scheme = SIP;
|
|
}
|
|
|
|
/** Sets the value of the <code>ttl</code> parameter. The ttl parameter
|
|
* specifies the time-to-live value when packets are sent using UDP
|
|
* multicast. This is equivalent to setParameter("ttl", ttl).
|
|
*
|
|
* @param ttl - new value of the <code>ttl</code> parameter
|
|
*/
|
|
public void setTTLParam(int ttl) {
|
|
if (ttl <= 0)
|
|
throw new IllegalArgumentException("Bad ttl value");
|
|
if (uriParms != null) {
|
|
NameValue nv = new NameValue("ttl", Integer.valueOf(ttl));
|
|
uriParms.set(nv);
|
|
}
|
|
}
|
|
|
|
/** Sets the value of the "transport" parameter. This parameter specifies
|
|
* which transport protocol to use for sending requests and responses to
|
|
* this entity. The following values are defined: "udp", "tcp", "sctp",
|
|
* "tls", but other values may be used also. This method is equivalent to
|
|
* setParameter("transport", transport). Transport parameter constants
|
|
* are defined in the {@link javax.sip.ListeningPoint}.
|
|
*
|
|
* @param transport - new value for the "transport" parameter
|
|
* @see javax.sip.ListeningPoint
|
|
*/
|
|
public void setTransportParam(String transport) throws ParseException {
|
|
if (transport == null)
|
|
throw new NullPointerException("null arg");
|
|
if (transport.compareToIgnoreCase("UDP") == 0
|
|
|| transport.compareToIgnoreCase("TLS") == 0
|
|
|| transport.compareToIgnoreCase("TCP") == 0
|
|
|| transport.compareToIgnoreCase("SCTP") == 0) {
|
|
NameValue nv = new NameValue(TRANSPORT, transport.toLowerCase());
|
|
uriParms.set(nv);
|
|
} else
|
|
throw new ParseException("bad transport " + transport, 0);
|
|
}
|
|
|
|
/** Returns the user part of this SipURI, or null if it is not set.
|
|
*
|
|
* @return the user part of this SipURI
|
|
*/
|
|
public String getUserParam() {
|
|
return getParameter("user");
|
|
|
|
}
|
|
|
|
/** Returns whether the the <code>lr</code> parameter is set. This is
|
|
* equivalent to hasParameter("lr"). This interface has no getLrParam as
|
|
* RFC3261 does not specify any values for the "lr" paramater.
|
|
*
|
|
* @return true if the "lr" parameter is set, false otherwise.
|
|
*/
|
|
public boolean hasLrParam() {
|
|
return uriParms.getNameValue("lr") != null;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns whether the <code>gr</code> parameter is set.
|
|
*
|
|
* Not part on the interface since gruu is not part of the base RFC3261.
|
|
*/
|
|
public boolean hasGrParam() {
|
|
return uriParms.getNameValue(GRUU) != null;
|
|
}
|
|
|
|
/**
|
|
* Sets the <code>gr</code> parameter.
|
|
*
|
|
* Not part on the interface since gruu is not part of the base RFC3261.
|
|
*/
|
|
public void setGrParam(String value) {
|
|
this.uriParms.set(GRUU, value); // JvB: fixed to not add duplicates
|
|
}
|
|
|
|
/**
|
|
* Sets the <code>gr</code> parameter.
|
|
*
|
|
* Not part on the interface since gruu is not part of the base RFC3261.
|
|
*/
|
|
public String getGrParam() {
|
|
return (String) this.uriParms.getValue(GRUU); // JvB: fixed to not add duplicates
|
|
}
|
|
|
|
/**
|
|
*remove the +sip-instance value from the parameter list if it exists.
|
|
*/
|
|
|
|
}
|