/** * $RCSfile: MessageRouter.java,v $ * $Revision: 3007 $ * $Date: 2005-10-31 13:29:25 -0300 (Mon, 31 Oct 2005) $ * * Copyright (C) 2005-2008 Jive Software. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.jivesoftware.openfire; import java.util.Date; import java.util.List; import java.util.StringTokenizer; import org.dom4j.DocumentFactory; import org.dom4j.Element; import org.dom4j.QName; import org.jivesoftware.openfire.carbons.Sent; import org.jivesoftware.openfire.container.BasicModule; import org.jivesoftware.openfire.forward.Forwarded; import org.jivesoftware.openfire.interceptor.InterceptorManager; import org.jivesoftware.openfire.interceptor.PacketRejectedException; import org.jivesoftware.openfire.session.ClientSession; import org.jivesoftware.openfire.session.LocalClientSession; import org.jivesoftware.openfire.session.Session; import org.jivesoftware.openfire.user.UserManager; import org.jivesoftware.util.JiveGlobals; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.xmpp.packet.JID; import org.xmpp.packet.Message; import org.xmpp.packet.Packet; import org.xmpp.packet.PacketError; /** * <p>Route message packets throughout the server.</p> * <p>Routing is based on the recipient and sender addresses. The typical * packet will often be routed twice, once from the sender to some internal * server component for handling or processing, and then back to the router * to be delivered to it's final destination.</p> * * @author Iain Shigeoka */ public class MessageRouter extends BasicModule { private static Logger log = LoggerFactory.getLogger(MessageRouter.class); private OfflineMessageStrategy messageStrategy; private RoutingTable routingTable; private SessionManager sessionManager; private MulticastRouter multicastRouter; private UserManager userManager; private String serverName; /** * Constructs a message router. */ public MessageRouter() { super("XMPP Message Router"); } /** * <p>Performs the actual packet routing.</p> * <p>You routing is considered 'quick' and implementations may not take * excessive amounts of time to complete the routing. If routing will take * a long amount of time, the actual routing should be done in another thread * so this method returns quickly.</p> * <h2>Warning</h2> * <p>Be careful to enforce concurrency DbC of concurrent by synchronizing * any accesses to class resources.</p> * * @param packet The packet to route * @throws NullPointerException If the packet is null */ public void route(Message packet) { if (packet == null) { throw new NullPointerException(); } ClientSession session = sessionManager.getSession(packet.getFrom()); try { // Invoke the interceptors before we process the read packet InterceptorManager.getInstance().invokeInterceptors(packet, session, true, false); if (session == null || session.getStatus() == Session.STATUS_AUTHENTICATED) { JID recipientJID = packet.getTo(); // If the server receives a message stanza with no 'to' attribute, it MUST treat the message as if the 'to' address were the bare JID <localpart@domainpart> of the sending entity. if (recipientJID == null) { recipientJID = packet.getFrom().asBareJID(); } // Check if the message was sent to the server hostname if (recipientJID.getNode() == null && recipientJID.getResource() == null && serverName.equals(recipientJID.getDomain())) { if (packet.getElement().element("addresses") != null) { // Message includes multicast processing instructions. Ask the multicastRouter // to route this packet multicastRouter.route(packet); } else { // Message was sent to the server hostname so forward it to a configurable // set of JID's (probably admin users) sendMessageToAdmins(packet); } return; } boolean isAcceptable = true; if (session instanceof LocalClientSession) { // Check if we could process messages from the recipient. // If not, return a not-acceptable error as per XEP-0016: // If the user attempts to send an outbound stanza to a contact and that stanza type is blocked, the user's server MUST NOT route the stanza to the contact but instead MUST return a <not-acceptable/> error Message dummyMessage = packet.createCopy(); dummyMessage.setFrom(packet.getTo()); dummyMessage.setTo(packet.getFrom()); if (!((LocalClientSession) session).canProcess(dummyMessage)) { packet.setTo(session.getAddress()); packet.setFrom((JID)null); packet.setError(PacketError.Condition.not_acceptable); session.process(packet); isAcceptable = false; } } if (isAcceptable) { boolean isPrivate = packet.getElement().element(QName.get("private", "urn:xmpp:carbons:2")) != null; try { // Deliver stanza to requested route //增加发送时间 if (packet instanceof Message) { Message message = (Message) packet; java.sql.Timestamp date = new java.sql.Timestamp(new Date().getTime()); Element chatInfoElement = message.getElement().element("chatinfo"); if(chatInfoElement != null && !"".equals(chatInfoElement)){ Element timeElement = DocumentFactory.getInstance().createDocument().addElement("sendtime"); timeElement.setText(String.valueOf(date.getTime())); chatInfoElement.add(timeElement); message.addChildElement("sendtime", String.valueOf(date.getTime())); } } routingTable.routePacket(recipientJID, packet, false); } catch (Exception e) { log.error("Failed to route packet: " + packet.toXML(), e); routingFailed(recipientJID, packet); } // Sent carbon copies to other resources of the sender: // When a client sends a <message/> of type "chat" if (packet.getType() == Message.Type.chat && !isPrivate && session != null) { // && session.isMessageCarbonsEnabled() ??? // must the own session also be carbon enabled? List<JID> routes = routingTable.getRoutes(packet.getFrom().asBareJID(), null); for (JID route : routes) { // The sending server SHOULD NOT send a forwarded copy to the sending full JID if it is a Carbons-enabled resource. if (!route.equals(session.getAddress())) { ClientSession clientSession = sessionManager.getSession(route); if (clientSession != null && clientSession.isMessageCarbonsEnabled()) { Message message = new Message(); // The wrapping message SHOULD maintain the same 'type' attribute value message.setType(packet.getType()); // the 'from' attribute MUST be the Carbons-enabled user's bare JID message.setFrom(packet.getFrom().asBareJID()); // and the 'to' attribute SHOULD be the full JID of the resource receiving the copy message.setTo(route); // The content of the wrapping message MUST contain a <sent/> element qualified by the namespace "urn:xmpp:carbons:2", which itself contains a <forwarded/> qualified by the namespace "urn:xmpp:forward:0" that contains the original <message/> stanza. message.addExtension(new Sent(new Forwarded(packet))); clientSession.process(message); } } } } } } else { packet.setTo(session.getAddress()); packet.setFrom((JID)null); packet.setError(PacketError.Condition.not_authorized); session.process(packet); } // Invoke the interceptors after we have processed the read packet InterceptorManager.getInstance().invokeInterceptors(packet, session, true, true); } catch (PacketRejectedException e) { // An interceptor rejected this packet if (session != null && e.getRejectionMessage() != null && e.getRejectionMessage().trim().length() > 0) { // A message for the rejection will be sent to the sender of the rejected packet Message reply = new Message(); reply.setID(packet.getID()); reply.setTo(session.getAddress()); reply.setFrom(packet.getTo()); reply.setType(packet.getType()); reply.setThread(packet.getThread()); reply.setBody(e.getRejectionMessage()); session.process(reply); } } } /** * Forwards the received message to the list of users defined in the property * <b>xmpp.forward.admins</b>. The property may include bare JIDs or just usernames separated * by commas or white spaces. When using bare JIDs the target user may belong to a remote * server.<p> * * If the property <b>xmpp.forward.admins</b> was not defined then the message will be sent * to all the users allowed to enter the admin console. * * @param packet the message to forward. */ private void sendMessageToAdmins(Message packet) { String jids = JiveGlobals.getProperty("xmpp.forward.admins"); if (jids != null && jids.trim().length() > 0) { // Forward the message to the users specified in the "xmpp.forward.admins" property StringTokenizer tokenizer = new StringTokenizer(jids, ", "); while (tokenizer.hasMoreTokens()) { String username = tokenizer.nextToken(); Message forward = packet.createCopy(); if (username.contains("@")) { // Use the specified bare JID address as the target address forward.setTo(username); } else { forward.setTo(username + "@" + serverName); } route(forward); } } else { // Forward the message to the users allowed to log into the admin console for (JID jid : XMPPServer.getInstance().getAdmins()) { Message forward = packet.createCopy(); forward.setTo(jid); route(forward); } } } @Override public void initialize(XMPPServer server) { super.initialize(server); messageStrategy = server.getOfflineMessageStrategy(); routingTable = server.getRoutingTable(); sessionManager = server.getSessionManager(); multicastRouter = server.getMulticastRouter(); userManager = server.getUserManager(); serverName = server.getServerInfo().getXMPPDomain(); } /** * Notification message indicating that a packet has failed to be routed to the recipient. * * @param recipient address of the entity that failed to receive the packet. * @param packet Message packet that failed to be sent to the recipient. */ public void routingFailed( JID recipient, Packet packet ) { log.debug( "Message sent to unreachable address: " + packet.toXML() ); final Message msg = (Message) packet; boolean storeOffline = true; if ( msg.getType().equals( Message.Type.chat ) && serverName.equals( recipient.getDomain() ) && recipient.getResource() != null ) { // Find an existing AVAILABLE session with non-negative priority. for (JID address : routingTable.getRoutes(recipient.asBareJID(), packet.getFrom())) { ClientSession session = routingTable.getClientRoute(address); if (session != null && session.isInitialized()) { if (session.getPresence().getPriority() >= 1) { storeOffline = false; } } } } if ( !storeOffline ) { // If message was sent to an unavailable full JID of a user then retry using the bare JID. routingTable.routePacket( recipient.asBareJID(), packet, false ); } else { // Delegate to offline message strategy, which will either bounce or ignore the message depending on user settings. messageStrategy.storeOffline( (Message) packet ); } } }