/**
* Handles registration of a new configuration form.
*
* @param event the <tt>ServiceEvent</tt> that notified us
*/
public void serviceChanged(ServiceEvent event) {
Object sService = AdvancedConfigActivator.bundleContext.getService(event.getServiceReference());
// we don't care if the source service is not a configuration form
if (!(sService instanceof ConfigurationForm)) return;
ConfigurationForm configForm = (ConfigurationForm) sService;
/*
* This AdvancedConfigurationPanel is an advanced ConfigurationForm so
* don't try to add it to itself.
*/
if ((configForm == this) || !configForm.isAdvanced()) return;
switch (event.getType()) {
case ServiceEvent.REGISTERED:
if (logger.isInfoEnabled())
logger.info("Handling registration of a new Configuration Form.");
this.addConfigForm(configForm);
break;
case ServiceEvent.UNREGISTERING:
this.removeConfigForm(configForm);
break;
}
}
/**
* Returns existing chat rooms for the given <tt>chatRoomProvider</tt>.
*
* @param chatRoomProvider the <tt>ChatRoomProviderWrapper</tt>, which chat rooms we're looking
* for
* @return existing chat rooms for the given <tt>chatRoomProvider</tt>
*/
public List<String> getExistingChatRooms(ChatRoomProviderWrapper chatRoomProvider) {
if (chatRoomProvider == null) return null;
ProtocolProviderService protocolProvider = chatRoomProvider.getProtocolProvider();
if (protocolProvider == null) return null;
OperationSetMultiUserChat groupChatOpSet =
protocolProvider.getOperationSet(OperationSetMultiUserChat.class);
if (groupChatOpSet == null) return null;
List<String> chatRooms = null;
try {
chatRooms = groupChatOpSet.getExistingChatRooms();
} catch (OperationFailedException e) {
if (logger.isTraceEnabled())
logger.trace(
"Failed to obtain existing chat rooms for server: "
+ protocolProvider.getAccountID().getService(),
e);
} catch (OperationNotSupportedException e) {
if (logger.isTraceEnabled())
logger.trace(
"Failed to obtain existing chat rooms for server: "
+ protocolProvider.getAccountID().getService(),
e);
}
return chatRooms;
}
/**
* Tries to obtain a mapped/public address for the specified port (possibly by executing a STUN
* query).
*
* @param dst the destination that we'd like to use this address with.
* @param port the port whose mapping we are interested in.
* @return a public address corresponding to the specified port or null if all attempts to
* retrieve such an address have failed.
* @throws IOException if an error occurs while stun4j is using sockets.
* @throws BindException if the port is already in use.
*/
public InetSocketAddress getPublicAddressFor(InetAddress dst, int port)
throws IOException, BindException {
if (!useStun || (dst instanceof Inet6Address)) {
logger.debug(
"Stun is disabled for destination "
+ dst
+ ", skipping mapped address recovery (useStun="
+ useStun
+ ", IPv6@="
+ (dst instanceof Inet6Address)
+ ").");
// we'll still try to bind though so that we could notify the caller
// if the port has been taken already.
DatagramSocket bindTestSocket = new DatagramSocket(port);
bindTestSocket.close();
// if we're here then the port was free.
return new InetSocketAddress(getLocalHost(dst), port);
}
StunAddress mappedAddress = queryStunServer(port);
InetSocketAddress result = null;
if (mappedAddress != null) result = mappedAddress.getSocketAddress();
else {
// Apparently STUN failed. Let's try to temporarily disble it
// and use algorithms in getLocalHost(). ... We should probably
// eveng think about completely disabling stun, and not only
// temporarily.
// Bug report - John J. Barton - IBM
InetAddress localHost = getLocalHost(dst);
result = new InetSocketAddress(localHost, port);
}
if (logger.isDebugEnabled())
logger.debug("Returning mapping for port:" + port + " as follows: " + result);
return result;
}
/** The logic that runs in separate thread. Dispatching responses. */
public void run() {
if (connection == null) {
logger.error("No connection.");
return;
}
try {
connectionReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
if (!connectionReader.readLine().contains("XiVO")) {
logger.error("Error xivo with server!");
destroy();
return;
}
String line;
while ((line = connectionReader.readLine()) != null || !stopped) {
try {
if (logger.isTraceEnabled()) logger.trace("Read from server:" + line);
handle((JSONObject) JSONValue.parseWithException(line));
} catch (Throwable ex) {
logger.error("Error parsing object:" + line, ex);
}
}
} catch (IOException ex) {
destroy();
}
}
/**
* 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);
}
/**
* Method fired when "add" button is clicked.
*
* @param v add button's <tt>View</tt>
*/
public void onAddClicked(View v) {
Spinner accountsSpiner = (Spinner) findViewById(R.id.selectAccountSpinner);
Account selectedAcc = (Account) accountsSpiner.getSelectedItem();
if (selectedAcc == null) {
logger.error("No account selected");
return;
}
ProtocolProviderService pps = selectedAcc.getProtocolProvider();
if (pps == null) {
logger.error("No provider registered for account " + selectedAcc.getAccountName());
return;
}
View content = findViewById(android.R.id.content);
String contactAddress = ViewUtil.getTextViewValue(content, R.id.editContactName);
String displayName = ViewUtil.getTextViewValue(content, R.id.editDisplayName);
if (displayName != null && displayName.length() > 0) {
addRenameListener(pps, null, contactAddress, displayName);
}
Spinner groupSpinner = (Spinner) findViewById(R.id.selectGroupSpinner);
ContactListUtils.addContact(
pps, (MetaContactGroup) groupSpinner.getSelectedItem(), contactAddress);
finish();
}
/**
* 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);
}
}
/**
* 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 + ".");
}
}
/**
* Processes the session initiation {@link SessionIQ} that we were created with, passing its
* content to the media handler and then sends either a "session-info/ringing" or a "terminate"
* response.
*
* @param sessionInitIQ The {@link SessionIQ} that created the session that we are handling here.
*/
protected synchronized void processSessionInitiate(SessionIQ sessionInitIQ) {
// Do initiate the session.
this.sessionInitIQ = sessionInitIQ;
this.initiator = true;
RtpDescriptionPacketExtension description = null;
for (PacketExtension ext : sessionInitIQ.getExtensions()) {
if (ext.getElementName().equals(RtpDescriptionPacketExtension.ELEMENT_NAME)) {
description = (RtpDescriptionPacketExtension) ext;
break;
}
}
if (description == null) {
logger.info("No description in incoming session initiate");
// send an error response;
String reasonText = "Error: no description";
SessionIQ errResp =
GTalkPacketFactory.createSessionTerminate(
sessionInitIQ.getTo(),
sessionInitIQ.getFrom(),
sessionInitIQ.getID(),
Reason.INCOMPATIBLE_PARAMETERS,
reasonText);
setState(CallPeerState.FAILED, reasonText);
getProtocolProvider().getConnection().sendPacket(errResp);
return;
}
try {
getMediaHandler().processOffer(description);
} catch (Exception ex) {
logger.info("Failed to process an incoming session initiate", ex);
// send an error response;
String reasonText = "Error: " + ex.getMessage();
SessionIQ errResp =
GTalkPacketFactory.createSessionTerminate(
sessionInitIQ.getTo(),
sessionInitIQ.getFrom(),
sessionInitIQ.getID(),
Reason.INCOMPATIBLE_PARAMETERS,
reasonText);
setState(CallPeerState.FAILED, reasonText);
getProtocolProvider().getConnection().sendPacket(errResp);
return;
}
// If we do not get the info about the remote peer yet. Get it right
// now.
if (this.getDiscoveryInfo() == null) {
String calleeURI = sessionInitIQ.getFrom();
retrieveDiscoveryInfo(calleeURI);
}
}
/**
* 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");
}
}
/**
* Stop the bundle. Nothing to stop for now.
*
* @param bundleContext <tt>BundleContext</tt> provided by OSGi framework
* @throws Exception if something goes wrong during stop
*/
public void stop(BundleContext bundleContext) throws Exception {
if (logger.isDebugEnabled()) logger.debug("Update checker [STOPPED]");
if (mUpdateExecutor != null) {
mUpdateExecutor.shutdown();
mUpdateExecutor = null;
}
}
/**
* Handles {@link EventFactory#FOCUS_JOINED_ROOM_TOPIC} and {@link
* EventFactory#CONFERENCE_ROOM_TOPIC}.
*
* <p>{@inheritDoc}
*/
@Override
public void handleEvent(Event event) {
String topic = event.getTopic();
if (!topic.equals(EventFactory.FOCUS_JOINED_ROOM_TOPIC)
&& !topic.equals(EventFactory.CONFERENCE_ROOM_TOPIC)) {
logger.error("Unexpected event topic: " + topic);
return;
}
String roomJid = (String) event.getProperty(EventFactory.ROOM_JID_KEY);
JitsiMeetConference conference = focusManager.getConference(roomJid);
if (conference == null) {
logger.error("Conference is null");
return;
}
ChatRoom chatRoom = conference.getChatRoom();
if (chatRoom == null) {
logger.error("Chat room is null");
return;
}
JitsiMeetServices meetServices = focusManager.getJitsiMeetServices();
ComponentVersionsExtension versionsExtension = new ComponentVersionsExtension();
// XMPP
Version xmppServerVersion = meetServices.getXMPPServerVersion();
if (xmppServerVersion != null) {
versionsExtension.addComponentVersion(
ComponentVersionsExtension.COMPONENT_XMPP_SERVER,
xmppServerVersion.getNameVersionOsString());
}
// Conference focus
org.jitsi.service.version.Version jicofoVersion = versionService.getCurrentVersion();
versionsExtension.addComponentVersion(
ComponentVersionsExtension.COMPONENT_FOCUS,
jicofoVersion.getApplicationName()
+ "("
+ jicofoVersion.toString()
+ ","
+ System.getProperty("os.name")
+ ")");
// Videobridge
// It is not be reported for FOCUS_JOINED_ROOM_TOPIC
String bridgeJid = (String) event.getProperty(EventFactory.BRIDGE_JID_KEY);
Version jvbVersion = bridgeJid == null ? null : meetServices.getBridgeVersion(bridgeJid);
if (jvbVersion != null) {
versionsExtension.addComponentVersion(
ComponentVersionsExtension.COMPONENT_VIDEOBRIDGE, jvbVersion.getNameVersionOsString());
}
meetTools.sendPresenceExtension(chatRoom, versionsExtension);
if (logger.isDebugEnabled()) logger.debug("Sending versions: " + versionsExtension.toXML());
}
/**
* Place to put some hacks if needed on incoming requests.
*
* @param event the incoming request event.
* @return status <code>true</code> if we don't need to process this message, just discard it and
* <code>false</code> otherwise.
*/
private boolean applyNonConformanceHacks(RequestEvent event) {
Request request = event.getRequest();
try {
/*
* Max-Forwards is required, yet there are UAs which do not
* place it. SipProvider#getNewServerTransaction(Request)
* will throw an exception in the case of a missing
* Max-Forwards header and this method will eventually just
* log it thus ignoring the whole event.
*/
if (request.getHeader(MaxForwardsHeader.NAME) == null) {
// it appears that some buggy providers do send requests
// with no Max-Forwards headers, as we are at application level
// and we know there will be no endless loops
// there is no problem of adding headers and process normally
// this messages
MaxForwardsHeader maxForwards =
SipFactory.getInstance().createHeaderFactory().createMaxForwardsHeader(70);
request.setHeader(maxForwards);
}
} catch (Throwable ex) {
logger.warn("Cannot apply incoming request modification!", ex);
}
try {
// using asterisk voice mail initial notify for messages
// is ok, but on the fly received messages their notify comes
// without subscription-state, so we add it in order to be able to
// process message.
if (request.getMethod().equals(Request.NOTIFY)
&& request.getHeader(EventHeader.NAME) != null
&& ((EventHeader) request.getHeader(EventHeader.NAME))
.getEventType()
.equals(OperationSetMessageWaitingSipImpl.EVENT_PACKAGE)
&& request.getHeader(SubscriptionStateHeader.NAME) == null) {
request.addHeader(
new HeaderFactoryImpl().createSubscriptionStateHeader(SubscriptionStateHeader.ACTIVE));
}
} catch (Throwable ex) {
logger.warn("Cannot apply incoming request modification!", ex);
}
try {
// receiving notify message without subscription state
// used for keep-alive pings, they have done their job
// and are no more need. Skip processing them to avoid
// filling logs with unneeded exceptions.
if (request.getMethod().equals(Request.NOTIFY)
&& request.getHeader(SubscriptionStateHeader.NAME) == null) {
return true;
}
} catch (Throwable ex) {
logger.warn("Cannot apply incoming request modification!", ex);
}
return false;
}
/**
* Process candidates received.
*
* @param sessionInitIQ The {@link SessionIQ} that created the session we are handling here
*/
public void processCandidates(SessionIQ sessionInitIQ) {
Collection<PacketExtension> extensions = sessionInitIQ.getExtensions();
List<GTalkCandidatePacketExtension> candidates = new ArrayList<GTalkCandidatePacketExtension>();
for (PacketExtension ext : extensions) {
if (ext.getElementName().equalsIgnoreCase(GTalkCandidatePacketExtension.ELEMENT_NAME)) {
GTalkCandidatePacketExtension cand = (GTalkCandidatePacketExtension) ext;
candidates.add(cand);
}
}
try {
getMediaHandler().processCandidates(candidates);
} catch (OperationFailedException ofe) {
logger.warn("Failed to process an incoming candidates", ofe);
// send an error response
String reasonText = "Error: " + ofe.getMessage();
SessionIQ errResp =
GTalkPacketFactory.createSessionTerminate(
sessionInitIQ.getTo(),
sessionInitIQ.getFrom(),
sessionInitIQ.getID(),
Reason.GENERAL_ERROR,
reasonText);
getMediaHandler().getTransportManager().close();
setState(CallPeerState.FAILED, reasonText);
getProtocolProvider().getConnection().sendPacket(errResp);
return;
}
// HACK for FreeSwitch that send accept message before sending
// candidates
if (sessAcceptedWithNoCands != null) {
if (isInitiator()) {
try {
answer();
} catch (OperationFailedException e) {
logger.info("Failed to answer call (FreeSwitch hack)");
}
} else {
final SessionIQ sess = sessAcceptedWithNoCands;
sessAcceptedWithNoCands = null;
// run in another thread to not block smack receive thread and
// possibly delay others candidates messages.
new Thread() {
@Override
public void run() {
processSessionAccept(sess);
}
}.start();
}
sessAcceptedWithNoCands = null;
}
}
/**
* 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();
}
}
/**
* Sends command to server.
*
* @return is command successful sent.
*/
private boolean send(JSONObject obj) {
if (connection == null || connectionWriter == null) return false;
if (logger.isTraceEnabled()) logger.trace("Send to server:" + obj);
connectionWriter.println(obj);
return true;
}
/**
* Returns the <tt>URL</tt> of the image corresponding to the given key.
*
* @param urlKey The identifier of the image in the resource properties file.
* @return the <tt>URL</tt> of the image corresponding to the given key
*/
public URL getImageURL(String urlKey) {
String path = getImagePath(urlKey);
if (path == null || path.length() == 0) {
if (logger.isInfoEnabled()) logger.info("Missing resource for key: " + urlKey);
return null;
}
return getImageURLForPath(path);
}
public void appendToEnd(String text) {
Element root = document.getDefaultRootElement();
try {
document.insertAfterEnd(root.getElement(root.getElementCount() - 1), text);
} catch (BadLocationException e) {
logger.error("Insert in the HTMLDocument failed.", e);
} catch (IOException e) {
logger.error("Insert in the HTMLDocument failed.", e);
}
}
/** The default constructor for the SSH protocol provider. */
public ProtocolProviderServiceSSHImpl() {
logger.trace("Creating a ssh provider.");
try {
// converting to milliseconds
connectionTimeout = Integer.parseInt(Resources.getString("connectionTimeout")) * 1000;
} catch (NumberFormatException ex) {
logger.error("Connection Timeout set to 30 seconds");
}
}
/**
* Ends the call with for this <tt>CallPeer</tt>. Depending on the state of the peer the method
* would send a CANCEL, BYE, or BUSY_HERE message and set the new state to DISCONNECTED.
*
* @param failed indicates if the hangup is following to a call failure or simply a disconnect
* @param reasonText the text, if any, to be set on the <tt>ReasonPacketExtension</tt> as the
* value of its
* @param reasonOtherExtension the <tt>PacketExtension</tt>, if any, to be set on the
* <tt>ReasonPacketExtension</tt> as the value of its <tt>otherExtension</tt> property
*/
public void hangup(boolean failed, String reasonText, PacketExtension reasonOtherExtension) {
// do nothing if the call is already ended
if (CallPeerState.DISCONNECTED.equals(getState()) || CallPeerState.FAILED.equals(getState())) {
if (logger.isDebugEnabled())
logger.debug("Ignoring a request to hangup a call peer " + "that is already DISCONNECTED");
return;
}
CallPeerState prevPeerState = getState();
getMediaHandler().getTransportManager().close();
if (failed) setState(CallPeerState.FAILED, reasonText);
else setState(CallPeerState.DISCONNECTED, reasonText);
SessionIQ responseIQ = null;
if (prevPeerState.equals(CallPeerState.CONNECTED) || CallPeerState.isOnHold(prevPeerState)) {
responseIQ =
GTalkPacketFactory.createBye(getProtocolProvider().getOurJID(), peerJID, getSID());
responseIQ.setInitiator(isInitiator() ? getAddress() : getProtocolProvider().getOurJID());
} else if (CallPeerState.CONNECTING.equals(prevPeerState)
|| CallPeerState.CONNECTING_WITH_EARLY_MEDIA.equals(prevPeerState)
|| CallPeerState.ALERTING_REMOTE_SIDE.equals(prevPeerState)) {
responseIQ =
GTalkPacketFactory.createCancel(getProtocolProvider().getOurJID(), peerJID, getSID());
responseIQ.setInitiator(isInitiator() ? getAddress() : getProtocolProvider().getOurJID());
} else if (prevPeerState.equals(CallPeerState.INCOMING_CALL)) {
responseIQ =
GTalkPacketFactory.createBusy(getProtocolProvider().getOurJID(), peerJID, getSID());
responseIQ.setInitiator(isInitiator() ? getAddress() : getProtocolProvider().getOurJID());
} else if (prevPeerState.equals(CallPeerState.BUSY)
|| prevPeerState.equals(CallPeerState.FAILED)) {
// For FAILED and BUSY we only need to update CALL_STATUS
// as everything else has been done already.
} else {
logger.info("Could not determine call peer state!");
}
if (responseIQ != null) {
if (reasonOtherExtension != null) {
ReasonPacketExtension reason =
(ReasonPacketExtension)
responseIQ.getExtension(
ReasonPacketExtension.ELEMENT_NAME, ReasonPacketExtension.NAMESPACE);
if (reason == null) {
if (reasonOtherExtension instanceof ReasonPacketExtension) {
responseIQ.setReason((ReasonPacketExtension) reasonOtherExtension);
}
} else reason.setOtherExtension(reasonOtherExtension);
}
getProtocolProvider().getConnection().sendPacket(responseIQ);
}
}
public void insertAfterStart(String text) {
Element root = this.document.getDefaultRootElement();
try {
this.document.insertBeforeStart(root.getElement(0), text);
} catch (BadLocationException e) {
logger.error("Insert in the HTMLDocument failed.", e);
} catch (IOException e) {
logger.error("Insert in the HTMLDocument failed.", e);
}
}
/**
* Initializes this network address manager service implementation and starts all
* processes/threads associated with this address manager, such as a stun firewall/nat detector,
* keep alive threads, binding lifetime discovery threads and etc. The method may also be used
* after a call to stop() as a reinitialization technique.
*/
public void start() {
// init stun
String stunAddressStr = null;
int port = -1;
stunAddressStr = NetaddrActivator.getConfigurationService().getString(PROP_STUN_SERVER_ADDRESS);
String portStr = NetaddrActivator.getConfigurationService().getString(PROP_STUN_SERVER_PORT);
this.localHostFinderSocket = initRandomPortSocket();
if (stunAddressStr == null || portStr == null) {
useStun = false;
// we use the default stun server address only for chosing a public
// route and not for stun queries.
stunServerAddress = new StunAddress(DEFAULT_STUN_SERVER_ADDRESS, DEFAULT_STUN_SERVER_PORT);
logger.info(
"Stun server address("
+ stunAddressStr
+ ")/port("
+ portStr
+ ") not set (or invalid). Disabling STUN.");
} else {
try {
port = Integer.valueOf(portStr).intValue();
} catch (NumberFormatException ex) {
logger.error(portStr + " is not a valid port number. " + "Defaulting to 3478", ex);
port = 3478;
}
stunServerAddress = new StunAddress(stunAddressStr, port);
detector = new SimpleAddressDetector(stunServerAddress);
if (logger.isDebugEnabled()) {
logger.debug(
"Created a STUN Address detector for the following "
+ "STUN server: "
+ stunAddressStr
+ ":"
+ port);
}
detector.start();
logger.debug("STUN server detector started;");
// make sure that someone doesn't set invalid stun address and port
NetaddrActivator.getConfigurationService()
.addVetoableChangeListener(PROP_STUN_SERVER_ADDRESS, this);
NetaddrActivator.getConfigurationService()
.addVetoableChangeListener(PROP_STUN_SERVER_PORT, this);
// now start a thread query to the stun server and only set the
// useStun flag to true if it succeeds.
launchStunServerTest();
}
}
/**
* Logs the specified message and details.
*
* @param message the message to log
* @param from the message sender
* @param to the message addressee
* @param status message status
* @param sender determines whether we are the origin of this message.
*/
public void logMessage(
SIPMessage message, String from, String to, String status, boolean sender) {
if (!logger.isInfoEnabled()) return;
String msgHeader;
if (sender) msgHeader = "JAIN-SIP sent a message from=\"";
else msgHeader = "JAIN-SIP received a message from=\"";
if (logger.isInfoEnabled())
logger.info(msgHeader + from + "\" to=\"" + to + "\" (status: " + status + "):\n" + message);
}
/**
* 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);
}
}
/**
* The method queries a Stun server for a binding for the specified port.
*
* @param port the port to resolve (the stun message gets sent trhough that port)
* @return StunAddress the address returned by the stun server or null if an error occurred or no
* address was returned
* @throws IOException if an error occurs while stun4j is using sockets.
* @throws BindException if the port is already in use.
*/
private StunAddress queryStunServer(int port) throws IOException, BindException {
StunAddress mappedAddress = null;
if (detector != null && useStun) {
mappedAddress = detector.getMappingFor(port);
if (logger.isDebugEnabled())
logger.debug(
"For port:"
+ port
+ "a Stun server returned the "
+ "following mapping ["
+ mappedAddress);
}
return mappedAddress;
}
/**
* Start the swing notification service
*
* @param bc
* @throws java.lang.Exception
*/
public void start(BundleContext bc) throws Exception {
if (logger.isInfoEnabled()) logger.info("Swing Notification ...[ STARTING ]");
bundleContext = bc;
PopupMessageHandler handler = null;
handler = new PopupMessageHandlerSwingImpl();
getConfigurationService();
bc.registerService(PopupMessageHandler.class.getName(), handler, null);
if (logger.isInfoEnabled()) logger.info("Swing Notification ...[REGISTERED]");
}
/** Handles new incoming object. */
private void handle(JSONObject incomingObject) {
if (!incomingObject.containsKey("class")) return;
try {
String classField = (String) incomingObject.get("class");
if (classField.equals("loginko")) {
showError(null, null, "Unauthorized. Cannot login: "******"errorstring"));
logger.error("Error login: "******"errorstring"));
destroy();
return;
} else if (classField.equals("login_id_ok")) {
SipAccountIDImpl accountID = (SipAccountIDImpl) sipProvider.getAccountID();
boolean useSipCredentials = accountID.isClistOptionUseSipCredentials();
String password;
if (useSipCredentials) {
password = SipActivator.getProtocolProviderFactory().loadPassword(accountID);
} else {
password = accountID.getClistOptionPassword();
}
if (!authorize((String) incomingObject.get("sessionid"), password))
logger.error("Error login authorization!");
return;
} else if (classField.equals("login_pass_ok")) {
if (!sendCapas((JSONArray) incomingObject.get("capalist")))
logger.error("Error send capas!");
return;
} else if (classField.equals("login_capas_ok")) {
if (!sendFeatures(
(String) incomingObject.get("astid"), (String) incomingObject.get("xivo_userid")))
logger.error("Problem send features get!");
return;
} else if (classField.equals("features")) {
if (!getPhoneList()) logger.error("Problem send get phones!");
return;
} else if (classField.equals("phones")) {
phonesRecieved(incomingObject);
return;
} else if (classField.equals("disconn")) {
destroy();
return;
} else {
if (logger.isTraceEnabled()) logger.trace("unhandled classField: " + incomingObject);
return;
}
} catch (Throwable t) {
logger.error("Error handling incoming object", t);
}
}
/**
* The dependent service is available and the bundle will start.
*
* @param dependentService the UIService this activator is waiting.
*/
@Override
public void start(Object dependentService) {
if (logger.isDebugEnabled()) logger.debug("Update checker [STARTED]");
ConfigurationService cfg = getConfiguration();
if (OSUtils.IS_WINDOWS) {
updateService = new Update();
bundleContext.registerService(UpdateService.class.getName(), updateService, null);
// Register the "Check for Updates" menu item if
// the "Check for Updates" property isn't disabled.
if (!cfg.getBoolean(CHECK_FOR_UPDATES_MENU_DISABLED_PROP, false)) {
// Register the "Check for Updates" menu item.
CheckForUpdatesMenuItemComponent checkForUpdatesMenuItemComponent =
new CheckForUpdatesMenuItemComponent(Container.CONTAINER_HELP_MENU);
Hashtable<String, String> toolsMenuFilter = new Hashtable<String, String>();
toolsMenuFilter.put(Container.CONTAINER_ID, Container.CONTAINER_HELP_MENU.getID());
bundleContext.registerService(
PluginComponent.class.getName(), checkForUpdatesMenuItemComponent, toolsMenuFilter);
}
// Check for software update upon startup if enabled.
if (cfg.getBoolean(UPDATE_ENABLED, true)) updateService.checkForUpdates(false);
}
if (cfg.getBoolean(CHECK_FOR_UPDATES_DAILY_ENABLED_PROP, false)) {
logger.info("Scheduled update checking enabled");
// Schedule a "check for updates" task that will run once a day
int hoursToWait = calcHoursToWait();
Runnable updateRunnable =
new Runnable() {
public void run() {
logger.debug("Performing scheduled update check");
getUpdateService().checkForUpdates(false);
}
};
mUpdateExecutor = Executors.newSingleThreadScheduledExecutor();
mUpdateExecutor.scheduleAtFixedRate(
updateRunnable, hoursToWait, 24 * 60 * 60, TimeUnit.SECONDS);
}
if (logger.isDebugEnabled()) logger.debug("Update checker [REGISTERED]");
}
static {
try {
URL url = SpellCheckActivator.bundleContext.getBundle().getResource(RESOURCE_LOC);
InputStream stream = url.openStream();
if (stream == null) throw new IOException();
// strict parsing options
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(false);
factory.setIgnoringComments(true);
factory.setIgnoringElementContentWhitespace(true);
// parses configuration xml
/*-
* Warning: Felix is unable to import the com.sun.rowset.internal
* package, meaning this can't use the XmlErrorHandler. This causes
* a warning and a default handler to be attached. Otherwise this
* should have: builder.setErrorHandler(new XmlErrorHandler());
*/
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(stream);
// iterates over nodes, parsing contents
Node root = doc.getChildNodes().item(1);
NodeList categories = root.getChildNodes();
for (int i = 0; i < categories.getLength(); ++i) {
Node node = categories.item(i);
if (node.getNodeName().equals(NODE_DEFAULTS)) {
parseDefaults(node.getChildNodes());
} else if (node.getNodeName().equals(NODE_LOCALES)) {
parseLocales(node.getChildNodes());
} else {
logger.warn("Unrecognized category: " + node.getNodeName());
}
}
} catch (IOException exc) {
logger.error("Unable to load spell checker parameters", exc);
} catch (SAXException exc) {
logger.error("Unable to parse spell checker parameters", exc);
} catch (ParserConfigurationException exc) {
logger.error("Unable to parse spell checker parameters", exc);
}
}
/** Prepares the factory for bundle shutdown. */
public void stop() {
if (logger.isTraceEnabled()) logger.trace("Preparing to stop all protocol providers of" + this);
synchronized (registeredAccounts) {
for (Enumeration<ServiceRegistration> registrations = registeredAccounts.elements();
registrations.hasMoreElements(); ) {
ServiceRegistration reg = registrations.nextElement();
stop(reg);
reg.unregister();
}
registeredAccounts.clear();
}
}
