gov.nist.javax.sip.message.SIPRequest Maven / Gradle / Ivy
/*
* 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.message;
import gov.nist.javax.sip.address.*;
import gov.nist.core.*;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.Set;
import java.io.UnsupportedEncodingException;
import java.util.Iterator;
import javax.sip.address.URI;
import javax.sip.message.*;
import java.text.ParseException;
import javax.sip.*;
import javax.sip.header.*;
import gov.nist.javax.sip.header.*;
/*
* Acknowledgements: Mark Bednarek made a few fixes to this code. Jeff Keyser
* added two methods that create responses and generate cancel requests from
* incoming orignial requests without the additional overhead of encoding and
* decoding messages. Bruno Konik noticed an extraneous newline added to the end
* of the buffer when encoding it. Incorporates a bug report from Andreas
* Bystr�m. Szabo Barna noticed a contact in a cancel request - this is a
* pointless header for cancel. Antonis Kyardis contributed bug fixes. Jeroen
* van Bemmel noted that method names are case sensitive, should use equals() in
* getting CannonicalName
*
*/
/**
* The SIP Request structure.
*
* @version 1.2 $Revision: 1.38 $ $Date: 2008/10/02 21:14:22 $
* @since 1.1
*
* @author M. Ranganathan
*
*
*
*/
public final class SIPRequest extends SIPMessage implements
javax.sip.message.Request {
private static final long serialVersionUID = 3360720013577322927L;
private static final String DEFAULT_USER = "ip";
private static final String DEFAULT_TRANSPORT = "udp";
private transient Object transactionPointer;
private RequestLine requestLine;
private transient Object messageChannel;
private Object inviteTransaction; // The original invite request for a
// given cancel request
/**
* Set of target refresh methods, currently: INVITE, UPDATE, SUBSCRIBE,
* NOTIFY, REFER
*
* A target refresh request and its response MUST have a Contact
*/
private static final Set targetRefreshMethods = new HashSet();
/*
* A table that maps a name string to its cannonical constant. This is used
* to speed up parsing of messages .equals reduces to == if we use the
* constant value.
*/
private static final Hashtable nameTable = new Hashtable();
private static void putName(String name) {
nameTable.put(name, name);
}
static {
targetRefreshMethods.add(Request.INVITE);
targetRefreshMethods.add(Request.UPDATE);
targetRefreshMethods.add(Request.SUBSCRIBE);
targetRefreshMethods.add(Request.NOTIFY);
targetRefreshMethods.add(Request.REFER);
putName(Request.INVITE);
putName(Request.BYE);
putName(Request.CANCEL);
putName(Request.ACK);
putName(Request.PRACK);
putName(Request.INFO);
putName(Request.MESSAGE);
putName(Request.NOTIFY);
putName(Request.OPTIONS);
putName(Request.PRACK);
putName(Request.PUBLISH);
putName(Request.REFER);
putName(Request.REGISTER);
putName(Request.SUBSCRIBE);
putName(Request.UPDATE);
}
/**
* @return true iff the method is a target refresh
*/
public static boolean isTargetRefresh(String ucaseMethod) {
return targetRefreshMethods.contains(ucaseMethod);
}
/**
* Set to standard constants to speed up processing. this makes equals
* comparisons run much faster in the stack because then it is just identity
* comparision. Character by char comparison is not required. The method
* returns the String CONSTANT corresponding to the String name.
*
*/
public static String getCannonicalName(String method) {
if (nameTable.containsKey(method))
return (String) nameTable.get(method);
else
return method;
}
/**
* Get the Request Line of the SIPRequest.
*
* @return the request line of the SIP Request.
*/
public RequestLine getRequestLine() {
return requestLine;
}
/**
* Set the request line of the SIP Request.
*
* @param requestLine
* is the request line to set in the SIP Request.
*/
public void setRequestLine(RequestLine requestLine) {
this.requestLine = requestLine;
}
/**
* Constructor.
*/
public SIPRequest() {
super();
}
/**
* Convert to a formatted string for pretty printing. Note that the encode
* method converts this into a sip message that is suitable for
* transmission. Note hack here if you want to convert the nice curly
* brackets into some grotesque XML tag.
*
* @return a string which can be used to examine the message contents.
*
*/
public String debugDump() {
String superstring = super.debugDump();
stringRepresentation = "";
sprint(SIPRequest.class.getName());
sprint("{");
if (requestLine != null)
sprint(requestLine.debugDump());
sprint(superstring);
sprint("}");
return stringRepresentation;
}
/**
* Check header for constraints. (1) Invite options and bye requests can
* only have SIP URIs in the contact headers. (2) Request must have cseq, to
* and from and via headers. (3) Method in request URI must match that in
* CSEQ.
*/
public void checkHeaders() throws ParseException {
String prefix = "Missing a required header : ";
/* Check for required headers */
if (getCSeq() == null) {
throw new ParseException(prefix + CSeqHeader.NAME, 0);
}
if (getTo() == null) {
throw new ParseException(prefix + ToHeader.NAME, 0);
}
if (this.callIdHeader == null || this.callIdHeader.getCallId() == null
|| callIdHeader.getCallId().equals("")) {
throw new ParseException(prefix + CallIdHeader.NAME, 0);
}
if (getFrom() == null) {
throw new ParseException(prefix + FromHeader.NAME, 0);
}
if (getViaHeaders() == null) {
throw new ParseException(prefix + ViaHeader.NAME, 0);
}
if (getMaxForwards() == null) {
throw new ParseException(prefix + MaxForwardsHeader.NAME, 0);
}
if (getTopmostVia() == null)
throw new ParseException("No via header in request! ", 0);
if (getMethod().equals(Request.NOTIFY)) {
if (getHeader(SubscriptionStateHeader.NAME) == null)
throw new ParseException(prefix + SubscriptionStateHeader.NAME,
0);
if (getHeader(EventHeader.NAME) == null)
throw new ParseException(prefix + EventHeader.NAME, 0);
} else if (getMethod().equals(Request.PUBLISH)) {
/*
* For determining the type of the published event state, the EPA
* MUST include a single Event header field in PUBLISH requests. The
* value of this header field indicates the event package for which
* this request is publishing event state.
*/
if (getHeader(EventHeader.NAME) == null)
throw new ParseException(prefix + EventHeader.NAME, 0);
}
/*
* RFC 3261 8.1.1.8 The Contact header field MUST be present and contain
* exactly one SIP or SIPS URI in any request that can result in the
* establishment of a dialog. For the methods defined in this
* specification, that includes only the INVITE request. For these
* requests, the scope of the Contact is global. That is, the Contact
* header field value contains the URI at which the UA would like to
* receive requests, and this URI MUST be valid even if used in
* subsequent requests outside of any dialogs.
*
* If the Request-URI or top Route header field value contains a SIPS
* URI, the Contact header field MUST contain a SIPS URI as well.
*/
if (requestLine.getMethod().equals(Request.INVITE)
|| requestLine.getMethod().equals(Request.SUBSCRIBE)
|| requestLine.getMethod().equals(Request.REFER)) {
if (this.getContactHeader() == null) {
// Make sure this is not a target refresh. If this is a target
// refresh its ok not to have a contact header. Otherwise
// contact header is mandatory.
if (this.getToTag() == null)
throw new ParseException(prefix + ContactHeader.NAME, 0);
}
if (requestLine.getUri() instanceof SipUri) {
String scheme = ((SipUri) requestLine.getUri()).getScheme();
if ("sips".equalsIgnoreCase(scheme)) {
SipUri sipUri = (SipUri) this.getContactHeader()
.getAddress().getURI();
if (!sipUri.getScheme().equals("sips")) {
throw new ParseException(
"Scheme for contact should be sips:" + sipUri,
0);
}
}
}
}
/*
* Contact header is mandatory for a SIP INVITE request.
*/
if (this.getContactHeader() == null
&& (this.getMethod().equals(Request.INVITE)
|| this.getMethod().equals(Request.REFER) || this
.getMethod().equals(Request.SUBSCRIBE))) {
throw new ParseException(
"Contact Header is Mandatory for a SIP INVITE", 0);
}
if (requestLine != null
&& requestLine.getMethod() != null
&& getCSeq().getMethod() != null
&& requestLine.getMethod().compareTo(getCSeq().getMethod()) != 0) {
throw new ParseException(
"CSEQ method mismatch with Request-Line ", 0);
}
}
/**
* Set the default values in the request URI if necessary.
*/
protected void setDefaults() {
// The request line may be unparseable (set to null by the
// exception handler.
if (requestLine == null)
return;
String method = requestLine.getMethod();
// The requestLine may be malformed!
if (method == null)
return;
GenericURI u = requestLine.getUri();
if (u == null)
return;
if (method.compareTo(Request.REGISTER) == 0
|| method.compareTo(Request.INVITE) == 0) {
if (u instanceof SipUri) {
SipUri sipUri = (SipUri) u;
sipUri.setUserParam(DEFAULT_USER);
try {
sipUri.setTransportParam(DEFAULT_TRANSPORT);
} catch (ParseException ex) {
}
}
}
}
/**
* Patch up the request line as necessary.
*/
protected void setRequestLineDefaults() {
String method = requestLine.getMethod();
if (method == null) {
CSeq cseq = (CSeq) this.getCSeq();
if (cseq != null) {
method = getCannonicalName(cseq.getMethod());
requestLine.setMethod(method);
}
}
}
/**
* A conveniance function to access the Request URI.
*
* @return the requestURI if it exists.
*/
public javax.sip.address.URI getRequestURI() {
if (this.requestLine == null)
return null;
else
return (javax.sip.address.URI) this.requestLine.getUri();
}
/**
* Sets the RequestURI of Request. The Request-URI is a SIP or SIPS URI or a
* general URI. It indicates the user or service to which this request is
* being addressed. SIP elements MAY support Request-URIs with schemes other
* than "sip" and "sips", for example the "tel" URI scheme. SIP elements MAY
* translate non-SIP URIs using any mechanism at their disposal, resulting
* in SIP URI, SIPS URI, or some other scheme.
*
* @param uri
* the new Request URI of this request message
*/
public void setRequestURI(URI uri) {
if (this.requestLine == null) {
this.requestLine = new RequestLine();
}
this.requestLine.setUri((GenericURI) uri);
}
/**
* Set the method.
*
* @param method
* is the method to set.
* @throws IllegalArgumentException
* if the method is null
*/
public void setMethod(String method) {
if (method == null)
throw new IllegalArgumentException("null method");
if (this.requestLine == null) {
this.requestLine = new RequestLine();
}
// Set to standard constants to speed up processing.
// this makes equals compares run much faster in the
// stack because then it is just identity comparision
String meth = getCannonicalName(method);
this.requestLine.setMethod(meth);
if (this.cSeqHeader != null) {
try {
this.cSeqHeader.setMethod(meth);
} catch (ParseException e) {
}
}
}
/**
* Get the method from the request line.
*
* @return the method from the request line if the method exits and null if
* the request line or the method does not exist.
*/
public String getMethod() {
if (requestLine == null)
return null;
else
return requestLine.getMethod();
}
/**
* Encode the SIP Request as a string.
*
* @return an encoded String containing the encoded SIP Message.
*/
public String encode() {
String retval;
if (requestLine != null) {
this.setRequestLineDefaults();
retval = requestLine.encode() + super.encode();
} else
retval = super.encode();
return retval;
}
/**
* Encode only the headers and not the content.
*/
public String encodeMessage() {
String retval;
if (requestLine != null) {
this.setRequestLineDefaults();
retval = requestLine.encode() + super.encodeSIPHeaders();
} else
retval = super.encodeSIPHeaders();
return retval;
}
/**
* ALias for encode above.
*/
public String toString() {
return this.encode();
}
/**
* Make a clone (deep copy) of this object. You can use this if you want to
* modify a request while preserving the original
*
* @return a deep copy of this object.
*/
public Object clone() {
SIPRequest retval = (SIPRequest) super.clone();
// Do not copy over the tx pointer -- this is only for internal
// tracking.
retval.transactionPointer = null;
if (this.requestLine != null)
retval.requestLine = (RequestLine) this.requestLine.clone();
return retval;
}
/**
* Compare for equality.
*
* @param other
* object to compare ourselves with.
*/
public boolean equals(Object other) {
if (!this.getClass().equals(other.getClass()))
return false;
SIPRequest that = (SIPRequest) other;
return requestLine.equals(that.requestLine) && super.equals(other);
}
/**
* Get the message as a linked list of strings. Use this if you want to
* iterate through the message.
*
* @return a linked list containing the request line and headers encoded as
* strings.
*/
public LinkedList getMessageAsEncodedStrings() {
LinkedList retval = super.getMessageAsEncodedStrings();
if (requestLine != null) {
this.setRequestLineDefaults();
retval.addFirst(requestLine.encode());
}
return retval;
}
/**
* Match with a template. You can use this if you want to match incoming
* messages with a pattern and do something when you find a match. This is
* useful for building filters/pattern matching responders etc.
*
* @param matchObj
* object to match ourselves with (null matches wildcard)
*
*/
public boolean match(Object matchObj) {
if (matchObj == null)
return true;
else if (!matchObj.getClass().equals(this.getClass()))
return false;
else if (matchObj == this)
return true;
SIPRequest that = (SIPRequest) matchObj;
RequestLine rline = that.requestLine;
if (this.requestLine == null && rline != null)
return false;
else if (this.requestLine == rline)
return super.match(matchObj);
return requestLine.match(that.requestLine) && super.match(matchObj);
}
/**
* Get a dialog identifier. Generates a string that can be used as a dialog
* identifier.
*
* @param isServer
* is set to true if this is the UAS and set to false if this is
* the UAC
*/
public String getDialogId(boolean isServer) {
CallID cid = (CallID) this.getCallId();
StringBuffer retval = new StringBuffer(cid.getCallId());
From from = (From) this.getFrom();
To to = (To) this.getTo();
if (!isServer) {
// retval.append(COLON).append(from.getUserAtHostPort());
if (from.getTag() != null) {
retval.append(COLON);
retval.append(from.getTag());
}
// retval.append(COLON).append(to.getUserAtHostPort());
if (to.getTag() != null) {
retval.append(COLON);
retval.append(to.getTag());
}
} else {
// retval.append(COLON).append(to.getUserAtHostPort());
if (to.getTag() != null) {
retval.append(COLON);
retval.append(to.getTag());
}
// retval.append(COLON).append(from.getUserAtHostPort());
if (from.getTag() != null) {
retval.append(COLON);
retval.append(from.getTag());
}
}
return retval.toString().toLowerCase();
}
/**
* Get a dialog id given the remote tag.
*/
public String getDialogId(boolean isServer, String toTag) {
From from = (From) this.getFrom();
CallID cid = (CallID) this.getCallId();
StringBuffer retval = new StringBuffer(cid.getCallId());
if (!isServer) {
// retval.append(COLON).append(from.getUserAtHostPort());
if (from.getTag() != null) {
retval.append(COLON);
retval.append(from.getTag());
}
// retval.append(COLON).append(to.getUserAtHostPort());
if (toTag != null) {
retval.append(COLON);
retval.append(toTag);
}
} else {
// retval.append(COLON).append(to.getUserAtHostPort());
if (toTag != null) {
retval.append(COLON);
retval.append(toTag);
}
// retval.append(COLON).append(from.getUserAtHostPort());
if (from.getTag() != null) {
retval.append(COLON);
retval.append(from.getTag());
}
}
return retval.toString().toLowerCase();
}
/**
* Encode this into a byte array. This is used when the body has been set as
* a binary array and you want to encode the body as a byte array for
* transmission.
*
* @return a byte array containing the SIPRequest encoded as a byte array.
*/
public byte[] encodeAsBytes( String transport ) {
if (this.requestLine == null) {
// Encoding a null message. Return 0 byte array.
return new byte[0];
}
byte[] rlbytes = null;
if (requestLine != null) {
try {
rlbytes = requestLine.encode().getBytes("UTF-8");
} catch (UnsupportedEncodingException ex) {
InternalErrorHandler.handleException(ex);
}
}
byte[] superbytes = super.encodeAsBytes( transport );
byte[] retval = new byte[rlbytes.length + superbytes.length];
System.arraycopy(rlbytes, 0, retval, 0, rlbytes.length);
System.arraycopy(superbytes, 0, retval, rlbytes.length,
superbytes.length);
return retval;
}
/**
* Creates a default SIPResponse message for this request. Note You must add
* the necessary tags to outgoing responses if need be. For efficiency, this
* method does not clone the incoming request. If you want to modify the
* outgoing response, be sure to clone the incoming request as the headers
* are shared and any modification to the headers of the outgoing response
* will result in a modification of the incoming request. Tag fields are
* just copied from the incoming request. Contact headers are removed from
* the incoming request. Added by Jeff Keyser.
*
* @param statusCode
* Status code for the response. Reason phrase is generated.
*
* @return A SIPResponse with the status and reason supplied, and a copy of
* all the original headers from this request.
*/
public SIPResponse createResponse(int statusCode) {
String reasonPhrase = SIPResponse.getReasonPhrase(statusCode);
return this.createResponse(statusCode, reasonPhrase);
}
/**
* Creates a default SIPResponse message for this request. Note You must add
* the necessary tags to outgoing responses if need be. For efficiency, this
* method does not clone the incoming request. If you want to modify the
* outgoing response, be sure to clone the incoming request as the headers
* are shared and any modification to the headers of the outgoing response
* will result in a modification of the incoming request. Tag fields are
* just copied from the incoming request. Contact headers are removed from
* the incoming request. Added by Jeff Keyser. Route headers are not added
* to the response.
*
* @param statusCode
* Status code for the response.
* @param reasonPhrase
* Reason phrase for this response.
*
* @return A SIPResponse with the status and reason supplied, and a copy of
* all the original headers from this request except the ones that
* are not supposed to be part of the response .
*/
public SIPResponse createResponse(int statusCode, String reasonPhrase) {
SIPResponse newResponse;
Iterator headerIterator;
SIPHeader nextHeader;
newResponse = new SIPResponse();
try {
newResponse.setStatusCode(statusCode);
} catch (ParseException ex) {
throw new IllegalArgumentException("Bad code " + statusCode);
}
if (reasonPhrase != null)
newResponse.setReasonPhrase(reasonPhrase);
else
newResponse
.setReasonPhrase(SIPResponse.getReasonPhrase(statusCode));
headerIterator = getHeaders();
while (headerIterator.hasNext()) {
nextHeader = (SIPHeader) headerIterator.next();
if (nextHeader instanceof From
|| nextHeader instanceof To
|| nextHeader instanceof ViaList
|| nextHeader instanceof CallID
|| (statusCode / 100 <= 2 && statusCode != 100 && nextHeader instanceof RecordRouteList)
// No record routing for error and 100 (only applies to 100 not all 1xx)
|| nextHeader instanceof CSeq
// We just copy TimeStamp for all headers (not just 100).
|| nextHeader instanceof TimeStamp) {
try {
newResponse.attachHeader((SIPHeader) nextHeader.clone(),
false);
} catch (SIPDuplicateHeaderException e) {
e.printStackTrace();
}
}
}
if (MessageFactoryImpl.getUserAgentHeader() != null ) {
newResponse.setHeader(MessageFactoryImpl.getUserAgentHeader());
}
if (newResponse.getStatusCode() == 100) {
// Trying is never supposed to have the tag parameter set.
newResponse.getTo().removeParameter("tag");
}
return newResponse;
}
/**
* Creates a default SIPResquest message that would cancel this request.
* Note that tag assignment and removal of is left to the caller (we use
* whatever tags are present in the original request).
*
* @return A CANCEL SIPRequest constructed according to RFC3261 section 9.1
*
* @throws SipException
* @throws ParseException
*/
public SIPRequest createCancelRequest() throws SipException {
// see RFC3261 9.1
// A CANCEL request SHOULD NOT be sent to cancel a request other than
// INVITE
if ( !this.getMethod().equals(Request.INVITE) )
throw new SipException("Attempt to create CANCEL for " + this.getMethod());
/*
* The following procedures are used to construct a CANCEL request. The
* Request-URI, Call-ID, To, the numeric part of CSeq, and From header
* fields in the CANCEL request MUST be identical to those in the
* request being cancelled, including tags. A CANCEL constructed by a
* client MUST have only a single Via header field value matching the
* top Via value in the request being cancelled. Using the same values
* for these header fields allows the CANCEL to be matched with the
* request it cancels (Section 9.2 indicates how such matching occurs).
* However, the method part of the CSeq header field MUST have a value
* of CANCEL. This allows it to be identified and processed as a
* transaction in its own right (See Section 17).
*/
SIPRequest cancel = new SIPRequest();
cancel.setRequestLine((RequestLine) this.requestLine.clone());
cancel.setMethod(Request.CANCEL);
cancel.setHeader((Header) this.callIdHeader.clone());
cancel.setHeader((Header) this.toHeader.clone());
cancel.setHeader((Header) cSeqHeader.clone());
try {
cancel.getCSeq().setMethod(Request.CANCEL);
} catch (ParseException e) {
e.printStackTrace(); // should not happen
}
cancel.setHeader((Header) this.fromHeader.clone());
cancel.addFirst((Header) this.getTopmostVia().clone());
cancel.setHeader((Header) this.maxForwardsHeader.clone());
/*
* If the request being cancelled contains a Route header field, the
* CANCEL request MUST include that Route header field's values.
*/
if (this.getRouteHeaders() != null) {
cancel.setHeader((SIPHeaderList) this.getRouteHeaders().clone());
}
if (MessageFactoryImpl.getUserAgentHeader() != null ) {
cancel.setHeader(MessageFactoryImpl.getUserAgentHeader());
}
return cancel;
}
/**
* Creates a default ACK SIPRequest message for this original request. Note
* that the defaultACK SIPRequest does not include the content of the
* original SIPRequest. If responseToHeader is null then the toHeader of
* this request is used to construct the ACK. Note that tag fields are just
* copied from the original SIP Request. Added by Jeff Keyser.
*
* @param responseToHeader
* To header to use for this request.
*
* @return A SIPRequest with an ACK method.
*/
public SIPRequest createAckRequest(To responseToHeader) {
SIPRequest newRequest;
Iterator headerIterator;
SIPHeader nextHeader;
newRequest = new SIPRequest();
newRequest.setRequestLine((RequestLine) this.requestLine.clone());
newRequest.setMethod(Request.ACK);
headerIterator = getHeaders();
while (headerIterator.hasNext()) {
nextHeader = (SIPHeader) headerIterator.next();
if (nextHeader instanceof RouteList) {
// Ack and cancel do not get ROUTE headers.
// Route header for ACK is assigned by the
// Dialog if necessary.
continue;
} else if (nextHeader instanceof ProxyAuthorization) {
// Remove proxy auth header.
// Assigned by the Dialog if necessary.
continue;
} else if (nextHeader instanceof ContentLength) {
// Adding content is responsibility of user.
nextHeader = (SIPHeader) nextHeader.clone();
try {
((ContentLength) nextHeader).setContentLength(0);
} catch (InvalidArgumentException e) {
}
} else if (nextHeader instanceof ContentType) {
// Content type header is removed since
// content length is 0.
continue;
} else if (nextHeader instanceof CSeq) {
// The CSeq header field in the
// ACK MUST contain the same value for the
// sequence number as was present in the
// original request, but the method parameter
// MUST be equal to "ACK".
CSeq cseq = (CSeq) nextHeader.clone();
try {
cseq.setMethod(Request.ACK);
} catch (ParseException e) {
}
nextHeader = cseq;
} else if (nextHeader instanceof To) {
if (responseToHeader != null) {
nextHeader = responseToHeader;
} else {
nextHeader = (SIPHeader) nextHeader.clone();
}
} else if (nextHeader instanceof ContactList
|| nextHeader instanceof Expires) {
// CONTACT header does not apply for ACK requests.
continue;
} else if (nextHeader instanceof ViaList) {
// Bug reported by Gianluca Martinello
// The ACK MUST contain a single Via header field,
// and this MUST be equal to the top Via header
// field of the original
// request.
nextHeader = (SIPHeader) ((ViaList) nextHeader).getFirst()
.clone();
} else {
nextHeader = (SIPHeader) nextHeader.clone();
}
try {
newRequest.attachHeader(nextHeader, false);
} catch (SIPDuplicateHeaderException e) {
e.printStackTrace();
}
}
if (MessageFactoryImpl.getUserAgentHeader() != null ) {
newRequest.setHeader(MessageFactoryImpl.getUserAgentHeader());
}
return newRequest;
}
/**
* Creates an ACK for non-2xx responses according to RFC3261 17.1.1.3
*
* @return A SIPRequest with an ACK method.
* @throws SipException
* @throws NullPointerException
* @throws ParseException
*
* @author jvb
*/
public final SIPRequest createErrorAck(To responseToHeader)
throws SipException, ParseException {
/*
* The ACK request constructed by the client transaction MUST contain
* values for the Call-ID, From, and Request-URI that are equal to the
* values of those header fields in the request passed to the transport
* by the client transaction (call this the "original request"). The To
* header field in the ACK MUST equal the To header field in the
* response being acknowledged, and therefore will usually differ from
* the To header field in the original request by the addition of the
* tag parameter. The ACK MUST contain a single Via header field, and
* this MUST be equal to the top Via header field of the original
* request. The CSeq header field in the ACK MUST contain the same value
* for the sequence number as was present in the original request, but
* the method parameter MUST be equal to "ACK".
*/
SIPRequest newRequest = new SIPRequest();
newRequest.setRequestLine((RequestLine) this.requestLine.clone());
newRequest.setMethod(Request.ACK);
newRequest.setHeader((Header) this.callIdHeader.clone());
newRequest.setHeader((Header) this.maxForwardsHeader.clone()); // ISSUE
// 130
// fix
newRequest.setHeader((Header) this.fromHeader.clone());
newRequest.setHeader((Header) responseToHeader.clone());
newRequest.addFirst((Header) this.getTopmostVia().clone());
newRequest.setHeader((Header) cSeqHeader.clone());
newRequest.getCSeq().setMethod(Request.ACK);
/*
* If the INVITE request whose response is being acknowledged had Route
* header fields, those header fields MUST appear in the ACK. This is to
* ensure that the ACK can be routed properly through any downstream
* stateless proxies.
*/
if (this.getRouteHeaders() != null) {
newRequest
.setHeader((SIPHeaderList) this.getRouteHeaders().clone());
}
if (MessageFactoryImpl.getUserAgentHeader() != null ) {
newRequest.setHeader(MessageFactoryImpl.getUserAgentHeader());
}
return newRequest;
}
/**
* Create a new default SIPRequest from the original request. Warning: the
* newly created SIPRequest, shares the headers of this request but we
* generate any new headers that we need to modify so the original request
* is umodified. However, if you modify the shared headers after this
* request is created, then the newly created request will also be modified.
* If you want to modify the original request without affecting the returned
* Request make sure you clone it before calling this method.
*
* Only required headers are copied.
*
* - Contact headers are not included in the newly created request.
* Setting the appropriate sequence number is the responsibility of the
* caller.
* - RouteList is not copied for ACK and CANCEL
* - Note that we DO NOT copy the body of the argument into the returned
* header. We do not copy the content type header from the original request
* either. These have to be added seperately and the content length has to
* be correctly set if necessary the content length is set to 0 in the
* returned header.
* - Contact List is not copied from the original request.
* - RecordRoute List is not included from original request.
* - Via header is not included from the original request.
*
*
* @param requestLine
* is the new request line.
*
* @param switchHeaders
* is a boolean flag that causes to and from headers to switch
* (set this to true if you are the server of the transaction and
* are generating a BYE request). If the headers are switched, we
* generate new From and To headers otherwise we just use the
* incoming headers.
*
* @return a new Default SIP Request which has the requestLine specified.
*
*/
public SIPRequest createSIPRequest(RequestLine requestLine,
boolean switchHeaders) {
SIPRequest newRequest = new SIPRequest();
newRequest.requestLine = requestLine;
Iterator headerIterator = this.getHeaders();
while (headerIterator.hasNext()) {
SIPHeader nextHeader = (SIPHeader) headerIterator.next();
// For BYE and cancel set the CSeq header to the
// appropriate method.
if (nextHeader instanceof CSeq) {
CSeq newCseq = (CSeq) nextHeader.clone();
nextHeader = newCseq;
try {
newCseq.setMethod(requestLine.getMethod());
} catch (ParseException e) {
}
} else if (nextHeader instanceof ViaList) {
Via via = (Via) (((ViaList) nextHeader).getFirst().clone());
via.removeParameter("branch");
nextHeader = via;
// Cancel and ACK preserve the branch ID.
} else if (nextHeader instanceof To) {
To to = (To) nextHeader;
if (switchHeaders) {
nextHeader = new From(to);
((From) nextHeader).removeTag();
} else {
nextHeader = (SIPHeader) to.clone();
((To) nextHeader).removeTag();
}
} else if (nextHeader instanceof From) {
From from = (From) nextHeader;
if (switchHeaders) {
nextHeader = new To(from);
((To) nextHeader).removeTag();
} else {
nextHeader = (SIPHeader) from.clone();
((From) nextHeader).removeTag();
}
} else if (nextHeader instanceof ContentLength) {
ContentLength cl = (ContentLength) nextHeader.clone();
try {
cl.setContentLength(0);
} catch (InvalidArgumentException e) {
}
nextHeader = cl;
} else if (!(nextHeader instanceof CallID)
&& !(nextHeader instanceof MaxForwards)) {
// Route is kept by dialog.
// RR is added by the caller.
// Contact is added by the Caller
// Any extension headers must be added
// by the caller.
continue;
}
try {
newRequest.attachHeader(nextHeader, false);
} catch (SIPDuplicateHeaderException e) {
e.printStackTrace();
}
}
if (MessageFactoryImpl.getUserAgentHeader() != null ) {
newRequest.setHeader(MessageFactoryImpl.getUserAgentHeader());
}
return newRequest;
}
/**
* Create a BYE request from this request.
*
* @param switchHeaders
* is a boolean flag that causes from and isServerTransaction to
* headers to be swapped. Set this to true if you are the server
* of the dialog and are generating a BYE request for the dialog.
* @return a new default BYE request.
*/
public SIPRequest createBYERequest(boolean switchHeaders) {
RequestLine requestLine = (RequestLine) this.requestLine.clone();
requestLine.setMethod("BYE");
return this.createSIPRequest(requestLine, switchHeaders);
}
/**
* Create an ACK request from this request. This is suitable for generating
* an ACK for an INVITE client transaction.
*
* @return an ACK request that is generated from this request.
*/
public SIPRequest createACKRequest() {
RequestLine requestLine = (RequestLine) this.requestLine.clone();
requestLine.setMethod(Request.ACK);
return this.createSIPRequest(requestLine, false);
}
/**
* Get the host from the topmost via header.
*
* @return the string representation of the host from the topmost via
* header.
*/
public String getViaHost() {
Via via = (Via) this.getViaHeaders().getFirst();
return via.getHost();
}
/**
* Get the port from the topmost via header.
*
* @return the port from the topmost via header (5060 if there is no port
* indicated).
*/
public int getViaPort() {
Via via = (Via) this.getViaHeaders().getFirst();
if (via.hasPort())
return via.getPort();
else
return 5060;
}
/**
* Get the first line encoded.
*
* @return a string containing the encoded request line.
*/
public String getFirstLine() {
if (requestLine == null)
return null;
else
return this.requestLine.encode();
}
/**
* Set the sip version.
*
* @param sipVersion
* the sip version to set.
*/
public void setSIPVersion(String sipVersion) throws ParseException {
if (sipVersion == null || !sipVersion.equalsIgnoreCase("SIP/2.0"))
throw new ParseException("sipVersion", 0);
this.requestLine.setSIPVersion(sipVersion);
}
/**
* Get the SIP version.
*
* @return the SIP version from the request line.
*/
public String getSIPVersion() {
return this.requestLine.getSipVersion();
}
/**
* Book keeping method to return the current tx for the request if one
* exists.
*
* @return the assigned tx.
*/
public Object getTransaction() {
// Return an opaque pointer to the transaction object.
// This is for consistency checking and quick lookup.
return this.transactionPointer;
}
/**
* Book keeping field to set the current tx for the request.
*
* @param transaction
*/
public void setTransaction(Object transaction) {
this.transactionPointer = transaction;
}
/**
* Book keeping method to get the messasge channel for the request.
*
* @return the message channel for the request.
*/
public Object getMessageChannel() {
// return opaque ptr to the message chanel on
// which the message was recieved. For consistency
// checking and lookup.
return this.messageChannel;
}
/**
* Set the message channel for the request ( bookkeeping field ).
*
* @param messageChannel
*/
public void setMessageChannel(Object messageChannel) {
this.messageChannel = messageChannel;
}
/**
* Generates an Id for checking potentially merged requests.
*
* @return String to check for merged requests
*/
public String getMergeId() {
/*
* generate an identifier from the From tag, Call-ID, and CSeq
*/
String fromTag = this.getFromTag();
String cseq = this.cSeqHeader.toString();
String callId = this.callIdHeader.getCallId();
if (fromTag != null) {
return new StringBuffer().append(fromTag).append(":").append(cseq)
.append(":").append(callId).toString();
} else
return null;
}
/**
* @param inviteTransaction
* the inviteTransaction to set
*/
public void setInviteTransaction(Object inviteTransaction) {
this.inviteTransaction = inviteTransaction;
}
/**
* @return the inviteTransaction
*/
public Object getInviteTransaction() {
return inviteTransaction;
}
/**
* Return true if this is a null request (i.e. does not have a request line ).
*
* @return true if null request.
*/
public boolean isNullRequest() {
return this.requestLine == null;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy