/**
* Creates an invite request using the Tested Implementation and then tests creating a cancel for
* the same invite request.
*/
public void testCreateCancel() {
try {
Request invite = createTiInviteRequest(null, null, null);
ClientTransaction tran = null;
try {
tran = tiSipProvider.getNewClientTransaction(invite);
} catch (TransactionUnavailableException exc) {
throw new TiUnexpectedError(
"A TransactionUnavailableException was thrown while trying to "
+ "create a new client transaction",
exc);
}
Request cancel = null;
try {
cancel = tran.createCancel();
} catch (SipException ex) {
ex.printStackTrace();
fail("Failed to create cancel request!");
}
assertEquals(
"The created request did not have a CANCEL method.", cancel.getMethod(), Request.CANCEL);
assertEquals(
"Request-URIs of the original and the cancel request do not match",
cancel.getRequestURI(),
invite.getRequestURI());
assertEquals(
"Call-IDs of the original and the cancel request do not match",
cancel.getHeader(CallIdHeader.NAME),
invite.getHeader(CallIdHeader.NAME));
assertEquals(
"ToHeaders of the original and the cancel request do not match",
cancel.getHeader(ToHeader.NAME),
invite.getHeader(ToHeader.NAME));
assertTrue(
"The CSeqHeader's sequence number of the original and "
+ "the cancel request do not match",
((CSeqHeader) cancel.getHeader(CSeqHeader.NAME)).getSequenceNumber()
== ((CSeqHeader) invite.getHeader(CSeqHeader.NAME)).getSequenceNumber());
assertEquals(
"The CSeqHeader's method of the cancel request was not CANCEL",
((CSeqHeader) cancel.getHeader(CSeqHeader.NAME)).getMethod(),
Request.CANCEL);
assertTrue(
"There was no ViaHeader in the cancel request",
cancel.getHeaders(ViaHeader.NAME).hasNext());
Iterator cancelVias = cancel.getHeaders(ViaHeader.NAME);
ViaHeader cancelVia = ((ViaHeader) cancelVias.next());
ViaHeader inviteVia = ((ViaHeader) invite.getHeaders(ViaHeader.NAME).next());
assertEquals(
"ViaHeaders of the original and the cancel request do not match!", cancelVia, inviteVia);
assertFalse("Cancel request had more than one ViaHeader.", cancelVias.hasNext());
} catch (Throwable exc) {
exc.printStackTrace();
fail(exc.getClass().getName() + ": " + exc.getMessage());
}
assertTrue(new Exception().getStackTrace()[0].toString(), true);
}
public void sendCancel() {
try {
System.out.println("Sending cancel");
Request cancelRequest = inviteTid.createCancel();
ClientTransaction cancelTid = sipProvider.getNewClientTransaction(cancelRequest);
cancelTid.sendRequest();
} catch (Exception ex) {
ex.printStackTrace();
}
}
public void processResponse(ResponseEvent responseReceivedEvent) {
/// System.out.println("=> BUNDLE: br.ufes.inf.ngn.televoto.client.logic | CLASS: LogicListener
// | METOD: processResponse ");//By Ju
try {
Response myResponse = responseReceivedEvent.getResponse();
logger.info("<<< " + myResponse.toString());
ClientTransaction thisClientTransaction = responseReceivedEvent.getClientTransaction();
int myStatusCode = myResponse.getStatusCode();
switch (status) {
case WAIT_PROV:
if (!thisClientTransaction.equals(myClientTransaction))
myClientTransaction = thisClientTransaction;
if (myStatusCode < 200) {
status = WAIT_FINAL;
myDialog = thisClientTransaction.getDialog();
} else if (myStatusCode < 300) {
myDialog = thisClientTransaction.getDialog();
CSeqHeader originalCSeq =
(CSeqHeader) myClientTransaction.getRequest().getHeader(CSeqHeader.NAME);
long numseq = originalCSeq.getSeqNumber();
Request myAck = myDialog.createAck(numseq);
myAck.addHeader(myContactHeader);
myDialog.sendAck(myAck);
// logger.info(">>> "+myAck.toString());
status = ESTABLISHED;
byte[] cont = (byte[]) myResponse.getContent();
answerInfo = mySdpManager.getSdp(cont);
} else {
if (myStatusCode == 401) {
} else {
status = IDLE;
CSeqHeader originalCSeq =
(CSeqHeader) myClientTransaction.getRequest().getHeader(CSeqHeader.NAME);
long numseq = originalCSeq.getSeqNumber();
Request myAck = myDialog.createAck(numseq);
myAck.addHeader(myContactHeader);
myDialog.sendAck(myAck);
// logger.info(">>> "+myAck.toString());
}
}
break;
case WAIT_FINAL:
if (!thisClientTransaction.equals(myClientTransaction))
myClientTransaction = thisClientTransaction;
if (myStatusCode < 200) {
status = WAIT_FINAL;
myDialog = thisClientTransaction.getDialog();
} else if (myStatusCode < 300) {
if (useQueue.equals("yes")) {
status = IDLE;
} else {
status = ESTABLISHED;
}
myDialog = thisClientTransaction.getDialog();
CSeqHeader originalCSeq =
(CSeqHeader) myClientTransaction.getRequest().getHeader(CSeqHeader.NAME);
long numseq = originalCSeq.getSeqNumber();
Request myAck = myDialog.createAck(numseq); // Aquiiii
myAck.addHeader(myContactHeader);
myDialog.sendAck(myAck);
// logger.info(">>> "+myAck.toString());
byte[] cont = (byte[]) myResponse.getContent();
answerInfo = mySdpManager.getSdp(cont);
} else {
// Cancelando requisição ao cliente
Request myCancelRequest = myClientTransaction.createCancel();
ClientTransaction myCancelClientTransaction =
mySipProvider.getNewClientTransaction(myCancelRequest);
myCancelClientTransaction.sendRequest();
// logger.info(">>> " + myCancelRequest.toString());
status = IDLE;
}
break;
case REGISTERING:
if (!thisClientTransaction.equals(myClientTransaction))
myClientTransaction = thisClientTransaction;
if (myStatusCode == 200) {
status = IDLE;
if (!Unregistring) {
System.out.println(myName + ": Registrado");
// inserir captura de timestamp
// logger.info(myName + ";INVITE;" + getTime());
// Random gerador = new Random();
// int temp = gerador.nextInt(10);
// System.out.println(myName + ": Esperando " + temp + "segundos");
// Thread.sleep(temp);
System.out.println(myName + ": chamando " + destination);
SdpInfo offerInfo = new SdpInfo();
offerInfo.IpAddress = myIP;
offerInfo.aport = myAudioPort;
offerInfo.aformat = 0;
byte[] content = mySdpManager.createSdp(offerInfo);
// Via
// ViaHeader comentei
myViaHeader = myHeaderFactory.createViaHeader(myIP, myPort, "udp", null);
myViaHeader.setRPort();
ArrayList viaHeaders = new ArrayList();
viaHeaders.add(myViaHeader);
// From
Address addressOfRecord = myAddressFactory.createAddress("<sip:" + myUserID + ">");
FromHeader myFromHeader = myHeaderFactory.createFromHeader(addressOfRecord, "456249");
// To
String dstURI[] = destination.split("@");
String dstSipAlias = dstURI[0];
Address destinationAddress =
myAddressFactory.createAddress("<sip:" + destination + ">");
javax.sip.address.URI myRequestURI = destinationAddress.getURI();
ToHeader myToHeader = myHeaderFactory.createToHeader(destinationAddress, null);
// MaxForwards
MaxForwardsHeader myMaxForwardsHeader = myHeaderFactory.createMaxForwardsHeader(70);
// Call-ID
CallIdHeader myCallIdHeader = mySipProvider.getNewCallId();
// CSeq
Random random = new Random();
CSeqHeader myCSeqHeader =
myHeaderFactory.createCSeqHeader(random.nextInt(1000) * 1L, "INVITE");
// Create SIP request
Request myRequest =
myMessageFactory.createRequest(
myRequestURI,
"INVITE",
myCallIdHeader,
myCSeqHeader,
myFromHeader,
myToHeader,
viaHeaders,
myMaxForwardsHeader);
// Contact
Address contactAddress =
myAddressFactory.createAddress(
"<sip:" + mySipAlias + "@" + myIP + ":" + myPort + ";transport=udp>");
myContactHeader = myHeaderFactory.createContactHeader(contactAddress);
myRequest.addHeader(myContactHeader);
// Allow
Allow myAllow = new Allow();
myAllow.setMethod(
"INVITE, ACK, CANCEL, BYE, MESSAGE, OPTIONS, NOTIFY, PRACK, UPDATE, REFER");
myRequest.addHeader(myAllow);
// Privacy
Privacy myPrivacy = new Privacy("none");
myRequest.addHeader(myPrivacy);
// PPreferredIdentity
HeaderFactoryImpl myHeaderFactoryImpl = new HeaderFactoryImpl();
PPreferredIdentityHeader myPPreferredIdentityHeader =
myHeaderFactoryImpl.createPPreferredIdentityHeader(
myAddressFactory.createAddress("sip:" + myName + '@' + myServer));
myRequest.addHeader(myPPreferredIdentityHeader);
// Route
Address routeAddress =
myAddressFactory.createAddress("sip:orig@scscf." + myServer + ":6060;lr");
// RouteHeader comentei
myRouteHeader = myHeaderFactory.createRouteHeader(routeAddress);
myRequest.addHeader(myRouteHeader);
// Para proxy funcionar
SipURI outboundProxyURI = myAddressFactory.createSipURI("proxy", myProxyIP);
outboundProxyURI.setLrParam();
outboundProxyURI.setPort(myProxyPort);
myRouteHeader =
myHeaderFactory.createRouteHeader(
myAddressFactory.createAddress(outboundProxyURI));
myRequest.addFirst(myRouteHeader);
// Content Type
ContentTypeHeader contentTypeHeader =
myHeaderFactory.createContentTypeHeader("application", "sdp");
myRequest.setContent(content, contentTypeHeader);
// ClientTransaction comentei aqui
myClientTransaction = mySipProvider.getNewClientTransaction(myRequest);
myClientTransaction.setRetransmitTimer(700);
myClientTransaction.sendRequest();
status = WAIT_PROV;
logger.info(">>> " + myRequest.toString());
} else {
this.setOff(mySipStack);
}
} else {
if (myStatusCode == 403) {
System.out.println("Problemas com credenciais!!!!\n");
} else if (myStatusCode == 401) {
myName = (String) this.getLocalName();
myUserID = (String) this.getLocalName() + "@" + myServer;
Address contactAddress =
myAddressFactory.createAddress("sip:" + myName + '@' + myIP + ":" + myPort);
myContactHeader = myHeaderFactory.createContactHeader(contactAddress);
myViaHeader = myHeaderFactory.createViaHeader(myIP, myPort, "udp", null);
fromAddress = myAddressFactory.createAddress(myName + " <sip:" + myUserID + ">");
Address registrarAddress = myAddressFactory.createAddress("sip:" + myServer);
Address registerToAddress = fromAddress;
Address registerFromAddress = fromAddress;
ToHeader myToHeader = myHeaderFactory.createToHeader(registerToAddress, null);
FromHeader myFromHeader =
myHeaderFactory.createFromHeader(registerFromAddress, "647554");
ArrayList myViaHeaders = new ArrayList();
myViaHeaders.add(myViaHeader);
// System.out.println("myClientTransaction.getRequest():"+
// myClientTransaction.getRequest());
CSeqHeader originalCSeq =
(CSeqHeader) myClientTransaction.getRequest().getHeader(CSeqHeader.NAME);
long numseq = originalCSeq.getSeqNumber();
MaxForwardsHeader myMaxForwardsHeader = myHeaderFactory.createMaxForwardsHeader(70);
CSeqHeader myCSeqHeader = myHeaderFactory.createCSeqHeader(numseq + 1L, "REGISTER");
CallIdHeader myCallID =
(CallIdHeader) myClientTransaction.getRequest().getHeader(CallIdHeader.NAME);
CallIdHeader myCallIDHeader = myCallID;
SipURI myRequestURI = (SipURI) registrarAddress.getURI();
Request myRegisterRequest =
myMessageFactory.createRequest(
myRequestURI,
"REGISTER",
myCallIDHeader,
myCSeqHeader,
myFromHeader,
myToHeader,
myViaHeaders,
myMaxForwardsHeader);
myRegisterRequest.addHeader(myContactHeader);
// Expires
ExpiresHeader myExpiresHeader;
if (Unregistring) {
myExpiresHeader = myHeaderFactory.createExpiresHeader(0);
myContactHeader.setExpires(0);
} else {
myExpiresHeader = myHeaderFactory.createExpiresHeader(60000);
}
myRegisterRequest.addHeader(myExpiresHeader);
// Allow
Allow myAllow = new Allow();
myAllow.setMethod(
"INVITE, ACK, CANCEL, BYE, MESSAGE, OPTIONS, NOTIFY, PRACK, UPDATE, REFER");
myRegisterRequest.addHeader(myAllow);
// Privacy
Privacy myPrivacy = new Privacy("none");
myRegisterRequest.addHeader(myPrivacy);
// PPreferredIdentity
HeaderFactoryImpl myHeaderFactoryImpl = new HeaderFactoryImpl();
PPreferredIdentityHeader myPPreferredIdentityHeader =
myHeaderFactoryImpl.createPPreferredIdentityHeader(
myAddressFactory.createAddress("sip:" + myName + '@' + myServer));
myRegisterRequest.addHeader(myPPreferredIdentityHeader);
// Supported
Supported mySupported = new Supported("path");
myRegisterRequest.addHeader(mySupported);
myWWWAuthenticateHeader =
Utils.makeAuthHeader(
myHeaderFactory, myResponse, myRegisterRequest, myUserID, myPassword);
myRegisterRequest.addHeader(myWWWAuthenticateHeader);
myClientTransaction = mySipProvider.getNewClientTransaction(myRegisterRequest);
myClientTransaction.sendRequest();
// logger.info(">>> "+myRegisterRequest.toString());
// System.out.println(">>> " + myRegisterRequest.toString());
status = REGISTERING;
}
}
break;
}
} catch (Exception excep) {
excep.printStackTrace();
}
}
/**
* JvB: Tests transmission of an INVITE followed by CANCELlation of that request -> INVITE <- 100
* -> CANCEL <- OK <- 487 -> ACK
*
* <p>Note: for 1.2 it is impossible to manually set the top via branch to something not
* RFC3261-compliant
*/
private void doCancelTest(boolean rfc3261Compliant) {
try {
Request invite = createTiInviteRequest(null, null, null);
ClientTransaction tran = null;
try {
eventCollector.collectRequestEvent(riSipProvider);
// This call overwrites any branch we set
tran = tiSipProvider.getNewClientTransaction(invite);
// And this call too
tran.sendRequest();
} catch (SipException ex) {
throw new TiUnexpectedError("A SipExceptionOccurred while trying to send request!", ex);
} catch (TooManyListenersException ex) {
throw new TckInternalError("Failed to regiest a SipListener with an RI SipProvider", ex);
}
waitForMessage();
RequestEvent inviteReceivedEvent = eventCollector.extractCollectedRequestEvent();
if (inviteReceivedEvent == null || inviteReceivedEvent.getRequest() == null)
throw new TiUnexpectedError("The invite request was not received by the RI!");
// At this point the ClientTransaction should be CALLING!
assertEquals(TransactionState.CALLING, tran.getState());
// Send a TRYING response
try {
eventCollector.collectResponseEvent(tiSipProvider);
} catch (TooManyListenersException ex) {
throw new TiUnexpectedError("Failed to register a SipListener with TI", ex);
}
try {
Response resp =
riMessageFactory.createResponse(Response.TRYING, inviteReceivedEvent.getRequest());
addStatus(inviteReceivedEvent.getRequest(), resp);
riSipProvider.sendResponse(resp);
} catch (Throwable ex) {
throw new TckInternalError("The TCK could not send a trying response back to the TI", ex);
}
waitForMessage();
// Analyze the TRYING response and Tran state back at the TI
ResponseEvent responseEvent = eventCollector.extractCollectedResponseEvent();
assertNotNull(
"The Tested Implementation did not pass a 1xx response to the TU!", responseEvent);
assertNotNull(
"The Tested Implementation did not pass a 1xx response to the TU!",
responseEvent.getResponse());
assertTrue(
"A response different from TYING was passed to the TU!",
responseEvent.getResponse().getStatusCode() == Response.TRYING);
assertSame(
"The TRYING response was not associated with the right transaction.",
tran,
responseEvent.getClientTransaction());
// verify the the tran state is now PROCEEDING
assertEquals(
"The ClientTransaction did not pass in the PROCEEDING state after "
+ "receiving 1xx provisional response",
tran.getState(),
TransactionState.PROCEEDING);
// Send a CANCEL from the TI
Request tiCancel = tran.createCancel();
/*
* this works, but since we cannot patch the INVITE the test fails
* if (!rfc3261Compliant) { ((ViaHeader)
* tiCancel.getHeader("Via")).setBranch( "xxx" ); // Not allowed by
* RI // ((FromHeader) tiCancel.getHeader("From")).setTag( "" ); }
*/
ClientTransaction tiCancelTrans;
try {
eventCollector.collectRequestEvent(riSipProvider);
tiCancelTrans = tiSipProvider.getNewClientTransaction(tiCancel);
tiCancelTrans.sendRequest();
} catch (SipException ex) {
throw new TiUnexpectedError("A SipExceptionOccurred while trying to send CANCEL!", ex);
}
waitForMessage();
RequestEvent cancelReceivedEvent = eventCollector.extractCollectedRequestEvent();
if (cancelReceivedEvent == null || cancelReceivedEvent.getRequest() == null)
throw new TiUnexpectedError("The CANCEL request was not received by the RI!");
// Send 200 OK to the CANCEL
try {
eventCollector.collectResponseEvent(tiSipProvider);
} catch (TooManyListenersException ex) {
throw new TiUnexpectedError("Failed to register a SipListener with TI", ex);
}
Response riCancelOk = null;
try {
riCancelOk = riMessageFactory.createResponse(Response.OK, cancelReceivedEvent.getRequest());
addStatus(cancelReceivedEvent.getRequest(), riCancelOk);
riSipProvider.sendResponse(riCancelOk);
} catch (Throwable ex) {
throw new TckInternalError(
"The TCK could not send a CANCEL OK response back to the TI", ex);
}
waitForMessage();
// Analyze the OK response and Tran state back at the TI
responseEvent = eventCollector.extractCollectedResponseEvent();
if (responseEvent == null || responseEvent.getResponse() == null) {
throw new TiUnexpectedError("The CANCEL OK response was not received by the TI!");
}
// Send 487 to the INVITE, expect ACK
try {
eventCollector.collectResponseEvent(tiSipProvider);
} catch (TooManyListenersException ex) {
throw new TiUnexpectedError("Failed to register a SipListener with TI", ex);
}
SipEventCollector ackCollector = new SipEventCollector();
try {
ackCollector.collectRequestEvent(riSipProvider);
} catch (TooManyListenersException ex) {
throw new TckInternalError("Failed to regiest a SipListener with an RI SipProvider", ex);
}
Response riInviteTerminated = null;
try {
riInviteTerminated =
riMessageFactory.createResponse(
Response.REQUEST_TERMINATED, inviteReceivedEvent.getRequest());
addStatus(inviteReceivedEvent.getRequest(), riInviteTerminated);
riSipProvider.sendResponse(riInviteTerminated);
} catch (Throwable ex) {
throw new TckInternalError(
"The TCK could not send a INVITE 487 response back to the TI", ex);
}
waitForMessage();
// Analyze the REQUEST_TERMINATED response and Tran state back at
// the TI
responseEvent = eventCollector.extractCollectedResponseEvent();
assertNotNull(
"The Tested Implementation did not pass a 300-699 response to the TU!", responseEvent);
assertNotNull(
"The Tested Implementation did not pass a 300-699 response to the TU!",
responseEvent.getResponse());
assertSame(
"The 487 response was not associated with the right transaction",
tran,
responseEvent.getClientTransaction());
assertEquals(
"A response different from 487 was passed to the TU",
Response.REQUEST_TERMINATED,
responseEvent.getResponse().getStatusCode());
assertEquals(
"The ClientTransaction did not pass in the COMPLETED state after "
+ "receiving 300-699 final response",
tran.getState(),
TransactionState.COMPLETED);
// check whether the ackCollector has caught any fish
RequestEvent ackReceivedEvent = ackCollector.extractCollectedRequestEvent();
assertNotNull("The TI did not send an ACK request event", ackReceivedEvent);
assertNotNull("The TI did not send an ACK request", ackReceivedEvent.getRequest());
assertEquals(Request.ACK, ackReceivedEvent.getRequest().getMethod());
// Try to kill remaining ACK retransmissions?
} catch (Throwable exc) {
exc.printStackTrace();
fail(exc.getClass().getName() + ": " + exc.getMessage());
}
assertTrue(new Exception().getStackTrace()[0].toString(), true);
// Unfortunately we can't assert the TERMINATED state as timerK timerD
// is not exported by JAIN SIP
}
