Exemplo n.º 1
0
 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();
 }
Exemplo n.º 2
0
  // 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);
  }
Exemplo n.º 3
0
  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);
    }
  }