/** * 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 }