/** * Routes the Presence packet. * * @param packet the packet to route */ public void route(Presence packet) { if (packet == null) { throw new NullPointerException(); } // 根据发送包的jid查询建立连接的会话(session) ClientSession session = sessionManager.getSession(packet.getFrom()); // 当没有建立连接且状态为非连接状态,进行Presence包处理 if (session == null || session.getStatus() != Session.STATUS_CONNECTED) { handle(packet); } else { // 返回未授权错误 packet.setTo(session.getAddress()); packet.setFrom((JID) null); packet.setError(PacketError.Condition.not_authorized); session.process(packet); } }
private void processPresence(Element doc) { log.debug("processPresence()..."); Presence packet; try { packet = new Presence(doc, false); } catch (IllegalArgumentException e) { log.debug("Rejecting packet. JID malformed", e); Presence reply = new Presence(); reply.setID(doc.attributeValue("id")); reply.setTo(session.getAddress()); reply.getElement().addAttribute("from", doc.attributeValue("to")); reply.setError(PacketError.Condition.jid_malformed); session.process(reply); return; } if (session.getStatus() == Session.STATUS_CLOSED && packet.isAvailable()) { log.warn("Ignoring available presence packet of closed session: " + packet); return; } packet.setFrom(session.getAddress()); router.route(packet); session.incrementClientPacketCount(); if (session.getStatus() == Session.STATUS_AUTHENTICATED && packet.isAvailable()) { String userName = session.getAddress().getNode(); System.out.println("Query username : -> " + userName); if (null != userName && !"".equals(userName)) { NotificationMO mo = new NotificationMO(); mo.setUsername(userName); mo.setStatus(NotificationMO.STATUS_NOT_SEND); List<NotificationMO> list = notificationService.queryNotification(mo); if (!list.isEmpty()) { for (NotificationMO notificationMO : list) { notificationManager.sendOfflineNotification(notificationMO); } } else { log.info(" no offline notification, username = "******"userName is null !!!!!!"); } } }
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); } }