func (this *ToParser) Parse() (sh header.Header, ParseException error) {
to := header.NewTo()
this.HeaderName(TokenTypes_TO)
if ParseException = this.AddressParametersParser.Parse(to); ParseException != nil {
return nil, ParseException
}
this.GetLexer().Match('\n')
addr := to.GetAddress().(*address.AddressImpl)
if addr.GetAddressType() == address.ADDRESS_SPEC {
// the parameters are header parameters.
if to.GetAddress().GetURI().IsSipURI() {
sipUri, _ := to.GetAddress().GetURI().(*address.SipURIImpl)
parms := sipUri.GetUriParms()
if parms != nil && parms.Len() > 0 {
to.SetParameters(parms)
sipUri.RemoveUriParms()
}
}
}
return to, nil
}
/**
SIPHeader sipHeader =
(SIPHeader)
((ViaList) nextHeader).GetFirst().clone() ;
nextHeader = new ViaList();
((ViaList)nextHeader).add(sipHeader);
**/
//nextHeader = (ViaList) ((ViaList) nextHeader).clone();
} else if cseq, ok := nextHeader.(*header.CSeq); ok { // CSeq method for a cancel request must be cancel.
//CSeq cseq = (CSeq) nextHeader.clone();
//try{
cseq.SetMethod(CANCEL)
//}
//catch(ParseException e){}
nextHeader = cseq
}
//try {
newRequest.AttachHeader2(nextHeader, false)
// } catch(SIPDuplicateHeaderException e){
// e.printStackTrace();
// }
}
return newRequest
}
// /** 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 nil 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.
// */
func (this *SIPRequest) CreateAckRequest(responseToHeader *header.To) *SIPRequest {
// SIPRequest newRequest;
// Iterator headerIterator;
// SIPHeader nextHeader;
newRequest := NewSIPRequest()
newRequest.SetRequestLine(this.requestLine)
newRequest.SetMethod(ACK)
for headerIterator := this.getHeaders().Front(); headerIterator != nil; headerIterator = headerIterator.Next() {
nextHeader := headerIterator.Value.(header.Header)
if _, ok := nextHeader.(*header.RouteList); ok {
// Ack and cancel do not Get ROUTE headers.
// Route header for ACK is assigned by the
// Dialog if necessary.
continue
} else if _, ok := nextHeader.(*header.ProxyAuthorization); ok {
// Remove proxy auth header.
// Assigned by the Dialog if necessary.
continue
} else if cl, ok := nextHeader.(*header.ContentLength); ok {
// Adding content is responsibility of user.
//nextHeader = nextHeader.(*header.ContentLength)
//try{
cl.SetContentLength(0)
nextHeader = cl
//}
//catch(InvalidArgumentException e){}
} else if _, ok := nextHeader.(*header.ContentType); ok {
// Content type header is removed since
// content length is 0. Bug fix from
// Antonis Kyardis.
continue
} else if cseq, ok := nextHeader.(*header.CSeq); ok {
// 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".
//nextHeader = nextHeader.(*header.CSeq)
//try{
cseq.SetMethod(ACK)
nextHeader = cseq
//catch(ParseException e){}
// = cseq;
} else if _, ok := nextHeader.(*header.To); ok {
if responseToHeader != nil {
nextHeader = responseToHeader
} else {
//nextHeader = (SIPHeader) nextHeader.clone();
}
} else if vl, ok := nextHeader.(*header.ViaList); ok {
// 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 = vl.Front().Value.(header.Header)
} else {
//nextHeader = (SIPHeader) nextHeader.clone();
}
//try {
newRequest.AttachHeader2(nextHeader, false)
// } catch(SIPDuplicateHeaderException e){
// e.printStackTrace();
// }
}
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.
// * <ul>
// * <li>
// * Contact headers are not included in the newly created request.
// * Setting the appropriate sequence number is the responsibility of
// * the caller. </li>
// * <li> RouteList is not copied for ACK and CANCEL </li>
// * <li> 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.
// * </li>
// * <li>Contact List is not copied from the original request.</li>
// * <li>RecordRoute List is not included from original request. </li>
// * <li>Via header is not included from the original request. </li>
// * </ul>
// *
// *@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.
// *
// */
func (this *SIPRequest) CreateSIPRequest(requestLine *header.RequestLine, switchHeaders bool) *SIPRequest {
newRequest := NewSIPRequest()
newRequest.requestLine = this.requestLine
for headerIterator := this.getHeaders().Front(); headerIterator != nil; headerIterator = headerIterator.Next() {
nextHeader := headerIterator.Value.(header.Header)
// For BYE and cancel Set the CSeq header to the
// appropriate method.
if newCseq, ok := nextHeader.(*header.CSeq); ok {
// CSeq newCseq = (CSeq) nextHeader.clone();
nextHeader = newCseq
//try{
newCseq.SetMethod(this.requestLine.GetMethod())
//}
//catch(ParseException e){}
} else if vl, ok := nextHeader.(*header.ViaList); ok {
via := vl.Front().Value.(*header.Via)
via.RemoveParameter("branch")
nextHeader = via
// Cancel and ACK preserve the branch ID.
} else if to, ok := nextHeader.(*header.To); ok {
if switchHeaders {
from := header.NewFrom()
from.CloneTo(to)
from.RemoveTag()
nextHeader = from
} else {
//to2 := to.Clone().(*To)
to.RemoveTag()
nextHeader = to
}
} else if from, ok := nextHeader.(*header.From); ok {
if switchHeaders {
to := header.NewTo()
to.CloneFrom(from)
to.RemoveTag()
nextHeader = to
} else {
//from2 := from.Clone().(*From)
from.RemoveTag()
nextHeader = from
}
} else if cl, ok := nextHeader.(*header.ContentLength); ok {
//ContentLength cl =
// (ContentLength) nextHeader.clone();
//try{
cl.SetContentLength(0)
//}
//catch(InvalidArgumentException e){}
nextHeader = cl
} else {
_, ok1 := nextHeader.(*header.CallID)
_, ok2 := nextHeader.(*header.MaxForwards)
if !ok1 && !ok2 {
// 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.AttachHeader2(nextHeader, false)
//} catch(SIPDuplicateHeaderException e){
// e.printStackTrace();
//}
}
return newRequest
}