/** Tests sending a request from a ClientTransaction. */ public void testSendRequest() { try { Request invite = createTiInviteRequest(null, null, null); RequestEvent receivedRequestEvent = null; ClientTransaction tran = null; try { tran = tiSipProvider.getNewClientTransaction(invite); eventCollector.collectRequestEvent(riSipProvider); tran.sendRequest(); waitForMessage(); receivedRequestEvent = eventCollector.extractCollectedRequestEvent(); assertNotNull("The sent request was not received by the RI!", receivedRequestEvent); assertNotNull( "The sent request was not received by the RI!", receivedRequestEvent.getRequest()); } catch (TransactionUnavailableException exc) { throw new TiUnexpectedError( "A TransactionUnavailableException was thrown while trying to " + "create a new client transaction", exc); } catch (SipException exc) { exc.printStackTrace(); fail("The SipException was thrown while trying to send the request."); } catch (TooManyListenersException exc) { throw new TckInternalError( "A TooManyListenersException was thrown while trying " + "to add a SipListener to an RI SipProvider", exc); } } catch (Throwable exc) { exc.printStackTrace(); fail(exc.getClass().getName() + ": " + exc.getMessage()); } assertTrue(new Exception().getStackTrace()[0].toString(), true); }
/** * Creates and sends a SUBSCRIBE request to the subscription <tt>Address</tt>/Request URI of a * specific <tt>Subscription</tt> in order to request receiving event notifications and adds the * specified <tt>Subscription</tt> to the list of subscriptions managed by this instance. The * added <tt>Subscription</tt> may later receive notifications to process the <tt>Request</tt>s * and/or <tt>Response</tt>s which constitute the signaling session associated with it. If the * attempt to create and send the SUBSCRIBE request fails, the specified <tt>Subscription</tt> is * not added to the list of subscriptions managed by this instance. * * @param subscription a <tt>Subscription</tt> which specifies the properties of the SUBSCRIBE * request to be created and sent, to be added to the list of subscriptions managed by this * instance * @throws OperationFailedException if we fail constructing or sending the subscription request. */ public void subscribe(Subscription subscription) throws OperationFailedException { Dialog dialog = subscription.getDialog(); if ((dialog != null) && DialogState.TERMINATED.equals(dialog.getState())) dialog = null; // create the subscription ClientTransaction subscribeTransaction = null; try { subscribeTransaction = (dialog == null) ? createSubscription(subscription, subscriptionDuration) : createSubscription(subscription, dialog, subscriptionDuration); } catch (OperationFailedException ex) { ProtocolProviderServiceSipImpl.throwOperationFailedException( "Failed to create the subscription", OperationFailedException.INTERNAL_ERROR, ex, logger); } // we register the contact to find him when the OK will arrive CallIdHeader callIdHeader = (CallIdHeader) subscribeTransaction.getRequest().getHeader(CallIdHeader.NAME); String callId = callIdHeader.getCallId(); addSubscription(callId, subscription); // send the message try { if (dialog == null) subscribeTransaction.sendRequest(); else dialog.sendRequest(subscribeTransaction); } catch (SipException ex) { // this contact will never been accepted or rejected removeSubscription(callId, subscription); ProtocolProviderServiceSipImpl.throwOperationFailedException( "Failed to send the subscription", OperationFailedException.NETWORK_FAILURE, ex, logger); } }
/** * Attempts to re-generate the corresponding request with the proper credentials. * * @param clientTransaction the corresponding transaction * @param response the challenge * @param jainSipProvider the provider that received the challenge * @throws OperationFailedException if processing the authentication challenge fails. */ private void processAuthenticationChallenge( ClientTransaction clientTransaction, Response response, SipProvider jainSipProvider) throws OperationFailedException { try { if (logger.isDebugEnabled()) logger.debug("Authenticating a message request."); ClientTransaction retryTran = null; // we synch here to protect seqN increment synchronized (this) { retryTran = sipProvider .getSipSecurityManager() .handleChallenge(response, clientTransaction, jainSipProvider, seqN++); } if (retryTran == null) { if (logger.isTraceEnabled()) logger.trace("No password supplied or error occured!"); return; } retryTran.sendRequest(); return; } catch (Exception exc) { logger.error("We failed to authenticate a message request.", exc); throw new OperationFailedException( "Failed to authenticate" + "a message request", OperationFailedException.INTERNAL_ERROR, exc); } }
public void processResponse(ResponseEvent responseReceivedEvent) { // Log.info("Registering response...." + sipCallId); Response response = (Response) responseReceivedEvent.getResponse(); int statusCode = response.getStatusCode(); String method = ((CSeqHeader) response.getHeader(CSeqHeader.NAME)).getMethod(); Log.debug("Got response " + response); if (statusCode == Response.OK) { isRegistered = true; Log.info( "Voice bridge successfully registered with " + registrar + " for " + proxyCredentials.getXmppUserName()); PluginImpl.sipRegisterStatus = "Registered ok with " + proxyCredentials.getHost(); sipServerCallback.removeSipListener(sipCallId); } else if (statusCode == Response.UNAUTHORIZED || statusCode == Response.PROXY_AUTHENTICATION_REQUIRED) { if (method.equals(Request.REGISTER)) { CSeqHeader cseq = (CSeqHeader) response.getHeader(CSeqHeader.NAME); if (cseq.getSequenceNumber() < 2) { ClientTransaction regTrans = SipService.handleChallenge( response, responseReceivedEvent.getClientTransaction(), proxyCredentials); if (regTrans != null) { try { regTrans.sendRequest(); } catch (Exception e) { Log.info("Registration failed, cannot send transaction " + e); PluginImpl.sipRegisterStatus = "Registration error " + e.toString(); } } else { Log.info("Registration failed, cannot create transaction"); PluginImpl.sipRegisterStatus = "Registration cannot create transaction"; } } else { Log.info("Registration failed " + responseReceivedEvent); PluginImpl.sipRegisterStatus = "Registration failed"; } } } else { Log.info("Unrecognized response: " + response); } }
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 responseEvent) { if (responseEvent.getResponse().getStatusCode() == 200) { SIPClientTransaction sipClientTx = (SIPClientTransaction) responseEvent.getClientTransaction(); if (sipClientTx != null && Request.INVITE.equals(sipClientTx.getMethod())) { try { ClientTransaction inviteTid = sipProvider.getNewClientTransaction(sipClientTx.createAck()); inviteTid.sendRequest(); } catch (Exception e) { throw new RuntimeException(e); } } } }
/** * Sends <tt>messageRequest</tt> to the specified destination and logs <tt>messageContent</tt> for * later use. * * @param messageRequest the <tt>SipRequest</tt> that we are about to send. * @param to the Contact that we are sending <tt>messageRequest</tt> to. * @param messageContent the SC <tt>Message</tt> that was used to create the <tt>Request</tt> . * @throws TransactionUnavailableException if we fail creating the transaction required to send * <tt>messageRequest</tt>. * @throws SipException if we fail sending <tt>messageRequest</tt>. */ void sendMessageRequest(Request messageRequest, Contact to, Message messageContent) throws TransactionUnavailableException, SipException { // Transaction ClientTransaction messageTransaction; SipProvider jainSipProvider = this.sipProvider.getDefaultJainSipProvider(); messageTransaction = jainSipProvider.getNewClientTransaction(messageRequest); // send the message messageTransaction.sendRequest(); // we register the reference to this message to retrieve it when // we'll receive the response message String key = ((CallIdHeader) messageRequest.getHeader(CallIdHeader.NAME)).getCallId(); this.sentMsg.put(key, messageContent); }
public void unregister() throws IOException { if (!isRegistered) { return; } cancelPendingRegistrations(); isRegistered = false; if (this.registerRequest == null) { Log.info("Couldn't find the initial register request"); throw new IOException("Couldn't find the initial register request"); } Request unregisterRequest = (Request) registerRequest.clone(); try { unregisterRequest.getExpires().setExpires(0); CSeqHeader cSeqHeader = (CSeqHeader) unregisterRequest.getHeader(CSeqHeader.NAME); // [issue 1] - increment registration cseq number // reported by - Roberto Tealdi <*****@*****.**> cSeqHeader.setSequenceNumber(cSeqHeader.getSequenceNumber() + 1); } catch (InvalidArgumentException e) { Log.info("Unable to set Expires Header " + e.getMessage()); return; } ClientTransaction unregisterTransaction = null; try { unregisterTransaction = sipProvider.getNewClientTransaction(unregisterRequest); } catch (TransactionUnavailableException e) { throw new IOException("Unable to create a unregister transaction " + e.getMessage()); } try { unregisterTransaction.sendRequest(); } catch (SipException e) { Log.info("Faied to send unregister request " + e.getMessage()); return; } }
private void register() throws IOException { Log.info("Registering with " + registrar); FromHeader fromHeader = getFromHeader(); Address fromAddress = fromHeader.getAddress(); // Request URI SipURI requestURI = null; try { requestURI = addressFactory.createSipURI(null, registrar); } catch (ParseException e) { throw new IOException("Bad registrar address:" + registrar + " " + e.getMessage()); } // requestURI.setPort(registrarPort); try { requestURI.setTransportParam(sipProvider.getListeningPoint().getTransport()); } catch (ParseException e) { throw new IOException( sipProvider.getListeningPoint().getTransport() + " is not a valid transport! " + e.getMessage()); } CallIdHeader callIdHeader = sipProvider.getNewCallId(); CSeqHeader cSeqHeader = null; try { cSeqHeader = headerFactory.createCSeqHeader(1, Request.REGISTER); } catch (ParseException e) { // Should never happen throw new IOException("Corrupt Sip Stack " + e.getMessage()); } catch (InvalidArgumentException e) { // Should never happen throw new IOException("The application is corrupt "); } ToHeader toHeader = null; try { String proxyWorkAround = System.getProperty("com.sun.mc.softphone.REGISTRAR_WORKAROUND"); if (proxyWorkAround != null && proxyWorkAround.toUpperCase().equals("TRUE")) { SipURI toURI = (SipURI) (requestURI.clone()); toURI.setUser(System.getProperty("user.name")); toHeader = headerFactory.createToHeader(addressFactory.createAddress(toURI), null); } else { toHeader = headerFactory.createToHeader(fromAddress, null); } } catch (ParseException e) { throw new IOException( "Could not create a To header for address:" + fromHeader.getAddress() + " " + e.getMessage()); } ArrayList viaHeaders = getLocalViaHeaders(); MaxForwardsHeader maxForwardsHeader = getMaxForwardsHeader(); Request request = null; try { request = messageFactory.createRequest( requestURI, Request.REGISTER, callIdHeader, cSeqHeader, fromHeader, toHeader, viaHeaders, maxForwardsHeader); } catch (ParseException e) { throw new IOException("Could not create the register request! " + e.getMessage()); } ExpiresHeader expHeader = null; for (int retry = 0; retry < 2; retry++) { try { expHeader = headerFactory.createExpiresHeader(expires); } catch (InvalidArgumentException e) { if (retry == 0) { continue; } throw new IOException( "Invalid registrations expiration parameter - " + expires + " " + e.getMessage()); } } request.addHeader(expHeader); ContactHeader contactHeader = getRegistrationContactHeader(); request.addHeader(contactHeader); try { SipURI routeURI = (SipURI) addressFactory.createURI("sip:" + proxyCredentials.getProxy() + ";lr"); RouteHeader routeHeader = headerFactory.createRouteHeader(addressFactory.createAddress(routeURI)); request.addHeader(routeHeader); } catch (Exception e) { Log.error("Creating registration route error ", e); } ClientTransaction regTrans = null; try { regTrans = sipProvider.getNewClientTransaction(request); } catch (TransactionUnavailableException e) { throw new IOException( "Could not create a register transaction!\n" + "Check that the Registrar address is correct! " + e.getMessage()); } try { sipCallId = callIdHeader.getCallId(); sipServerCallback.addSipListener(sipCallId, this); registerRequest = request; regTrans.sendRequest(); Log.debug("Sent register request " + registerRequest); if (expires > 0) { scheduleReRegistration(); } } catch (Exception e) { throw new IOException("Could not send out the register request! " + e.getMessage()); } this.registerRequest = request; }
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(); } }
public void processResponse(ResponseEvent responseEvent) { Response response = responseEvent.getResponse(); ClientTransaction clientTransaction = responseEvent.getClientTransaction(); CSeqHeader cseqHeader = (CSeqHeader) response.getHeader(CSeqHeader.NAME); logger.debug("***** Response: " + response.getStatusCode() + " received by UA *****"); logger.debug(response); logger.debug("***** Response dispatched *****"); if (response.getStatusCode() == Response.PROXY_AUTHENTICATION_REQUIRED || response.getStatusCode() == Response.UNAUTHORIZED) { if (clientTransaction == null) { logger.info("Bad username ?"); } else { try { logger.debug("IMUserAgent, processResponse(), Credentials to provide!"); // WE start the authentication process!!! // Let's get the Request related to this response: Request clonedRequest = (Request) clientTransaction.getRequest().clone(); if (clonedRequest == null) { logger.debug( "IMUserAgent, processResponse(), the request " + " that caused the 407 has not been retrieved!!! Return cancelled!"); } else { // Let's increase the Cseq: cseqHeader = (CSeqHeader) clonedRequest.getHeader(CSeqHeader.NAME); cseqHeader.setSequenceNumber(cseqHeader.getSequenceNumber() + 1); // Let's add a Proxy-Authorization header: // We send the informations stored: FromHeader fromHeader = (FromHeader) clonedRequest.getHeader(FromHeader.NAME); String fromURI = fromHeader.getAddress().getURI().toString(); Header header; if (fromURI.equals(getLocalURI())) { header = authenticationProcess.getHeader(response); } else { String fromAddress = IMUtilities.getUsernameFromURI(fromURI); logger.info("Fetching credentials dor user: "******"ERROR, user not found"); header = null; } } if (header == null) { logger.debug( "IMUserAgent, processResponse(), Proxy-Authorization " + " header is null, the request is not resent"); } else { clonedRequest.setHeader(header); ClientTransaction newClientTransaction = getSipProvider().getNewClientTransaction(clonedRequest); newClientTransaction.sendRequest(); logger.debug( "IMUserAgent, processResponse(), REGISTER " + "with credentials sent:\n" + clonedRequest); } } } catch (Exception e) { e.printStackTrace(); } } } else { if (cseqHeader.getMethod().equals("REGISTER")) { // logger.info("REGISTER Response received"); sipRC.processResponse(responseEvent); } else if (cseqHeader.getMethod().equals("ACK")) { } else if (cseqHeader.getMethod().equals("MESSAGE")) { sipMC.processResponse(responseEvent); } } }
public void setup() { /// System.out.println("=> BUNDLE: br.ufes.inf.ngn.televoto.client.logic | CLASS: LogicListener // | METOD: setup ");//By Ju try { // String log4jConfPath = "//etc//osgi//log4j.properties"; //comentei // PropertyConfigurator.configure(log4jConfPath); if (!Unregistring) { // Se é um registro Object parametros[] = new Object[9]; parametros = getArguments(); myDataSource = Activator.ds; myServer = (String) parametros[3]; destination = (String) parametros[6]; dialTimes = (Integer) parametros[7]; useQueue = (String) parametros[8]; try { myIP = InetAddress.getLocalHost().getHostAddress(); } catch (UnknownHostException e) { e.printStackTrace(); } mySipAlias = (String) parametros[0]; myName = (String) this.getLocalName(); myUserID = (String) parametros[1]; ; myPassword = (String) parametros[5]; myPort = (Integer) parametros[2]; myAudioPort = (Integer) parametros[4]; myProxyIP = (String) parametros[9]; myProxyPort = (Integer) parametros[10]; afmt = Activator.afmt; mySipFactory = SipFactory.getInstance(); mySipFactory.setPathName("gov.nist"); } mySdpManager = new SdpManager(); answerInfo = new SdpInfo(); offerInfo = new SdpInfo(); myProperties = new Properties(); myProperties.setProperty("javax.sip.STACK_NAME", myName); myProperties.setProperty( "javax.sip.OUTBOUND_PROXY", myProxyIP + ":" + myProxyPort + "/UDP"); // Proxy mySipStack = mySipFactory.createSipStack(myProperties); myMessageFactory = mySipFactory.createMessageFactory(); myHeaderFactory = mySipFactory.createHeaderFactory(); myAddressFactory = mySipFactory.createAddressFactory(); if (!Unregistring) { myListeningPoint = mySipStack.createListeningPoint(myIP, myPort, "udp"); mySipProvider = mySipStack.createSipProvider(myListeningPoint); mySipProvider.addSipListener(this); } myViaHeader = myHeaderFactory.createViaHeader(myIP, myPort, "udp", null); Address routeAddress = myAddressFactory.createAddress("sip:" + myServer + ";lr"); myRouteHeader = myHeaderFactory.createRouteHeader(routeAddress); 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); MaxForwardsHeader myMaxForwardsHeader = myHeaderFactory.createMaxForwardsHeader(70); Random random = new Random(); CSeqHeader myCSeqHeader = myHeaderFactory.createCSeqHeader(random.nextInt(1000) * 1L, "REGISTER"); CallIdHeader myCallIDHeader = mySipProvider.getNewCallId(); SipURI myRequestURI = (SipURI) registrarAddress.getURI(); Request myRegisterRequest = myMessageFactory.createRequest( myRequestURI, "REGISTER", myCallIDHeader, myCSeqHeader, myFromHeader, myToHeader, myViaHeaders, myMaxForwardsHeader); // Expires ExpiresHeader myExpiresHeader; if (Unregistring) { myContactHeader.setExpires(0); myExpiresHeader = myHeaderFactory.createExpiresHeader(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); // Contact Address contactAddress = myAddressFactory.createAddress( "sip:" + myName + '@' + myIP + ":" + myPort + ";transport=udp"); myContactHeader = myHeaderFactory.createContactHeader(contactAddress); myRegisterRequest.addHeader(myContactHeader); // Authorization Authorization myAuthorization = new Authorization(); myAuthorization.setScheme("Digest"); myAuthorization.setUsername(myUserID); myAuthorization.setRealm(myServer); myAuthorization.setNonce(""); myAuthorization.setURI(myRegisterRequest.getRequestURI()); myAuthorization.setResponse(""); myRegisterRequest.addHeader(myAuthorization); // PPreferredIdentity HeaderFactoryImpl myHeaderFactoryImpl = new HeaderFactoryImpl(); PPreferredIdentityHeader myPPreferredIdentityHeader = myHeaderFactoryImpl.createPPreferredIdentityHeader( myAddressFactory.createAddress("sip:" + myName + '@' + myServer)); myRegisterRequest.addHeader(myPPreferredIdentityHeader); // Privacy Privacy myPrivacy = new Privacy("none"); myRegisterRequest.addHeader(myPrivacy); // Supported Supported mySupported = new Supported("path"); myRegisterRequest.addHeader(mySupported); // Envia requisição SIP myClientTransaction = mySipProvider.getNewClientTransaction(myRegisterRequest); myClientTransaction.sendRequest(); // logger.info(myRegisterRequest.toString()); // System.out.println(">>> " + myRegisterRequest.toString()); status = REGISTERING; } catch (Exception e) { e.printStackTrace(); } }
public void processRequest(RequestEvent requestReceivedEvent) { /// System.out.println("=> BUNDLE: br.ufes.inf.ngn.televoto.client.logic | CLASS: LogicListener // | METOD: processRequest ");//By Ju String method; Response myResponse; ToHeader myToHeader; Request myRequest = requestReceivedEvent.getRequest(); method = myRequest.getMethod(); // logger.info(myRequest.toString()); if (!method.equals("CANCEL")) { myServerTransaction = requestReceivedEvent.getServerTransaction(); } try { switch (status) { case WAIT_PROV: status = WAIT_ACK; System.out.println("Chamando...."); break; case IDLE: if (method.equals("INVITE")) { if (myServerTransaction == null) { myServerTransaction = mySipProvider.getNewServerTransaction(myRequest); } byte[] cont = (byte[]) myRequest.getContent(); offerInfo = mySdpManager.getSdp(cont); answerInfo.IpAddress = myIP; answerInfo.aport = myAudioPort; answerInfo.aformat = offerInfo.aformat; if (useQueue.equals("yes")) { status = ESTABLISHED; } else { // envio do PROVISIONAL 180 myResponse = myMessageFactory.createResponse(180, myRequest); myResponse.addHeader(myContactHeader); myToHeader = (ToHeader) myResponse.getHeader("To"); myToHeader.setTag("454326"); myServerTransaction.sendResponse(myResponse); myDialog = myServerTransaction.getDialog(); // logger.info(">>> "+myResponse.toString()); status = WAIT_ACK; } // inicio do envio do ACK ao cliente em confirmacao ao PROV_180 e envio do SDP Request originalRequest = myServerTransaction.getRequest(); myResponse = myMessageFactory.createResponse(200, originalRequest); // System.out.println(originalRequest.toString()); myToHeader = (ToHeader) myResponse.getHeader("To"); myResponse.addHeader(myContactHeader); // SEND ANSWER SDP ContentTypeHeader contentTypeHeader = myHeaderFactory.createContentTypeHeader("application", "sdp"); byte[] content = mySdpManager.createSdp(answerInfo); myResponse.setContent(content, contentTypeHeader); // aguardando ACK do cliente myServerTransaction.sendResponse(myResponse); myDialog = myServerTransaction.getDialog(); new Timer().schedule(new MyTimerTask(this), 500000); // Aqui!!! // logger.info(">>> " + myResponse.toString()); } if (method.equals("OPTIONS")) { if (myServerTransaction == null) { myServerTransaction = mySipProvider.getNewServerTransaction(myRequest); } Request originalRequest = myServerTransaction.getRequest(); myResponse = myMessageFactory.createResponse(200, originalRequest); myResponse.addHeader(myContactHeader); myServerTransaction.sendResponse(myResponse); } break; case ESTABLISHED: if (method.equals("BYE")) { // capturar o timestamp // logger.info(myName + ";BYE;" + getTime()); System.out.println(myName + ": BYE"); myResponse = myMessageFactory.createResponse(200, myRequest); myResponse.addHeader(myContactHeader); myServerTransaction.sendResponse(myResponse); // logger.info(">>> "+myResponse.toString()); if (ack == 1) { ack = 0; redial++; if (redial <= dialTimes) { // inserir captura timestamp logger.info(myName + ";BYE;" + getTime()); System.out.println(myName + ": rediscagem " + redial + " para: " + destination); String dstURI[] = destination.split("@"); String dstSipAlias = dstURI[0]; Address destinationAddress = myAddressFactory.createAddress(dstSipAlias + " <sip:" + destination + ">"); javax.sip.address.URI myRequestURI = destinationAddress.getURI(); Address addressOfRecord = myAddressFactory.createAddress( mySipAlias + " <sip:" + mySipAlias + "@" + myIP + ":" + myPort + ">"); // HeaderFactory comentei myHeaderFactory = mySipFactory.createHeaderFactory(); // ViaHeader comentei myViaHeader = myHeaderFactory.createViaHeader(myIP, myPort, "udp", null); ArrayList viaHeaders = new ArrayList(); viaHeaders.add(myViaHeader); MaxForwardsHeader myMaxForwardsHeader = myHeaderFactory.createMaxForwardsHeader(70); CallIdHeader myCallIdHeader = mySipProvider.getNewCallId(); CSeqHeader myCSeqHeader = myHeaderFactory.createCSeqHeader(1L, "INVITE"); FromHeader myFromHeader = myHeaderFactory.createFromHeader(addressOfRecord, "456249"); myToHeader = myHeaderFactory.createToHeader(destinationAddress, null); myRequest = myMessageFactory.createRequest( myRequestURI, "INVITE", myCallIdHeader, myCSeqHeader, myFromHeader, myToHeader, viaHeaders, myMaxForwardsHeader); Address contactAddress = myAddressFactory.createAddress( "<sip:" + mySipAlias + "@" + myIP + ":" + myPort + ">"); myContactHeader = myHeaderFactory.createContactHeader(contactAddress); myRequest.addHeader(myContactHeader); SdpInfo offerInfo = new SdpInfo(); offerInfo.IpAddress = myIP; offerInfo.aport = myAudioPort; offerInfo.aformat = 0; ContentTypeHeader contentTypeHeader = myHeaderFactory.createContentTypeHeader("application", "sdp"); byte[] content = mySdpManager.createSdp(offerInfo); myRequest.setContent(content, contentTypeHeader); // ClientTransaction Comentei aqui myClientTransaction = mySipProvider.getNewClientTransaction(myRequest); myClientTransaction.sendRequest(); logger.info(myName + ";INVITE;" + getTime()); // System.out.println(myRequest); status = WAIT_PROV; } else { status = IDLE; System.out.println(myName + ": pronto."); } } else ack++; } break; case RINGING: if (method.equals("CANCEL")) { ServerTransaction myCancelServerTransaction = requestReceivedEvent.getServerTransaction(); Request originalRequest = myServerTransaction.getRequest(); myResponse = myMessageFactory.createResponse(487, originalRequest); myServerTransaction.sendResponse(myResponse); Response myCancelResponse = myMessageFactory.createResponse(200, myRequest); myCancelServerTransaction.sendResponse(myCancelResponse); // logger.info(">>> "+myResponse.toString()); // logger.info(">>> "+myCancelResponse.toString()); status = IDLE; } break; case WAIT_ACK: if (method.equals("ACK")) { status = ESTABLISHED; System.out.println("Conectado ..."); // SendMedia(offerInfo.IpAddress, offerInfo.aport); } break; } } catch (Exception e) { e.printStackTrace(); } }
@Override public void run() { try { logger.logEntry(); // From FromHeader fromHeader = null; try { // this keep alive task only makes sense in case we have // a registrar so we deliberately use our AOR and do not // use the getOurSipAddress() method. fromHeader = provider .getHeaderFactory() .createFromHeader( provider.getRegistrarConnection().getAddressOfRecord(), SipMessageFactory.generateLocalTag()); } catch (ParseException ex) { // this should never happen so let's just log and bail. logger.error("Failed to generate a from header for " + "our register request.", ex); return; } // Call ID Header CallIdHeader callIdHeader = provider.getDefaultJainSipProvider().getNewCallId(); // CSeq Header CSeqHeader cSeqHeader = null; try { cSeqHeader = provider.getHeaderFactory().createCSeqHeader(getNextCSeqValue(), Request.OPTIONS); } catch (ParseException ex) { // Should never happen logger.error("Corrupt Sip Stack", ex); return; } catch (InvalidArgumentException ex) { // Should never happen logger.error("The application is corrupt", ex); return; } // To Header ToHeader toHeader = null; try { // this request isn't really going anywhere so we put our // own address in the To Header. toHeader = provider.getHeaderFactory().createToHeader(fromHeader.getAddress(), null); } catch (ParseException ex) { logger.error("Could not create a To header for address:" + fromHeader.getAddress(), ex); return; } // MaxForwardsHeader MaxForwardsHeader maxForwardsHeader = provider.getMaxForwardsHeader(); // Request Request request = null; try { // create a host-only uri for the request uri header. String domain = ((SipURI) toHeader.getAddress().getURI()).getHost(); // request URI SipURI requestURI = provider.getAddressFactory().createSipURI(null, domain); // Via Headers ArrayList<ViaHeader> viaHeaders = provider.getLocalViaHeaders(requestURI); request = provider .getMessageFactory() .createRequest( requestURI, Request.OPTIONS, callIdHeader, cSeqHeader, fromHeader, toHeader, viaHeaders, maxForwardsHeader); if (logger.isDebugEnabled()) logger.debug("Created OPTIONS request " + request); } catch (ParseException ex) { logger.error("Could not create an OPTIONS request!", ex); return; } Iterator<String> supportedMethods = provider.getSupportedMethods().iterator(); // add to the allows header all methods that we support while (supportedMethods.hasNext()) { String method = supportedMethods.next(); // don't support REGISTERs if (method.equals(Request.REGISTER)) continue; request.addHeader(provider.getHeaderFactory().createAllowHeader(method)); } Iterator<String> events = provider.getKnownEventsList().iterator(); synchronized (provider.getKnownEventsList()) { while (events.hasNext()) { String event = events.next(); request.addHeader(provider.getHeaderFactory().createAllowEventsHeader(event)); } } // Transaction ClientTransaction optionsTrans = null; try { optionsTrans = provider.getDefaultJainSipProvider().getNewClientTransaction(request); } catch (TransactionUnavailableException ex) { logger.error("Could not create options transaction!\n", ex); return; } try { optionsTrans.sendRequest(); if (logger.isDebugEnabled()) logger.debug("sent request= " + request); } catch (SipException ex) { logger.error("Could not send out the options request!", ex); if (ex.getCause() instanceof IOException) { // IOException problem with network disconnect(); } return; } } catch (Exception ex) { logger.error("Cannot send OPTIONS keep alive", ex); } }
/** * Tries to steer a TI client transaction through the following scenario * Calling-->Completed-->Terminated. Apart from state transitions, we also test, retransmissions * and proper hiding/passing of messages to the TU. */ public void testCallingCompletedTerminatedScenario() { try { Request invite = createTiInviteRequest(null, null, null); // JvB: test // ((MessageExt) invite).getFirstViaHeader().setParameter( "rport", // null ); ClientTransaction tran = null; try { eventCollector.collectRequestEvent(riSipProvider); tran = tiSipProvider.getNewClientTransaction(invite); 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()); // Check Request retransmission try { eventCollector.collectRequestEvent(riSipProvider); } catch (TooManyListenersException ex) { throw new TckInternalError("Failed to regiest a SipListener with an RI SipProvider", ex); } // Wait for the retransmission timer to fire if it had not already // done so. if (tran.getRetransmitTimer() > MESSAGES_ARRIVE_FOR) sleep((long) tran.getRetransmitTimer() - MESSAGES_ARRIVE_FOR); // subtract // the // time // we // waited // for // the // invite // Wait for the retransmitted request to arrive waitForMessage(); inviteReceivedEvent = eventCollector.extractCollectedRequestEvent(); assertNotNull("The invite request was not retransmitted!", inviteReceivedEvent); assertNotNull("The invite request was not retransmitted!", inviteReceivedEvent.getRequest()); assertEquals(Request.INVITE, inviteReceivedEvent.getRequest().getMethod()); // At this point the ClientTransaction should STILL be CALLING! assertEquals(TransactionState.CALLING, tran.getState()); // Send a 486 BUSY HERE (final) response from the RI try { eventCollector.collectResponseEvent(tiSipProvider); } catch (TooManyListenersException ex) { throw new TiUnexpectedError("Failed to register a SipListener with TI", ex); } // The BUSY_HERE response should trigger some ACKs so let's register // a listener with the RI 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 busyHere = null; try { busyHere = riMessageFactory.createResponse(Response.BUSY_HERE, inviteReceivedEvent.getRequest()); addStatus(inviteReceivedEvent.getRequest(), busyHere); // JvB: set to-tag, check it against the ACK generated ((ToHeader) busyHere.getHeader("to")).setTag("ack-to-test"); riSipProvider.sendResponse((Response) busyHere.clone()); } catch (Throwable ex) { throw new TckInternalError( "The TCK could not send a BUSY HERE response back to the TI", ex); } waitForMessage(); // Analyze the BUSY_HERE response and Tran state back at the TI ResponseEvent 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 BUSY_HERE response was not associated with the right transaction", tran, responseEvent.getClientTransaction()); assertSame( "A response different from BUSY_HERE was passed to the TU", tran, responseEvent.getClientTransaction()); 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", ackReceivedEvent); assertNotNull("The TI did not send an ACK request", ackReceivedEvent.getRequest()); assertEquals(Request.ACK, ackReceivedEvent.getRequest().getMethod()); // Try to kill remaining ACK retransmissions // TODO this may not always work .. should give it a specific // timeout value waitForMessage(); // Now let's retransmit the final response. This time it shouldn't // be // passed to the TU but an ACK should still be sent try { eventCollector.collectResponseEvent(tiSipProvider); } catch (TooManyListenersException ex) { throw new TiUnexpectedError("Failed to register a SipListener with TI", ex); } // go fish the ack try { ackCollector.collectRequestEvent(riSipProvider); } catch (TooManyListenersException ex) { throw new TckInternalError("Failed to regiest a SipListener with an RI SipProvider", ex); } try { riSipProvider.sendResponse((Response) busyHere.clone()); } catch (Throwable ex) { throw new TckInternalError( "The TCK could not send a BUSY HERE response back to the TI", ex); } waitForMessage(); // The TU shouldn't see the retransmitted BUSY_HERE response responseEvent = eventCollector.extractCollectedResponseEvent(); assertNull( "The Tested Implementation passed a retransmitted 300-699 response " + "to the TU instead of just silently acknowledging it!", responseEvent); // We must still be in the completed state. assertEquals( "The ClientTransaction did not stay long enough in the COMPLETED " + "state.", tran.getState(), TransactionState.COMPLETED); // check whether the ackCollector has caught any fish ackReceivedEvent = ackCollector.extractCollectedRequestEvent(); assertNotNull("The TI did not send an ACK request to the second response", ackReceivedEvent); assertNotNull( "The TI did not send an ACK request to the second response", ackReceivedEvent.getRequest()); assertEquals(Request.ACK, ackReceivedEvent.getRequest().getMethod()); // JvB: verify to tag assertEquals( "The To header field in the ACK MUST equal the To header field " + " in the response being acknowledged", "ack-to-test", ((ToHeader) ackReceivedEvent.getRequest().getHeader("to")).getTag()); } 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 timerD // is not exported by JAIN SIP }
public void leaveConference() { log.info("leaveConference()"); try { String fromName = "notetaker"; String fromSipAddress = "jmik.org"; String fromDisplayName = "Conference Note Taker"; String toSipAddress = peerIP; String toUser = roomId; String toDisplayName = roomId; // create >From Header SipURI fromAddress = addressFactory.createSipURI(fromName, fromSipAddress); Address fromNameAddress = addressFactory.createAddress(fromAddress); fromNameAddress.setDisplayName(fromDisplayName); FromHeader fromHeader = headerFactory.createFromHeader(fromNameAddress, "12345"); // create To Header SipURI toAddress = addressFactory.createSipURI(toUser, toSipAddress); Address toNameAddress = addressFactory.createAddress(toAddress); toNameAddress.setDisplayName(toDisplayName); ToHeader toHeader = headerFactory.createToHeader(toNameAddress, null); // create Request URI SipURI requestURI = addressFactory.createSipURI(toUser, peerIP + ":" + peerPort); // Create ViaHeaders ArrayList<ViaHeader> viaHeaders = new ArrayList<ViaHeader>(); ViaHeader viaHeader = headerFactory.createViaHeader(myIP, myPort, "udp", null); viaHeaders.add(viaHeader); // Create ContentTypeHeader ContentTypeHeader contentTypeHeader = headerFactory.createContentTypeHeader("application", "sdp"); // Create a new CallId header CallIdHeader callIdHeader = headerFactory.createCallIdHeader(callId); // Create a new Cseq header CSeqHeader cSeqHeader = headerFactory.createCSeqHeader(3, Request.BYE); // Create a new MaxForwardsHeader MaxForwardsHeader maxForwards = headerFactory.createMaxForwardsHeader(70); // Create the request. Request request = messageFactory.createRequest( requestURI, Request.BYE, callIdHeader, cSeqHeader, fromHeader, toHeader, viaHeaders, maxForwards); // Create contact headers String contactHost = sipStack.getIPAddress(); SipURI contactUrl = addressFactory.createSipURI(fromName, contactHost); contactUrl.setPort(myPort); // Create the contact name address. SipURI contactURI = addressFactory.createSipURI(fromName, myIP); contactURI.setPort(myPort); Address contactAddress = addressFactory.createAddress(contactURI); // Add the contact address. contactAddress.setDisplayName(fromName); ContactHeader contactHeader = headerFactory.createContactHeader(contactAddress); request.addHeader(contactHeader); // Create the client transaction. ClientTransaction inviteTid = sipProvider.getNewClientTransaction(request); // send the request out. inviteTid.sendRequest(); log.info("leaveConference invite \n" + request); } catch (Exception e) { throw new RuntimeException(e); } }
public void joinConference() { log.info("joinConference()"); try { String fromName = "notetaker"; String fromSipAddress = "jmik.org"; String fromDisplayName = "Conference Note Taker"; String toSipAddress = peerIP; String toUser = roomId; String toDisplayName = roomId; // create >From Header SipURI fromAddress = addressFactory.createSipURI(fromName, fromSipAddress); Address fromNameAddress = addressFactory.createAddress(fromAddress); fromNameAddress.setDisplayName(fromDisplayName); FromHeader fromHeader = headerFactory.createFromHeader(fromNameAddress, "12345"); // create To Header SipURI toAddress = addressFactory.createSipURI(toUser, toSipAddress); Address toNameAddress = addressFactory.createAddress(toAddress); toNameAddress.setDisplayName(toDisplayName); ToHeader toHeader = headerFactory.createToHeader(toNameAddress, null); // create Request URI SipURI requestURI = addressFactory.createSipURI(toUser, peerIP + ":" + peerPort); // Create ViaHeaders ArrayList<ViaHeader> viaHeaders = new ArrayList<ViaHeader>(); ViaHeader viaHeader = headerFactory.createViaHeader(myIP, myPort, "udp", null); viaHeaders.add(viaHeader); // Create ContentTypeHeader ContentTypeHeader contentTypeHeader = headerFactory.createContentTypeHeader("application", "sdp"); // Create a new CallId header CallIdHeader callIdHeader = sipProvider.getNewCallId(); callId = callIdHeader.getCallId(); // Create a new Cseq header CSeqHeader cSeqHeader = headerFactory.createCSeqHeader(1, Request.INVITE); // Create a new MaxForwardsHeader MaxForwardsHeader maxForwards = headerFactory.createMaxForwardsHeader(70); // Create the request. Request request = messageFactory.createRequest( requestURI, Request.INVITE, callIdHeader, cSeqHeader, fromHeader, toHeader, viaHeaders, maxForwards); // Create contact headers String contactHost = sipStack.getIPAddress(); SipURI contactUrl = addressFactory.createSipURI(fromName, contactHost); contactUrl.setPort(myPort); // Create the contact name address. SipURI contactURI = addressFactory.createSipURI(fromName, myIP); contactURI.setPort(myPort); Address contactAddress = addressFactory.createAddress(contactURI); // Add the contact address. contactAddress.setDisplayName(fromName); ContactHeader contactHeader = headerFactory.createContactHeader(contactAddress); request.addHeader(contactHeader); String sdpData = "v=0\r\n" + "o=username 0 0" + "IN IP4 " + myIP + "\r\n" + "s=The Funky Flow\r\n" + "c=IN IP4 " + myIP + "\r\n" + "t=0 0\r\n" + "m=audio 0 RTP/AVP 0 97 8 3\r\n" + "a=rtpmap:0 PCMU/8000\r\n" + "a=rtpmap:3 GSM/8000\r\n" + "a=rtpmap:8 PCMA/8000\r\n" + "a=rtpmap:97 iLBC/8000\r\n" + "a=fmtp:97 mode=30\r\n"; request.setContent(sdpData, contentTypeHeader); if (logger.isDebugEnabled()) logger.debug("request\n:" + request + "\n"); // Create the client transaction. ClientTransaction inviteTid = sipProvider.getNewClientTransaction(request); // send the request out. inviteTid.sendRequest(); log.info("joinConference invite sent"); } catch (Exception e) { throw new RuntimeException(e); } }
public void sendPublish(String localURI, String status) { try { logger.debug("Sending PUBLISH in progress"); int proxyPort = imUA.getProxyPort(); String proxyAddress = imUA.getProxyAddress(); String imProtocol = imUA.getIMProtocol(); SipStack sipStack = imUA.getSipStack(); SipProvider sipProvider = imUA.getSipProvider(); MessageFactory messageFactory = imUA.getMessageFactory(); HeaderFactory headerFactory = imUA.getHeaderFactory(); AddressFactory addressFactory = imUA.getAddressFactory(); // Request-URI: if (localURI.startsWith("sip:")) localURI = localURI.substring(4, localURI.length()); SipURI requestURI = addressFactory.createSipURI(null, localURI); requestURI.setPort(proxyPort); requestURI.setTransportParam(imProtocol); // Via header String branchId = Utils.generateBranchId(); ViaHeader viaHeader = headerFactory.createViaHeader( imUA.getIMAddress(), imUA.getIMPort(), imProtocol, branchId); Vector viaList = new Vector(); viaList.addElement(viaHeader); // To header: System.out.println("XXX localURI=" + localURI); Address localAddress = addressFactory.createAddress("sip:" + localURI); ToHeader toHeader = headerFactory.createToHeader(localAddress, null); // From header: String localTag = Utils.generateTag(); FromHeader fromHeader = headerFactory.createFromHeader(localAddress, localTag); // Call-ID: CallIdHeader callIdHeader = headerFactory.createCallIdHeader(callIdCounter + localURI); // CSeq: CSeqHeader cseqHeader = headerFactory.createCSeqHeader(1L, "PUBLISH"); // MaxForwards header: MaxForwardsHeader maxForwardsHeader = headerFactory.createMaxForwardsHeader(70); // Create Request Request request = messageFactory.createRequest( requestURI, "PUBLISH", callIdHeader, cseqHeader, fromHeader, toHeader, viaList, maxForwardsHeader); // Expires header: (none, let server chose) // Event header: Header header = headerFactory.createHeader("Event", "presence"); request.setHeader(header); RouteHeader routeHeader = this.imUA.getRouteToProxy(); request.setHeader(routeHeader); // Content and Content-Type header: String basic; if (status.equals("offline")) basic = "closed"; else basic = "open"; String content = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + "<presence xmlns=\"urn:ietf:params:xml:ns:pidf\"" + " entity=\"" + localURI + "\">\n" + " <tuple id=\"" + entity + "\">\n" + " <status>\n" + " <basic>" + basic + "</basic>\n" + " </status>\n" + " <note>" + status + "</note>\n" + " </tuple>\n" + "</presence>"; ContentTypeHeader contentTypeHeader = headerFactory.createContentTypeHeader("application", "pidf+xml"); request.setContent(content, contentTypeHeader); // Content-Length header: ContentLengthHeader contentLengthHeader = headerFactory.createContentLengthHeader(content.length()); request.setContentLength(contentLengthHeader); // Send request ClientTransaction clientTransaction = sipProvider.getNewClientTransaction(request); clientTransaction.sendRequest(); } catch (Exception ex) { ex.printStackTrace(); } }
public ClientTransaction call(SipURI destination) { try { String fromName = "B2BUA"; String fromSipAddress = "here.com"; String fromDisplayName = "B2BUA"; String toSipAddress = "there.com"; String toUser = "******"; String toDisplayName = "Target"; // create >From Header SipURI fromAddress = addressFactory.createSipURI(fromName, fromSipAddress); Address fromNameAddress = addressFactory.createAddress(fromAddress); fromNameAddress.setDisplayName(fromDisplayName); FromHeader fromHeader = headerFactory.createFromHeader( fromNameAddress, new Long(counter.getAndIncrement()).toString()); // create To Header SipURI toAddress = addressFactory.createSipURI(toUser, toSipAddress); Address toNameAddress = addressFactory.createAddress(toAddress); toNameAddress.setDisplayName(toDisplayName); ToHeader toHeader = headerFactory.createToHeader(toNameAddress, null); // create Request URI SipURI requestURI = destination; // Create ViaHeaders ArrayList viaHeaders = new ArrayList(); String ipAddress = listeningPoint.getIPAddress(); ViaHeader viaHeader = headerFactory.createViaHeader( ipAddress, sipProvider.getListeningPoint(transport).getPort(), transport, null); // add via headers viaHeaders.add(viaHeader); // Create ContentTypeHeader ContentTypeHeader contentTypeHeader = headerFactory.createContentTypeHeader("application", "sdp"); // Create a new CallId header CallIdHeader callIdHeader = sipProvider.getNewCallId(); // Create a new Cseq header CSeqHeader cSeqHeader = headerFactory.createCSeqHeader(1L, Request.INVITE); // Create a new MaxForwardsHeader MaxForwardsHeader maxForwards = headerFactory.createMaxForwardsHeader(70); // Create the request. Request request = messageFactory.createRequest( requestURI, Request.INVITE, callIdHeader, cSeqHeader, fromHeader, toHeader, viaHeaders, maxForwards); // Create contact headers String host = "127.0.0.1"; SipURI contactUrl = addressFactory.createSipURI(fromName, host); contactUrl.setPort(listeningPoint.getPort()); contactUrl.setLrParam(); // Create the contact name address. SipURI contactURI = addressFactory.createSipURI(fromName, host); contactURI.setPort(sipProvider.getListeningPoint(transport).getPort()); Address contactAddress = addressFactory.createAddress(contactURI); // Add the contact address. contactAddress.setDisplayName(fromName); ContactHeader contactHeader = headerFactory.createContactHeader(contactAddress); request.addHeader(contactHeader); // You can add extension headers of your own making // to the outgoing SIP request. // Add the extension header. Header extensionHeader = headerFactory.createHeader("My-Header", "my header value"); request.addHeader(extensionHeader); String sdpData = "v=0\r\n" + "o=4855 13760799956958020 13760799956958020" + " IN IP4 129.6.55.78\r\n" + "s=mysession session\r\n" + "p=+46 8 52018010\r\n" + "c=IN IP4 129.6.55.78\r\n" + "t=0 0\r\n" + "m=audio 6022 RTP/AVP 0 4 18\r\n" + "a=rtpmap:0 PCMU/8000\r\n" + "a=rtpmap:4 G723/8000\r\n" + "a=rtpmap:18 G729A/8000\r\n" + "a=ptime:20\r\n"; byte[] contents = sdpData.getBytes(); request.setContent(contents, contentTypeHeader); // You can add as many extension headers as you // want. extensionHeader = headerFactory.createHeader("My-Other-Header", "my new header value "); request.addHeader(extensionHeader); Header callInfoHeader = headerFactory.createHeader("Call-Info", "<http://www.antd.nist.gov>"); request.addHeader(callInfoHeader); // Create the client transaction. ClientTransaction inviteTid = sipProvider.getNewClientTransaction(request); System.out.println("inviteTid = " + inviteTid); // send the request out. inviteTid.sendRequest(); return inviteTid; } catch (Exception ex) { System.out.println(ex.getMessage()); ex.printStackTrace(); } return null; }
/** * Tries to steer a TI client transaction through the following scenario Calling-->Terminated. * Apart from state transitions, we also test, retransmissions and proper hiding/passing of * messages to the TU. */ public void testCallingTerminatedScenario() { try { Request invite = createTiInviteRequest(null, null, null); ClientTransaction tran = null; try { eventCollector.collectRequestEvent(riSipProvider); tran = tiSipProvider.getNewClientTransaction(invite); 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()); // Check Request retransmission try { eventCollector.collectRequestEvent(riSipProvider); } catch (TooManyListenersException ex) { throw new TckInternalError("Failed to regiest a SipListener with an RI SipProvider", ex); } // Wait for the retransmission timer to fire if it had not already // done so. if (tran.getRetransmitTimer() > MESSAGES_ARRIVE_FOR) sleep((long) tran.getRetransmitTimer() - MESSAGES_ARRIVE_FOR); // subtract // the // time // we // waited // for // the // invite // Wait for the retransmitted request to arrive waitForMessage(); inviteReceivedEvent = eventCollector.extractCollectedRequestEvent(); assertNotNull("The invite request was not retransmitted!", inviteReceivedEvent); assertNotNull("The invite request was not retransmitted!", inviteReceivedEvent.getRequest()); assertEquals(Request.INVITE, inviteReceivedEvent.getRequest().getMethod()); // At this point the ClientTransaction should STILL be CALLING! assertEquals(TransactionState.CALLING, tran.getState()); // Send a 200 OK (final) response from the RI try { eventCollector.collectResponseEvent(tiSipProvider); } catch (TooManyListenersException ex) { throw new TiUnexpectedError("Failed to register a SipListener with TI", ex); } // The OK response shouldn't trigger any ACKs so let's register // a listener with the RI to verify whether that is the case 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 ok = null; try { ok = riMessageFactory.createResponse(Response.OK, inviteReceivedEvent.getRequest()); addStatus(inviteReceivedEvent.getRequest(), ok); // JvB: MUST add Contact too! ContactHeader contact = riHeaderFactory.createContactHeader(((ToHeader) ok.getHeader("To")).getAddress()); ok.addHeader(contact); // end JvB riSipProvider.sendResponse(ok); } catch (Throwable ex) { throw new TckInternalError("The TCK could not send an OK response back to the TI", ex); } waitForMessage(); // Analyze the OK response and Tran state back at the TI ResponseEvent responseEvent = eventCollector.extractCollectedResponseEvent(); assertNotNull( "The Tested Implementation did not pass a 200 OK response to the TU!", responseEvent); assertNotNull( "The Tested Implementation did not pass a 200 OK response to the TU!", responseEvent.getResponse()); assertSame( "The OK response was not associated with the right transaction", tran, responseEvent.getClientTransaction()); assertSame( "A response different from OK was passed to the TU", tran, responseEvent.getClientTransaction()); assertEquals( "The ClientTransaction did not pass in the TERMINATED state after " + "receiving 200 final response", tran.getState(), TransactionState.TERMINATED); // check whether the ackCollector has caught any fish RequestEvent ackReceivedEvent = ackCollector.extractCollectedRequestEvent(); assertNull("The TI sent an ACK to an OK (this is TU's job)!", ackReceivedEvent); // Now let's retransmit the final response and see that it is // passed to the TU (again no ACKs should be sent by the TI) try { eventCollector.collectResponseEvent(tiSipProvider); } catch (TooManyListenersException ex) { throw new TiUnexpectedError("Failed to register a SipListener with TI", ex); } // go fish the ack try { ackCollector.collectRequestEvent(riSipProvider); } catch (TooManyListenersException ex) { throw new TckInternalError("Failed to regiest a SipListener with an RI SipProvider", ex); } try { riSipProvider.sendResponse((Response) ok.clone()); } catch (Throwable ex) { throw new TckInternalError("The TCK could not send an OK response back to the TI", ex); } waitForMessage(); // Did we get the 2nd OK? responseEvent = eventCollector.extractCollectedResponseEvent(); /* * JvB: see previous comment * * assertNotNull( "The TI did not pass to the TU a retransmitted OK * response!", responseEvent); assertNotNull( "The TI did not pass * to the TU a retransmitted OK response!", * responseEvent.getResponse()); assertTrue( "The TI passed to the * TU a bad response!", * responseEvent.getResponse().getStatusCode()==Response.OK); */ // JvB: TBD // assertNull( "The TI should filter the retransmitted OK response", // responseEvent ); // We must still be in the terminated state. assertEquals( "The ClientTransaction mysteriously left the TERMINATED state!", tran.getState(), TransactionState.TERMINATED); // check whether the ackCollector has caught any fish ackReceivedEvent = ackCollector.extractCollectedRequestEvent(); assertNull( "The TI sent an ACK request to the second OK response " + "(OK acks are TU's responsibility)!", ackReceivedEvent); } catch (Throwable exc) { exc.printStackTrace(); fail(exc.getClass().getName() + ": " + exc.getMessage()); } assertTrue(new Exception().getStackTrace()[0].toString(), true); }
public void sendMessage( String localSipURL, String remoteSipURL, String text, ChatSession chatSession) { try { DebugIM.println("IMMessageProcessing, ChatSession:" + chatSession); DebugIM.println("Sending a MESSAGE in progress to " + remoteSipURL); SipProvider sipProvider = imUA.getSipProvider(); MessageFactory messageFactory = imUA.getMessageFactory(); HeaderFactory headerFactory = imUA.getHeaderFactory(); AddressFactory addressFactory = imUA.getAddressFactory(); String proxyAddress = imUA.getProxyAddress(); SipURI requestURI = null; if (proxyAddress != null) { requestURI = addressFactory.createSipURI(null, proxyAddress); requestURI.setPort(imUA.getProxyPort()); requestURI.setTransportParam(imUA.getIMProtocol()); } else { requestURI = (SipURI) addressFactory.createURI(remoteSipURL); requestURI.setTransportParam(imUA.getIMProtocol()); } // Call-Id: CallIdHeader callIdHeader = null; // CSeq: CSeqHeader cseqHeader = null; // To header: ToHeader toHeader = null; // From Header: FromHeader fromHeader = null; // Via header String branchId = Utils.generateBranchId(); ViaHeader viaHeader = headerFactory.createViaHeader( imUA.getIMAddress(), imUA.getIMPort(), imUA.getIMProtocol(), branchId); Vector viaList = new Vector(); viaList.addElement(viaHeader); // MaxForwards header: MaxForwardsHeader maxForwardsHeader = headerFactory.createMaxForwardsHeader(70); Dialog dialog = chatSession.getDialog(); if (chatSession.isEstablishedSession()) { DebugIM.println( "DEBUG, IMMessageProcessing, sendMessage(), we get" + " the DIALOG from the ChatSession"); Address localAddress = dialog.getLocalParty(); Address remoteAddress = dialog.getRemoteParty(); // if (dialog.isServer()) { // We received the first MESSAGE fromHeader = headerFactory.createFromHeader(localAddress, dialog.getLocalTag()); toHeader = headerFactory.createToHeader(remoteAddress, dialog.getRemoteTag()); // } // else { // } int cseq = dialog.getLocalSequenceNumber(); DebugIM.println("the cseq number got from the dialog:" + cseq); cseqHeader = headerFactory.createCSeqHeader(cseq, "MESSAGE"); callIdHeader = dialog.getCallId(); } else { DebugIM.println( "DEBUG, IMMessageProcessing, sendMessage(), the " + " session has not been established yet! We create the first message"); // To header: Address toAddress = addressFactory.createAddress(remoteSipURL); // From Header: Address fromAddress = addressFactory.createAddress(localSipURL); // We have to initiate the dialog: means to create the From tag String localTag = Utils.generateTag(); fromHeader = headerFactory.createFromHeader(fromAddress, localTag); toHeader = headerFactory.createToHeader(toAddress, null); // CSeq: cseqHeader = headerFactory.createCSeqHeader(1, "MESSAGE"); // Call-ID: callIdCounter++; callIdHeader = (CallIdHeader) headerFactory.createCallIdHeader("nist-sip-im-message-callId" + callIdCounter); } // Content-Type: ContentTypeHeader contentTypeHeader = headerFactory.createContentTypeHeader("text", "plain"); contentTypeHeader.setParameter("charset", "UTF-8"); Request request = messageFactory.createRequest( requestURI, "MESSAGE", callIdHeader, cseqHeader, fromHeader, toHeader, viaList, maxForwardsHeader, contentTypeHeader, text); // Contact header: SipURI sipURI = addressFactory.createSipURI(null, imUA.getIMAddress()); sipURI.setPort(imUA.getIMPort()); sipURI.setTransportParam(imUA.getIMProtocol()); Address contactAddress = addressFactory.createAddress(sipURI); ContactHeader contactHeader = headerFactory.createContactHeader(contactAddress); request.setHeader(contactHeader); // ProxyAuthorization header if not null: ProxyAuthorizationHeader proxyAuthHeader = imUA.getProxyAuthorizationHeader(); if (proxyAuthHeader != null) request.setHeader(proxyAuthHeader); ClientTransaction clientTransaction = sipProvider.getNewClientTransaction(request); if (chatSession.isEstablishedSession()) { dialog.sendRequest(clientTransaction); DebugIM.println( "IMessageProcessing, sendMessage(), MESSAGE sent" + " using the dialog:\n" + request); } else { clientTransaction.sendRequest(); DebugIM.println( "IMessageProcessing, sendMessage(), MESSAGE sent" + " using a new client transaction:\n" + request); } } catch (Exception ex) { ex.printStackTrace(); } }
public void sendSubscribe(String localURL, String buddyURI, boolean EXPIRED) { try { logger.debug("Sending SUBSCRIBE in progress to the buddy: " + buddyURI); int proxyPort = imUA.getProxyPort(); String proxyAddress = imUA.getProxyAddress(); String imProtocol = imUA.getIMProtocol(); SipStack sipStack = imUA.getSipStack(); SipProvider sipProvider = imUA.getSipProvider(); MessageFactory messageFactory = imUA.getMessageFactory(); HeaderFactory headerFactory = imUA.getHeaderFactory(); AddressFactory addressFactory = imUA.getAddressFactory(); // Request-URI: // URI requestURI=addressFactory.createURI(buddyURI); SipURI requestURI = addressFactory.createSipURI(null, proxyAddress); requestURI.setPort(proxyPort); requestURI.setTransportParam(imProtocol); // Call-Id: CallIdHeader callIdHeader = null; // CSeq: CSeqHeader cseqHeader = null; // To header: ToHeader toHeader = null; // From Header: FromHeader fromHeader = null; // Via header String branchId = Utils.generateBranchId(); ViaHeader viaHeader = headerFactory.createViaHeader( imUA.getIMAddress(), imUA.getIMPort(), imProtocol, branchId); Vector viaList = new Vector(); viaList.addElement(viaHeader); PresenceManager presenceManager = imUA.getPresenceManager(); Presentity presentity = presenceManager.getPresentity(buddyURI); Dialog dialog = null; if (presentity != null) dialog = presentity.getDialog(); if (dialog != null) { // We have to remove the subscriber and the Presentity related // with this Buddy... presenceManager.removePresentity(buddyURI); Subscriber subscriber = presenceManager.getSubscriber(buddyURI); if (subscriber == null) { // It means that the guy does not have us in his buddy list // nothing to do!!! } else { presenceManager.removeSubscriber(buddyURI); } Address localAddress = dialog.getLocalParty(); Address remoteAddress = dialog.getRemoteParty(); fromHeader = headerFactory.createFromHeader(localAddress, dialog.getLocalTag()); toHeader = headerFactory.createToHeader(remoteAddress, dialog.getRemoteTag()); long cseq = dialog.getLocalSeqNumber(); cseqHeader = headerFactory.createCSeqHeader(cseq, "MESSAGE"); callIdHeader = dialog.getCallId(); } else { String localTag = Utils.generateTag(); Address toAddress = addressFactory.createAddress(buddyURI); Address fromAddress = addressFactory.createAddress(localURL); fromHeader = headerFactory.createFromHeader(fromAddress, localTag); toHeader = headerFactory.createToHeader(toAddress, null); // CSeq: cseqHeader = headerFactory.createCSeqHeader(1L, "SUBSCRIBE"); callIdCounter++; // Call-ID: callIdHeader = (CallIdHeader) headerFactory.createCallIdHeader("nist-sip-im-subscribe-callId" + callIdCounter); } // MaxForwards header: MaxForwardsHeader maxForwardsHeader = headerFactory.createMaxForwardsHeader(70); Request request = messageFactory.createRequest( requestURI, "SUBSCRIBE", callIdHeader, cseqHeader, fromHeader, toHeader, viaList, maxForwardsHeader); RouteHeader rh = this.imUA.getRouteToProxy(); request.setHeader(rh); // Contact header: SipURI sipURI = addressFactory.createSipURI(null, imUA.getIMAddress()); sipURI.setPort(imUA.getIMPort()); sipURI.setTransportParam(imUA.getIMProtocol()); Address contactAddress = addressFactory.createAddress(sipURI); ContactHeader contactHeader = headerFactory.createContactHeader(contactAddress); request.setHeader(contactHeader); ExpiresHeader expiresHeader = null; if (EXPIRED) { expiresHeader = headerFactory.createExpiresHeader(0); } else { expiresHeader = headerFactory.createExpiresHeader(presenceManager.getExpiresTime()); } request.setHeader(expiresHeader); // WE have to add a new Header: "Event" Header eventHeader = headerFactory.createHeader("Event", "presence"); request.setHeader(eventHeader); // Add Acceptw Header Header acceptHeader = headerFactory.createHeader("Accept", "application/pidf+xml"); request.setHeader(acceptHeader); // ProxyAuthorization header if not null: ProxyAuthorizationHeader proxyAuthHeader = imUA.getProxyAuthorizationHeader(); if (proxyAuthHeader != null) request.setHeader(proxyAuthHeader); ClientTransaction clientTransaction = sipProvider.getNewClientTransaction(request); if (dialog != null) { dialog.sendRequest(clientTransaction); } else { clientTransaction.sendRequest(); } logger.debug("IMSubscribeProcessing, sendSubscribe(), SUBSCRIBE sent:\n" + request); } catch (Exception ex) { ex.printStackTrace(); } }
/** Tests creating of ACK requests. */ public void testCreateAck() { try { // 1. Create and send the original request Request invite = createTiInviteRequest(null, null, null); RequestEvent receivedRequestEvent = null; ClientTransaction tran = null; try { tran = tiSipProvider.getNewClientTransaction(invite); eventCollector.collectRequestEvent(riSipProvider); tran.sendRequest(); waitForMessage(); receivedRequestEvent = eventCollector.extractCollectedRequestEvent(); if (receivedRequestEvent == null || receivedRequestEvent.getRequest() == null) throw new TiUnexpectedError("The sent request was not received by the RI!"); } catch (TooManyListenersException ex) { throw new TckInternalError( "A TooManyListenersException was thrown while trying to add " + "a SipListener to an RI SipProvider.", ex); } catch (SipException ex) { throw new TiUnexpectedError("The TI failed to send the request!", ex); } Request receivedRequest = receivedRequestEvent.getRequest(); // 2. Create and send the response Response ok = null; try { ok = riMessageFactory.createResponse(Response.OK, receivedRequest); } catch (ParseException ex) { throw new TckInternalError("Failed to create an OK response!", ex); } // Send the response using the RI and collect using TI try { eventCollector.collectResponseEvent(tiSipProvider); } catch (TooManyListenersException ex) { throw new TiUnexpectedError("Error while trying to add riSipProvider"); } try { riSipProvider.sendResponse(ok); } catch (SipException ex) { throw new TckInternalError("Could not send back the response", ex); } waitForMessage(); ResponseEvent responseEvent = eventCollector.extractCollectedResponseEvent(); // 3. Now let's create the ack if (responseEvent == null || responseEvent.getResponse() == null) throw new TiUnexpectedError("The TI failed to receive the response!"); if (responseEvent.getClientTransaction() != tran) throw new TiUnexpectedError( "The TI has associated a new ClientTransaction to a response " + "instead of using existing one!"); Request ack = null; try { ack = tran.createAck(); } catch (SipException ex) { ex.printStackTrace(); fail("A SipException was thrown while creating an ack request"); } assertNotNull("ClientTransaction.createAck returned null!", ack); assertEquals( "The created request did not have a CANCEL method.", ack.getMethod(), Request.ACK); assertEquals( "Request-URIs of the original and the ack request do not match", ack.getRequestURI(), invite.getRequestURI()); assertEquals( "Call-IDs of the original and the ack request do not match", ack.getHeader(CallIdHeader.NAME), invite.getHeader(CallIdHeader.NAME)); assertEquals( "ToHeaders of the original and the ack request do not match", ack.getHeader(ToHeader.NAME), invite.getHeader(ToHeader.NAME)); assertTrue( "The CSeqHeader's sequence number of the original and " + "the ack request do not match", ((CSeqHeader) ack.getHeader(CSeqHeader.NAME)).getSequenceNumber() == ((CSeqHeader) invite.getHeader(CSeqHeader.NAME)).getSequenceNumber()); assertEquals( "The CSeqHeader's method of the ack request was not ACK", ((CSeqHeader) ack.getHeader(CSeqHeader.NAME)).getMethod(), Request.ACK); } catch (Throwable exc) { exc.printStackTrace(); fail(exc.getClass().getName() + ": " + exc.getMessage()); } assertTrue(new Exception().getStackTrace()[0].toString(), true); }
/** * 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 }
public void init() { SipFactory sipFactory = null; sipStack = null; sipFactory = SipFactory.getInstance(); sipFactory.setPathName("gov.nist"); Properties properties = new Properties(); // If you want to try TCP transport change the following to String transport = "udp"; String peerHostPort = "127.0.0.1:5070"; properties.setProperty("javax.sip.OUTBOUND_PROXY", peerHostPort + "/" + transport); // If you want to use UDP then uncomment this. properties.setProperty("javax.sip.STACK_NAME", "shootist"); // The following properties are specific to nist-sip // and are not necessarily part of any other jain-sip // implementation. // You can set a max message size for tcp transport to // guard against denial of service attack. properties.setProperty("gov.nist.javax.sip.DEBUG_LOG", "shootistdebug.txt"); properties.setProperty("gov.nist.javax.sip.SERVER_LOG", "shootistlog.txt"); // Drop the client connection after we are done with the transaction. properties.setProperty("gov.nist.javax.sip.CACHE_CLIENT_CONNECTIONS", "false"); // Set to 0 (or NONE) in your production code for max speed. // You need 16 (or TRACE) for logging traces. 32 (or DEBUG) for debug + traces. // Your code will limp at 32 but it is best for debugging. properties.setProperty("gov.nist.javax.sip.TRACE_LEVEL", "DEBUG"); if (System.getProperty("enableNIO") != null && System.getProperty("enableNIO").equalsIgnoreCase("true")) { properties.setProperty( "gov.nist.javax.sip.MESSAGE_PROCESSOR_FACTORY", NioMessageProcessorFactory.class.getName()); } try { // Create SipStack object sipStack = sipFactory.createSipStack(properties); System.out.println("createSipStack " + sipStack); } catch (PeerUnavailableException e) { // could not find // gov.nist.jain.protocol.ip.sip.SipStackImpl // in the classpath e.printStackTrace(); System.err.println(e.getMessage()); fail("Problem with setup"); } try { headerFactory = sipFactory.createHeaderFactory(); addressFactory = sipFactory.createAddressFactory(); messageFactory = sipFactory.createMessageFactory(); udpListeningPoint = sipStack.createListeningPoint("127.0.0.1", 5060, "udp"); sipProvider = sipStack.createSipProvider(udpListeningPoint); Shootist listener = this; sipProvider.addSipListener(listener); String fromName = "BigGuy"; String fromSipAddress = "here.com"; String fromDisplayName = "The Master Blaster"; String toSipAddress = "there.com"; String toUser = "******"; String toDisplayName = "The Little Blister"; // create >From Header SipURI fromAddress = addressFactory.createSipURI(fromName, fromSipAddress); Address fromNameAddress = addressFactory.createAddress(fromAddress); fromNameAddress.setDisplayName(fromDisplayName); FromHeader fromHeader = headerFactory.createFromHeader(fromNameAddress, "12345"); // create To Header SipURI toAddress = addressFactory.createSipURI(toUser, toSipAddress); Address toNameAddress = addressFactory.createAddress(toAddress); toNameAddress.setDisplayName(toDisplayName); ToHeader toHeader = headerFactory.createToHeader(toNameAddress, null); // create Request URI SipURI requestURI = addressFactory.createSipURI(toUser, peerHostPort); // Create ViaHeaders ArrayList viaHeaders = new ArrayList(); String ipAddress = udpListeningPoint.getIPAddress(); ViaHeader viaHeader = headerFactory.createViaHeader( ipAddress, sipProvider.getListeningPoint(transport).getPort(), transport, null); // add via headers viaHeaders.add(viaHeader); // Create ContentTypeHeader ContentTypeHeader contentTypeHeader = headerFactory.createContentTypeHeader("application", "sdp"); // Create a new CallId header CallIdHeader callIdHeader = sipProvider.getNewCallId(); // Create a new Cseq header CSeqHeader cSeqHeader = headerFactory.createCSeqHeader(1L, Request.INVITE); // Create a new MaxForwardsHeader MaxForwardsHeader maxForwards = headerFactory.createMaxForwardsHeader(70); // Create the request. Request request = messageFactory.createRequest( requestURI, Request.INVITE, callIdHeader, cSeqHeader, fromHeader, toHeader, viaHeaders, maxForwards); // Create contact headers String host = "127.0.0.1"; SipURI contactUrl = addressFactory.createSipURI(fromName, host); contactUrl.setPort(udpListeningPoint.getPort()); contactUrl.setLrParam(); // Create the contact name address. SipURI contactURI = addressFactory.createSipURI(fromName, host); contactURI.setPort(sipProvider.getListeningPoint(transport).getPort()); Address contactAddress = addressFactory.createAddress(contactURI); // Add the contact address. contactAddress.setDisplayName(fromName); contactHeader = headerFactory.createContactHeader(contactAddress); request.addHeader(contactHeader); // You can add extension headers of your own making // to the outgoing SIP request. // Add the extension header. Header extensionHeader = headerFactory.createHeader("My-Header", "my header value"); request.addHeader(extensionHeader); String sdpData = "v=0\r\n" + "o=4855 13760799956958020 13760799956958020" + " IN IP4 129.6.55.78\r\n" + "s=mysession session\r\n" + "p=+46 8 52018010\r\n" + "c=IN IP4 129.6.55.78\r\n" + "t=0 0\r\n" + "m=audio 6022 RTP/AVP 0 4 18\r\n" + "a=rtpmap:0 PCMU/8000\r\n" + "a=rtpmap:4 G723/8000\r\n" + "a=rtpmap:18 G729A/8000\r\n" + "a=ptime:20\r\n"; byte[] contents = sdpData.getBytes(); request.setContent(contents, contentTypeHeader); // You can add as many extension headers as you // want. extensionHeader = headerFactory.createHeader("My-Other-Header", "my new header value "); request.addHeader(extensionHeader); Header callInfoHeader = headerFactory.createHeader("Call-Info", "<http://www.antd.nist.gov>"); request.addHeader(callInfoHeader); // Create the client transaction. ClientTransaction inviteTid = sipProvider.getNewClientTransaction(request); // send the request out. inviteTid.sendRequest(); dialog = inviteTid.getDialog(); } catch (Exception ex) { fail("cannot create or send initial invite"); } }
/** * Implements {@link MethodProcessor#processResponse(ResponseEvent)}. Handles only responses to * SUBSCRIBE requests because they are the only requests concerning event package subscribers (and * the only requests sent by them, for that matter) and if the processing of a given response * requires event package-specific handling, delivers the response to the matching * <tt>Subscription</tt> instance. Examples of such event package-specific handling include * letting the respective <tt>Subscription</tt> handle the success or failure in the establishment * of a subscription. * * @param responseEvent a <tt>ResponseEvent</tt> specifying the SIP <tt>Response</tt> to be * processed * @return <tt>true</tt> if the SIP <tt>Response</tt> specified by <tt>responseEvent</tt> was * processed; otherwise, <tt>false</tt> */ @Override public boolean processResponse(ResponseEvent responseEvent) { Response response = responseEvent.getResponse(); CSeqHeader cseqHeader = (CSeqHeader) response.getHeader(CSeqHeader.NAME); if (cseqHeader == null) { logger.error("An incoming response did not contain a CSeq header"); return false; } if (!Request.SUBSCRIBE.equals(cseqHeader.getMethod())) return false; ClientTransaction clientTransaction = responseEvent.getClientTransaction(); Request request = clientTransaction.getRequest(); /* * Don't handle responses to requests not coming from this event * package. */ if (request != null) { EventHeader eventHeader = (EventHeader) request.getHeader(EventHeader.NAME); if ((eventHeader == null) || !eventPackage.equalsIgnoreCase(eventHeader.getEventType())) return false; } // Find the subscription. CallIdHeader callIdHeader = (CallIdHeader) response.getHeader(CallIdHeader.NAME); String callId = callIdHeader.getCallId(); Subscription subscription = getSubscription(callId); // if it's the response to an unsubscribe message, we just ignore it // whatever the response is however if we need to handle a // challenge, we do it ExpiresHeader expHeader = response.getExpires(); int statusCode = response.getStatusCode(); SipProvider sourceProvider = (SipProvider) responseEvent.getSource(); if (((expHeader != null) && (expHeader.getExpires() == 0)) || (subscription == null)) // this handle the unsubscription // case where we removed the contact // from subscribedContacts { boolean processed = false; if ((statusCode == Response.UNAUTHORIZED) || (statusCode == Response.PROXY_AUTHENTICATION_REQUIRED)) { try { processAuthenticationChallenge(clientTransaction, response, sourceProvider); processed = true; } catch (OperationFailedException e) { logger.error("can't handle the challenge", e); } } else if ((statusCode != Response.OK) && (statusCode != Response.ACCEPTED)) processed = true; // any other cases (200/202) will imply a NOTIFY, so we will // handle the end of a subscription there return processed; } if ((statusCode >= Response.OK) && (statusCode < Response.MULTIPLE_CHOICES)) { // OK (200/202) if ((statusCode == Response.OK) || (statusCode == Response.ACCEPTED)) { if (expHeader == null) { // not conform to rfc3265 logger.error("no Expires header in this response"); return false; } SubscriptionRefreshTask refreshTask = new SubscriptionRefreshTask(subscription); subscription.setTimerTask(refreshTask); int refreshDelay = expHeader.getExpires(); // try to keep a margin if the refresh delay allows it if (refreshDelay >= (2 * refreshMargin)) refreshDelay -= refreshMargin; timer.schedule(refreshTask, refreshDelay * 1000); // do it to remember the dialog in case of a polling // subscription (which means no call to finalizeSubscription) subscription.setDialog(clientTransaction.getDialog()); subscription.processSuccessResponse(responseEvent, statusCode); } } else if ((statusCode >= Response.MULTIPLE_CHOICES) && (statusCode < Response.BAD_REQUEST)) { if (logger.isInfoEnabled()) logger.info( "Response to subscribe to " + subscription.getAddress() + ": " + response.getReasonPhrase()); } else if (statusCode >= Response.BAD_REQUEST) { // if the response is a 423 response, just re-send the request // with a valid expires value if (statusCode == Response.INTERVAL_TOO_BRIEF) { MinExpiresHeader min = (MinExpiresHeader) response.getHeader(MinExpiresHeader.NAME); if (min == null) { logger.error("no minimal expires value in this 423 " + "response"); return false; } ExpiresHeader exp = request.getExpires(); try { exp.setExpires(min.getExpires()); } catch (InvalidArgumentException e) { logger.error("can't set the new expires value", e); return false; } ClientTransaction transac = null; try { transac = protocolProvider.getDefaultJainSipProvider().getNewClientTransaction(request); } catch (TransactionUnavailableException e) { logger.error("can't create the client transaction", e); return false; } try { transac.sendRequest(); } catch (SipException e) { logger.error("can't send the new request", e); return false; } return true; // UNAUTHORIZED (401/407) } else if ((statusCode == Response.UNAUTHORIZED) || (statusCode == Response.PROXY_AUTHENTICATION_REQUIRED)) { try { processAuthenticationChallenge(clientTransaction, response, sourceProvider); } catch (OperationFailedException e) { logger.error("can't handle the challenge", e); removeSubscription(callId, subscription); subscription.processFailureResponse(responseEvent, statusCode); } // 408 480 486 600 603 : non definitive reject // others: definitive reject (or not implemented) } else { if (logger.isDebugEnabled()) logger.debug("error received from the network:\n" + response); removeSubscription(callId, subscription); subscription.processFailureResponse(responseEvent, statusCode); } } return true; }