/** * When a message is received determines whether to open a new chat window or chat window tab, or * to indicate that a message is received from a contact which already has an open chat. When the * chat is found checks if in mode "Auto popup enabled" and if this is the case shows the message * in the appropriate chat panel. * * @param evt the event containing details on the received message */ public void messageReceived(MessageReceivedEvent evt) { if (logger.isTraceEnabled()) logger.trace("MESSAGE RECEIVED from contact: " + evt.getSourceContact().getAddress()); Contact protocolContact = evt.getSourceContact(); ContactResource contactResource = evt.getContactResource(); Message message = evt.getSourceMessage(); int eventType = evt.getEventType(); MetaContact metaContact = GuiActivator.getContactListService().findMetaContactByContact(protocolContact); if (metaContact != null) { messageReceived( protocolContact, contactResource, metaContact, message, eventType, evt.getTimestamp(), evt.getCorrectedMessageUID(), evt.isPrivateMessaging(), evt.getPrivateMessagingContactRoom()); } else { if (logger.isTraceEnabled()) logger.trace("MetaContact not found for protocol contact: " + protocolContact + "."); } }
/** * Removes the group created in the server stored contact list by the create group test, makes * sure that the corresponding event has been generated and verifies that the group is not in the * list any more. */ public void postTestRemoveGroup() { logger.trace("testing removal of server stored groups"); // first add a listener GroupChangeCollector groupChangeCollector = new GroupChangeCollector(); opSetPersPresence1.addServerStoredGroupChangeListener(groupChangeCollector); try { // remove the group opSetPersPresence1.removeServerStoredContactGroup( opSetPersPresence1.getServerStoredContactListRoot().getGroup(testGroupName2)); } catch (OperationFailedException ex) { logger.error("error removing group", ex); } groupChangeCollector.waitForEvent(10000); opSetPersPresence1.removeServerStoredGroupChangeListener(groupChangeCollector); // check whether we got group created event assertEquals("Collected Group Change event", 1, groupChangeCollector.collectedEvents.size()); assertEquals( "Group name.", testGroupName2, ((ServerStoredGroupEvent) groupChangeCollector.collectedEvents.get(0)) .getSourceGroup() .getGroupName()); // check whether the group is still on the contact list ContactGroup group = opSetPersPresence1.getServerStoredContactListRoot().getGroup(testGroupName2); assertNull("A freshly removed group was still on the contact list.", group); }
/** * Put the JAIN-SIP stack in a state where it cannot receive any data and frees the network ports * used. That is to say remove JAIN-SIP <tt>ListeningPoint</tt>s and <tt>SipProvider</tt>s. */ @SuppressWarnings("unchecked") // jain-sip legacy code private void stopListening() { try { this.secureJainSipProvider.removeSipListener(this); this.stack.deleteSipProvider(this.secureJainSipProvider); this.secureJainSipProvider = null; this.clearJainSipProvider.removeSipListener(this); this.stack.deleteSipProvider(this.clearJainSipProvider); this.clearJainSipProvider = null; Iterator<ListeningPoint> it = this.stack.getListeningPoints(); Vector<ListeningPoint> lpointsToRemove = new Vector<ListeningPoint>(); while (it.hasNext()) { lpointsToRemove.add(it.next()); } it = lpointsToRemove.iterator(); while (it.hasNext()) { this.stack.deleteListeningPoint(it.next()); } this.stack.stop(); if (logger.isTraceEnabled()) logger.trace("stopped listening"); } catch (ObjectInUseException ex) { logger.fatal("Failed to stop listening", ex); } }
/** * Adds this <tt>listener</tt> as a candidate recipient for the dispatching of new messages * received from the JAIN-SIP <tt>SipProvider</tt>s. * * @param listener a new possible target for the dispatching process. * @throws OperationFailedException if creating one of the underlying <tt>SipProvider</tt>s fails * for whatever reason. */ public void addSipListener(ProtocolProviderServiceSipImpl listener) throws OperationFailedException { synchronized (this.listeners) { if (this.listeners.size() == 0) startListening(); this.listeners.add(listener); if (logger.isTraceEnabled()) logger.trace(this.listeners.size() + " listeners now"); } }
/** * This <tt>listener</tt> will no longer be a candidate recipient for the dispatching of new * messages received from the JAIN-SIP <tt>SipProvider</tt>s. * * @param listener possible target to remove for the dispatching process. */ public void removeSipListener(ProtocolProviderServiceSipImpl listener) { synchronized (this.listeners) { this.listeners.remove(listener); int listenerCount = listeners.size(); if (logger.isTraceEnabled()) logger.trace(listenerCount + " listeners left"); if (listenerCount == 0) stopListening(); } }
public AuthorizationRequest createAuthorizationRequest(Contact contact) { logger.trace("createAuthorizationRequest " + contact); AuthorizationRequest authReq = new AuthorizationRequest(); authReq.setReason(authorizationRequestReason); isAuthorizationRequestSent = true; return authReq; }
/** * When a sent message is delivered shows it in the chat conversation panel. * * @param evt the event containing details on the message delivery */ public void messageDelivered(MessageDeliveredEvent evt) { Contact contact = evt.getDestinationContact(); MetaContact metaContact = GuiActivator.getContactListService().findMetaContactByContact(contact); if (logger.isTraceEnabled()) logger.trace("MESSAGE DELIVERED to contact: " + contact.getAddress()); ChatPanel chatPanel = chatWindowManager.getContactChat(metaContact, false); if (chatPanel != null) { Message msg = evt.getSourceMessage(); ProtocolProviderService protocolProvider = contact.getProtocolProvider(); if (logger.isTraceEnabled()) logger.trace( "MESSAGE DELIVERED: process message to chat for contact: " + contact.getAddress() + " MESSAGE: " + msg.getContent()); chatPanel.addMessage( this.mainFrame.getAccountAddress(protocolProvider), this.mainFrame.getAccountDisplayName(protocolProvider), evt.getTimestamp(), Chat.OUTGOING_MESSAGE, msg.getContent(), msg.getContentType(), msg.getMessageUID(), evt.getCorrectedMessageUID()); if (evt.isSmsMessage() && !ConfigurationUtils.isSmsNotifyTextDisabled()) { chatPanel.addMessage( contact.getDisplayName(), new Date(), Chat.ACTION_MESSAGE, GuiActivator.getResources().getI18NString("service.gui.SMS_SUCCESSFULLY_SENT"), "text"); } } }
/** * Retrieves and returns that ProtocolProviderService that this transaction belongs to, or * <tt>null</tt> if we couldn't associate it with a provider based on neither the request nor the * transaction itself. * * @param transaction the transaction that we'd like to determine a provider for. * @return a reference to the <tt>ProtocolProviderServiceSipImpl</tt> that <tt>transaction</tt> * was associated with or <tt>null</tt> if we couldn't determine which one it is. */ private ProtocolProviderServiceSipImpl getServiceData(Transaction transaction) { ProtocolProviderServiceSipImpl service = (ProtocolProviderServiceSipImpl) SipApplicationData.getApplicationData( transaction.getRequest(), SipApplicationData.KEY_SERVICE); if (service != null) { if (logger.isTraceEnabled()) logger.trace("service was found in request data"); return service; } service = (ProtocolProviderServiceSipImpl) SipApplicationData.getApplicationData( transaction.getDialog(), SipApplicationData.KEY_SERVICE); if (service != null) { if (logger.isTraceEnabled()) logger.trace("service was found in dialog data"); } return service; }
/** * Creates a group in the server stored contact list, makes sure that the corresponding event has * been generated and verifies that the group is in the list. * * @throws java.lang.Exception */ public void postTestCreateGroup() throws Exception { // first clear the list fixture.clearProvidersLists(); Object o = new Object(); synchronized (o) { o.wait(3000); } logger.trace("testing creation of server stored groups"); // first add a listener GroupChangeCollector groupChangeCollector = new GroupChangeCollector(); opSetPersPresence1.addServerStoredGroupChangeListener(groupChangeCollector); // create the group opSetPersPresence1.createServerStoredContactGroup( opSetPersPresence1.getServerStoredContactListRoot(), testGroupName); groupChangeCollector.waitForEvent(10000); opSetPersPresence1.removeServerStoredGroupChangeListener(groupChangeCollector); // check whether we got group created event assertEquals("Collected Group Change events: ", 1, groupChangeCollector.collectedEvents.size()); assertEquals( "Group name.", testGroupName, ((ServerStoredGroupEvent) groupChangeCollector.collectedEvents.get(0)) .getSourceGroup() .getGroupName()); // check whether the group is retrievable ContactGroup group = opSetPersPresence1.getServerStoredContactListRoot().getGroup(testGroupName); assertNotNull("A newly created group was not in the contact list.", group); assertEquals("New group name", testGroupName, group.getGroupName()); // when opearting with groups . the group must have entries // so changes to take effect. Otherwise group will be lost after loggingout try { opSetPersPresence1.subscribe(group, fixture.userID2); synchronized (o) { o.wait(1500); } } catch (Exception ex) { fail("error adding entry to group : " + group.getGroupName() + " " + ex.getMessage()); } }
/** * Dispatches the event received from a JAIN-SIP <tt>SipProvider</tt> to one of our "candidate * recipient" listeners. * * @param event the event received for a <tt>SipProvider</tt>. */ public void processIOException(IOExceptionEvent event) { try { if (logger.isTraceEnabled()) logger.trace(event); // impossible to dispatch, log here if (logger.isDebugEnabled()) logger.debug("@todo implement processIOException()"); } catch (Throwable exc) { // any exception thrown within our code should be caught here // so that we could log it rather than interrupt stack activity with // it. this.logApplicationException(DialogTerminatedEvent.class, exc); } }
/** * Receives options requests and replies with an OK response containing methods that we support. * * @param requestEvent the incoming options request. * @return <tt>true</tt> if request has been successfully processed, <tt>false</tt> otherwise */ @Override public boolean processRequest(RequestEvent requestEvent) { Response optionsOK = null; try { optionsOK = provider.getMessageFactory().createResponse(Response.OK, requestEvent.getRequest()); // add to the allows header all methods that we support for (String method : provider.getSupportedMethods()) { // don't support REGISTERs if (!method.equals(Request.REGISTER)) optionsOK.addHeader(provider.getHeaderFactory().createAllowHeader(method)); } Iterable<String> knownEventsList = provider.getKnownEventsList(); synchronized (knownEventsList) { for (String event : knownEventsList) optionsOK.addHeader(provider.getHeaderFactory().createAllowEventsHeader(event)); } } catch (ParseException ex) { // What else could we do apart from logging? logger.warn("Failed to create an incoming OPTIONS request", ex); return false; } try { SipStackSharing.getOrCreateServerTransaction(requestEvent).sendResponse(optionsOK); } catch (TransactionUnavailableException ex) { // this means that we received an OPTIONS request outside the scope // of a transaction which could mean that someone is simply sending // us b****hit to keep a NAT connection alive, so let's not get too // excited. if (logger.isInfoEnabled()) logger.info("Failed to respond to an incoming " + "transactionless OPTIONS request"); if (logger.isTraceEnabled()) logger.trace("Exception was:", ex); return false; } catch (InvalidArgumentException ex) { // What else could we do apart from logging? logger.warn("Failed to send an incoming OPTIONS request", ex); return false; } catch (SipException ex) { // What else could we do apart from logging? logger.warn("Failed to send an incoming OPTIONS request", ex); return false; } return true; }
/** * Subscribes this provider as interested in receiving notifications for new mail messages from * Google mail services such as Gmail or Google Apps. */ private void subscribeForGmailNotifications() { // first check support for the notification service String accountIDService = jabberProvider.getAccountID().getService(); boolean notificationsAreSupported = jabberProvider.isFeatureSupported(accountIDService, NewMailNotificationIQ.NAMESPACE); if (!notificationsAreSupported) { if (logger.isDebugEnabled()) logger.debug( accountIDService + " does not seem to provide a Gmail notification " + " service so we won't be trying to subscribe for it"); return; } if (logger.isDebugEnabled()) logger.debug( accountIDService + " seems to provide a Gmail notification " + " service so we will try to subscribe for it"); ProviderManager providerManager = ProviderManager.getInstance(); providerManager.addIQProvider( MailboxIQ.ELEMENT_NAME, MailboxIQ.NAMESPACE, new MailboxIQProvider()); providerManager.addIQProvider( NewMailNotificationIQ.ELEMENT_NAME, NewMailNotificationIQ.NAMESPACE, new NewMailNotificationProvider()); Connection connection = jabberProvider.getConnection(); connection.addPacketListener(new MailboxIQListener(), new PacketTypeFilter(MailboxIQ.class)); connection.addPacketListener( new NewMailNotificationListener(), new PacketTypeFilter(NewMailNotificationIQ.class)); if (opSetPersPresence.getCurrentStatusMessage().equals(JabberStatusEnum.OFFLINE)) return; // create a query with -1 values for newer-than-tid and // newer-than-time attributes MailboxQueryIQ mailboxQuery = new MailboxQueryIQ(); if (logger.isTraceEnabled()) logger.trace( "sending mailNotification for acc: " + jabberProvider.getAccountID().getAccountUniqueID()); jabberProvider.getConnection().sendPacket(mailboxQuery); }
/** * Put the stack in a state where it can receive data on three UDP/TCP ports (2 for clear * communication, 1 for TLS). That is to say create the related JAIN-SIP <tt>ListeningPoint</tt>s * and <tt>SipProvider</tt>s. * * @throws OperationFailedException if creating one of the underlying <tt>SipProvider</tt>s fails * for whatever reason. */ private void startListening() throws OperationFailedException { try { int bindRetriesValue = getBindRetriesValue(); this.createProvider(this.getPreferredClearPort(), bindRetriesValue, false); this.createProvider(this.getPreferredSecurePort(), bindRetriesValue, true); this.stack.start(); if (logger.isTraceEnabled()) logger.trace("started listening"); } catch (Exception ex) { logger.error( "An unexpected error happened while creating the" + "SipProviders and ListeningPoints."); throw new OperationFailedException( "An unexpected error hapenned" + "while initializing the SIP stack", OperationFailedException.INTERNAL_ERROR, ex); } }
public void processAuthorizationResponse( AuthorizationResponse response, Contact sourceContact) { synchronized (this) { isAuthorizationResponseReceived = true; this.response = response; authorizationResponseString = response.getReason(); logger.trace( "processAuthorizationResponse '" + authorizationResponseString + "' " + response.getResponseCode() + " " + sourceContact); notifyAll(); } }
/** * Function called when a icq file transfer request arrive * * @param manager the joustsim manager * @param transfer the incoming transfer */ public void handleNewIncomingConnection( RvConnectionManager manager, IncomingRvConnection transfer) { if (transfer instanceof IncomingFileTransfer) { if (logger.isTraceEnabled()) logger.trace("Incoming Icq file transfer request " + transfer.getClass()); if (!(transfer instanceof IncomingFileTransfer)) { logger.warn("Wrong file transfer."); return; } OperationSetPersistentPresenceIcqImpl opSetPersPresence = (OperationSetPersistentPresenceIcqImpl) icqProvider.getOperationSet(OperationSetPersistentPresence.class); Contact sender = opSetPersPresence.findContactByID(transfer.getBuddyScreenname().getFormatted()); IncomingFileTransfer incomingFileTransfer = (IncomingFileTransfer) transfer; final Date newDate = new Date(); final IncomingFileTransferRequest req = new IncomingFileTransferRequestIcqImpl( icqProvider, this, incomingFileTransfer, sender, newDate); // this handels when we receive request and before accept or decline // it we receive cancel transfer.addEventListener( new RvConnectionEventListener() { public void handleEventWithStateChange( RvConnection transfer, RvConnectionState state, RvConnectionEvent event) { if (state == FileTransferState.FAILED && event instanceof BuddyCancelledEvent) { fireFileTransferRequestCanceled( new FileTransferRequestEvent( OperationSetFileTransferIcqImpl.this, req, newDate)); } } public void handleEvent(RvConnection arg0, RvConnectionEvent arg1) {} }); fireFileTransferRequest(new FileTransferRequestEvent(this, req, newDate)); } }
/** * Dispatches the event received from a JAIN-SIP <tt>SipProvider</tt> to one of our "candidate * recipient" listeners. * * @param event the event received for a <tt>SipProvider</tt>. */ public void processResponse(ResponseEvent event) { try { // we don't have to accept the transaction since we // created the request ClientTransaction transaction = event.getClientTransaction(); if (logger.isTraceEnabled()) logger.trace( "received response: " + event.getResponse().getStatusCode() + " " + event.getResponse().getReasonPhrase()); if (transaction == null) { logger.warn("Transaction is null, probably already expired!"); return; } ProtocolProviderServiceSipImpl service = getServiceData(transaction); if (service != null) { // Mark the dialog for the dispatching of later in-dialog // responses. If there is no dialog then the initial request // sure is marked otherwise we won't have found the service with // getServiceData(). The request has to be marked in case we // receive one more response in an out-of-dialog transaction. if (event.getDialog() != null) { SipApplicationData.setApplicationData( event.getDialog(), SipApplicationData.KEY_SERVICE, service); } service.processResponse(event); } else { logger.error( "We received a response which " + "wasn't marked, please report this to " + "*****@*****.**"); } } catch (Throwable exc) { // any exception thrown within our code should be caught here // so that we could log it rather than interrupt stack activity with // it. this.logApplicationException(DialogTerminatedEvent.class, exc); } }
/** * Dispatches the event received from a JAIN-SIP <tt>SipProvider</tt> to one of our "candidate * recipient" listeners. * * @param event the event received for a <tt>SipProvider</tt>. */ public void processDialogTerminated(DialogTerminatedEvent event) { try { ProtocolProviderServiceSipImpl recipient = (ProtocolProviderServiceSipImpl) SipApplicationData.getApplicationData( event.getDialog(), SipApplicationData.KEY_SERVICE); if (recipient == null) { logger.error( "Dialog wasn't marked, please report this to " + "*****@*****.**"); } else { if (logger.isTraceEnabled()) logger.trace("service was found with dialog data"); recipient.processDialogTerminated(event); } } catch (Throwable exc) { // any exception thrown within our code should be caught here // so that we could log it rather than interrupt stack activity with // it. this.logApplicationException(DialogTerminatedEvent.class, exc); } }
/** * Renames our test group and checks whether corresponding events are triggered. Verifies whether * the group has really changed its name and whether it is findable by its new name. Also makes * sure that it does not exist under its previous name any more. */ public void postTestRenameGroup() { logger.trace("Testing renaming groups."); ContactGroup group = opSetPersPresence1.getServerStoredContactListRoot().getGroup(testGroupName); // first add a listener GroupChangeCollector groupChangeCollector = new GroupChangeCollector(); opSetPersPresence1.addServerStoredGroupChangeListener(groupChangeCollector); // change the name and wait for a confirmation event opSetPersPresence1.renameServerStoredContactGroup(group, testGroupName2); groupChangeCollector.waitForEvent(10000); opSetPersPresence1.removeServerStoredGroupChangeListener(groupChangeCollector); // examine the event assertEquals("Collected Group Change event", 1, groupChangeCollector.collectedEvents.size()); assertEquals( "Group name.", testGroupName2, ((ServerStoredGroupEvent) groupChangeCollector.collectedEvents.get(0)) .getSourceGroup() .getGroupName()); // check whether the group is still on the contact list ContactGroup oldGroup = opSetPersPresence1.getServerStoredContactListRoot().getGroup(testGroupName); assertNull("A group was still findable by its old name after renaming.", oldGroup); // make sure that we could find the group by its new name. ContactGroup newGroup = opSetPersPresence1.getServerStoredContactListRoot().getGroup(testGroupName2); assertNotNull("Could not find a renamed group by its new name.", newGroup); }
public AuthorizationResponse processAuthorisationRequest( AuthorizationRequest req, Contact sourceContact) { logger.debug("Processing in " + this); synchronized (this) { logger.trace("processAuthorisationRequest " + req + " " + sourceContact); isAuthorizationRequestReceived = true; authorizationRequestReason = req.getReason(); notifyAll(); // will wait as a normal user Object lock = new Object(); synchronized (lock) { try { lock.wait(2000); } catch (Exception ex) { } } return responseToRequest; } }
/** * Constructor for this class. Creates the JAIN-SIP stack. * * @throws OperationFailedException if creating the stack fails. */ SipStackSharing() throws OperationFailedException { // init of the stack try { SipFactory sipFactory = SipFactory.getInstance(); sipFactory.setPathName("org.jitsi.gov.nist"); Properties sipStackProperties = new SipStackProperties(); // Create SipStack object this.stack = sipFactory.createSipStack(sipStackProperties); if (logger.isTraceEnabled()) logger.trace("Created stack: " + this.stack); // set our custom address resolver managing SRV records AddressResolverImpl addressResolver = new AddressResolverImpl(); ((SIPTransactionStack) this.stack).setAddressResolver(addressResolver); SipActivator.getNetworkAddressManagerService().addNetworkConfigurationChangeListener(this); } catch (Exception ex) { logger.fatal("Failed to get SIP Factory.", ex); throw new OperationFailedException( "Failed to get SIP Factory", OperationFailedException.INTERNAL_ERROR, ex); } }
/** * Helper function used to send a message to a contact, with the given extensions attached. * * @param to The contact to send the message to. * @param toResource The resource to send the message to or null if no resource has been specified * @param message The message to send. * @param extensions The XMPP extensions that should be attached to the message before sending. * @return The MessageDeliveryEvent that resulted after attempting to send this message, so the * calling function can modify it if needed. */ private MessageDeliveredEvent sendMessage( Contact to, ContactResource toResource, Message message, PacketExtension[] extensions) { if (!(to instanceof ContactJabberImpl)) throw new IllegalArgumentException("The specified contact is not a Jabber contact." + to); assertConnected(); org.jivesoftware.smack.packet.Message msg = new org.jivesoftware.smack.packet.Message(); String toJID = null; if (toResource != null) { if (toResource.equals(ContactResource.BASE_RESOURCE)) { toJID = to.getAddress(); } else toJID = ((ContactResourceJabberImpl) toResource).getFullJid(); } if (toJID == null) { toJID = to.getAddress(); } msg.setPacketID(message.getMessageUID()); msg.setTo(toJID); for (PacketExtension ext : extensions) { msg.addExtension(ext); } if (logger.isTraceEnabled()) logger.trace("Will send a message to:" + toJID + " chat.jid=" + toJID); MessageDeliveredEvent msgDeliveryPendingEvt = new MessageDeliveredEvent(message, to, toResource); MessageDeliveredEvent[] transformedEvents = messageDeliveryPendingTransform(msgDeliveryPendingEvt); if (transformedEvents == null || transformedEvents.length == 0) return null; for (MessageDeliveredEvent event : transformedEvents) { String content = event.getSourceMessage().getContent(); if (message.getContentType().equals(HTML_MIME_TYPE)) { msg.setBody(Html2Text.extractText(content)); // Check if the other user supports XHTML messages // make sure we use our discovery manager as it caches calls if (jabberProvider.isFeatureListSupported(toJID, HTML_NAMESPACE)) { // Add the XHTML text to the message XHTMLManager.addBody(msg, OPEN_BODY_TAG + content + CLOSE_BODY_TAG); } } else { // this is plain text so keep it as it is. msg.setBody(content); } // msg.addExtension(new Version()); if (event.isMessageEncrypted() && isCarbonEnabled) { msg.addExtension(new CarbonPacketExtension.PrivateExtension()); } MessageEventManager.addNotificationsRequests(msg, true, false, false, true); String threadID = getThreadIDForAddress(toJID); if (threadID == null) threadID = nextThreadID(); msg.setThread(threadID); msg.setType(org.jivesoftware.smack.packet.Message.Type.chat); msg.setFrom(jabberProvider.getConnection().getUser()); jabberProvider.getConnection().sendPacket(msg); putJidForAddress(toJID, threadID); } return new MessageDeliveredEvent(message, to, toResource); }
/** * Used by methods testing state transiotions * * @param newStatus the IcqStatusEnum field corresponding to the status that we'd like the * opeation set to enter. * @throws Exception in case changing the state causes an exception */ public void subtestStateTransition(IcqStatusEnum newStatus) throws Exception { logger.trace(" --=== beginning state transition test ===--"); PresenceStatus oldStatus = operationSetPresence.getPresenceStatus(); String oldStatusMessage = operationSetPresence.getCurrentStatusMessage(); String newStatusMessage = statusMessageRoot + newStatus; logger.debug( "old status is=" + oldStatus.getStatusName() + " new status=" + newStatus.getStatusName()); // First register a listener to make sure that all corresponding // events have been generated. PresenceStatusEventCollector statusEventCollector = new PresenceStatusEventCollector(); operationSetPresence.addProviderPresenceStatusListener(statusEventCollector); // change the status operationSetPresence.publishPresenceStatus(newStatus, newStatusMessage); // test event notification. statusEventCollector.waitForPresEvent(10000); statusEventCollector.waitForStatMsgEvent(10000); // sometimes we don't get response from the server for the // changed status. we will query it once again. // and wait for the response if (statusEventCollector.collectedPresEvents.size() == 0) { logger.trace("Will query again status as we haven't received one"); operationSetPresence.queryContactStatus(fixture.icqAccountID.getUserID()); statusEventCollector.waitForPresEvent(10000); } operationSetPresence.removeProviderPresenceStatusListener(statusEventCollector); assertEquals( "Events dispatched during an event transition.", 1, statusEventCollector.collectedPresEvents.size()); assertEquals( "A status changed event contained wrong old status.", oldStatus, ((ProviderPresenceStatusChangeEvent) statusEventCollector.collectedPresEvents.get(0)) .getOldStatus()); assertEquals( "A status changed event contained wrong new status.", newStatus, ((ProviderPresenceStatusChangeEvent) statusEventCollector.collectedPresEvents.get(0)) .getNewStatus()); // verify that the operation set itself is aware of the status change assertEquals( "opSet.getPresenceStatus() did not return properly.", newStatus, operationSetPresence.getPresenceStatus()); IcqStatusEnum actualStatus = fixture.testerAgent.getBuddyStatus(fixture.icqAccountID.getUserID()); assertEquals( "The underlying implementation did not switch to the " + "requested presence status.", newStatus, actualStatus); // check whether the server returned the status message that we've set. assertEquals( "No status message events.", 1, statusEventCollector.collectedStatMsgEvents.size()); assertEquals( "A status message event contained wrong old value.", oldStatusMessage, ((PropertyChangeEvent) statusEventCollector.collectedStatMsgEvents.get(0)).getOldValue()); assertEquals( "A status message event contained wrong new value.", newStatusMessage, ((PropertyChangeEvent) statusEventCollector.collectedStatMsgEvents.get(0)).getNewValue()); // verify that the operation set itself is aware of the new status msg. assertEquals( "opSet.getCurrentStatusMessage() did not return properly.", newStatusMessage, operationSetPresence.getCurrentStatusMessage()); logger.trace(" --=== finished test ===--"); // make it sleep a bit cause the aol server gets mad otherwise. pauseBetweenStateChanges(); }
/** * Find the <tt>ProtocolProviderServiceSipImpl</tt> (one of our "candidate recipient" listeners) * which this <tt>request</tt> should be dispatched to. The strategy is to look first at the * request URI, and then at the To field to find a matching candidate for dispatching. Note that * this method takes a <tt>Request</tt> as param, and not a <tt>ServerTransaction</tt>, because * sometimes <tt>RequestEvent</tt>s have no associated <tt>ServerTransaction</tt>. * * @param request the <tt>Request</tt> to find a recipient for. * @return a suitable <tt>ProtocolProviderServiceSipImpl</tt>. */ private ProtocolProviderServiceSipImpl findTargetFor(Request request) { if (request == null) { logger.error("request shouldn't be null."); return null; } List<ProtocolProviderServiceSipImpl> currentListenersCopy = new ArrayList<ProtocolProviderServiceSipImpl>(this.getSipListeners()); // Let's first narrow down candidate choice by comparing // addresses and ports (no point in delivering to a provider with a // non matching IP address since they will reject it anyway). filterByAddress(currentListenersCopy, request); if (currentListenersCopy.size() == 0) { logger.error("no listeners"); return null; } URI requestURI = request.getRequestURI(); if (requestURI.isSipURI()) { String requestUser = ((SipURI) requestURI).getUser(); List<ProtocolProviderServiceSipImpl> candidates = new ArrayList<ProtocolProviderServiceSipImpl>(); // check if the Request-URI username is // one of ours usernames for (ProtocolProviderServiceSipImpl listener : currentListenersCopy) { String ourUserID = listener.getAccountID().getUserID(); // logger.trace(ourUserID + " *** " + requestUser); if (ourUserID.equals(requestUser)) { if (logger.isTraceEnabled()) logger.trace("suitable candidate found: " + listener.getAccountID()); candidates.add(listener); } } // the perfect match // every other case is approximation if (candidates.size() == 1) { ProtocolProviderServiceSipImpl perfectMatch = candidates.get(0); if (logger.isTraceEnabled()) logger.trace("Will dispatch to \"" + perfectMatch.getAccountID() + "\""); return perfectMatch; } // more than one account match if (candidates.size() > 1) { // check if a custom param exists in the contact // address (set for registrar accounts) for (ProtocolProviderServiceSipImpl candidate : candidates) { String hostValue = ((SipURI) requestURI).getParameter(SipStackSharing.CONTACT_ADDRESS_CUSTOM_PARAM_NAME); if (hostValue == null) continue; if (hostValue.equals(candidate.getContactAddressCustomParamValue())) { if (logger.isTraceEnabled()) logger.trace( "Will dispatch to \"" + candidate.getAccountID() + "\" because " + "\" the custom param was set"); return candidate; } } // Past this point, our guess is not reliable. We try to find // the "least worst" match based on parameters like the To field // check if the To header field host part // matches any of our SIP hosts for (ProtocolProviderServiceSipImpl candidate : candidates) { URI fromURI = ((FromHeader) request.getHeader(FromHeader.NAME)).getAddress().getURI(); if (fromURI.isSipURI() == false) continue; SipURI ourURI = (SipURI) candidate.getOurSipAddress((SipURI) fromURI).getURI(); String ourHost = ourURI.getHost(); URI toURI = ((ToHeader) request.getHeader(ToHeader.NAME)).getAddress().getURI(); if (toURI.isSipURI() == false) continue; String toHost = ((SipURI) toURI).getHost(); // logger.trace(toHost + "***" + ourHost); if (toHost.equals(ourHost)) { if (logger.isTraceEnabled()) logger.trace( "Will dispatch to \"" + candidate.getAccountID() + "\" because " + "host in the To: is the same as in our AOR"); return candidate; } } // fallback on the first candidate ProtocolProviderServiceSipImpl target = candidates.iterator().next(); logger.info( "Will randomly dispatch to \"" + target.getAccountID() + "\" because there is ambiguity on the username from" + " the Request-URI"); if (logger.isTraceEnabled()) logger.trace("\n" + request); return target; } // fallback on any account ProtocolProviderServiceSipImpl target = currentListenersCopy.iterator().next(); if (logger.isDebugEnabled()) logger.debug( "Will randomly dispatch to \"" + target.getAccountID() + "\" because the username in the Request-URI " + "is unknown or empty"); if (logger.isTraceEnabled()) logger.trace("\n" + request); return target; } else { logger.error("Request-URI is not a SIP URI, dropping"); } return null; }
/** * Dispatches the event received from a JAIN-SIP <tt>SipProvider</tt> to one of our "candidate * recipient" listeners. * * @param event the event received for a <tt>SipProvider</tt>. */ public void processRequest(RequestEvent event) { try { Request request = event.getRequest(); if (logger.isTraceEnabled()) logger.trace("received request: " + request.getMethod()); /* * Create the transaction if it doesn't exist yet. If it is a * dialog-creating request, the dialog will also be automatically * created by the stack. */ if (event.getServerTransaction() == null) { try { // apply some hacks if needed on incoming request // to be compliant with some servers/clients // if needed stop further processing. if (applyNonConformanceHacks(event)) return; SipProvider source = (SipProvider) event.getSource(); ServerTransaction transaction = source.getNewServerTransaction(request); /* * Update the event, otherwise getServerTransaction() and * getDialog() will still return their previous value. */ event = new RequestEvent(source, transaction, transaction.getDialog(), request); } catch (SipException ex) { logger.error( "couldn't create transaction, please report " + "this to [email protected]", ex); } } ProtocolProviderServiceSipImpl service = getServiceData(event.getServerTransaction()); if (service != null) { service.processRequest(event); } else { service = findTargetFor(request); if (service == null) { logger.error("couldn't find a ProtocolProviderServiceSipImpl " + "to dispatch to"); if (event.getServerTransaction() != null) event.getServerTransaction().terminate(); } else { /* * Mark the dialog for the dispatching of later in-dialog * requests. If there is no dialog, we need to mark the * request to dispatch a possible timeout when sending the * response. */ Object container = event.getDialog(); if (container == null) container = request; SipApplicationData.setApplicationData(container, SipApplicationData.KEY_SERVICE, service); service.processRequest(event); } } } catch (Throwable exc) { /* * Any exception thrown within our code should be caught here so * that we could log it rather than interrupt stack activity with * it. */ this.logApplicationException(DialogTerminatedEvent.class, exc); // Unfortunately, death can hardly be ignored. if (exc instanceof ThreadDeath) throw (ThreadDeath) exc; } }
/** * The method would add a subscription for a contact, wait for a subscription event confirming the * subscription, then change the status of the newly added contact (which is actually the * IcqTesterAgent) and make sure that the corresponding notification events have been generated. * * @throws java.lang.Exception if an exception occurs during testing. */ public void postTestSubscribe() throws Exception { logger.debug("Testing Subscription and Subscription Event Dispatch."); // First create a subscription and verify that it really gets created. SubscriptionEventCollector subEvtCollector = new SubscriptionEventCollector(); logger.trace("set Auth Handler"); operationSetPresence.setAuthorizationHandler(authEventCollector); synchronized (authEventCollector) { authEventCollector.authorizationRequestReason = "Please deny my request!"; fixture.testerAgent.getAuthCmdFactory().responseReasonStr = "First authorization I will Deny!!!"; fixture.testerAgent.getAuthCmdFactory().ACCEPT = false; operationSetPresence.subscribe(fixture.testerAgent.getIcqUIN()); // this one collects event that the buddy has been added // to the list as awaiting SubscriptionEventCollector moveEvtCollector = new SubscriptionEventCollector(); operationSetPresence.addSubscriptionListener(moveEvtCollector); logger.debug("Waiting for authorization error and authorization response..."); authEventCollector.waitForAuthResponse(15000); assertTrue( "Error adding buddy not recieved or the buddy(" + fixture.testerAgent.getIcqUIN() + ") doesn't require authorization", authEventCollector.isAuthorizationRequestSent); assertNotNull( "Agent haven't received any reason for authorization", fixture.testerAgent.getAuthCmdFactory().requestReasonStr); assertEquals( "Error sent request reason is not as the received one", authEventCollector.authorizationRequestReason, fixture.testerAgent.getAuthCmdFactory().requestReasonStr); logger.debug( "authEventCollector.isAuthorizationResponseReceived " + authEventCollector.isAuthorizationResponseReceived); assertTrue("Response not received!", authEventCollector.isAuthorizationResponseReceived); boolean isAcceptedAuthReuest = authEventCollector.response.getResponseCode().equals(AuthorizationResponse.ACCEPT); assertEquals( "Response is not as the sent one", fixture.testerAgent.getAuthCmdFactory().ACCEPT, isAcceptedAuthReuest); assertNotNull( "We didn't receive any reason! ", authEventCollector.authorizationResponseString); assertEquals( "The sent response reason is not as the received one", fixture.testerAgent.getAuthCmdFactory().responseReasonStr, authEventCollector.authorizationResponseString); // here we must wait for server to move the awaiting buddy // to the first specified group synchronized (moveEvtCollector) { moveEvtCollector.waitForEvent(20000); // don't want any more events operationSetPresence.removeSubscriptionListener(moveEvtCollector); } Contact c = operationSetPresence.findContactByID(fixture.testerAgent.getIcqUIN()); logger.debug("I will remove " + c + " from group : " + c.getParentContactGroup()); UnsubscribeWait unsubscribeEvtCollector = new UnsubscribeWait(); operationSetPresence.addSubscriptionListener(unsubscribeEvtCollector); synchronized (unsubscribeEvtCollector) { operationSetPresence.unsubscribe(c); logger.debug("Waiting to be removed..."); unsubscribeEvtCollector.waitForUnsubscribre(20000); logger.debug("Received unsubscribed ok or we lost patients!"); // don't want any more events operationSetPresence.removeSubscriptionListener(unsubscribeEvtCollector); } // so we haven't asserted so everithing is fine lets try to be authorized authEventCollector.authorizationRequestReason = "Please accept my request!"; fixture.testerAgent.getAuthCmdFactory().responseReasonStr = "Second authorization I will Accept!!!"; fixture.testerAgent.getAuthCmdFactory().ACCEPT = true; // clear some things authEventCollector.isAuthorizationRequestSent = false; authEventCollector.isAuthorizationResponseReceived = false; authEventCollector.authorizationResponseString = null; logger.debug( "I will add buddy does it exists ? " + (operationSetPresence.findContactByID(fixture.testerAgent.getIcqUIN()) != null)); // add the listener beacuse now our authorization will be accepted // and so the buddy will be finally added to the list operationSetPresence.addSubscriptionListener(subEvtCollector); // subscribe again so we can trigger again the authorization procedure operationSetPresence.subscribe(fixture.testerAgent.getIcqUIN()); logger.debug( "Waiting ... Subscribe must fail and the authorization process " + "to be trigered again so waiting for auth response ..."); authEventCollector.waitForAuthResponse(15000); assertTrue( "Error adding buddy not recieved or the buddy(" + fixture.testerAgent.getIcqUIN() + ") doesn't require authorization", authEventCollector.isAuthorizationRequestSent); assertNotNull( "Agent haven't received any reason for authorization", fixture.testerAgent.getAuthCmdFactory().requestReasonStr); // not working for now assertEquals( "Error sent request reason", authEventCollector.authorizationRequestReason, fixture.testerAgent.getAuthCmdFactory().requestReasonStr); // wait for authorization process to be finnished // the modification of buddy (server will inform us // that he removed - awaiting authorization flag) Object obj = new Object(); synchronized (obj) { logger.debug("wait for authorization process to be finnished"); obj.wait(10000); logger.debug("Stop waiting!"); } subEvtCollector.waitForEvent(10000); // don't want any more events operationSetPresence.removeSubscriptionListener(subEvtCollector); } // after adding awaitingAuthorization group here are catched 3 events // 1 - creating unresolved contact // 2 - move of the contact to awaitingAuthorization group // 3 - move of the contact from awaitingAuthorization group to original group assertTrue( "Subscription event dispatching failed.", subEvtCollector.collectedEvents.size() > 0); EventObject evt = null; Iterator<EventObject> events = subEvtCollector.collectedEvents.iterator(); while (events.hasNext()) { EventObject elem = events.next(); if (elem instanceof SubscriptionEvent) { if (((SubscriptionEvent) elem).getEventID() == SubscriptionEvent.SUBSCRIPTION_CREATED) evt = (SubscriptionEvent) elem; } } Object source = null; Contact srcContact = null; ProtocolProviderService srcProvider = null; // the event can be SubscriptionEvent and the new added one // SubscriptionMovedEvent if (evt instanceof SubscriptionEvent) { SubscriptionEvent subEvt = (SubscriptionEvent) evt; source = subEvt.getSource(); srcContact = subEvt.getSourceContact(); srcProvider = subEvt.getSourceProvider(); } assertEquals( "SubscriptionEvent Source:", fixture.testerAgent.getIcqUIN(), ((Contact) source).getAddress()); assertEquals( "SubscriptionEvent Source Contact:", fixture.testerAgent.getIcqUIN(), srcContact.getAddress()); assertSame("SubscriptionEvent Source Provider:", fixture.provider, srcProvider); subEvtCollector.collectedEvents.clear(); // make the user agent tester change its states and make sure we are // notified logger.debug("Testing presence notifications."); IcqStatusEnum testerAgentOldStatus = fixture.testerAgent.getPresneceStatus(); IcqStatusEnum testerAgentNewStatus = IcqStatusEnum.FREE_FOR_CHAT; long testerAgentNewStatusLong = FullUserInfo.ICQSTATUS_FFC; // in case we are by any chance already in a FREE_FOR_CHAT status, we'll // be changing to something else if (testerAgentOldStatus.equals(testerAgentNewStatus)) { testerAgentNewStatus = IcqStatusEnum.DO_NOT_DISTURB; testerAgentNewStatusLong = FullUserInfo.ICQSTATUS_DND; } // now do the actual status notification testing ContactPresenceEventCollector contactPresEvtCollector = new ContactPresenceEventCollector(fixture.testerAgent.getIcqUIN(), testerAgentNewStatus); operationSetPresence.addContactPresenceStatusListener(contactPresEvtCollector); synchronized (contactPresEvtCollector) { if (!fixture.testerAgent.enterStatus(testerAgentNewStatusLong)) { throw new RuntimeException( "Tester UserAgent Failed to switch to the " + testerAgentNewStatus.getStatusName() + " state."); } // we may already have the event, but it won't hurt to check. contactPresEvtCollector.waitForEvent(12000); operationSetPresence.removeContactPresenceStatusListener(contactPresEvtCollector); } if (contactPresEvtCollector.collectedEvents.size() == 0) { logger.info( "PROBLEM. Authorisation process doesn't have finnished " + "Server doesn't report us for changing authorization flag! Will try to authorize once again"); fixture.testerAgent.sendAuthorizationReplay( fixture.icqAccountID.getUserID(), fixture.testerAgent.getAuthCmdFactory().responseReasonStr, fixture.testerAgent.getAuthCmdFactory().ACCEPT); Object obj = new Object(); synchronized (obj) { logger.debug("wait for authorization process to be finnished for second time"); obj.wait(10000); logger.debug("Stop waiting!"); } testerAgentOldStatus = fixture.testerAgent.getPresneceStatus(); testerAgentNewStatusLong = FullUserInfo.ICQSTATUS_FFC; // in case we are by any chance already in a FREE_FOR_CHAT status, we'll // be changing to something else if (testerAgentOldStatus.equals(testerAgentNewStatus)) { testerAgentNewStatus = IcqStatusEnum.OCCUPIED; testerAgentNewStatusLong = FullUserInfo.ICQSTATUS_OCCUPIED; } contactPresEvtCollector = new ContactPresenceEventCollector(fixture.testerAgent.getIcqUIN(), testerAgentNewStatus); operationSetPresence.addContactPresenceStatusListener(contactPresEvtCollector); synchronized (contactPresEvtCollector) { if (!fixture.testerAgent.enterStatus(testerAgentNewStatusLong)) { throw new RuntimeException( "Tester UserAgent Failed to switch to the " + testerAgentNewStatus.getStatusName() + " state."); } // we may already have the event, but it won't hurt to check. contactPresEvtCollector.waitForEvent(12000); operationSetPresence.removeContactPresenceStatusListener(contactPresEvtCollector); } } assertEquals( "Presence Notif. event dispatching failed.", 1, contactPresEvtCollector.collectedEvents.size()); ContactPresenceStatusChangeEvent presEvt = (ContactPresenceStatusChangeEvent) contactPresEvtCollector.collectedEvents.get(0); assertEquals( "Presence Notif. event Source:", fixture.testerAgent.getIcqUIN(), ((Contact) presEvt.getSource()).getAddress()); assertEquals( "Presence Notif. event Source Contact:", fixture.testerAgent.getIcqUIN(), presEvt.getSourceContact().getAddress()); assertSame( "Presence Notif. event Source Provider:", fixture.provider, presEvt.getSourceProvider()); PresenceStatus reportedNewStatus = presEvt.getNewStatus(); PresenceStatus reportedOldStatus = presEvt.getOldStatus(); assertEquals("Reported new PresenceStatus: ", testerAgentNewStatus, reportedNewStatus); // don't require equality between the reported old PresenceStatus and // the actual presence status of the tester agent because a first // notification is not supposed to have the old status as it really was. assertNotNull("Reported old PresenceStatus: ", reportedOldStatus); /** @todo tester agent changes status message we see the new message */ /** @todo we should see the alias of the tester agent. */ Object obj = new Object(); synchronized (obj) { logger.debug("wait a moment. give time to server"); obj.wait(4000); } }
/** * Attach JAIN-SIP <tt>SipProvider</tt> and <tt>ListeningPoint</tt> to the stack either for clear * communications or TLS. Clear UDP and TCP <tt>ListeningPoint</tt>s are not handled separately as * the former is a fallback for the latter (depending on the size of the data transmitted). Both * <tt>ListeningPoint</tt>s must be bound to the same address and port in order for the related * <tt>SipProvider</tt> to be created. If a UDP or TCP <tt>ListeningPoint</tt> cannot bind, retry * for both on another port. * * @param preferredPort which port to try first to bind. * @param retries how many times should we try to find a free port to bind * @param secure whether to create the TLS SipProvider. or the clear UDP/TCP one. * @throws TransportNotSupportedException in case we try to create a provider for a transport not * currently supported by jain-sip * @throws InvalidArgumentException if we try binding to an illegal port (which we won't) * @throws ObjectInUseException if another <tt>SipProvider</tt> is already associated with this * <tt>ListeningPoint</tt>. * @throws TransportAlreadySupportedException if there is already a ListeningPoint associated to * this <tt>SipProvider</tt> with the same transport of the <tt>ListeningPoint</tt>. * @throws TooManyListenersException if we try to add a new <tt>SipListener</tt> with a * <tt>SipProvider</tt> when one was already registered. */ private void createProvider(int preferredPort, int retries, boolean secure) throws TransportNotSupportedException, InvalidArgumentException, ObjectInUseException, TransportAlreadySupportedException, TooManyListenersException { String context = (secure ? "TLS: " : "clear UDP/TCP: "); if (retries < 0) { // very unlikely to happen with the default 50 retries logger.error(context + "couldn't find free ports to listen on."); return; } ListeningPoint tlsLP = null; ListeningPoint udpLP = null; ListeningPoint tcpLP = null; try { if (secure) { tlsLP = this.stack.createListeningPoint( NetworkUtils.IN_ADDR_ANY, preferredPort, ListeningPoint.TLS); if (logger.isTraceEnabled()) logger.trace("TLS secure ListeningPoint has been created."); this.secureJainSipProvider = this.stack.createSipProvider(tlsLP); this.secureJainSipProvider.addSipListener(this); } else { udpLP = this.stack.createListeningPoint( NetworkUtils.IN_ADDR_ANY, preferredPort, ListeningPoint.UDP); tcpLP = this.stack.createListeningPoint( NetworkUtils.IN_ADDR_ANY, preferredPort, ListeningPoint.TCP); if (logger.isTraceEnabled()) logger.trace("UDP and TCP clear ListeningPoints have " + "been created."); this.clearJainSipProvider = this.stack.createSipProvider(udpLP); this.clearJainSipProvider.addListeningPoint(tcpLP); this.clearJainSipProvider.addSipListener(this); } if (logger.isTraceEnabled()) logger.trace(context + "SipProvider has been created."); } catch (InvalidArgumentException ex) { // makes sure we didn't leave an open listener // as both UDP and TCP listener have to bind to the same port if (tlsLP != null) this.stack.deleteListeningPoint(tlsLP); if (udpLP != null) this.stack.deleteListeningPoint(udpLP); if (tcpLP != null) this.stack.deleteListeningPoint(tcpLP); // FIXME: "Address already in use" is not working // as ex.getMessage() displays in the locale language in SC // (getMessage() is always supposed to be English though) // this should be a temporary workaround // if (ex.getMessage().indexOf("Address already in use") != -1) // another software is probably using the port if (ex.getCause() instanceof java.io.IOException) { if (logger.isDebugEnabled()) logger.debug("Port " + preferredPort + " seems in use for either TCP or UDP."); // tries again on a new random port int currentlyTriedPort = NetworkUtils.getRandomPortNumber(); if (logger.isDebugEnabled()) logger.debug("Retrying bind on port " + currentlyTriedPort); this.createProvider(currentlyTriedPort, retries - 1, secure); } else throw ex; } }