public void arrayChanged(TCObject source, int startPos, Object array, int length) { if (isTransactionLoggingDisabled()) { return; } try { disableTransactionLogging(); Object pojo = source.getPeerObject(); ClientTransaction tx = getTransaction(pojo); if (!ClassUtils.isPrimitiveArray(array)) { Object[] objArray = (Object[]) array; for (int i = 0; i < length; i++) { Object element = objArray[i]; if (!literalValues.isLiteralInstance(element)) { if (element != null) objectManager.checkPortabilityOfField(element, String.valueOf(i), pojo); TCObject tco = objectManager.lookupOrCreate(element); objArray[i] = tco.getObjectID(); // record the reference in this transaction -- This is to solve the race condition of // transactions // that reference objects newly "created" in other transactions that may not commit // before us if (element != null) tx.createObject(tco); } } } tx.arrayChanged(source, startPos, array, length); } finally { enableTransactionLogging(); } }
/** * 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); } }
public boolean tryBegin(String lockName, WaitInvocation timeout, int lockLevel) { logTryBegin0(lockName, lockLevel); if (isTransactionLoggingDisabled() || objectManager.isCreationInProgress()) { return true; } final TxnType txnType = getTxnTypeFromLockLevel(lockLevel); ClientTransaction currentTransaction = getTransactionOrNull(); if ((currentTransaction != null) && lockLevel == LockLevel.CONCURRENT) { // make formatter sane throw new AssertionError("Can't acquire concurrent locks in a nested lock context."); } final LockID lockID = lockManager.lockIDFor(lockName); boolean isLocked = lockManager.tryLock(lockID, timeout, lockLevel); if (!isLocked) { return isLocked; } pushTxContext(lockID, txnType); if (currentTransaction == null) { createTxAndInitContext(); } else { currentTransaction.setTransactionContext(this.peekContext()); } return isLocked; }
/** 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); }
/** * 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); } }
/** Process the invite request. */ public void processInvite(RequestEvent requestEvent, ServerTransaction serverTransaction) { SipProvider sipProvider = (SipProvider) requestEvent.getSource(); Request request = requestEvent.getRequest(); try { System.out.println("b2bua: got an Invite sending Trying"); ServerTransaction st = requestEvent.getServerTransaction(); if (st == null) { st = sipProvider.getNewServerTransaction(request); } Dialog dialog = st.getDialog(); ToHeader to = (ToHeader) request.getHeader(ToHeader.NAME); SipURI toUri = (SipURI) to.getAddress().getURI(); SipURI target = registrar.get(toUri.getUser()); if (target == null) { System.out.println("User " + toUri + " is not registered."); throw new RuntimeException("User not registered " + toUri); } else { ClientTransaction otherLeg = call(target); otherLeg.setApplicationData(st); st.setApplicationData(otherLeg); dialog.setApplicationData(otherLeg.getDialog()); otherLeg.getDialog().setApplicationData(dialog); } } catch (Exception ex) { ex.printStackTrace(); System.exit(0); } }
/** * In order to support ReentrantLock, the TransactionContext that is going to be removed when * doing a commit may not always be at the top of a stack because an reentrant lock could issue a * lock within a synchronized block (although it is highly not recommended). Therefore, when a * commit is issued, we need to search back the stack from the top of the stack to find the * appropriate TransactionContext to be removed. Most likely, the TransactionContext to be removed * will be on the top of the stack. Therefore, the performance should be make must difference. * Only in some weird situations where reentrantLock is mixed with synchronized block will the * TransactionContext to be removed be found otherwise. */ public void commit(String lockName) throws UnlockedSharedObjectException { logCommit0(); if (isTransactionLoggingDisabled() || objectManager.isCreationInProgress()) { return; } // ClientTransaction tx = popTransaction(); ClientTransaction tx = getTransaction(); LockID lockID = lockManager.lockIDFor(lockName); if (lockID == null || lockID.isNull()) { lockID = tx.getLockID(); } boolean hasCommitted = commit(lockID, tx, false); popTransaction(lockManager.lockIDFor(lockName)); if (peekContext() != null) { if (hasCommitted) { createTxAndInitContext(); } else { // If the current transaction has not committed, we will reuse the current transaction // so that the current changes will have a chance to commit at the next commit point. tx.setTransactionContext(peekContext()); setTransaction(tx); } } }
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); } }
/** * Creates an invite request using the Tested Implementation and then tests creating a cancel for * the same invite request. */ public void testCreateCancel() { try { Request invite = createTiInviteRequest(null, null, null); ClientTransaction tran = null; try { tran = tiSipProvider.getNewClientTransaction(invite); } catch (TransactionUnavailableException exc) { throw new TiUnexpectedError( "A TransactionUnavailableException was thrown while trying to " + "create a new client transaction", exc); } Request cancel = null; try { cancel = tran.createCancel(); } catch (SipException ex) { ex.printStackTrace(); fail("Failed to create cancel request!"); } assertEquals( "The created request did not have a CANCEL method.", cancel.getMethod(), Request.CANCEL); assertEquals( "Request-URIs of the original and the cancel request do not match", cancel.getRequestURI(), invite.getRequestURI()); assertEquals( "Call-IDs of the original and the cancel request do not match", cancel.getHeader(CallIdHeader.NAME), invite.getHeader(CallIdHeader.NAME)); assertEquals( "ToHeaders of the original and the cancel request do not match", cancel.getHeader(ToHeader.NAME), invite.getHeader(ToHeader.NAME)); assertTrue( "The CSeqHeader's sequence number of the original and " + "the cancel request do not match", ((CSeqHeader) cancel.getHeader(CSeqHeader.NAME)).getSequenceNumber() == ((CSeqHeader) invite.getHeader(CSeqHeader.NAME)).getSequenceNumber()); assertEquals( "The CSeqHeader's method of the cancel request was not CANCEL", ((CSeqHeader) cancel.getHeader(CSeqHeader.NAME)).getMethod(), Request.CANCEL); assertTrue( "There was no ViaHeader in the cancel request", cancel.getHeaders(ViaHeader.NAME).hasNext()); Iterator cancelVias = cancel.getHeaders(ViaHeader.NAME); ViaHeader cancelVia = ((ViaHeader) cancelVias.next()); ViaHeader inviteVia = ((ViaHeader) invite.getHeaders(ViaHeader.NAME).next()); assertEquals( "ViaHeaders of the original and the cancel request do not match!", cancelVia, inviteVia); assertFalse("Cancel request had more than one ViaHeader.", cancelVias.hasNext()); } catch (Throwable exc) { exc.printStackTrace(); fail(exc.getClass().getName() + ": " + exc.getMessage()); } assertTrue(new Exception().getStackTrace()[0].toString(), true); }
public void notify(String lockName, boolean all, Object object) throws UnlockedSharedObjectException { final ClientTransaction currentTxn = getTransaction(); LockID lockID = lockManager.lockIDFor(lockName); if (lockID == null || lockID.isNull()) { lockID = currentTxn.getLockID(); } currentTxn.addNotify(lockManager.notify(lockID, all)); }
public void literalValueChanged(TCObject source, Object newValue, Object oldValue) { if (isTransactionLoggingDisabled()) { return; } try { disableTransactionLogging(); Object pojo = source.getPeerObject(); ClientTransaction tx = getTransaction(pojo); tx.literalValueChanged(source, newValue, oldValue); } finally { enableTransactionLogging(); } }
/** * 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 checkWriteAccess(Object context) { if (isTransactionLoggingDisabled()) { return; } // First check if we have any TXN context at all (else exception thrown) ClientTransaction txn = getTransaction(context); // make sure we're not in a read-only transaction // txn.readOnlyCheck(); if (txn.getTransactionType() == TxnType.READ_ONLY) { throw new ReadOnlyException( "Current transaction with read-only access attempted to modify a shared object. " + "\nPlease alter the locks section of your Terracotta configuration so that the methods involved in this transaction have read/write access.", Thread.currentThread().getName(), cidProvider.getChannelID().toLong()); } }
public void wait(String lockName, WaitInvocation call, Object object) throws UnlockedSharedObjectException, InterruptedException { final ClientTransaction topTxn = getTransaction(); LockID lockID = lockManager.lockIDFor(lockName); if (lockID == null || lockID.isNull()) { lockID = topTxn.getLockID(); } commit(lockID, topTxn, true); try { lockManager.wait(lockID, call, object, waitListener); } finally { createTxAndInitContext(); } }
private boolean commitInternal( LockID lockID, ClientTransaction currentTransaction, boolean isWaitContext) { Assert.assertNotNull("transaction", currentTransaction); try { disableTransactionLogging(); // If the current transactionContext is READ_ONLY, there is no need to commit. TransactionContext tc = peekContext(lockID); if (tc.getType().equals(TxnType.READ_ONLY)) { txMonitor.committedReadTransaction(); return false; } boolean hasPendingCreateObjects = objectManager.hasPendingCreateObjects(); if (hasPendingCreateObjects) { objectManager.addPendingCreateObjectsToTransaction(); } currentTransaction.setAlreadyCommitted(); if (currentTransaction.hasChangesOrNotifies() || hasPendingCreateObjects) { if (txMonitor.isEnabled()) { currentTransaction.updateMBean(txMonitor); } remoteTxManager.commit(currentTransaction); } return true; } finally { enableTransactionLogging(); // always try to unlock even if we are throwing an exception // if (!isWaitContext && !currentTransaction.isNull()) { // lockManager.unlock(currentTransaction.getLockID()); // } if (!isWaitContext && !currentTransaction.isNull()) { if (lockID != null && !lockID.isNull()) { lockManager.unlock(lockID); } else { throw new AssertionError("Trying to unlock with lockID = null!"); } } } }
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; } }
/** Test whether new ClientTransactions are properly created. */ public void testGetNewClientTransaction() { try { Request invite = createTiInviteRequest(null, null, null); ClientTransaction tran = null; try { tran = tiSipProvider.getNewClientTransaction(invite); } catch (TransactionUnavailableException exc) { exc.printStackTrace(); fail( "A TransactionUnavailableException was thrown while trying to " + "create a new client transaction"); } assertNotNull( "A null ClientTransaction was returned by SipProvider." + "getNewClientTransaction().", tran); String tranBranch = tran.getBranchId(); String reqBranch = ((ViaHeader) invite.getHeader(ViaHeader.NAME)).getBranch(); assertEquals( "The newly created transaction did not have the same " + "branch id as the request that created it", tranBranch, reqBranch); assertNotNull( "The newly created transaction returned a null Dialog. " + "Please check the docs on Transaction.getDialog()", tran.getDialog()); assertNotNull( "The transaction's getRequest() method returned a null Request ", tran.getRequest()); assertEquals( "The transaction's getRequest() method returned a Request " + "that did not match the one that we used to create it!", tran.getRequest(), invite); } catch (Throwable exc) { exc.printStackTrace(); fail(exc.getClass().getName() + ": " + exc.getMessage()); } assertTrue(new Exception().getStackTrace()[0].toString(), true); }
public boolean begin(String lockName, int lockLevel) { logBegin0(lockName, lockLevel); if (isTransactionLoggingDisabled() || objectManager.isCreationInProgress()) { return false; } final TxnType txnType = getTxnTypeFromLockLevel(lockLevel); ClientTransaction currentTransaction = getTransactionOrNull(); final LockID lockID = lockManager.lockIDFor(lockName); pushTxContext(lockID, txnType); if (currentTransaction == null) { createTxAndInitContext(); } else { currentTransaction.setTransactionContext(this.peekContext()); } lockManager.lock(lockID, lockLevel); return true; }
public void processResponse(ResponseEvent responseEvent) { ClientTransaction ct = responseEvent.getClientTransaction(); Response response = responseEvent.getResponse(); ServerTransaction st = (ServerTransaction) ct.getApplicationData(); try { Response otherResponse = messageFactory.createResponse(response.getStatusCode(), st.getRequest()); if (response.getStatusCode() == 200 && ct.getRequest().getMethod().equals("INVITE")) { Address address = addressFactory.createAddress("B2BUA <sip:" + myAddress + ":" + myPort + ">"); ContactHeader contactHeader = headerFactory.createContactHeader(address); response.addHeader(contactHeader); ToHeader toHeader = (ToHeader) otherResponse.getHeader(ToHeader.NAME); if (toHeader.getTag() == null) toHeader.setTag(new Long(counter.getAndIncrement()).toString()); otherResponse.addHeader(contactHeader); } st.sendResponse(otherResponse); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } }
public void logicalInvoke(TCObject source, int method, String methodName, Object[] parameters) { if (isTransactionLoggingDisabled()) { return; } try { disableTransactionLogging(); Object pojo = source.getPeerObject(); ClientTransaction tx = getTransaction(pojo); for (int i = 0; i < parameters.length; i++) { Object p = parameters[i]; boolean isLiteral = literalValues.isLiteralInstance(p); if (!isLiteral) { if (p != null) { objectManager.checkPortabilityOfLogicalAction(parameters, i, methodName, pojo); } TCObject tco = objectManager.lookupOrCreate(p); parameters[i] = tco.getObjectID(); if (p != null) { // record the reference in this transaction -- This is to solve the race condition of // transactions // that reference objects newly "created" in other transactions that may not commit // before us tx.createObject(tco); } } } tx.logicalInvoke(source, method, parameters, methodName); } finally { enableTransactionLogging(); } }
public void fieldChanged( TCObject source, String classname, String fieldname, Object newValue, int index) { if (isTransactionLoggingDisabled()) { return; } try { disableTransactionLogging(); Object pojo = source.getPeerObject(); ClientTransaction tx = getTransaction(pojo); logFieldChanged0(source, classname, fieldname, newValue, tx); if (newValue != null && literalValues.isLiteralInstance(newValue)) { tx.fieldChanged(source, classname, fieldname, newValue, index); } else { if (newValue != null) { objectManager.checkPortabilityOfField(newValue, fieldname, pojo); } TCObject tco = objectManager.lookupOrCreate(newValue); tx.fieldChanged(source, classname, fieldname, tco.getObjectID(), index); // record the reference in this transaction -- This is to solve the race condition of // transactions // that reference objects newly "created" in other transactions that may not commit before // us if (newValue != null) { tx.createObject(tco); } } } finally { enableTransactionLogging(); } }
/** Process the any in dialog request - MESSAGE, BYE, INFO, UPDATE. */ public void processInDialogRequest( RequestEvent requestEvent, ServerTransaction serverTransactionId) { SipProvider sipProvider = (SipProvider) requestEvent.getSource(); Request request = requestEvent.getRequest(); Dialog dialog = requestEvent.getDialog(); System.out.println("local party = " + dialog.getLocalParty()); try { System.out.println("b2bua: got a bye sending OK."); Response response = messageFactory.createResponse(200, request); serverTransactionId.sendResponse(response); System.out.println("Dialog State is " + serverTransactionId.getDialog().getState()); Dialog otherLeg = (Dialog) dialog.getApplicationData(); Request otherBye = otherLeg.createRequest(request.getMethod()); ClientTransaction clientTransaction = sipProvider.getNewClientTransaction(otherBye); clientTransaction.setApplicationData(serverTransactionId); serverTransactionId.setApplicationData(clientTransaction); otherLeg.sendRequest(clientTransaction); } catch (Exception ex) { ex.printStackTrace(); System.exit(0); } }
/* * Begin Third-Party Call Control. */ public void initiateCall() throws IOException { try { try { busyTreatment = new TreatmentManager("busy.au", 0); } catch (IOException e) { Logger.println("Invalid busy treatment: " + e.getMessage()); } Logger.writeFile("Call " + cp + ": Begin SIP third party call"); setState(CallState.INVITED); InetSocketAddress isa = callHandler.getReceiveAddress(); if (isa == null) { throw new IOException("can't get receiver socket!"); } // send INVITE to the CallParticipant clientTransaction = sipUtil.sendInvite(cp, isa); if (clientTransaction == null) { Logger.error("Error placing call: " + cp); setState(CallState.ENDED, "Reason='Error placing call'"); throw new IOException("Error placing call: " + cp); } CallIdHeader callIdHeader = (CallIdHeader) clientTransaction.getRequest().getHeader(CallIdHeader.NAME); sipCallId = callIdHeader.getCallId(); sipServerCallback = SipServer.getSipServerCallback(); sipServerCallback.addSipListener(sipCallId, this); } catch (java.text.ParseException e) { Logger.println("Call " + cp + " Error placing call " + cp + ": " + e.getMessage()); setState(CallState.ENDED, "Reason='Error placing call " + cp + " " + e.getMessage() + "'"); throw new IOException("Error placing call " + cp + " " + e.getMessage()); } catch (InvalidArgumentException e) { Logger.println("Call " + cp + " Error placing call " + cp + ": " + e.getMessage()); setState(CallState.ENDED, "Reason='Error placing call " + cp + " " + e.getMessage() + "'"); throw new IOException("Error placing call " + cp + " " + e.getMessage()); } catch (SipException e) { Logger.println("Call " + cp + " Error placing call " + cp + ": " + e.getMessage()); setState(CallState.ENDED, "Reason='Error placing call " + cp + " " + e.getMessage() + "'"); throw new IOException("Error placing call " + cp + " " + e.getMessage()); } }
public void processOK(Response responseCloned, ClientTransaction clientTransaction) { try { logger.debug("Processing OK for SUBSCRIBE in progress..."); ExpiresHeader expiresHeader = (ExpiresHeader) responseCloned.getHeader(ExpiresHeader.NAME); if (expiresHeader != null && expiresHeader.getExpires() == 0) { logger.debug( "DEBUG, IMSubscribeProcessing, processOK(), we got" + " the OK for the unsubscribe..."); } else { // We have to create or update the presentity! PresenceManager presenceManager = imUA.getPresenceManager(); String presentityURL = IMUtilities.getKey(responseCloned, "To"); Dialog dialog = clientTransaction.getDialog(); if (dialog != null) presenceManager.addPresentity(presentityURL, responseCloned, dialog); else { logger.debug( "ERROR, IMSubscribeProcessing, processOK(), the" + " dialog for the SUBSCRIBE we sent is null!!!" + " No presentity added...."); } // WE have to create a new Buddy in the GUI!!! InstantMessagingGUI imGUI = imUA.getInstantMessagingGUI(); BuddyList buddyList = imGUI.getBuddyList(); if (!buddyList.hasBuddy(presentityURL)) { buddyList.addBuddy(presentityURL, "offline"); } else { logger.debug("The buddy is already in the Buddy list..."); } } logger.debug("Processing OK for SUBSCRIBE completed..."); } catch (Exception ex) { ex.printStackTrace(); } }
public void addReference(TCObject tco) { ClientTransaction txn = getTransactionOrNull(); if (txn != null) { txn.createObject(tco); } }
@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); } }
/** 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); }
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(); } }
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 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.IP_ADDRESS", "127.0.0.1"); properties.setProperty("javax.sip.OUTBOUND_PROXY", peerHostPort + "/" + transport); properties.setProperty("javax.sip.STACK_NAME", "shootist"); properties.setProperty("javax.sip.RETRANSMISSION_FILTER", "on"); // 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.MAX_MESSAGE_SIZE", "1048576"); 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 in your production code for max speed. // You need 16 for logging traces. 32 for debug + traces. // Your code will limp at 32 but it is best for debugging. properties.setProperty("gov.nist.javax.sip.TRACE_LEVEL", "0"); 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()); System.exit(0); } try { headerFactory = sipFactory.createHeaderFactory(); addressFactory = sipFactory.createAddressFactory(); messageFactory = sipFactory.createMessageFactory(); udpListeningPoint = sipStack.createListeningPoint(sipStack.getIPAddress(), 5060, "udp"); udpProvider = sipStack.createSipProvider(udpListeningPoint); Shootist listener = this; udpProvider.addSipListener(listener); tcpListeningPoint = sipStack.createListeningPoint(sipStack.getIPAddress(), 5060, "tcp"); tcpProvider = sipStack.createSipProvider(tcpListeningPoint); tcpProvider.addSipListener(listener); SipProvider sipProvider = transport.equalsIgnoreCase("udp") ? udpProvider : tcpProvider; String fromName = "BigGuy"; String fromSipAddress = "here.com"; String fromDisplayName = "The Master Blaster"; String toSipAddress = "there.com"; String toUser = "******"; String toDisplayName = "The Little Blister"; // send the request out. for (int i = 0; i < 100; i++) { // create >From Header SipURI fromAddress = addressFactory.createSipURI(fromName, fromSipAddress); Address fromNameAddress = addressFactory.createAddress(fromAddress); fromNameAddress.setDisplayName(fromDisplayName); FromHeader fromHeader = headerFactory.createFromHeader(fromNameAddress, "12345" + i); // 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(); int port = sipProvider.getListeningPoint(transport).getPort(); ViaHeader viaHeader = headerFactory.createViaHeader(sipStack.getIPAddress(), port, 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 = sipStack.getIPAddress(); SipURI contactUrl = addressFactory.createSipURI(fromName, host); contactUrl.setPort(tcpListeningPoint.getPort()); // 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); // 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); 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); inviteTid.sendRequest(); } } catch (Exception ex) { System.out.println(ex.getMessage()); ex.printStackTrace(); usage(); } }