public String getPresenceStatus(String jid) throws UserNotFoundException {
log.debug("getPresenceStatus " + jid);
JID targetJID = new JID(jid);
User user = userManager.getUser(targetJID.getNode());
Presence presence = presenceManager.getPresence(user);
if (presence == null) {
log.debug("User is offline");
return "";
}
return presence.getStatus();
}
// Experimental - to be debugged and tested
public Presence getForeignUserPresence(String sender, String jid) throws UserNotFoundException {
log.debug("getPresence : sender = " + sender + " jid = " + jid);
if (jid == null) {
throw new UserNotFoundException("Target JID not found in request");
}
JID targetJID = new JID(jid);
// Check that the sender is not requesting information of a remote server entity
if (targetJID.getDomain() == null || XMPPServer.getInstance().isRemote(targetJID)) {
throw new UserNotFoundException("Domain does not matches local server domain");
}
if (!hostname.equals(targetJID.getDomain())) {
// Sender is requesting information about component presence, so we send a
// presence probe to the component.
presenceManager.probePresence(componentJID, targetJID);
// Wait 30 seconds until we get the probe presence result
int count = 0;
Presence presence = probedPresence.get(jid);
while (presence == null) {
if (count > 300) {
// After 30 seconds, timeout
throw new UserNotFoundException("Request for component presence has timed-out.");
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// don't care!
}
presence = probedPresence.get(jid);
count++;
}
// Clean-up probe presence result
probedPresence.remove(jid);
// Return component presence
return presence;
}
if (targetJID.getNode() == null
|| !UserManager.getInstance().isRegisteredUser(targetJID.getNode())) {
// Sender is requesting presence information of an anonymous user
throw new UserNotFoundException("Username is null");
}
User user = userManager.getUser(targetJID.getNode());
log.debug("user = "******"isNameVisible " + user.isNameVisible());
return ((PresenceManagerImpl) presenceManager).getPresence(user);
}
public void setPresenceState(String jid, UnifiedPresence.XmppPresence xmppPresence)
throws UserNotFoundException {
log.debug("setPresenceState : " + jid + " XmppPresence = " + xmppPresence);
if (jid == null) {
throw new UserNotFoundException("Target JID not found in request");
}
JID targetJID = new JID(jid);
// Check that the sender is not requesting information of a remote server entity
if (targetJID.getDomain() == null || XMPPServer.getInstance().isRemote(targetJID)) {
throw new UserNotFoundException("Domain does not matches local server domain");
}
User user = userManager.getUser(targetJID.getNode());
Presence presence = presenceManager.getPresence(user);
if (presence == null) {
log.debug("User is OFFLINE -- cannot set presence state");
return;
}
presence.setShow(xmppPresence.asPresenceShowEnum());
user.getRoster().broadcastPresence(presence);
}
public void process(Presence presence) throws PacketException {
try {
JID senderJID = presence.getFrom();
JID recipientJID = presence.getTo();
Presence.Type type = presence.getType();
// Reject presence subscription requests sent to the local server itself.
if (recipientJID == null || recipientJID.toString().equals(serverName)) {
if (type == Presence.Type.subscribe) {
Presence reply = new Presence();
reply.setTo(senderJID);
reply.setFrom(recipientJID);
reply.setType(Presence.Type.unsubscribed);
deliverer.deliver(reply);
}
return;
}
try {
Roster senderRoster = getRoster(senderJID);
if (senderRoster != null) {
manageSub(recipientJID, true, type, senderRoster);
}
Roster recipientRoster = getRoster(recipientJID);
boolean recipientSubChanged = false;
if (recipientRoster != null) {
recipientSubChanged = manageSub(senderJID, false, type, recipientRoster);
}
// Do not forward the packet to the recipient if the presence is of type subscribed
// and the recipient user has not changed its subscription state.
if (!(type == Presence.Type.subscribed
&& recipientRoster != null
&& !recipientSubChanged)) {
// If the user is already subscribed to the *local* user's presence then do not
// forward the subscription request. Also, do not send an auto-reply on behalf
// of the user. This presence stanza is the user's server know that it MUST no
// longer send notification of the subscription state change to the user.
// See http://tools.ietf.org/html/rfc3921#section-7 and/or OF-38
if (type == Presence.Type.subscribe && recipientRoster != null && !recipientSubChanged) {
try {
RosterItem.SubType subType = recipientRoster.getRosterItem(senderJID).getSubStatus();
if (subType == RosterItem.SUB_FROM || subType == RosterItem.SUB_BOTH) {
return;
}
} catch (UserNotFoundException e) {
// Weird case: Roster item does not exist. Should never happen
Log.error(
"User does not exist while trying to update roster item. "
+ "This should never happen (this indicates a programming "
+ "logic error). Processing stanza: "
+ presence.toString(),
e);
}
}
// Try to obtain a handler for the packet based on the routes. If the handler is
// a module, the module will be able to handle the packet. If the handler is a
// Session the packet will be routed to the client. If a route cannot be found
// then the packet will be delivered based on its recipient and sender.
List<JID> jids = routingTable.getRoutes(recipientJID, null);
if (!jids.isEmpty()) {
for (JID jid : jids) {
Presence presenteToSend = presence.createCopy();
// Stamp the presence with the user's bare JID as the 'from' address,
// as required by section 8.2.5 of RFC 3921
presenteToSend.setFrom(senderJID.toBareJID());
routingTable.routePacket(jid, presenteToSend, false);
}
} else {
deliverer.deliver(presence.createCopy());
}
if (type == Presence.Type.subscribed) {
// Send the presence of the local user to the remote user. The remote user
// subscribed to the presence of the local user and the local user accepted
JID prober =
localServer.isLocal(recipientJID)
? new JID(recipientJID.toBareJID())
: recipientJID;
presenceManager.probePresence(prober, senderJID);
PresenceEventDispatcher.subscribedToPresence(recipientJID, senderJID);
}
}
if (type == Presence.Type.unsubscribed) {
// Send unavailable presence from all of the local user's available resources
// to the remote user
presenceManager.sendUnavailableFromSessions(recipientJID, senderJID);
PresenceEventDispatcher.unsubscribedToPresence(senderJID, recipientJID);
}
} catch (SharedGroupException e) {
Presence result = presence.createCopy();
JID sender = result.getFrom();
result.setFrom(presence.getTo());
result.setTo(sender);
result.setError(PacketError.Condition.not_acceptable);
deliverer.deliver(result);
}
} catch (Exception e) {
Log.error(LocaleUtils.getLocalizedString("admin.error"), e);
}
}
