on either a form to fill out, or a set of data results. + * + * @return description of the data. + */ + public String getTitle() { + return dataForm.getTitle(); + } + + + /** + * Returns the meaning of the data within the context. The data could be part of a form + * to fill out, a form submission or data results. + * + * Possible form types are: + * <ul> + * <li>form -> Indicates a form to fill out.</li> + * <li>submit -> The form is filled out, and this is the data that is being returned from + * the form.</li> + * <li>cancel -> The form was cancelled. Tell the asker that piece of information.</li> + * <li>result -> Data results being returned from a search, or some other query.</li> + * </ul> + * + * @return the form's type. + */ + public String getType() { + return dataForm.getType(); + } + + + /** + * Sets instructions that explain how to fill out the form and what the form is about. + * + * @param instructions instructions that explain how to fill out the form. + */ + public void setInstructions(String instructions) { + // Split the instructions into multiple instructions for each existent newline + ArrayList<String> instructionsList = new ArrayList<String>(); + StringTokenizer st = new StringTokenizer(instructions, "\n"); + while (st.hasMoreTokens()) { + instructionsList.add(st.nextToken()); + } + // Set the new list of instructions + dataForm.setInstructions(instructionsList); + + } + + + /** + * Sets the description of the data. It is similar to the title on a web page or an X window. + * You can put a <title/> on either a form to fill out, or a set of data results. + * + * @param title description of the data. + */ + public void setTitle(String title) { + dataForm.setTitle(title); + } + + /** + * Returns a DataForm that serves to send this Form to the server. If the form is of type + * submit, it may contain fields with no value. These fields will be removed since they only + * exist to assist the user while editing/completing the form in a UI. + * + * @return the wrapped DataForm. + */ + public DataForm getDataFormToSend() { + if (isSubmitType()) { + // Create a new DataForm that contains only the answered fields + DataForm dataFormToSend = new DataForm(getType()); + for(Iterator<FormField> it=getFields();it.hasNext();) { + FormField field = it.next(); + if (field.getValues().hasNext()) { + dataFormToSend.addField(field); + } + } + return dataFormToSend; + } + return dataForm; + } + + /** + * Returns true if the form is a form to fill out. + * + * @return if the form is a form to fill out. + */ + private boolean isFormType() { + return TYPE_FORM.equals(dataForm.getType()); + } + + /** + * Returns true if the form is a form to submit. + * + * @return if the form is a form to submit. + */ + private boolean isSubmitType() { + return TYPE_SUBMIT.equals(dataForm.getType()); + } + + /** + * Returns a new Form to submit the completed values. The new Form will include all the fields + * of the original form except for the fields of type FIXED. Only the HIDDEN fields will + * include the same value of the original form. The other fields of the new form MUST be + * completed. If a field remains with no answer when sending the completed form, then it won't + * be included as part of the completed form. + * + * The reason why the fields with variables are included in the new form is to provide a model + * for binding with any UI. This means that the UIs will use the original form (of type + * "form") to learn how to render the form, but the UIs will bind the fields to the form of + * type submit. + * + * @return a Form to submit the completed values. + */ + public Form createAnswerForm() { + if (!isFormType()) { + throw new IllegalStateException("Only forms of type \"form\" could be answered"); + } + // Create a new Form + Form form = new Form(TYPE_SUBMIT); + for (Iterator<FormField> fields=getFields(); fields.hasNext();) { + FormField field = fields.next(); + // Add to the new form any type of field that includes a variable. + // Note: The fields of type FIXED are the only ones that don't specify a variable + if (field.getVariable() != null) { + FormField newField = new FormField(field.getVariable()); + newField.setType(field.getType()); + form.addField(newField); + // Set the answer ONLY to the hidden fields + if (FormField.TYPE_HIDDEN.equals(field.getType())) { + // Since a hidden field could have many values we need to collect them + // in a list + List<String> values = new ArrayList<String>(); + for (Iterator<String> it=field.getValues();it.hasNext();) { + values.add(it.next()); + } + form.setAnswer(field.getVariable(), values); + } + } + } + return form; + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/FormField.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/FormField.java new file mode 100644 index 0000000..2f2c00e --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/FormField.java @@ -0,0 +1,358 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +import org.jivesoftware.smack.util.StringUtils; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; + +/** + * Represents a field of a form. The field could be used to represent a question to complete, + * a completed question or a data returned from a search. The exact interpretation of the field + * depends on the context where the field is used. + * + * @author Gaston Dombiak + */ +public class FormField { + + public static final String TYPE_BOOLEAN = "boolean"; + public static final String TYPE_FIXED = "fixed"; + public static final String TYPE_HIDDEN = "hidden"; + public static final String TYPE_JID_MULTI = "jid-multi"; + public static final String TYPE_JID_SINGLE = "jid-single"; + public static final String TYPE_LIST_MULTI = "list-multi"; + public static final String TYPE_LIST_SINGLE = "list-single"; + public static final String TYPE_TEXT_MULTI = "text-multi"; + public static final String TYPE_TEXT_PRIVATE = "text-private"; + public static final String TYPE_TEXT_SINGLE = "text-single"; + + private String description; + private boolean required = false; + private String label; + private String variable; + private String type; + private final List<Option> options = new ArrayList<Option>(); + private final List<String> values = new ArrayList<String>(); + + /** + * Creates a new FormField with the variable name that uniquely identifies the field + * in the context of the form. + * + * @param variable the variable name of the question. + */ + public FormField(String variable) { + this.variable = variable; + } + + /** + * Creates a new FormField of type FIXED. The fields of type FIXED do not define a variable + * name. + */ + public FormField() { + this.type = FormField.TYPE_FIXED; + } + + /** + * Returns a description that provides extra clarification about the question. This information + * could be presented to the user either in tool-tip, help button, or as a section of text + * before the question. + * + * If the question is of type FIXED then the description should remain empty. + * + * @return description that provides extra clarification about the question. + */ + public String getDescription() { + return description; + } + + /** + * Returns the label of the question which should give enough information to the user to + * fill out the form. + * + * @return label of the question. + */ + public String getLabel() { + return label; + } + + /** + * Returns an Iterator for the available options that the user has in order to answer + * the question. + * + * @return Iterator for the available options. + */ + public Iterator<Option> getOptions() { + synchronized (options) { + return Collections.unmodifiableList(new ArrayList<Option>(options)).iterator(); + } + } + + /** + * Returns true if the question must be answered in order to complete the questionnaire. + * + * @return true if the question must be answered in order to complete the questionnaire. + */ + public boolean isRequired() { + return required; + } + + /** + * Returns an indicative of the format for the data to answer. Valid formats are: + * + * <ul> + * <li>text-single -> single line or word of text + * <li>text-private -> instead of showing the user what they typed, you show ***** to + * protect it + * <li>text-multi -> multiple lines of text entry + * <li>list-single -> given a list of choices, pick one + * <li>list-multi -> given a list of choices, pick one or more + * <li>boolean -> 0 or 1, true or false, yes or no. Default value is 0 + * <li>fixed -> fixed for putting in text to show sections, or just advertise your web + * site in the middle of the form + * <li>hidden -> is not given to the user at all, but returned with the questionnaire + * <li>jid-single -> Jabber ID - choosing a JID from your roster, and entering one based + * on the rules for a JID. + * <li>jid-multi -> multiple entries for JIDs + * </ul> + * + * @return format for the data to answer. + */ + public String getType() { + return type; + } + + /** + * Returns an Iterator for the default values of the question if the question is part + * of a form to fill out. Otherwise, returns an Iterator for the answered values of + * the question. + * + * @return an Iterator for the default values or answered values of the question. + */ + public Iterator<String> getValues() { + synchronized (values) { + return Collections.unmodifiableList(new ArrayList<String>(values)).iterator(); + } + } + + /** + * Returns the variable name that the question is filling out. + * + * @return the variable name of the question. + */ + public String getVariable() { + return variable; + } + + /** + * Sets a description that provides extra clarification about the question. This information + * could be presented to the user either in tool-tip, help button, or as a section of text + * before the question. + * + * If the question is of type FIXED then the description should remain empty. + * + * @param description provides extra clarification about the question. + */ + public void setDescription(String description) { + this.description = description; + } + + /** + * Sets the label of the question which should give enough information to the user to + * fill out the form. + * + * @param label the label of the question. + */ + public void setLabel(String label) { + this.label = label; + } + + /** + * Sets if the question must be answered in order to complete the questionnaire. + * + * @param required if the question must be answered in order to complete the questionnaire. + */ + public void setRequired(boolean required) { + this.required = required; + } + + /** + * Sets an indicative of the format for the data to answer. Valid formats are: + * + * <ul> + * <li>text-single -> single line or word of text + * <li>text-private -> instead of showing the user what they typed, you show ***** to + * protect it + * <li>text-multi -> multiple lines of text entry + * <li>list-single -> given a list of choices, pick one + * <li>list-multi -> given a list of choices, pick one or more + * <li>boolean -> 0 or 1, true or false, yes or no. Default value is 0 + * <li>fixed -> fixed for putting in text to show sections, or just advertise your web + * site in the middle of the form + * <li>hidden -> is not given to the user at all, but returned with the questionnaire + * <li>jid-single -> Jabber ID - choosing a JID from your roster, and entering one based + * on the rules for a JID. + * <li>jid-multi -> multiple entries for JIDs + * </ul> + * + * @param type an indicative of the format for the data to answer. + */ + public void setType(String type) { + this.type = type; + } + + /** + * Adds a default value to the question if the question is part of a form to fill out. + * Otherwise, adds an answered value to the question. + * + * @param value a default value or an answered value of the question. + */ + public void addValue(String value) { + synchronized (values) { + values.add(value); + } + } + + /** + * Adds a default values to the question if the question is part of a form to fill out. + * Otherwise, adds an answered values to the question. + * + * @param newValues default values or an answered values of the question. + */ + public void addValues(List<String> newValues) { + synchronized (values) { + values.addAll(newValues); + } + } + + /** + * Removes all the values of the field. + */ + protected void resetValues() { + synchronized (values) { + values.removeAll(new ArrayList<String>(values)); + } + } + + /** + * Adss an available options to the question that the user has in order to answer + * the question. + * + * @param option a new available option for the question. + */ + public void addOption(Option option) { + synchronized (options) { + options.add(option); + } + } + + public String toXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<field"); + // Add attributes + if (getLabel() != null) { + buf.append(" label=\"").append(getLabel()).append("\""); + } + if (getVariable() != null) { + buf.append(" var=\"").append(getVariable()).append("\""); + } + if (getType() != null) { + buf.append(" type=\"").append(getType()).append("\""); + } + buf.append(">"); + // Add elements + if (getDescription() != null) { + buf.append("<desc>").append(getDescription()).append("</desc>"); + } + if (isRequired()) { + buf.append("<required/>"); + } + // Loop through all the values and append them to the string buffer + for (Iterator<String> i = getValues(); i.hasNext();) { + buf.append("<value>").append(i.next()).append("</value>"); + } + // Loop through all the values and append them to the string buffer + for (Iterator i = getOptions(); i.hasNext();) { + buf.append(((Option) i.next()).toXML()); + } + buf.append("</field>"); + return buf.toString(); + } + + /** + * Represents the available option of a given FormField. + * + * @author Gaston Dombiak + */ + public static class Option { + + private String label; + private String value; + + public Option(String value) { + this.value = value; + } + + public Option(String label, String value) { + this.label = label; + this.value = value; + } + + /** + * Returns the label that represents the option. + * + * @return the label that represents the option. + */ + public String getLabel() { + return label; + } + + /** + * Returns the value of the option. + * + * @return the value of the option. + */ + public String getValue() { + return value; + } + + public String toString() { + return getLabel(); + } + + public String toXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<option"); + // Add attribute + if (getLabel() != null) { + buf.append(" label=\"").append(getLabel()).append("\""); + } + buf.append(">"); + // Add element + buf.append("<value>").append(StringUtils.escapeForXML(getValue())).append("</value>"); + + buf.append("</option>"); + return buf.toString(); + } + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/Gateway.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/Gateway.java new file mode 100644 index 0000000..5b5836f --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/Gateway.java @@ -0,0 +1,333 @@ +package org.jivesoftware.smackx; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.PacketCollector; +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.Roster; +import org.jivesoftware.smack.RosterEntry; +import org.jivesoftware.smack.SmackConfiguration; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.filter.PacketIDFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.packet.Presence; +import org.jivesoftware.smack.packet.Registration; +import org.jivesoftware.smack.util.StringUtils; +import org.jivesoftware.smackx.packet.DiscoverInfo; +import org.jivesoftware.smackx.packet.DiscoverInfo.Identity; + +/** + * This class provides an abstract view to gateways/transports. This class handles all + * actions regarding gateways and transports. + * @author Till Klocke + * + */ +public class Gateway { + + private Connection connection; + private ServiceDiscoveryManager sdManager; + private Roster roster; + private String entityJID; + private Registration registerInfo; + private Identity identity; + private DiscoverInfo info; + + Gateway(Connection connection, String entityJID){ + this.connection = connection; + this.roster = connection.getRoster(); + this.sdManager = ServiceDiscoveryManager.getInstanceFor(connection); + this.entityJID = entityJID; + } + + Gateway(Connection connection, String entityJID, DiscoverInfo info, Identity identity){ + this(connection, entityJID); + this.info = info; + this.identity = identity; + } + + private void discoverInfo() throws XMPPException{ + info = sdManager.discoverInfo(entityJID); + Iterator<Identity> iterator = info.getIdentities(); + while(iterator.hasNext()){ + Identity temp = iterator.next(); + if(temp.getCategory().equalsIgnoreCase("gateway")){ + this.identity = temp; + break; + } + } + } + + private Identity getIdentity() throws XMPPException{ + if(identity==null){ + discoverInfo(); + } + return identity; + } + + private Registration getRegisterInfo(){ + if(registerInfo==null){ + refreshRegisterInfo(); + } + return registerInfo; + } + + private void refreshRegisterInfo(){ + Registration packet = new Registration(); + packet.setFrom(connection.getUser()); + packet.setType(IQ.Type.GET); + packet.setTo(entityJID); + PacketCollector collector = + connection.createPacketCollector(new PacketIDFilter(packet.getPacketID())); + connection.sendPacket(packet); + Packet result = collector.nextResult(SmackConfiguration.getPacketReplyTimeout()); + collector.cancel(); + if(result instanceof Registration && result.getError()==null){ + Registration register = (Registration)result; + this.registerInfo = register; + } + } + + /** + * Checks if this gateway supports In-Band registration + * @return true if In-Band registration is supported + * @throws XMPPException + */ + public boolean canRegister() throws XMPPException{ + if(info==null){ + discoverInfo(); + } + return info.containsFeature("jabber:iq:register"); + } + + /** + * Returns all fields that are required to register to this gateway + * @return a list of required fields + */ + public List<String> getRequiredFields(){ + return getRegisterInfo().getRequiredFields(); + } + + /** + * Returns the name as proposed in this gateways identity discovered via service + * discovery + * @return a String of its name + * @throws XMPPException + */ + public String getName() throws XMPPException{ + if(identity==null){ + discoverInfo(); + } + return identity.getName(); + } + + /** + * Returns the type as proposed in this gateways identity discovered via service + * discovery. See {@link http://xmpp.org/registrar/disco-categories.html} for + * possible types + * @return a String describing the type + * @throws XMPPException + */ + public String getType() throws XMPPException{ + if(identity==null){ + discoverInfo(); + } + return identity.getType(); + } + + /** + * Returns true if the registration informations indicates that you are already + * registered with this gateway + * @return true if already registered + * @throws XMPPException + */ + public boolean isRegistered() throws XMPPException{ + return getRegisterInfo().isRegistered(); + } + + /** + * Returns the value of specific field of the registration information. Can be used + * to retrieve for example to retrieve username/password used on an already registered + * gateway. + * @param fieldName name of the field + * @return a String containing the value of the field or null + */ + public String getField(String fieldName){ + return getRegisterInfo().getField(fieldName); + } + + /** + * Returns a List of Strings of all field names which contain values. + * @return a List of field names + */ + public List<String> getFieldNames(){ + return getRegisterInfo().getFieldNames(); + } + + /** + * A convenience method for retrieving the username of an existing account + * @return String describing the username + */ + public String getUsername(){ + return getField("username"); + } + + /** + * A convenience method for retrieving the password of an existing accoung + * @return String describing the password + */ + public String getPassword(){ + return getField("password"); + } + + /** + * Returns instructions for registering with this gateway + * @return String containing instructions + */ + public String getInstructions(){ + return getRegisterInfo().getInstructions(); + } + + /** + * With this method you can register with this gateway or modify an existing registration + * @param username String describing the username + * @param password String describing the password + * @param fields additional fields like email. + * @throws XMPPException + */ + public void register(String username, String password, Map<String,String> fields)throws XMPPException{ + if(getRegisterInfo().isRegistered()) { + throw new IllegalStateException("You are already registered with this gateway"); + } + Registration register = new Registration(); + register.setFrom(connection.getUser()); + register.setTo(entityJID); + register.setType(IQ.Type.SET); + register.setUsername(username); + register.setPassword(password); + for(String s : fields.keySet()){ + register.addAttribute(s, fields.get(s)); + } + PacketCollector resultCollector = + connection.createPacketCollector(new PacketIDFilter(register.getPacketID())); + connection.sendPacket(register); + Packet result = + resultCollector.nextResult(SmackConfiguration.getPacketReplyTimeout()); + resultCollector.cancel(); + if(result!=null && result instanceof IQ){ + IQ resultIQ = (IQ)result; + if(resultIQ.getError()!=null){ + throw new XMPPException(resultIQ.getError()); + } + if(resultIQ.getType()==IQ.Type.ERROR){ + throw new XMPPException(resultIQ.getError()); + } + connection.addPacketListener(new GatewayPresenceListener(), + new PacketTypeFilter(Presence.class)); + roster.createEntry(entityJID, getIdentity().getName(), new String[]{}); + } + else{ + throw new XMPPException("Packet reply timeout"); + } + } + + /** + * A convenience method for registering or modifying an account on this gateway without + * additional fields + * @param username String describing the username + * @param password String describing the password + * @throws XMPPException + */ + public void register(String username, String password) throws XMPPException{ + register(username, password,new HashMap<String,String>()); + } + + /** + * This method removes an existing registration from this gateway + * @throws XMPPException + */ + public void unregister() throws XMPPException{ + Registration register = new Registration(); + register.setFrom(connection.getUser()); + register.setTo(entityJID); + register.setType(IQ.Type.SET); + register.setRemove(true); + PacketCollector resultCollector = + connection.createPacketCollector(new PacketIDFilter(register.getPacketID())); + connection.sendPacket(register); + Packet result = resultCollector.nextResult(SmackConfiguration.getPacketReplyTimeout()); + resultCollector.cancel(); + if(result!=null && result instanceof IQ){ + IQ resultIQ = (IQ)result; + if(resultIQ.getError()!=null){ + throw new XMPPException(resultIQ.getError()); + } + if(resultIQ.getType()==IQ.Type.ERROR){ + throw new XMPPException(resultIQ.getError()); + } + RosterEntry gatewayEntry = roster.getEntry(entityJID); + roster.removeEntry(gatewayEntry); + } + else{ + throw new XMPPException("Packet reply timeout"); + } + } + + /** + * Lets you login manually in this gateway. Normally a gateway logins you when it + * receives the first presence broadcasted by your server. But it is possible to + * manually login and logout by sending a directed presence. This method sends an + * empty available presence direct to the gateway. + */ + public void login(){ + Presence presence = new Presence(Presence.Type.available); + login(presence); + } + + /** + * This method lets you send the presence direct to the gateway. Type, To and From + * are modified. + * @param presence the presence used to login to gateway + */ + public void login(Presence presence){ + presence.setType(Presence.Type.available); + presence.setTo(entityJID); + presence.setFrom(connection.getUser()); + connection.sendPacket(presence); + } + + /** + * This method logs you out from this gateway by sending an unavailable presence + * to directly to this gateway. + */ + public void logout(){ + Presence presence = new Presence(Presence.Type.unavailable); + presence.setTo(entityJID); + presence.setFrom(connection.getUser()); + connection.sendPacket(presence); + } + + private class GatewayPresenceListener implements PacketListener{ + + public void processPacket(Packet packet) { + if(packet instanceof Presence){ + Presence presence = (Presence)packet; + if(entityJID.equals(presence.getFrom()) && + roster.contains(presence.getFrom()) && + presence.getType().equals(Presence.Type.subscribe)){ + Presence response = new Presence(Presence.Type.subscribed); + response.setTo(presence.getFrom()); + response.setFrom(StringUtils.parseBareAddress(connection.getUser())); + connection.sendPacket(response); + } + } + + } + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/GatewayManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/GatewayManager.java new file mode 100644 index 0000000..eee9cfc --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/GatewayManager.java @@ -0,0 +1,199 @@ +package org.jivesoftware.smackx; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.Roster; +import org.jivesoftware.smack.RosterEntry; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.util.StringUtils; +import org.jivesoftware.smackx.packet.DiscoverInfo; +import org.jivesoftware.smackx.packet.DiscoverItems; +import org.jivesoftware.smackx.packet.DiscoverInfo.Identity; +import org.jivesoftware.smackx.packet.DiscoverItems.Item; + +/** + * This class is the general entry point to gateway interaction (XEP-0100). + * This class discovers available gateways on the users servers, and + * can give you also a list of gateways the you user is registered with which + * are not on his server. All actual interaction with a gateway is handled in the + * class {@see Gateway}. + * @author Till Klocke + * + */ +public class GatewayManager { + + private static Map<Connection,GatewayManager> instances = + new HashMap<Connection,GatewayManager>(); + + private ServiceDiscoveryManager sdManager; + + private Map<String,Gateway> localGateways = new HashMap<String,Gateway>(); + + private Map<String,Gateway> nonLocalGateways = new HashMap<String,Gateway>(); + + private Map<String,Gateway> gateways = new HashMap<String,Gateway>(); + + private Connection connection; + + private Roster roster; + + private GatewayManager(){ + + } + + /** + * Creates a new instance of GatewayManager + * @param connection + * @throws XMPPException + */ + private GatewayManager(Connection connection) throws XMPPException{ + this.connection = connection; + this.roster = connection.getRoster(); + sdManager = ServiceDiscoveryManager.getInstanceFor(connection); + } + + /** + * Loads all gateways the users server offers + * @throws XMPPException + */ + private void loadLocalGateways() throws XMPPException{ + DiscoverItems items = sdManager.discoverItems(connection.getHost()); + Iterator<Item> iter = items.getItems(); + while(iter.hasNext()){ + String itemJID = iter.next().getEntityID(); + discoverGateway(itemJID); + } + } + + /** + * Discovers {@link DiscoveryInfo} and {@link DiscoveryInfo.Identity} of a gateway + * and creates a {@link Gateway} object representing this gateway. + * @param itemJID + * @throws XMPPException + */ + private void discoverGateway(String itemJID) throws XMPPException{ + DiscoverInfo info = sdManager.discoverInfo(itemJID); + Iterator<Identity> i = info.getIdentities(); + + while(i.hasNext()){ + Identity identity = i.next(); + String category = identity.getCategory(); + if(category.toLowerCase().equals("gateway")){ + gateways.put(itemJID, new Gateway(connection,itemJID)); + if(itemJID.contains(connection.getHost())){ + localGateways.put(itemJID, + new Gateway(connection,itemJID,info,identity)); + } + else{ + nonLocalGateways.put(itemJID, + new Gateway(connection,itemJID,info,identity)); + } + break; + } + } + } + + /** + * Loads all getways which are in the users roster, but are not supplied by the + * users server + * @throws XMPPException + */ + private void loadNonLocalGateways() throws XMPPException{ + if(roster!=null){ + for(RosterEntry entry : roster.getEntries()){ + if(entry.getUser().equalsIgnoreCase(StringUtils.parseServer(entry.getUser())) && + !entry.getUser().contains(connection.getHost())){ + discoverGateway(entry.getUser()); + } + } + } + } + + /** + * Returns an instance of GatewayManager for the given connection. If no instance for + * this connection exists a new one is created and stored in a Map. + * @param connection + * @return an instance of GatewayManager + * @throws XMPPException + */ + public GatewayManager getInstanceFor(Connection connection) throws XMPPException{ + synchronized(instances){ + if(instances.containsKey(connection)){ + return instances.get(connection); + } + GatewayManager instance = new GatewayManager(connection); + instances.put(connection, instance); + return instance; + } + } + + /** + * Returns a list of gateways which are offered by the users server, wether the + * user is registered to them or not. + * @return a List of Gateways + * @throws XMPPException + */ + public List<Gateway> getLocalGateways() throws XMPPException{ + if(localGateways.size()==0){ + loadLocalGateways(); + } + return new ArrayList<Gateway>(localGateways.values()); + } + + /** + * Returns a list of gateways the user has in his roster, but which are offered by + * remote servers. But note that this list isn't automatically refreshed. You have to + * refresh is manually if needed. + * @return a list of gateways + * @throws XMPPException + */ + public List<Gateway> getNonLocalGateways() throws XMPPException{ + if(nonLocalGateways.size()==0){ + loadNonLocalGateways(); + } + return new ArrayList<Gateway>(nonLocalGateways.values()); + } + + /** + * Refreshes the list of gateways offered by remote servers. + * @throws XMPPException + */ + public void refreshNonLocalGateways() throws XMPPException{ + loadNonLocalGateways(); + } + + /** + * Returns a Gateway object for a given JID. Please note that it is not checked if + * the JID belongs to valid gateway. If this JID doesn't belong to valid gateway + * all operations on this Gateway object should fail with a XMPPException. But there is + * no guarantee for that. + * @param entityJID + * @return a Gateway object + */ + public Gateway getGateway(String entityJID){ + if(localGateways.containsKey(entityJID)){ + return localGateways.get(entityJID); + } + if(nonLocalGateways.containsKey(entityJID)){ + return nonLocalGateways.get(entityJID); + } + if(gateways.containsKey(entityJID)){ + return gateways.get(entityJID); + } + Gateway gateway = new Gateway(connection,entityJID); + if(entityJID.contains(connection.getHost())){ + localGateways.put(entityJID, gateway); + } + else{ + nonLocalGateways.put(entityJID, gateway); + } + gateways.put(entityJID, gateway); + return gateway; + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/GroupChatInvitation.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/GroupChatInvitation.java new file mode 100644 index 0000000..a9ed35e --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/GroupChatInvitation.java @@ -0,0 +1,115 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +import org.jivesoftware.smack.packet.PacketExtension; +import org.jivesoftware.smack.provider.PacketExtensionProvider; +import org.xmlpull.v1.XmlPullParser; + +/** + * A group chat invitation packet extension, which is used to invite other + * users to a group chat room. To invite a user to a group chat room, address + * a new message to the user and set the room name appropriately, as in the + * following code example: + * + * <pre> + * Message message = new Message("user@chat.example.com"); + * message.setBody("Join me for a group chat!"); + * message.addExtension(new GroupChatInvitation("room@chat.example.com");); + * con.sendPacket(message); + * </pre> + * + * To listen for group chat invitations, use a PacketExtensionFilter for the + * <tt>x</tt> element name and <tt>jabber:x:conference</tt> namespace, as in the + * following code example: + * + * <pre> + * PacketFilter filter = new PacketExtensionFilter("x", "jabber:x:conference"); + * // Create a packet collector or packet listeners using the filter... + * </pre> + * + * Note: this protocol is outdated now that the Multi-User Chat (MUC) JEP is available + * (<a href="http://www.jabber.org/jeps/jep-0045.html">JEP-45</a>). However, most + * existing clients still use this older protocol. Once MUC support becomes more + * widespread, this API may be deprecated. + * + * @author Matt Tucker + */ +public class GroupChatInvitation implements PacketExtension { + + /** + * Element name of the packet extension. + */ + public static final String ELEMENT_NAME = "x"; + + /** + * Namespace of the packet extension. + */ + public static final String NAMESPACE = "jabber:x:conference"; + + private String roomAddress; + + /** + * Creates a new group chat invitation to the specified room address. + * GroupChat room addresses are in the form <tt>room@service</tt>, + * where <tt>service</tt> is the name of groupchat server, such as + * <tt>chat.example.com</tt>. + * + * @param roomAddress the address of the group chat room. + */ + public GroupChatInvitation(String roomAddress) { + this.roomAddress = roomAddress; + } + + /** + * Returns the address of the group chat room. GroupChat room addresses + * are in the form <tt>room@service</tt>, where <tt>service</tt> is + * the name of groupchat server, such as <tt>chat.example.com</tt>. + * + * @return the address of the group chat room. + */ + public String getRoomAddress() { + return roomAddress; + } + + public String getElementName() { + return ELEMENT_NAME; + } + + public String getNamespace() { + return NAMESPACE; + } + + public String toXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<x xmlns=\"jabber:x:conference\" jid=\"").append(roomAddress).append("\"/>"); + return buf.toString(); + } + + public static class Provider implements PacketExtensionProvider { + public PacketExtension parseExtension (XmlPullParser parser) throws Exception { + String roomAddress = parser.getAttributeValue("", "jid"); + // Advance to end of extension. + parser.next(); + return new GroupChatInvitation(roomAddress); + } + } +} \ No newline at end of file diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/LLServiceDiscoveryManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/LLServiceDiscoveryManager.java new file mode 100644 index 0000000..07f40f2 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/LLServiceDiscoveryManager.java @@ -0,0 +1,634 @@ +/* + * Copyright 2009 Jonas Ådahl. + * + * 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.smackx; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.LLPresence; +import org.jivesoftware.smack.LLPresenceListener; +import org.jivesoftware.smack.LLService; +import org.jivesoftware.smack.LLServiceConnectionListener; +import org.jivesoftware.smack.LLServiceListener; +import org.jivesoftware.smack.LLServiceStateListener; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.XMPPLLConnection; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smackx.entitycaps.CapsVerListener; +import org.jivesoftware.smackx.entitycaps.EntityCapsManager; +import org.jivesoftware.smackx.packet.DataForm; +import org.jivesoftware.smackx.packet.DiscoverInfo; +import org.jivesoftware.smackx.packet.DiscoverItems; + +/** + * LLServiceDiscoveryManager acts as a wrapper around ServiceDiscoveryManager + * as ServiceDiscoveryManager only creates an interface for requesting service + * information on existing connections. Simply said it creates new connections + * when needed, uses already active connections when appropriate and applies + * values to new connections. + * + * @author Jonas Ådahl + */ +public class LLServiceDiscoveryManager implements ServiceDiscoveryManagerInterface { + private static Map<LLService,LLServiceDiscoveryManager> serviceManagers = + new ConcurrentHashMap<LLService,LLServiceDiscoveryManager>(); + + private Map<String, NodeInformationProvider> nodeInformationProviders = + new ConcurrentHashMap<String,NodeInformationProvider>(); + private final List<String> features = + new ArrayList<String>(); + private DataForm extendedInfo = null; + + private LLService service; + private EntityCapsManager capsManager; + + /*static { + XMPPLLConnection.addLLConnectionListener(new ConnectionServiceMaintainer()); + }*/ + + public static void addServiceListener() { + LLService.addLLServiceListener(new LLServiceListener() { + public void serviceCreated(LLService service) { + addLLServiceDiscoveryManager( + new LLServiceDiscoveryManager(service)); + } + }); + } + + private LLServiceDiscoveryManager(LLService llservice) { + this.service = llservice; + + // Add LLService state listener + service.addServiceStateListener(new LLServiceStateListener() { + private void removeEntry() { + removeLLServiceDiscoveryManager(service); + } + + public void serviceClosed() { + removeEntry(); + } + + public void serviceClosedOnError(Exception e) { + removeEntry(); + } + + public void unknownOriginMessage(Message e) { + // ignore + } + + public void serviceNameChanged(String n, String o) { + // Remove entries + capsManager.removeUserCapsNode(n); + capsManager.removeUserCapsNode(o); + LLPresence np = service.getPresenceByServiceName(n); + LLPresence op = service.getPresenceByServiceName(o); + + // Add existing values, if any + if (np != null && np.getNode() != null && np.getVer() != null) + capsManager.addUserCapsNode(n, np.getNode() + "#" + np.getVer()); + if (op != null && op.getNode() != null && op.getVer() != null) + capsManager.addUserCapsNode(o, op.getNode() + "#" + op.getVer()); + } + }); + + // Entity Capabilities + capsManager = new EntityCapsManager(this); + capsManager.addCapsVerListener(new CapsPresenceRenewer()); + capsManager.calculateEntityCapsVersion(getOwnDiscoverInfo(), + ServiceDiscoveryManager.getIdentityType(), + ServiceDiscoveryManager.getIdentityName(), + extendedInfo); + + // Add presence listener. The presence listener will gather + // entity caps data + service.addPresenceListener(new LLPresenceListener() { + public void presenceNew(LLPresence presence) { + if (presence.getHash() != null && + presence.getNode() != null && + presence.getVer() != null) { + // Add presence to caps manager + capsManager.addUserCapsNode(presence.getServiceName(), + presence.getNode() + "#" + presence.getVer()); + } + } + + public void presenceRemove(LLPresence presence) { + + } + }); + + service.addLLServiceConnectionListener(new ConnectionServiceMaintainer()); + } + + /** + * Add LLServiceDiscoveryManager to the map of existing ones. + */ + private static void addLLServiceDiscoveryManager(LLServiceDiscoveryManager manager) { + serviceManagers.put(manager.service, manager); + } + + /** + * Remove LLServiceDiscoveryManager from the map of existing ones. + */ + private static void removeLLServiceDiscoveryManager(LLService service) { + serviceManagers.remove(service); + } + + /** + * Get the LLServiceDiscoveryManager instance for a specific Link-local service. + * + * @param service + */ + public static LLServiceDiscoveryManager getInstanceFor(LLService service) { + return serviceManagers.get(service); + } + + /** + * Returns the name of the client that will be returned when asked for the client identity + * in a disco request. The name could be any value you need to identity this client. + * + * @return the name of the client that will be returned when asked for the client identity + * in a disco request. + */ + public static String getIdentityName() { + return ServiceDiscoveryManager.getIdentityName(); + } + + /** + * Sets the name of the client that will be returned when asked for the client identity + * in a disco request. The name could be any value you need to identity this client. + * + * @param name the name of the client that will be returned when asked for the client identity + * in a disco request. + */ + public static void setIdentityName(String name) { + ServiceDiscoveryManager.setIdentityType(name); + } + + /** + * Returns the type of client that will be returned when asked for the client identity in a + * disco request. The valid types are defined by the category client. Follow this link to learn + * the possible types: <a href="http://www.jabber.org/registrar/disco-categories.html#client">Jabber::Registrar</a>. + * + * @return the type of client that will be returned when asked for the client identity in a + * disco request. + */ + public static String getIdentityType() { + return ServiceDiscoveryManager.getIdentityType(); + } + + /** + * Sets the type of client that will be returned when asked for the client identity in a + * disco request. The valid types are defined by the category client. Follow this link to learn + * the possible types: <a href="http://www.jabber.org/registrar/disco-categories.html#client">Jabber::Registrar</a>. + * + * @param type the type of client that will be returned when asked for the client identity in a + * disco request. + */ + public static void setIdentityType(String type) { + ServiceDiscoveryManager.setIdentityType(type); + } + + /** + * Add discover info response data. + * + * @param response the discover info response packet + */ + public void addDiscoverInfoTo(DiscoverInfo response) { + // Set this client identity + DiscoverInfo.Identity identity = new DiscoverInfo.Identity("client", + getIdentityName()); + identity.setType(getIdentityType()); + response.addIdentity(identity); + // Add the registered features to the response + synchronized (features) { + // Add Entity Capabilities (XEP-0115) feature node. + response.addFeature("http://jabber.org/protocol/caps"); + + for (Iterator<String> it = getFeatures(); it.hasNext();) { + response.addFeature(it.next()); + } + if (extendedInfo != null) { + response.addExtension(extendedInfo); + } + } + } + + /** + * Get a DiscoverInfo for the current entity caps node. + * + * @return a DiscoverInfo for the current entity caps node + */ + public DiscoverInfo getOwnDiscoverInfo() { + DiscoverInfo di = new DiscoverInfo(); + di.setType(IQ.Type.RESULT); + di.setNode(capsManager.getNode() + "#" + getEntityCapsVersion()); + + // Add discover info + addDiscoverInfoTo(di); + + for (String feature : features) { + di.addFeature(feature); + } + + return di; + } + + /** + * Returns a new or already established connection to the given service name. + * + * @param serviceName remote service to which we wish to be connected to. + * @returns an established connection to the given service name. + */ + private XMPPLLConnection getConnection(String serviceName) throws XMPPException { + return service.getConnection(serviceName); + } + + /** + * Returns a ServiceDiscoveryManager instance for a new or already established + * connection to the given service name. + * + * @param serviceName the name of the service we wish to get the ServiceDiscoveryManager instance for. + * @returns the ServiceDiscoveryManager instance. + */ + private ServiceDiscoveryManager getInstance(String serviceName) throws XMPPException { + return ServiceDiscoveryManager.getInstanceFor(getConnection(serviceName)); + } + + /** + * Registers extended discovery information of this XMPP entity. When this + * client is queried for its information this data form will be returned as + * specified by XEP-0128. + * + * + * Since no packet is actually sent to the server it is safe to perform this + * operation before logging to the server. In fact, you may want to + * configure the extended info before logging to the server so that the + * information is already available if it is required upon login. + * + * @param info + * the data form that contains the extend service discovery + * information. + */ + public void setExtendedInfo(DataForm info) { + extendedInfo = info; + + // set for already active connections + for (XMPPLLConnection connection : service.getConnections()) + ServiceDiscoveryManager.getInstanceFor(connection).setExtendedInfo(info); + + renewEntityCapsVersion(); + } + + /** + * Removes the dataform containing extended service discovery information + * from the information returned by this XMPP entity. + * + * Since no packet is actually sent to the server it is safe to perform this + * operation before logging to the server. + */ + public void removeExtendedInfo() { + extendedInfo = null; + + // remove for already active connections + for (XMPPLLConnection connection : service.getConnections()) + ServiceDiscoveryManager.getInstanceFor(connection).removeExtendedInfo(); + + renewEntityCapsVersion(); + } + + /** + * Returns the discovered information of a given XMPP entity addressed by its JID. + * + * @param entityID the address of the XMPP entity. + * @return the discovered information. + * @throws XMPPException if the operation failed for some reason. + */ + public DiscoverInfo discoverInfo(String serviceName) throws XMPPException { + DiscoverInfo info = capsManager.getDiscoverInfoByUser(serviceName); + + // If there is no cached information retrieve new one + if (info == null) { + // If the caps node is known, use it in the request. + String node = null; + + if (capsManager != null) { + // Get the newest node#version + node = capsManager.getNodeVersionByUser(serviceName); + } + + return discoverInfo(serviceName, node); + } + else { + return info; + } + } + + /** + * Returns the discovered information of a given XMPP entity addressed by its JID and + * note attribute. Use this message only when trying to query information which is not + * directly addressable. + * + * @param entityID the address of the XMPP entity. + * @param node the attribute that supplements the 'jid' attribute. + * @return the discovered information. + * @throws XMPPException if the operation failed for some reason. + */ + public DiscoverInfo discoverInfo(String serviceName, String node) throws XMPPException { + // Discover the entity's info + DiscoverInfo disco = new DiscoverInfo(); + disco.setType(IQ.Type.GET); + disco.setTo(serviceName); + disco.setNode(node); + + IQ result = service.getIQResponse(disco); + if (result == null) { + throw new XMPPException("No response from the server."); + } + if (result.getType() == IQ.Type.ERROR) { + throw new XMPPException(result.getError()); + } + if (result instanceof DiscoverInfo) { + return (DiscoverInfo) result; + } + throw new XMPPException("Result was not a disco info reply."); + } + + /** + * Returns the discovered items of a given XMPP entity addressed by its JID. + * + * @param entityID the address of the XMPP entity. + * @return the discovered information. + * @throws XMPPException if the operation failed for some reason. + */ + public DiscoverItems discoverItems(String entityID) throws XMPPException { + return discoverItems(entityID, null); + } + + /** + * Returns the discovered items of a given XMPP entity addressed by its JID and + * note attribute. Use this message only when trying to query information which is not + * directly addressable. + * + * @param entityID the address of the XMPP entity. + * @param node the attribute that supplements the 'jid' attribute. + * @return the discovered items. + * @throws XMPPException if the operation failed for some reason. + */ + public DiscoverItems discoverItems(String serviceName, String node) throws XMPPException { + // Discover the entity's items + DiscoverItems disco = new DiscoverItems(); + disco.setType(IQ.Type.GET); + disco.setTo(serviceName); + disco.setNode(node); + + IQ result = service.getIQResponse(disco); + if (result == null) { + throw new XMPPException("No response from the server."); + } + if (result.getType() == IQ.Type.ERROR) { + throw new XMPPException(result.getError()); + } + if (result instanceof DiscoverItems) { + return (DiscoverItems) result; + } + throw new XMPPException("Result was not a disco items reply."); + } + + /** + * Sets the NodeInformationProvider responsible for providing information + * (ie items) related to a given node. Every time this client receives a disco request + * regarding the items of a given node, the provider associated to that node will be the + * responsible for providing the requested information. + * + * In MUC, a node could be 'http://jabber.org/protocol/muc#rooms' which means that the + * NodeInformationProvider will provide information about the rooms where the user has joined. + * + * @param node the node whose items will be provided by the NodeInformationProvider. + * @param listener the NodeInformationProvider responsible for providing items related + * to the node. + */ + public void setNodeInformationProvider(String node, + NodeInformationProvider listener) { + // store this NodeInformationProvider so we can add it to new connections. + nodeInformationProviders.put(node, listener); + + // set for already active connections + for (XMPPLLConnection connection : service.getConnections()) + ServiceDiscoveryManager.getInstanceFor(connection).setNodeInformationProvider(node, listener); + } + + /** + * Removes the NodeInformationProvider responsible for providing information + * (ie items) related to a given node. This means that no more information will be + * available for the specified node. + * + * In MUC, a node could be 'http://jabber.org/protocol/muc#rooms' which means that the + * NodeInformationProvider will provide information about the rooms where the user has joined. + * + * @param node the node to remove the associated NodeInformationProvider. + */ + public void removeNodeInformationProvider(String node) { + // remove from wrapper class + nodeInformationProviders.remove(node); + + // remove from existing connections + for (XMPPLLConnection connection : service.getConnections()) + ServiceDiscoveryManager.getInstanceFor(connection).removeNodeInformationProvider(node); + } + + /** + * Returns the supported features by this XMPP entity. + * + * @return an Iterator on the supported features by this XMPP entity. + */ + public Iterator<String> getFeatures() { + synchronized (features) { + return Collections.unmodifiableList(new ArrayList<String>(features)).iterator(); + } + } + + /** + * Registers that a new feature is supported by this XMPP entity. When this client is + * queried for its information the registered features will be answered. + * + * Since no packet is actually sent to the server it is safe to perform this operation + * before logging to the server. In fact, you may want to configure the supported features + * before logging to the server so that the information is already available if it is required + * upon login. + * + * @param feature the feature to register as supported. + */ + public void addFeature(String feature) { + synchronized (features) { + features.add(feature); + } + + renewEntityCapsVersion(); + } + + /** + * Removes the specified feature from the supported features by this XMPP entity. + * + * Since no packet is actually sent to the server it is safe to perform this operation + * before logging to the server. + * + * @param feature the feature to remove from the supported features. + */ + public void removeFeature(String feature) { + synchronized (features) { + features.remove(feature); + for (XMPPLLConnection connection : service.getConnections()) + ServiceDiscoveryManager.getInstanceFor(connection).removeFeature(feature); + } + + renewEntityCapsVersion(); + } + + /** + * Returns true if the specified feature is registered in the ServiceDiscoveryManager. + * + * @param feature the feature to look for. + * @return a boolean indicating if the specified featured is registered or not. + */ + public boolean includesFeature(String feature) { + synchronized (features) { + return features.contains(feature); + } + } + + /** + * Returns true if the server supports publishing of items. A client may wish to publish items + * to the server so that the server can provide items associated to the client. These items will + * be returned by the server whenever the server receives a disco request targeted to the bare + * address of the client (i.e. user@host.com). + * + * @param entityID the address of the XMPP entity. + * @return true if the server supports publishing of items. + * @throws XMPPException if the operation failed for some reason. + */ + public boolean canPublishItems(String entityID) throws XMPPException { + DiscoverInfo info = discoverInfo(entityID); + return ServiceDiscoveryManager.canPublishItems(info); + } + + /** + * Publishes new items to a parent entity. The item elements to publish MUST have at least + * a 'jid' attribute specifying the Entity ID of the item, and an action attribute which + * specifies the action being taken for that item. Possible action values are: "update" and + * "remove". + * + * @param entityID the address of the XMPP entity. + * @param discoverItems the DiscoveryItems to publish. + * @throws XMPPException if the operation failed for some reason. + */ + public void publishItems(String entityID, DiscoverItems discoverItems) + throws XMPPException { + publishItems(entityID, null, discoverItems); + } + + /** + * Publishes new items to a parent entity and node. The item elements to publish MUST have at + * least a 'jid' attribute specifying the Entity ID of the item, and an action attribute which + * specifies the action being taken for that item. Possible action values are: "update" and + * "remove". + * + * @param entityID the address of the XMPP entity. + * @param node the attribute that supplements the 'jid' attribute. + * @param discoverItems the DiscoveryItems to publish. + * @throws XMPPException if the operation failed for some reason. + */ + public void publishItems(String entityID, String node, DiscoverItems discoverItems) + throws XMPPException { + getInstance(entityID).publishItems(entityID, node, discoverItems); + } + + private void renewEntityCapsVersion() { + if (capsManager != null) { + capsManager.calculateEntityCapsVersion(getOwnDiscoverInfo(), + ServiceDiscoveryManager.getIdentityType(), + ServiceDiscoveryManager.getIdentityName(), + extendedInfo); + } + } + + private String getEntityCapsVersion() { + if (capsManager != null) { + return capsManager.getCapsVersion(); + } + else { + return null; + } + } + + + /** + * In case that a connection is unavailable we create a new connection + * and push the service discovery procedure until the new connection is + * established. + */ + private class ConnectionServiceMaintainer implements LLServiceConnectionListener { + + public void connectionCreated(XMPPLLConnection connection) { + // Add service discovery for Link-local connections.\ + ServiceDiscoveryManager manager = + new ServiceDiscoveryManager(connection); + + // Set Entity Capabilities Manager + manager.setEntityCapsManager(capsManager); + + // Set extended info + manager.setExtendedInfo(extendedInfo); + + // Set node information providers + for (Map.Entry<String,NodeInformationProvider> entry : + nodeInformationProviders.entrySet()) { + manager.setNodeInformationProvider(entry.getKey(), entry.getValue()); + } + + // add features + synchronized (features) { + for (String feature : features) { + manager.addFeature(feature); + } + } + } + } + + private class CapsPresenceRenewer implements CapsVerListener { + public void capsVerUpdated(String ver) { + synchronized (service) { + try { + LLPresence presence = service.getLocalPresence(); + presence.setHash(EntityCapsManager.HASH_METHOD); + presence.setNode(capsManager.getNode()); + presence.setVer(ver); + service.updatePresence(presence); + } + catch (XMPPException xe) { + // ignore + } + } + } + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/LastActivityManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/LastActivityManager.java new file mode 100644 index 0000000..9e231c7 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/LastActivityManager.java @@ -0,0 +1,172 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2003-2006 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.smackx; + +import org.jivesoftware.smack.*; +import org.jivesoftware.smack.filter.AndFilter; +import org.jivesoftware.smack.filter.IQTypeFilter; +import org.jivesoftware.smack.filter.PacketIDFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smackx.packet.LastActivity; + +/** + * A last activity manager for handling information about the last activity associated + * with a Jabber ID. A manager handles incoming LastActivity requests of existing + * Connections. It also allows to request last activity information of other users. + * + * LastActivity (JEP-012) based on the sending JID's type allows for retrieval of: + * <ol> + * <li>How long a particular user has been idle + * <li>How long a particular user has been logged-out and the message the specified when doing so. + * <li>How long a host has been up. + * </ol> + * + * + * For example to get the idle time of a user logged in a resource, simple send the + * LastActivity packet to them, as in the following code: + * + * <pre> + * Connection con = new XMPPConnection("jabber.org"); + * con.login("john", "doe"); + * LastActivity activity = LastActivity.getLastActivity(con, "xray@jabber.org/Smack"); + * </pre> + * + * To get the lapsed time since the last user logout is the same as above but with + * out the resource: + * <pre> + * LastActivity activity = LastActivity.getLastActivity(con, "xray@jabber.org"); + * </pre> + * + * To get the uptime of a host, you simple send the LastActivity packet to it, as in the + * following code example: + * + * <pre> + * LastActivity activity = LastActivity.getLastActivity(con, "jabber.org"); + * </pre> + * + * @author Gabriel Guardincerri + */ + +public class LastActivityManager { + + private long lastMessageSent; + + private Connection connection; + + // Enable the LastActivity support on every established connection + static { + Connection.addConnectionCreationListener(new ConnectionCreationListener() { + public void connectionCreated(Connection connection) { + new LastActivityManager(connection); + } + }); + } + + /** + * Creates a last activity manager to response last activity requests. + * + * @param connection The Connection that the last activity requests will use. + */ + private LastActivityManager(Connection connection) { + this.connection = connection; + + // Listen to all the sent messages to reset the idle time on each one + connection.addPacketSendingListener(new PacketListener() { + public void processPacket(Packet packet) { + resetIdleTime(); + } + }, null); + + // Register a listener for a last activity query + connection.addPacketListener(new PacketListener() { + + public void processPacket(Packet packet) { + LastActivity message = new LastActivity(); + message.setType(IQ.Type.RESULT); + message.setTo(packet.getFrom()); + message.setFrom(packet.getTo()); + message.setPacketID(packet.getPacketID()); + message.setLastActivity(getIdleTime()); + + LastActivityManager.this.connection.sendPacket(message); + } + + }, new AndFilter(new IQTypeFilter(IQ.Type.GET), new PacketTypeFilter(LastActivity.class))); + } + + /** + * Resets the idle time to 0, this should be invoked when a new message is + * sent. + */ + private void resetIdleTime() { + lastMessageSent = System.currentTimeMillis(); + } + + /** + * The idle time is the lapsed time between the last message sent and now. + * + * @return the lapsed time between the last message sent and now. + */ + private long getIdleTime() { + long now = System.currentTimeMillis(); + return ((now - lastMessageSent) / 1000); + } + + /** + * Returns the last activity of a particular jid. If the jid is a full JID + * (i.e., a JID of the form of 'user@host/resource') then the last activity + * is the idle time of that connected resource. On the other hand, when the + * jid is a bare JID (e.g. 'user@host') then the last activity is the lapsed + * time since the last logout or 0 if the user is currently logged in. Moreover, + * when the jid is a server or component (e.g., a JID of the form 'host') the + * last activity is the uptime. + * + * @param con the current Connection. + * @param jid the JID of the user. + * @return the LastActivity packet of the jid. + * @throws XMPPException thrown if a server error has occured. + */ + public static LastActivity getLastActivity(Connection con, String jid) + throws XMPPException { + LastActivity activity = new LastActivity(); + activity.setTo(jid); + + PacketCollector collector = + con.createPacketCollector(new PacketIDFilter(activity.getPacketID())); + con.sendPacket(activity); + + LastActivity response = + (LastActivity) collector.nextResult(SmackConfiguration.getPacketReplyTimeout()); + + // Cancel the collector. + collector.cancel(); + if (response == null) { + throw new XMPPException("No response from server on status set."); + } + if (response.getError() != null) { + throw new XMPPException(response.getError()); + } + return response; + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/MessageEventManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/MessageEventManager.java new file mode 100644 index 0000000..f8f553a --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/MessageEventManager.java @@ -0,0 +1,310 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.filter.PacketExtensionFilter; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smackx.packet.MessageEvent; + +/** + * Manages message events requests and notifications. A MessageEventManager provides a high + * level access to request for notifications and send event notifications. It also provides + * an easy way to hook up custom logic when requests or notifications are received. + * + * @author Gaston Dombiak + */ +public class MessageEventManager { + + private List<MessageEventNotificationListener> messageEventNotificationListeners = new ArrayList<MessageEventNotificationListener>(); + private List<MessageEventRequestListener> messageEventRequestListeners = new ArrayList<MessageEventRequestListener>(); + + private Connection con; + + private PacketFilter packetFilter = new PacketExtensionFilter("x", "jabber:x:event"); + private PacketListener packetListener; + + /** + * Creates a new message event manager. + * + * @param con a Connection to a XMPP server. + */ + public MessageEventManager(Connection con) { + this.con = con; + init(); + } + + /** + * Adds event notification requests to a message. For each event type that + * the user wishes event notifications from the message recepient for, <tt>true</tt> + * should be passed in to this method. + * + * @param message the message to add the requested notifications. + * @param offline specifies if the offline event is requested. + * @param delivered specifies if the delivered event is requested. + * @param displayed specifies if the displayed event is requested. + * @param composing specifies if the composing event is requested. + */ + public static void addNotificationsRequests(Message message, boolean offline, + boolean delivered, boolean displayed, boolean composing) + { + // Create a MessageEvent Package and add it to the message + MessageEvent messageEvent = new MessageEvent(); + messageEvent.setOffline(offline); + messageEvent.setDelivered(delivered); + messageEvent.setDisplayed(displayed); + messageEvent.setComposing(composing); + message.addExtension(messageEvent); + } + + /** + * Adds a message event request listener. The listener will be fired anytime a request for + * event notification is received. + * + * @param messageEventRequestListener a message event request listener. + */ + public void addMessageEventRequestListener(MessageEventRequestListener messageEventRequestListener) { + synchronized (messageEventRequestListeners) { + if (!messageEventRequestListeners.contains(messageEventRequestListener)) { + messageEventRequestListeners.add(messageEventRequestListener); + } + } + } + + /** + * Removes a message event request listener. The listener will be fired anytime a request for + * event notification is received. + * + * @param messageEventRequestListener a message event request listener. + */ + public void removeMessageEventRequestListener(MessageEventRequestListener messageEventRequestListener) { + synchronized (messageEventRequestListeners) { + messageEventRequestListeners.remove(messageEventRequestListener); + } + } + + /** + * Adds a message event notification listener. The listener will be fired anytime a notification + * event is received. + * + * @param messageEventNotificationListener a message event notification listener. + */ + public void addMessageEventNotificationListener(MessageEventNotificationListener messageEventNotificationListener) { + synchronized (messageEventNotificationListeners) { + if (!messageEventNotificationListeners.contains(messageEventNotificationListener)) { + messageEventNotificationListeners.add(messageEventNotificationListener); + } + } + } + + /** + * Removes a message event notification listener. The listener will be fired anytime a notification + * event is received. + * + * @param messageEventNotificationListener a message event notification listener. + */ + public void removeMessageEventNotificationListener(MessageEventNotificationListener messageEventNotificationListener) { + synchronized (messageEventNotificationListeners) { + messageEventNotificationListeners.remove(messageEventNotificationListener); + } + } + + /** + * Fires message event request listeners. + */ + private void fireMessageEventRequestListeners( + String from, + String packetID, + String methodName) { + MessageEventRequestListener[] listeners = null; + Method method; + synchronized (messageEventRequestListeners) { + listeners = new MessageEventRequestListener[messageEventRequestListeners.size()]; + messageEventRequestListeners.toArray(listeners); + } + try { + method = + MessageEventRequestListener.class.getDeclaredMethod( + methodName, + new Class[] { String.class, String.class, MessageEventManager.class }); + for (int i = 0; i < listeners.length; i++) { + method.invoke(listeners[i], new Object[] { from, packetID, this }); + } + } catch (NoSuchMethodException e) { + e.printStackTrace(); + } catch (InvocationTargetException e) { + e.printStackTrace(); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } + + /** + * Fires message event notification listeners. + */ + private void fireMessageEventNotificationListeners( + String from, + String packetID, + String methodName) { + MessageEventNotificationListener[] listeners = null; + Method method; + synchronized (messageEventNotificationListeners) { + listeners = + new MessageEventNotificationListener[messageEventNotificationListeners.size()]; + messageEventNotificationListeners.toArray(listeners); + } + try { + method = + MessageEventNotificationListener.class.getDeclaredMethod( + methodName, + new Class[] { String.class, String.class }); + for (int i = 0; i < listeners.length; i++) { + method.invoke(listeners[i], new Object[] { from, packetID }); + } + } catch (NoSuchMethodException e) { + e.printStackTrace(); + } catch (InvocationTargetException e) { + e.printStackTrace(); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } + + private void init() { + // Listens for all message event packets and fire the proper message event listeners. + packetListener = new PacketListener() { + public void processPacket(Packet packet) { + Message message = (Message) packet; + MessageEvent messageEvent = + (MessageEvent) message.getExtension("x", "jabber:x:event"); + if (messageEvent.isMessageEventRequest()) { + // Fire event for requests of message events + for (Iterator it = messageEvent.getEventTypes(); it.hasNext();) + fireMessageEventRequestListeners( + message.getFrom(), + message.getPacketID(), + ((String) it.next()).concat("NotificationRequested")); + } else + // Fire event for notifications of message events + for (Iterator it = messageEvent.getEventTypes(); it.hasNext();) + fireMessageEventNotificationListeners( + message.getFrom(), + messageEvent.getPacketID(), + ((String) it.next()).concat("Notification")); + + }; + + }; + con.addPacketListener(packetListener, packetFilter); + } + + /** + * Sends the notification that the message was delivered to the sender of the original message + * + * @param to the recipient of the notification. + * @param packetID the id of the message to send. + */ + public void sendDeliveredNotification(String to, String packetID) { + // Create the message to send + Message msg = new Message(to); + // Create a MessageEvent Package and add it to the message + MessageEvent messageEvent = new MessageEvent(); + messageEvent.setDelivered(true); + messageEvent.setPacketID(packetID); + msg.addExtension(messageEvent); + // Send the packet + con.sendPacket(msg); + } + + /** + * Sends the notification that the message was displayed to the sender of the original message + * + * @param to the recipient of the notification. + * @param packetID the id of the message to send. + */ + public void sendDisplayedNotification(String to, String packetID) { + // Create the message to send + Message msg = new Message(to); + // Create a MessageEvent Package and add it to the message + MessageEvent messageEvent = new MessageEvent(); + messageEvent.setDisplayed(true); + messageEvent.setPacketID(packetID); + msg.addExtension(messageEvent); + // Send the packet + con.sendPacket(msg); + } + + /** + * Sends the notification that the receiver of the message is composing a reply + * + * @param to the recipient of the notification. + * @param packetID the id of the message to send. + */ + public void sendComposingNotification(String to, String packetID) { + // Create the message to send + Message msg = new Message(to); + // Create a MessageEvent Package and add it to the message + MessageEvent messageEvent = new MessageEvent(); + messageEvent.setComposing(true); + messageEvent.setPacketID(packetID); + msg.addExtension(messageEvent); + // Send the packet + con.sendPacket(msg); + } + + /** + * Sends the notification that the receiver of the message has cancelled composing a reply. + * + * @param to the recipient of the notification. + * @param packetID the id of the message to send. + */ + public void sendCancelledNotification(String to, String packetID) { + // Create the message to send + Message msg = new Message(to); + // Create a MessageEvent Package and add it to the message + MessageEvent messageEvent = new MessageEvent(); + messageEvent.setCancelled(true); + messageEvent.setPacketID(packetID); + msg.addExtension(messageEvent); + // Send the packet + con.sendPacket(msg); + } + + public void destroy() { + if (con != null) { + con.removePacketListener(packetListener); + } + } + + protected void finalize() throws Throwable { + destroy(); + super.finalize(); + } +} \ No newline at end of file diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/MessageEventNotificationListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/MessageEventNotificationListener.java new file mode 100644 index 0000000..335dae2 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/MessageEventNotificationListener.java @@ -0,0 +1,74 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +/** + * + * A listener that is fired anytime a message event notification is received. + * Message event notifications are received as a consequence of the request + * to receive notifications when sending a message. + * + * @author Gaston Dombiak + */ +public interface MessageEventNotificationListener { + + /** + * Called when a notification of message delivered is received. + * + * @param from the user that sent the notification. + * @param packetID the id of the message that was sent. + */ + public void deliveredNotification(String from, String packetID); + + /** + * Called when a notification of message displayed is received. + * + * @param from the user that sent the notification. + * @param packetID the id of the message that was sent. + */ + public void displayedNotification(String from, String packetID); + + /** + * Called when a notification that the receiver of the message is composing a reply is + * received. + * + * @param from the user that sent the notification. + * @param packetID the id of the message that was sent. + */ + public void composingNotification(String from, String packetID); + + /** + * Called when a notification that the receiver of the message is offline is received. + * + * @param from the user that sent the notification. + * @param packetID the id of the message that was sent. + */ + public void offlineNotification(String from, String packetID); + + /** + * Called when a notification that the receiver of the message cancelled the reply + * is received. + * + * @param from the user that sent the notification. + * @param packetID the id of the message that was sent. + */ + public void cancelledNotification(String from, String packetID); +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/MessageEventRequestListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/MessageEventRequestListener.java new file mode 100644 index 0000000..86e0808 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/MessageEventRequestListener.java @@ -0,0 +1,86 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +/** + * + * A listener that is fired anytime a message event request is received. + * Message event requests are received when the received message includes an extension + * like this: + * + * <pre> + * <x xmlns='jabber:x:event'> + * <offline/> + * <delivered/> + * <composing/> + * </x> + * </pre> + * + * In this example you can see that the sender of the message requests to be notified + * when the user couldn't receive the message because he/she is offline, the message + * was delivered or when the receiver of the message is composing a reply. + * + * @author Gaston Dombiak + */ +public interface MessageEventRequestListener { + + /** + * Called when a request for message delivered notification is received. + * + * @param from the user that sent the notification. + * @param packetID the id of the message that was sent. + * @param messageEventManager the messageEventManager that fired the listener. + */ + public void deliveredNotificationRequested(String from, String packetID, + MessageEventManager messageEventManager); + + /** + * Called when a request for message displayed notification is received. + * + * @param from the user that sent the notification. + * @param packetID the id of the message that was sent. + * @param messageEventManager the messageEventManager that fired the listener. + */ + public void displayedNotificationRequested(String from, String packetID, + MessageEventManager messageEventManager); + + /** + * Called when a request that the receiver of the message is composing a reply notification is + * received. + * + * @param from the user that sent the notification. + * @param packetID the id of the message that was sent. + * @param messageEventManager the messageEventManager that fired the listener. + */ + public void composingNotificationRequested(String from, String packetID, + MessageEventManager messageEventManager); + + /** + * Called when a request that the receiver of the message is offline is received. + * + * @param from the user that sent the notification. + * @param packetID the id of the message that was sent. + * @param messageEventManager the messageEventManager that fired the listener. + */ + public void offlineNotificationRequested(String from, String packetID, + MessageEventManager messageEventManager); + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/MultipleRecipientInfo.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/MultipleRecipientInfo.java new file mode 100644 index 0000000..a9ac0f8 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/MultipleRecipientInfo.java @@ -0,0 +1,98 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2003-2006 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.smackx; + +import org.jivesoftware.smackx.packet.MultipleAddresses; + +import java.util.List; + +/** + * MultipleRecipientInfo keeps information about the multiple recipients extension included + * in a received packet. Among the information we can find the list of TO and CC addresses. + * + * @author Gaston Dombiak + */ +public class MultipleRecipientInfo { + + MultipleAddresses extension; + + MultipleRecipientInfo(MultipleAddresses extension) { + this.extension = extension; + } + + /** + * Returns the list of {@link org.jivesoftware.smackx.packet.MultipleAddresses.Address} + * that were the primary recipients of the packet. + * + * @return list of primary recipients of the packet. + */ + public List getTOAddresses() { + return extension.getAddressesOfType(MultipleAddresses.TO); + } + + /** + * Returns the list of {@link org.jivesoftware.smackx.packet.MultipleAddresses.Address} + * that were the secondary recipients of the packet. + * + * @return list of secondary recipients of the packet. + */ + public List getCCAddresses() { + return extension.getAddressesOfType(MultipleAddresses.CC); + } + + /** + * Returns the JID of a MUC room to which responses should be sent or <tt>null</tt> if + * no specific address was provided. When no specific address was provided then the reply + * can be sent to any or all recipients. Otherwise, the user should join the specified room + * and send the reply to the room. + * + * @return the JID of a MUC room to which responses should be sent or <tt>null</tt> if + * no specific address was provided. + */ + public String getReplyRoom() { + List replyRoom = extension.getAddressesOfType(MultipleAddresses.REPLY_ROOM); + return replyRoom.isEmpty() ? null : ((MultipleAddresses.Address) replyRoom.get(0)).getJid(); + } + + /** + * Returns true if the received packet should not be replied. Use + * {@link MultipleRecipientManager#reply(org.jivesoftware.smack.Connection, org.jivesoftware.smack.packet.Message, org.jivesoftware.smack.packet.Message)} + * to send replies. + * + * @return true if the received packet should not be replied. + */ + public boolean shouldNotReply() { + return !extension.getAddressesOfType(MultipleAddresses.NO_REPLY).isEmpty(); + } + + /** + * Returns the address to which all replies are requested to be sent or <tt>null</tt> if + * no specific address was provided. When no specific address was provided then the reply + * can be sent to any or all recipients. + * + * @return the address to which all replies are requested to be sent or <tt>null</tt> if + * no specific address was provided. + */ + public MultipleAddresses.Address getReplyAddress() { + List replyTo = extension.getAddressesOfType(MultipleAddresses.REPLY_TO); + return replyTo.isEmpty() ? null : (MultipleAddresses.Address) replyTo.get(0); + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/MultipleRecipientManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/MultipleRecipientManager.java new file mode 100644 index 0000000..e8de33a --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/MultipleRecipientManager.java @@ -0,0 +1,353 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2003-2006 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.smackx; + +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.util.Cache; +import org.jivesoftware.smack.util.StringUtils; +import org.jivesoftware.smackx.packet.DiscoverInfo; +import org.jivesoftware.smackx.packet.DiscoverItems; +import org.jivesoftware.smackx.packet.MultipleAddresses; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +/** + * A MultipleRecipientManager allows to send packets to multiple recipients by making use of + * <a href="http://www.jabber.org/jeps/jep-0033.html">JEP-33: Extended Stanza Addressing</a>. + * It also allows to send replies to packets that were sent to multiple recipients. + * + * @author Gaston Dombiak + */ +public class MultipleRecipientManager { + + /** + * Create a cache to hold the 100 most recently accessed elements for a period of + * 24 hours. + */ + private static Cache services = new Cache(100, 24 * 60 * 60 * 1000); + + /** + * Sends the specified packet to the list of specified recipients using the + * specified connection. If the server has support for JEP-33 then only one + * packet is going to be sent to the server with the multiple recipient instructions. + * However, if JEP-33 is not supported by the server then the client is going to send + * the packet to each recipient. + * + * @param connection the connection to use to send the packet. + * @param packet the packet to send to the list of recipients. + * @param to the list of JIDs to include in the TO list or <tt>null</tt> if no TO + * list exists. + * @param cc the list of JIDs to include in the CC list or <tt>null</tt> if no CC + * list exists. + * @param bcc the list of JIDs to include in the BCC list or <tt>null</tt> if no BCC + * list exists. + * @throws XMPPException if server does not support JEP-33: Extended Stanza Addressing and + * some JEP-33 specific features were requested. + */ + public static void send(Connection connection, Packet packet, List to, List cc, List bcc) + throws XMPPException { + send(connection, packet, to, cc, bcc, null, null, false); + } + + /** + * Sends the specified packet to the list of specified recipients using the + * specified connection. If the server has support for JEP-33 then only one + * packet is going to be sent to the server with the multiple recipient instructions. + * However, if JEP-33 is not supported by the server then the client is going to send + * the packet to each recipient. + * + * @param connection the connection to use to send the packet. + * @param packet the packet to send to the list of recipients. + * @param to the list of JIDs to include in the TO list or <tt>null</tt> if no TO + * list exists. + * @param cc the list of JIDs to include in the CC list or <tt>null</tt> if no CC + * list exists. + * @param bcc the list of JIDs to include in the BCC list or <tt>null</tt> if no BCC + * list exists. + * @param replyTo address to which all replies are requested to be sent or <tt>null</tt> + * indicating that they can reply to any address. + * @param replyRoom JID of a MUC room to which responses should be sent or <tt>null</tt> + * indicating that they can reply to any address. + * @param noReply true means that receivers should not reply to the message. + * @throws XMPPException if server does not support JEP-33: Extended Stanza Addressing and + * some JEP-33 specific features were requested. + */ + public static void send(Connection connection, Packet packet, List to, List cc, List bcc, + String replyTo, String replyRoom, boolean noReply) throws XMPPException { + String serviceAddress = getMultipleRecipienServiceAddress(connection); + if (serviceAddress != null) { + // Send packet to target users using multiple recipient service provided by the server + sendThroughService(connection, packet, to, cc, bcc, replyTo, replyRoom, noReply, + serviceAddress); + } + else { + // Server does not support JEP-33 so try to send the packet to each recipient + if (noReply || (replyTo != null && replyTo.trim().length() > 0) || + (replyRoom != null && replyRoom.trim().length() > 0)) { + // Some specified JEP-33 features were requested so throw an exception alerting + // the user that this features are not available + throw new XMPPException("Extended Stanza Addressing not supported by server"); + } + // Send the packet to each individual recipient + sendToIndividualRecipients(connection, packet, to, cc, bcc); + } + } + + /** + * Sends a reply to a previously received packet that was sent to multiple recipients. Before + * attempting to send the reply message some checkings are performed. If any of those checkings + * fail then an XMPPException is going to be thrown with the specific error detail. + * + * @param connection the connection to use to send the reply. + * @param original the previously received packet that was sent to multiple recipients. + * @param reply the new message to send as a reply. + * @throws XMPPException if the original message was not sent to multiple recipients, or the + * original message cannot be replied or reply should be sent to a room. + */ + public static void reply(Connection connection, Message original, Message reply) + throws XMPPException { + MultipleRecipientInfo info = getMultipleRecipientInfo(original); + if (info == null) { + throw new XMPPException("Original message does not contain multiple recipient info"); + } + if (info.shouldNotReply()) { + throw new XMPPException("Original message should not be replied"); + } + if (info.getReplyRoom() != null) { + throw new XMPPException("Reply should be sent through a room"); + } + // Any <thread/> element from the initial message MUST be copied into the reply. + if (original.getThread() != null) { + reply.setThread(original.getThread()); + } + MultipleAddresses.Address replyAddress = info.getReplyAddress(); + if (replyAddress != null && replyAddress.getJid() != null) { + // Send reply to the reply_to address + reply.setTo(replyAddress.getJid()); + connection.sendPacket(reply); + } + else { + // Send reply to multiple recipients + List to = new ArrayList(); + List cc = new ArrayList(); + for (Iterator it = info.getTOAddresses().iterator(); it.hasNext();) { + String jid = ((MultipleAddresses.Address) it.next()).getJid(); + to.add(jid); + } + for (Iterator it = info.getCCAddresses().iterator(); it.hasNext();) { + String jid = ((MultipleAddresses.Address) it.next()).getJid(); + cc.add(jid); + } + // Add original sender as a 'to' address (if not already present) + if (!to.contains(original.getFrom()) && !cc.contains(original.getFrom())) { + to.add(original.getFrom()); + } + // Remove the sender from the TO/CC list (try with bare JID too) + String from = connection.getUser(); + if (!to.remove(from) && !cc.remove(from)) { + String bareJID = StringUtils.parseBareAddress(from); + to.remove(bareJID); + cc.remove(bareJID); + } + + String serviceAddress = getMultipleRecipienServiceAddress(connection); + if (serviceAddress != null) { + // Send packet to target users using multiple recipient service provided by the server + sendThroughService(connection, reply, to, cc, null, null, null, false, + serviceAddress); + } + else { + // Server does not support JEP-33 so try to send the packet to each recipient + sendToIndividualRecipients(connection, reply, to, cc, null); + } + } + } + + /** + * Returns the {@link MultipleRecipientInfo} contained in the specified packet or + * <tt>null</tt> if none was found. Only packets sent to multiple recipients will + * contain such information. + * + * @param packet the packet to check. + * @return the MultipleRecipientInfo contained in the specified packet or <tt>null</tt> + * if none was found. + */ + public static MultipleRecipientInfo getMultipleRecipientInfo(Packet packet) { + MultipleAddresses extension = (MultipleAddresses) packet + .getExtension("addresses", "http://jabber.org/protocol/address"); + return extension == null ? null : new MultipleRecipientInfo(extension); + } + + private static void sendToIndividualRecipients(Connection connection, Packet packet, + List to, List cc, List bcc) { + if (to != null) { + for (Iterator it = to.iterator(); it.hasNext();) { + String jid = (String) it.next(); + packet.setTo(jid); + connection.sendPacket(new PacketCopy(packet.toXML())); + } + } + if (cc != null) { + for (Iterator it = cc.iterator(); it.hasNext();) { + String jid = (String) it.next(); + packet.setTo(jid); + connection.sendPacket(new PacketCopy(packet.toXML())); + } + } + if (bcc != null) { + for (Iterator it = bcc.iterator(); it.hasNext();) { + String jid = (String) it.next(); + packet.setTo(jid); + connection.sendPacket(new PacketCopy(packet.toXML())); + } + } + } + + private static void sendThroughService(Connection connection, Packet packet, List to, + List cc, List bcc, String replyTo, String replyRoom, boolean noReply, + String serviceAddress) { + // Create multiple recipient extension + MultipleAddresses multipleAddresses = new MultipleAddresses(); + if (to != null) { + for (Iterator it = to.iterator(); it.hasNext();) { + String jid = (String) it.next(); + multipleAddresses.addAddress(MultipleAddresses.TO, jid, null, null, false, null); + } + } + if (cc != null) { + for (Iterator it = cc.iterator(); it.hasNext();) { + String jid = (String) it.next(); + multipleAddresses.addAddress(MultipleAddresses.CC, jid, null, null, false, null); + } + } + if (bcc != null) { + for (Iterator it = bcc.iterator(); it.hasNext();) { + String jid = (String) it.next(); + multipleAddresses.addAddress(MultipleAddresses.BCC, jid, null, null, false, null); + } + } + if (noReply) { + multipleAddresses.setNoReply(); + } + else { + if (replyTo != null && replyTo.trim().length() > 0) { + multipleAddresses + .addAddress(MultipleAddresses.REPLY_TO, replyTo, null, null, false, null); + } + if (replyRoom != null && replyRoom.trim().length() > 0) { + multipleAddresses.addAddress(MultipleAddresses.REPLY_ROOM, replyRoom, null, null, + false, null); + } + } + // Set the multiple recipient service address as the target address + packet.setTo(serviceAddress); + // Add extension to packet + packet.addExtension(multipleAddresses); + // Send the packet + connection.sendPacket(packet); + } + + /** + * Returns the address of the multiple recipients service. To obtain such address service + * discovery is going to be used on the connected server and if none was found then another + * attempt will be tried on the server items. The discovered information is going to be + * cached for 24 hours. + * + * @param connection the connection to use for disco. The connected server is going to be + * queried. + * @return the address of the multiple recipients service or <tt>null</tt> if none was found. + */ + private static String getMultipleRecipienServiceAddress(Connection connection) { + String serviceName = connection.getServiceName(); + String serviceAddress = (String) services.get(serviceName); + if (serviceAddress == null) { + synchronized (services) { + serviceAddress = (String) services.get(serviceName); + if (serviceAddress == null) { + + // Send the disco packet to the server itself + try { + DiscoverInfo info = ServiceDiscoveryManager.getInstanceFor(connection) + .discoverInfo(serviceName); + // Check if the server supports JEP-33 + if (info.containsFeature("http://jabber.org/protocol/address")) { + serviceAddress = serviceName; + } + else { + // Get the disco items and send the disco packet to each server item + DiscoverItems items = ServiceDiscoveryManager.getInstanceFor(connection) + .discoverItems(serviceName); + for (Iterator it = items.getItems(); it.hasNext();) { + DiscoverItems.Item item = (DiscoverItems.Item) it.next(); + info = ServiceDiscoveryManager.getInstanceFor(connection) + .discoverInfo(item.getEntityID(), item.getNode()); + if (info.containsFeature("http://jabber.org/protocol/address")) { + serviceAddress = serviceName; + break; + } + } + + } + // Cache the discovered information + services.put(serviceName, serviceAddress == null ? "" : serviceAddress); + } + catch (XMPPException e) { + e.printStackTrace(); + } + } + } + } + + return "".equals(serviceAddress) ? null : serviceAddress; + } + + /** + * Packet that holds the XML stanza to send. This class is useful when the same packet + * is needed to be sent to different recipients. Since using the same packet is not possible + * (i.e. cannot change the TO address of a queues packet to be sent) then this class was + * created to keep the XML stanza to send. + */ + private static class PacketCopy extends Packet { + + private String text; + + /** + * Create a copy of a packet with the text to send. The passed text must be a valid text to + * send to the server, no validation will be done on the passed text. + * + * @param text the whole text of the packet to send + */ + public PacketCopy(String text) { + this.text = text; + } + + public String toXML() { + return text; + } + + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/NodeInformationProvider.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/NodeInformationProvider.java new file mode 100644 index 0000000..816be4d --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/NodeInformationProvider.java @@ -0,0 +1,68 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +import org.jivesoftware.smackx.packet.DiscoverInfo; +import org.jivesoftware.smackx.packet.DiscoverItems; + +import java.util.List; + + +/** + * The NodeInformationProvider is responsible for providing supported indentities, features + * and hosted items (i.e. DiscoverItems.Item) about a given node. This information will be + * requested each time this XMPPP client receives a disco info or items requests on the + * given node. each time this XMPPP client receives a disco info or items requests on the + * given node. + * + * @author Gaston Dombiak + */ +public interface NodeInformationProvider { + + /** + * Returns a list of the Items {@link org.jivesoftware.smackx.packet.DiscoverItems.Item} + * defined in the node. For example, the MUC protocol specifies that an XMPP client should + * answer an Item for each joined room when asked for the rooms where the use has joined. + * + * @return a list of the Items defined in the node. + */ + public abstract List<DiscoverItems.Item> getNodeItems(); + + /** + * Returns a list of the features defined in the node. For + * example, the entity caps protocol specifies that an XMPP client + * should answer with each feature supported by the client version + * or extension. + * + * @return a list of the feature strings defined in the node. + */ + public abstract List<String> getNodeFeatures(); + + /** + * Returns a list of the indentites defined in the node. For + * example, the x-command protocol must provide an identity of + * category automation and type command-node for each command. + * + * @return a list of the Identities defined in the node. + */ + public abstract List<DiscoverInfo.Identity> getNodeIdentities(); + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/OfflineMessageHeader.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/OfflineMessageHeader.java new file mode 100644 index 0000000..55fd149 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/OfflineMessageHeader.java @@ -0,0 +1,85 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +import org.jivesoftware.smackx.packet.DiscoverItems; + +/** + * The OfflineMessageHeader holds header information of an offline message. The header + * information was retrieved using the {@link OfflineMessageManager} class. + * + * Each offline message is identified by the target user of the offline message and a unique stamp. + * Use {@link OfflineMessageManager#getMessages(java.util.List)} to retrieve the whole message. + * + * @author Gaston Dombiak + */ +public class OfflineMessageHeader { + /** + * Bare JID of the user that was offline when the message was sent. + */ + private String user; + /** + * Full JID of the user that sent the message. + */ + private String jid; + /** + * Stamp that uniquely identifies the offline message. This stamp will be used for + * getting the specific message or delete it. The stamp may be of the form UTC timestamps + * but it is not required to have that format. + */ + private String stamp; + + public OfflineMessageHeader(DiscoverItems.Item item) { + super(); + user = item.getEntityID(); + jid = item.getName(); + stamp = item.getNode(); + } + + /** + * Returns the bare JID of the user that was offline when the message was sent. + * + * @return the bare JID of the user that was offline when the message was sent. + */ + public String getUser() { + return user; + } + + /** + * Returns the full JID of the user that sent the message. + * + * @return the full JID of the user that sent the message. + */ + public String getJid() { + return jid; + } + + /** + * Returns the stamp that uniquely identifies the offline message. This stamp will + * be used for getting the specific message or delete it. The stamp may be of the + * form UTC timestamps but it is not required to have that format. + * + * @return the stamp that uniquely identifies the offline message. + */ + public String getStamp() { + return stamp; + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/OfflineMessageManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/OfflineMessageManager.java new file mode 100644 index 0000000..ea1c3ca --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/OfflineMessageManager.java @@ -0,0 +1,284 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +import org.jivesoftware.smack.PacketCollector; +import org.jivesoftware.smack.SmackConfiguration; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.filter.*; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smackx.packet.DiscoverInfo; +import org.jivesoftware.smackx.packet.DiscoverItems; +import org.jivesoftware.smackx.packet.OfflineMessageInfo; +import org.jivesoftware.smackx.packet.OfflineMessageRequest; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +/** + * The OfflineMessageManager helps manage offline messages even before the user has sent an + * available presence. When a user asks for his offline messages before sending an available + * presence then the server will not send a flood with all the offline messages when the user + * becomes online. The server will not send a flood with all the offline messages to the session + * that made the offline messages request or to any other session used by the user that becomes + * online. + * + * Once the session that made the offline messages request has been closed and the user becomes + * offline in all the resources then the server will resume storing the messages offline and will + * send all the offline messages to the user when he becomes online. Therefore, the server will + * flood the user when he becomes online unless the user uses this class to manage his offline + * messages. + * + * @author Gaston Dombiak + */ +public class OfflineMessageManager { + + private final static String namespace = "http://jabber.org/protocol/offline"; + + private Connection connection; + + private PacketFilter packetFilter; + + public OfflineMessageManager(Connection connection) { + this.connection = connection; + packetFilter = + new AndFilter(new PacketExtensionFilter("offline", namespace), + new PacketTypeFilter(Message.class)); + } + + /** + * Returns true if the server supports Flexible Offline Message Retrieval. When the server + * supports Flexible Offline Message Retrieval it is possible to get the header of the offline + * messages, get specific messages, delete specific messages, etc. + * + * @return a boolean indicating if the server supports Flexible Offline Message Retrieval. + * @throws XMPPException If the user is not allowed to make this request. + */ + public boolean supportsFlexibleRetrieval() throws XMPPException { + DiscoverInfo info = ServiceDiscoveryManager.getInstanceFor(connection).discoverInfo(connection.getServiceName()); + return info.containsFeature(namespace); + } + + /** + * Returns the number of offline messages for the user of the connection. + * + * @return the number of offline messages for the user of the connection. + * @throws XMPPException If the user is not allowed to make this request or the server does + * not support offline message retrieval. + */ + public int getMessageCount() throws XMPPException { + DiscoverInfo info = ServiceDiscoveryManager.getInstanceFor(connection).discoverInfo(null, + namespace); + Form extendedInfo = Form.getFormFrom(info); + if (extendedInfo != null) { + String value = extendedInfo.getField("number_of_messages").getValues().next(); + return Integer.parseInt(value); + } + return 0; + } + + /** + * Returns an iterator on <tt>OfflineMessageHeader</tt> that keep information about the + * offline message. The OfflineMessageHeader includes a stamp that could be used to retrieve + * the complete message or delete the specific message. + * + * @return an iterator on <tt>OfflineMessageHeader</tt> that keep information about the offline + * message. + * @throws XMPPException If the user is not allowed to make this request or the server does + * not support offline message retrieval. + */ + public Iterator<OfflineMessageHeader> getHeaders() throws XMPPException { + List<OfflineMessageHeader> answer = new ArrayList<OfflineMessageHeader>(); + DiscoverItems items = ServiceDiscoveryManager.getInstanceFor(connection).discoverItems( + null, namespace); + for (Iterator it = items.getItems(); it.hasNext();) { + DiscoverItems.Item item = (DiscoverItems.Item) it.next(); + answer.add(new OfflineMessageHeader(item)); + } + return answer.iterator(); + } + + /** + * Returns an Iterator with the offline <tt>Messages</tt> whose stamp matches the specified + * request. The request will include the list of stamps that uniquely identifies + * the offline messages to retrieve. The returned offline messages will not be deleted + * from the server. Use {@link #deleteMessages(java.util.List)} to delete the messages. + * + * @param nodes the list of stamps that uniquely identifies offline message. + * @return an Iterator with the offline <tt>Messages</tt> that were received as part of + * this request. + * @throws XMPPException If the user is not allowed to make this request or the server does + * not support offline message retrieval. + */ + public Iterator<Message> getMessages(final List<String> nodes) throws XMPPException { + List<Message> messages = new ArrayList<Message>(); + OfflineMessageRequest request = new OfflineMessageRequest(); + for (String node : nodes) { + OfflineMessageRequest.Item item = new OfflineMessageRequest.Item(node); + item.setAction("view"); + request.addItem(item); + } + // Filter packets looking for an answer from the server. + PacketFilter responseFilter = new PacketIDFilter(request.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Filter offline messages that were requested by this request + PacketFilter messageFilter = new AndFilter(packetFilter, new PacketFilter() { + public boolean accept(Packet packet) { + OfflineMessageInfo info = (OfflineMessageInfo) packet.getExtension("offline", + namespace); + return nodes.contains(info.getNode()); + } + }); + PacketCollector messageCollector = connection.createPacketCollector(messageFilter); + // Send the retrieval request to the server. + connection.sendPacket(request); + // Wait up to a certain number of seconds for a reply. + IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + + // Collect the received offline messages + Message message = (Message) messageCollector.nextResult( + SmackConfiguration.getPacketReplyTimeout()); + while (message != null) { + messages.add(message); + message = + (Message) messageCollector.nextResult( + SmackConfiguration.getPacketReplyTimeout()); + } + // Stop queuing offline messages + messageCollector.cancel(); + return messages.iterator(); + } + + /** + * Returns an Iterator with all the offline <tt>Messages</tt> of the user. The returned offline + * messages will not be deleted from the server. Use {@link #deleteMessages(java.util.List)} + * to delete the messages. + * + * @return an Iterator with all the offline <tt>Messages</tt> of the user. + * @throws XMPPException If the user is not allowed to make this request or the server does + * not support offline message retrieval. + */ + public Iterator<Message> getMessages() throws XMPPException { + List<Message> messages = new ArrayList<Message>(); + OfflineMessageRequest request = new OfflineMessageRequest(); + request.setFetch(true); + // Filter packets looking for an answer from the server. + PacketFilter responseFilter = new PacketIDFilter(request.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Filter offline messages that were requested by this request + PacketCollector messageCollector = connection.createPacketCollector(packetFilter); + // Send the retrieval request to the server. + connection.sendPacket(request); + // Wait up to a certain number of seconds for a reply. + IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + + // Collect the received offline messages + Message message = (Message) messageCollector.nextResult( + SmackConfiguration.getPacketReplyTimeout()); + while (message != null) { + messages.add(message); + message = + (Message) messageCollector.nextResult( + SmackConfiguration.getPacketReplyTimeout()); + } + // Stop queuing offline messages + messageCollector.cancel(); + return messages.iterator(); + } + + /** + * Deletes the specified list of offline messages. The request will include the list of + * stamps that uniquely identifies the offline messages to delete. + * + * @param nodes the list of stamps that uniquely identifies offline message. + * @throws XMPPException If the user is not allowed to make this request or the server does + * not support offline message retrieval. + */ + public void deleteMessages(List<String> nodes) throws XMPPException { + OfflineMessageRequest request = new OfflineMessageRequest(); + for (String node : nodes) { + OfflineMessageRequest.Item item = new OfflineMessageRequest.Item(node); + item.setAction("remove"); + request.addItem(item); + } + // Filter packets looking for an answer from the server. + PacketFilter responseFilter = new PacketIDFilter(request.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send the deletion request to the server. + connection.sendPacket(request); + // Wait up to a certain number of seconds for a reply. + IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + } + + /** + * Deletes all offline messages of the user. + * + * @throws XMPPException If the user is not allowed to make this request or the server does + * not support offline message retrieval. + */ + public void deleteMessages() throws XMPPException { + OfflineMessageRequest request = new OfflineMessageRequest(); + request.setPurge(true); + // Filter packets looking for an answer from the server. + PacketFilter responseFilter = new PacketIDFilter(request.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send the deletion request to the server. + connection.sendPacket(request); + // Wait up to a certain number of seconds for a reply. + IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/PEPListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/PEPListener.java new file mode 100644 index 0000000..1d39484 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/PEPListener.java @@ -0,0 +1,42 @@ +/** + * $RCSfile: PEPListener.java,v $ + * $Revision: 1.1 $ + * $Date: 2007/11/03 00:14:32 $ + * + * Copyright 2003-2007 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.smackx; + +import org.jivesoftware.smackx.packet.PEPEvent; + + +/** + * + * A listener that is fired anytime a PEP event message is received. + * + * @author Jeff Williams + */ +public interface PEPListener { + + /** + * Called when PEP events are received as part of a presence subscribe or message filter. + * + * @param from the user that sent the entries. + * @param event the event contained in the message. + */ + public void eventReceived(String from, PEPEvent event); + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/PEPManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/PEPManager.java new file mode 100644 index 0000000..857f1c4 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/PEPManager.java @@ -0,0 +1,160 @@ +/** + * $RCSfile: PEPManager.java,v $ + * $Revision: 1.4 $ + * $Date: 2007/11/06 21:43:40 $ + * + * Copyright 2003-2007 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.smackx; + +import java.util.ArrayList; +import java.util.List; + +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.filter.PacketExtensionFilter; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.packet.IQ.Type; +import org.jivesoftware.smackx.packet.PEPEvent; +import org.jivesoftware.smackx.packet.PEPItem; +import org.jivesoftware.smackx.packet.PEPPubSub; + +/** + * + * Manages Personal Event Publishing (XEP-163). A PEPManager provides a high level access to + * pubsub personal events. It also provides an easy way + * to hook up custom logic when events are received from another XMPP client through PEPListeners. + * + * Use example: + * + * <pre> + * PEPManager pepManager = new PEPManager(smackConnection); + * pepManager.addPEPListener(new PEPListener() { + * public void eventReceived(String inFrom, PEPEvent inEvent) { + * LOGGER.debug("Event received: " + inEvent); + * } + * }); + * + * PEPProvider pepProvider = new PEPProvider(); + * pepProvider.registerPEPParserExtension("http://jabber.org/protocol/tune", new TuneProvider()); + * ProviderManager.getInstance().addExtensionProvider("event", "http://jabber.org/protocol/pubsub#event", pepProvider); + * + * Tune tune = new Tune("jeff", "1", "CD", "My Title", "My Track"); + * pepManager.publish(tune); + * </pre> + * + * @author Jeff Williams + */ +public class PEPManager { + + private List<PEPListener> pepListeners = new ArrayList<PEPListener>(); + + private Connection connection; + + private PacketFilter packetFilter = new PacketExtensionFilter("event", "http://jabber.org/protocol/pubsub#event"); + private PacketListener packetListener; + + /** + * Creates a new PEP exchange manager. + * + * @param connection a Connection which is used to send and receive messages. + */ + public PEPManager(Connection connection) { + this.connection = connection; + init(); + } + + /** + * Adds a listener to PEPs. The listener will be fired anytime PEP events + * are received from remote XMPP clients. + * + * @param pepListener a roster exchange listener. + */ + public void addPEPListener(PEPListener pepListener) { + synchronized (pepListeners) { + if (!pepListeners.contains(pepListener)) { + pepListeners.add(pepListener); + } + } + } + + /** + * Removes a listener from PEP events. + * + * @param pepListener a roster exchange listener. + */ + public void removePEPListener(PEPListener pepListener) { + synchronized (pepListeners) { + pepListeners.remove(pepListener); + } + } + + /** + * Publish an event. + * + * @param item the item to publish. + */ + public void publish(PEPItem item) { + // Create a new message to publish the event. + PEPPubSub pubSub = new PEPPubSub(item); + pubSub.setType(Type.SET); + //pubSub.setFrom(connection.getUser()); + + // Send the message that contains the roster + connection.sendPacket(pubSub); + } + + /** + * Fires roster exchange listeners. + */ + private void firePEPListeners(String from, PEPEvent event) { + PEPListener[] listeners = null; + synchronized (pepListeners) { + listeners = new PEPListener[pepListeners.size()]; + pepListeners.toArray(listeners); + } + for (int i = 0; i < listeners.length; i++) { + listeners[i].eventReceived(from, event); + } + } + + private void init() { + // Listens for all roster exchange packets and fire the roster exchange listeners. + packetListener = new PacketListener() { + public void processPacket(Packet packet) { + Message message = (Message) packet; + PEPEvent event = (PEPEvent) message.getExtension("event", "http://jabber.org/protocol/pubsub#event"); + // Fire event for roster exchange listeners + firePEPListeners(message.getFrom(), event); + }; + + }; + connection.addPacketListener(packetListener, packetFilter); + } + + public void destroy() { + if (connection != null) + connection.removePacketListener(packetListener); + + } + + protected void finalize() throws Throwable { + destroy(); + super.finalize(); + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/PrivateDataManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/PrivateDataManager.java new file mode 100644 index 0000000..03ba448 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/PrivateDataManager.java @@ -0,0 +1,359 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +import org.jivesoftware.smack.PacketCollector; +import org.jivesoftware.smack.SmackConfiguration; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.filter.PacketIDFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.provider.IQProvider; +import org.jivesoftware.smackx.packet.DefaultPrivateData; +import org.jivesoftware.smackx.packet.PrivateData; +import org.jivesoftware.smackx.provider.PrivateDataProvider; +import org.xmlpull.v1.XmlPullParser; + +import java.util.Hashtable; +import java.util.Map; + +/** + * Manages private data, which is a mechanism to allow users to store arbitrary XML + * data on an XMPP server. Each private data chunk is defined by a element name and + * XML namespace. Example private data: + * + * <pre> + * <color xmlns="http://example.com/xmpp/color"> + * <favorite>blue</blue> + * <leastFavorite>puce</leastFavorite> + * </color> + * </pre> + * + * {@link PrivateDataProvider} instances are responsible for translating the XML into objects. + * If no PrivateDataProvider is registered for a given element name and namespace, then + * a {@link DefaultPrivateData} instance will be returned. + * + * Warning: this is an non-standard protocol documented by + * <a href="http://www.jabber.org/jeps/jep-0049.html">JEP-49</a>. Because this is a + * non-standard protocol, it is subject to change. + * + * @author Matt Tucker + */ +public class PrivateDataManager { + + /** + * Map of provider instances. + */ + private static Map privateDataProviders = new Hashtable(); + + /** + * Returns the private data provider registered to the specified XML element name and namespace. + * For example, if a provider was registered to the element name "prefs" and the + * namespace "http://www.xmppclient.com/prefs", then the following packet would trigger + * the provider: + * + * <pre> + * <iq type='result' to='joe@example.com' from='mary@example.com' id='time_1'> + * <query xmlns='jabber:iq:private'> + * <prefs xmlns='http://www.xmppclient.com/prefs'> + * <value1>ABC</value1> + * <value2>XYZ</value2> + * </prefs> + * </query> + * </iq></pre> + * + * Note: this method is generally only called by the internal Smack classes. + * + * @param elementName the XML element name. + * @param namespace the XML namespace. + * @return the PrivateData provider. + */ + public static PrivateDataProvider getPrivateDataProvider(String elementName, String namespace) { + String key = getProviderKey(elementName, namespace); + return (PrivateDataProvider)privateDataProviders.get(key); + } + + /** + * Adds a private data provider with the specified element name and name space. The provider + * will override any providers loaded through the classpath. + * + * @param elementName the XML element name. + * @param namespace the XML namespace. + * @param provider the private data provider. + */ + public static void addPrivateDataProvider(String elementName, String namespace, + PrivateDataProvider provider) + { + String key = getProviderKey(elementName, namespace); + privateDataProviders.put(key, provider); + } + + /** + * Removes a private data provider with the specified element name and namespace. + * + * @param elementName The XML element name. + * @param namespace The XML namespace. + */ + public static void removePrivateDataProvider(String elementName, String namespace) { + String key = getProviderKey(elementName, namespace); + privateDataProviders.remove(key); + } + + + private Connection connection; + + /** + * The user to get and set private data for. In most cases, this value should + * be <tt>null</tt>, as the typical use of private data is to get and set + * your own private data and not others. + */ + private String user; + + /** + * Creates a new private data manager. The connection must have + * undergone a successful login before being used to construct an instance of + * this class. + * + * @param connection an XMPP connection which must have already undergone a + * successful login. + */ + public PrivateDataManager(Connection connection) { + if (!connection.isAuthenticated()) { + throw new IllegalStateException("Must be logged in to XMPP server."); + } + this.connection = connection; + } + + /** + * Creates a new private data manager for a specific user (special case). Most + * servers only support getting and setting private data for the user that + * authenticated via the connection. However, some servers support the ability + * to get and set private data for other users (for example, if you are the + * administrator). The connection must have undergone a successful login before + * being used to construct an instance of this class. + * + * @param connection an XMPP connection which must have already undergone a + * successful login. + * @param user the XMPP address of the user to get and set private data for. + */ + public PrivateDataManager(Connection connection, String user) { + if (!connection.isAuthenticated()) { + throw new IllegalStateException("Must be logged in to XMPP server."); + } + this.connection = connection; + this.user = user; + } + + /** + * Returns the private data specified by the given element name and namespace. Each chunk + * of private data is uniquely identified by an element name and namespace pair. + * + * If a PrivateDataProvider is registered for the specified element name/namespace pair then + * that provider will determine the specific object type that is returned. If no provider + * is registered, a {@link DefaultPrivateData} instance will be returned. + * + * @param elementName the element name. + * @param namespace the namespace. + * @return the private data. + * @throws XMPPException if an error occurs getting the private data. + */ + public PrivateData getPrivateData(final String elementName, final String namespace) + throws XMPPException + { + // Create an IQ packet to get the private data. + IQ privateDataGet = new IQ() { + public String getChildElementXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<query xmlns=\"jabber:iq:private\">"); + buf.append("<").append(elementName).append(" xmlns=\"").append(namespace).append("\"/>"); + buf.append("</query>"); + return buf.toString(); + } + }; + privateDataGet.setType(IQ.Type.GET); + // Address the packet to the other account if user has been set. + if (user != null) { + privateDataGet.setTo(user); + } + + // Setup a listener for the reply to the set operation. + String packetID = privateDataGet.getPacketID(); + PacketCollector collector = connection.createPacketCollector(new PacketIDFilter(packetID)); + + // Send the private data. + connection.sendPacket(privateDataGet); + + // Wait up to five seconds for a response from the server. + IQ response = (IQ)collector.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + collector.cancel(); + if (response == null) { + throw new XMPPException("No response from the server."); + } + // If the server replied with an error, throw an exception. + else if (response.getType() == IQ.Type.ERROR) { + throw new XMPPException(response.getError()); + } + return ((PrivateDataResult)response).getPrivateData(); + } + + /** + * Sets a private data value. Each chunk of private data is uniquely identified by an + * element name and namespace pair. If private data has already been set with the + * element name and namespace, then the new private data will overwrite the old value. + * + * @param privateData the private data. + * @throws XMPPException if setting the private data fails. + */ + public void setPrivateData(final PrivateData privateData) throws XMPPException { + // Create an IQ packet to set the private data. + IQ privateDataSet = new IQ() { + public String getChildElementXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<query xmlns=\"jabber:iq:private\">"); + buf.append(privateData.toXML()); + buf.append("</query>"); + return buf.toString(); + } + }; + privateDataSet.setType(IQ.Type.SET); + // Address the packet to the other account if user has been set. + if (user != null) { + privateDataSet.setTo(user); + } + + // Setup a listener for the reply to the set operation. + String packetID = privateDataSet.getPacketID(); + PacketCollector collector = connection.createPacketCollector(new PacketIDFilter(packetID)); + + // Send the private data. + connection.sendPacket(privateDataSet); + + // Wait up to five seconds for a response from the server. + IQ response = (IQ)collector.nextResult(5000); + // Stop queuing results + collector.cancel(); + if (response == null) { + throw new XMPPException("No response from the server."); + } + // If the server replied with an error, throw an exception. + else if (response.getType() == IQ.Type.ERROR) { + throw new XMPPException(response.getError()); + } + } + + /** + * Returns a String key for a given element name and namespace. + * + * @param elementName the element name. + * @param namespace the namespace. + * @return a unique key for the element name and namespace pair. + */ + private static String getProviderKey(String elementName, String namespace) { + StringBuilder buf = new StringBuilder(); + buf.append("<").append(elementName).append("/><").append(namespace).append("/>"); + return buf.toString(); + } + + /** + * An IQ provider to parse IQ results containing private data. + */ + public static class PrivateDataIQProvider implements IQProvider { + public IQ parseIQ(XmlPullParser parser) throws Exception { + PrivateData privateData = null; + boolean done = false; + while (!done) { + int eventType = parser.next(); + if (eventType == XmlPullParser.START_TAG) { + String elementName = parser.getName(); + String namespace = parser.getNamespace(); + // See if any objects are registered to handle this private data type. + PrivateDataProvider provider = getPrivateDataProvider(elementName, namespace); + // If there is a registered provider, use it. + if (provider != null) { + privateData = provider.parsePrivateData(parser); + } + // Otherwise, use a DefaultPrivateData instance to store the private data. + else { + DefaultPrivateData data = new DefaultPrivateData(elementName, namespace); + boolean finished = false; + while (!finished) { + int event = parser.next(); + if (event == XmlPullParser.START_TAG) { + String name = parser.getName(); + // If an empty element, set the value with the empty string. + if (parser.isEmptyElementTag()) { + data.setValue(name,""); + } + // Otherwise, get the the element text. + else { + event = parser.next(); + if (event == XmlPullParser.TEXT) { + String value = parser.getText(); + data.setValue(name, value); + } + } + } + else if (event == XmlPullParser.END_TAG) { + if (parser.getName().equals(elementName)) { + finished = true; + } + } + } + privateData = data; + } + } + else if (eventType == XmlPullParser.END_TAG) { + if (parser.getName().equals("query")) { + done = true; + } + } + } + return new PrivateDataResult(privateData); + } + } + + /** + * An IQ packet to hold PrivateData GET results. + */ + private static class PrivateDataResult extends IQ { + + private PrivateData privateData; + + PrivateDataResult(PrivateData privateData) { + this.privateData = privateData; + } + + public PrivateData getPrivateData() { + return privateData; + } + + public String getChildElementXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<query xmlns=\"jabber:iq:private\">"); + if (privateData != null) { + privateData.toXML(); + } + buf.append("</query>"); + return buf.toString(); + } + } +} \ No newline at end of file diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/RemoteRosterEntry.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/RemoteRosterEntry.java new file mode 100644 index 0000000..acf0b0b --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/RemoteRosterEntry.java @@ -0,0 +1,114 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +import java.util.*; + +/** + * Represents a roster item, which consists of a JID and , their name and + * the groups the roster item belongs to. This roster item does not belong + * to the local roster. Therefore, it does not persist in the server. + * + * The idea of a RemoteRosterEntry is to be used as part of a roster exchange. + * + * @author Gaston Dombiak + */ +public class RemoteRosterEntry { + + private String user; + private String name; + private final List<String> groupNames = new ArrayList<String>(); + + /** + * Creates a new remote roster entry. + * + * @param user the user. + * @param name the user's name. + * @param groups the list of group names the entry will belong to, or <tt>null</tt> if the + * the roster entry won't belong to a group. + */ + public RemoteRosterEntry(String user, String name, String [] groups) { + this.user = user; + this.name = name; + if (groups != null) { + groupNames.addAll(Arrays.asList(groups)); + } + } + + /** + * Returns the user. + * + * @return the user. + */ + public String getUser() { + return user; + } + + /** + * Returns the user's name. + * + * @return the user's name. + */ + public String getName() { + return name; + } + + /** + * Returns an Iterator for the group names (as Strings) that the roster entry + * belongs to. + * + * @return an Iterator for the group names. + */ + public Iterator getGroupNames() { + synchronized (groupNames) { + return Collections.unmodifiableList(groupNames).iterator(); + } + } + + /** + * Returns a String array for the group names that the roster entry + * belongs to. + * + * @return a String[] for the group names. + */ + public String[] getGroupArrayNames() { + synchronized (groupNames) { + return Collections.unmodifiableList(groupNames).toArray(new String[groupNames.size()]); + } + } + + public String toXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<item jid=\"").append(user).append("\""); + if (name != null) { + buf.append(" name=\"").append(name).append("\""); + } + buf.append(">"); + synchronized (groupNames) { + for (String groupName : groupNames) { + buf.append("<group>").append(groupName).append("</group>"); + } + } + buf.append("</item>"); + return buf.toString(); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/ReportedData.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/ReportedData.java new file mode 100644 index 0000000..0d7b760 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/ReportedData.java @@ -0,0 +1,281 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.packet.PacketExtension; +import org.jivesoftware.smackx.packet.DataForm; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; + +/** + * Represents a set of data results returned as part of a search. The report is structured + * in columns and rows. + * + * @author Gaston Dombiak + */ +public class ReportedData { + + private List<Column> columns = new ArrayList<Column>(); + private List<Row> rows = new ArrayList<Row>(); + private String title = ""; + + /** + * Returns a new ReportedData if the packet is used for reporting data and includes an + * extension that matches the elementName and namespace "x","jabber:x:data". + * + * @param packet the packet used for reporting data. + */ + public static ReportedData getReportedDataFrom(Packet packet) { + // Check if the packet includes the DataForm extension + PacketExtension packetExtension = packet.getExtension("x","jabber:x:data"); + if (packetExtension != null) { + // Check if the existing DataForm is a result of a search + DataForm dataForm = (DataForm) packetExtension; + if (dataForm.getReportedData() != null) + return new ReportedData(dataForm); + } + // Otherwise return null + return null; + } + + + /** + * Creates a new ReportedData based on the returned dataForm from a search + *(namespace "jabber:iq:search"). + * + * @param dataForm the dataForm returned from a search (namespace "jabber:iq:search"). + */ + private ReportedData(DataForm dataForm) { + // Add the columns to the report based on the reported data fields + for (Iterator fields = dataForm.getReportedData().getFields(); fields.hasNext();) { + FormField field = (FormField)fields.next(); + columns.add(new Column(field.getLabel(), field.getVariable(), field.getType())); + } + + // Add the rows to the report based on the form's items + for (Iterator items = dataForm.getItems(); items.hasNext();) { + DataForm.Item item = (DataForm.Item)items.next(); + List<Field> fieldList = new ArrayList<Field>(columns.size()); + FormField field; + for (Iterator fields = item.getFields(); fields.hasNext();) { + field = (FormField) fields.next(); + // The field is created with all the values of the data form's field + List<String> values = new ArrayList<String>(); + for (Iterator<String> it=field.getValues(); it.hasNext();) { + values.add(it.next()); + } + fieldList.add(new Field(field.getVariable(), values)); + } + rows.add(new Row(fieldList)); + } + + // Set the report's title + this.title = dataForm.getTitle(); + } + + + public ReportedData(){ + // Allow for model creation of ReportedData. + } + + /** + * Adds a new <code>Row</code>. + * @param row the new row to add. + */ + public void addRow(Row row){ + rows.add(row); + } + + /** + * Adds a new <code>Column</code> + * @param column the column to add. + */ + public void addColumn(Column column){ + columns.add(column); + } + + + /** + * Returns an Iterator for the rows returned from a search. + * + * @return an Iterator for the rows returned from a search. + */ + public Iterator<Row> getRows() { + return Collections.unmodifiableList(new ArrayList<Row>(rows)).iterator(); + } + + /** + * Returns an Iterator for the columns returned from a search. + * + * @return an Iterator for the columns returned from a search. + */ + public Iterator<Column> getColumns() { + return Collections.unmodifiableList(new ArrayList<Column>(columns)).iterator(); + } + + + /** + * Returns the report's title. It is similar to the title on a web page or an X + * window. + * + * @return title of the report. + */ + public String getTitle() { + return title; + } + + /** + * + * Represents the columns definition of the reported data. + * + * @author Gaston Dombiak + */ + public static class Column { + private String label; + private String variable; + private String type; + + /** + * Creates a new column with the specified definition. + * + * @param label the columns's label. + * @param variable the variable name of the column. + * @param type the format for the returned data. + */ + public Column(String label, String variable, String type) { + this.label = label; + this.variable = variable; + this.type = type; + } + + /** + * Returns the column's label. + * + * @return label of the column. + */ + public String getLabel() { + return label; + } + + + /** + * Returns the column's data format. Valid formats are: + * + * <ul> + * <li>text-single -> single line or word of text + * <li>text-private -> instead of showing the user what they typed, you show ***** to + * protect it + * <li>text-multi -> multiple lines of text entry + * <li>list-single -> given a list of choices, pick one + * <li>list-multi -> given a list of choices, pick one or more + * <li>boolean -> 0 or 1, true or false, yes or no. Default value is 0 + * <li>fixed -> fixed for putting in text to show sections, or just advertise your web + * site in the middle of the form + * <li>hidden -> is not given to the user at all, but returned with the questionnaire + * <li>jid-single -> Jabber ID - choosing a JID from your roster, and entering one based + * on the rules for a JID. + * <li>jid-multi -> multiple entries for JIDs + * </ul> + * + * @return format for the returned data. + */ + public String getType() { + return type; + } + + + /** + * Returns the variable name that the column is showing. + * + * @return the variable name of the column. + */ + public String getVariable() { + return variable; + } + + + } + + public static class Row { + private List<Field> fields = new ArrayList<Field>(); + + public Row(List<Field> fields) { + this.fields = fields; + } + + /** + * Returns the values of the field whose variable matches the requested variable. + * + * @param variable the variable to match. + * @return the values of the field whose variable matches the requested variable. + */ + public Iterator getValues(String variable) { + for(Iterator<Field> it=getFields();it.hasNext();) { + Field field = it.next(); + if (variable.equalsIgnoreCase(field.getVariable())) { + return field.getValues(); + } + } + return null; + } + + /** + * Returns the fields that define the data that goes with the item. + * + * @return the fields that define the data that goes with the item. + */ + private Iterator<Field> getFields() { + return Collections.unmodifiableList(new ArrayList<Field>(fields)).iterator(); + } + } + + public static class Field { + private String variable; + private List<String> values; + + public Field(String variable, List<String> values) { + this.variable = variable; + this.values = values; + } + + /** + * Returns the variable name that the field represents. + * + * @return the variable name of the field. + */ + public String getVariable() { + return variable; + } + + /** + * Returns an iterator on the values reported as part of the search. + * + * @return the returned values of the search. + */ + public Iterator<String> getValues() { + return Collections.unmodifiableList(values).iterator(); + } + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/RosterExchangeListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/RosterExchangeListener.java new file mode 100644 index 0000000..6c21458 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/RosterExchangeListener.java @@ -0,0 +1,42 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +import java.util.Iterator; + +/** + * + * A listener that is fired anytime a roster exchange is received. + * + * @author Gaston Dombiak + */ +public interface RosterExchangeListener { + + /** + * Called when roster entries are received as part of a roster exchange. + * + * @param from the user that sent the entries. + * @param remoteRosterEntries the entries sent by the user. The entries are instances of + * RemoteRosterEntry. + */ + public void entriesReceived(String from, Iterator remoteRosterEntries); + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/RosterExchangeManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/RosterExchangeManager.java new file mode 100644 index 0000000..abb03ab --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/RosterExchangeManager.java @@ -0,0 +1,187 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.Roster; +import org.jivesoftware.smack.RosterEntry; +import org.jivesoftware.smack.RosterGroup; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.filter.PacketExtensionFilter; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smackx.packet.RosterExchange; + +/** + * + * Manages Roster exchanges. A RosterExchangeManager provides a high level access to send + * rosters, roster groups and roster entries to XMPP clients. It also provides an easy way + * to hook up custom logic when entries are received from another XMPP client through + * RosterExchangeListeners. + * + * @author Gaston Dombiak + */ +public class RosterExchangeManager { + + private List<RosterExchangeListener> rosterExchangeListeners = new ArrayList<RosterExchangeListener>(); + + private Connection con; + + private PacketFilter packetFilter = new PacketExtensionFilter("x", "jabber:x:roster"); + private PacketListener packetListener; + + /** + * Creates a new roster exchange manager. + * + * @param con a Connection which is used to send and receive messages. + */ + public RosterExchangeManager(Connection con) { + this.con = con; + init(); + } + + /** + * Adds a listener to roster exchanges. The listener will be fired anytime roster entries + * are received from remote XMPP clients. + * + * @param rosterExchangeListener a roster exchange listener. + */ + public void addRosterListener(RosterExchangeListener rosterExchangeListener) { + synchronized (rosterExchangeListeners) { + if (!rosterExchangeListeners.contains(rosterExchangeListener)) { + rosterExchangeListeners.add(rosterExchangeListener); + } + } + } + + /** + * Removes a listener from roster exchanges. The listener will be fired anytime roster + * entries are received from remote XMPP clients. + * + * @param rosterExchangeListener a roster exchange listener.. + */ + public void removeRosterListener(RosterExchangeListener rosterExchangeListener) { + synchronized (rosterExchangeListeners) { + rosterExchangeListeners.remove(rosterExchangeListener); + } + } + + /** + * Sends a roster to userID. All the entries of the roster will be sent to the + * target user. + * + * @param roster the roster to send + * @param targetUserID the user that will receive the roster entries + */ + public void send(Roster roster, String targetUserID) { + // Create a new message to send the roster + Message msg = new Message(targetUserID); + // Create a RosterExchange Package and add it to the message + RosterExchange rosterExchange = new RosterExchange(roster); + msg.addExtension(rosterExchange); + + // Send the message that contains the roster + con.sendPacket(msg); + } + + /** + * Sends a roster entry to userID. + * + * @param rosterEntry the roster entry to send + * @param targetUserID the user that will receive the roster entries + */ + public void send(RosterEntry rosterEntry, String targetUserID) { + // Create a new message to send the roster + Message msg = new Message(targetUserID); + // Create a RosterExchange Package and add it to the message + RosterExchange rosterExchange = new RosterExchange(); + rosterExchange.addRosterEntry(rosterEntry); + msg.addExtension(rosterExchange); + + // Send the message that contains the roster + con.sendPacket(msg); + } + + /** + * Sends a roster group to userID. All the entries of the group will be sent to the + * target user. + * + * @param rosterGroup the roster group to send + * @param targetUserID the user that will receive the roster entries + */ + public void send(RosterGroup rosterGroup, String targetUserID) { + // Create a new message to send the roster + Message msg = new Message(targetUserID); + // Create a RosterExchange Package and add it to the message + RosterExchange rosterExchange = new RosterExchange(); + for (RosterEntry entry : rosterGroup.getEntries()) { + rosterExchange.addRosterEntry(entry); + } + msg.addExtension(rosterExchange); + + // Send the message that contains the roster + con.sendPacket(msg); + } + + /** + * Fires roster exchange listeners. + */ + private void fireRosterExchangeListeners(String from, Iterator remoteRosterEntries) { + RosterExchangeListener[] listeners = null; + synchronized (rosterExchangeListeners) { + listeners = new RosterExchangeListener[rosterExchangeListeners.size()]; + rosterExchangeListeners.toArray(listeners); + } + for (int i = 0; i < listeners.length; i++) { + listeners[i].entriesReceived(from, remoteRosterEntries); + } + } + + private void init() { + // Listens for all roster exchange packets and fire the roster exchange listeners. + packetListener = new PacketListener() { + public void processPacket(Packet packet) { + Message message = (Message) packet; + RosterExchange rosterExchange = + (RosterExchange) message.getExtension("x", "jabber:x:roster"); + // Fire event for roster exchange listeners + fireRosterExchangeListeners(message.getFrom(), rosterExchange.getRosterEntries()); + }; + + }; + con.addPacketListener(packetListener, packetFilter); + } + + public void destroy() { + if (con != null) + con.removePacketListener(packetListener); + + } + protected void finalize() throws Throwable { + destroy(); + super.finalize(); + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/ServiceDiscoveryManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/ServiceDiscoveryManager.java new file mode 100644 index 0000000..fc9cace --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/ServiceDiscoveryManager.java @@ -0,0 +1,789 @@ +/** + * $RCSfile$ + * $Revision: 9920 $ + * $Date: 2008-02-16 00:32:46 +0800 (Sat, 16 Feb 2008) $ + * + * Copyright 2003-2007 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.smackx; + +import org.jivesoftware.smack.*; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.filter.PacketIDFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.packet.Presence; +import org.jivesoftware.smack.packet.XMPPError; +import org.jivesoftware.smackx.entitycaps.CapsVerListener; +import org.jivesoftware.smackx.entitycaps.EntityCapsManager; +import org.jivesoftware.smackx.packet.CapsExtension; +import org.jivesoftware.smackx.packet.DiscoverInfo; +import org.jivesoftware.smackx.packet.DiscoverItems; +import org.jivesoftware.smackx.packet.DataForm; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +/** + * Manages discovery of services in XMPP entities. This class provides: + * <ol> + * <li>A registry of supported features in this XMPP entity. + * <li>Automatic response when this XMPP entity is queried for information. + * <li>Ability to discover items and information of remote XMPP entities. + * <li>Ability to publish publicly available items. + * </ol> + * + * @author Gaston Dombiak + */ +public class ServiceDiscoveryManager implements ServiceDiscoveryManagerInterface { + + private static String identityName = "Smack"; + private static String identityType = "pc"; + + private static boolean cacheNonCaps=true; + + private boolean sendPresence = false; + + private Map<String,DiscoverInfo> nonCapsCache = + new ConcurrentHashMap<String,DiscoverInfo>(); + + private EntityCapsManager capsManager; + + private static Map<Connection, ServiceDiscoveryManager> instances = + new ConcurrentHashMap<Connection, ServiceDiscoveryManager>(); + + private Connection connection; + private final List<String> features = new ArrayList<String>(); + private DataForm extendedInfo = null; + private Map<String, NodeInformationProvider> nodeInformationProviders = + new ConcurrentHashMap<String, NodeInformationProvider>(); + + // Create a new ServiceDiscoveryManager on every established connection + static { + // Add service discovery for normal XMPP c2s connections + XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() { + public void connectionCreated(Connection connection) { + new ServiceDiscoveryManager(connection); + } + }); + } + + /** + * Creates a new ServiceDiscoveryManager for a given connection. This means that the + * service manager will respond to any service discovery request that the connection may + * receive. + * + * @param connection the connection to which a ServiceDiscoveryManager is going to be created. + */ + public ServiceDiscoveryManager(Connection connection) { + this.connection = connection; + + // For every XMPPConnection, add one EntityCapsManager. + if (connection instanceof XMPPConnection + && ((XMPPConnection)connection).isEntityCapsEnabled()) { + setEntityCapsManager(new EntityCapsManager(this)); + capsManager.addCapsVerListener(new CapsPresenceRenewer()); + } + + renewEntityCapsVersion(); + + init(); + } + + /** + * Returns the ServiceDiscoveryManager instance associated with a given Connection. + * + * @param connection the connection used to look for the proper ServiceDiscoveryManager. + * @return the ServiceDiscoveryManager associated with a given Connection. + */ + public static ServiceDiscoveryManager getInstanceFor(Connection connection) { + return instances.get(connection); + } + + /** + * Returns the name of the client that will be returned when asked for the client identity + * in a disco request. The name could be any value you need to identity this client. + * + * @return the name of the client that will be returned when asked for the client identity + * in a disco request. + */ + public static String getIdentityName() { + return identityName; + } + + /** + * Sets the name of the client that will be returned when asked for the client identity + * in a disco request. The name could be any value you need to identity this client. + * + * @param name the name of the client that will be returned when asked for the client identity + * in a disco request. + */ + public static void setIdentityName(String name) { + identityName = name; + } + + /** + * Returns the type of client that will be returned when asked for the client identity in a + * disco request. The valid types are defined by the category client. Follow this link to learn + * the possible types: <a href="http://xmpp.org/registrar/disco-categories.html#client">Jabber::Registrar</a>. + * + * @return the type of client that will be returned when asked for the client identity in a + * disco request. + */ + public static String getIdentityType() { + return identityType; + } + + /** + * Sets the type of client that will be returned when asked for the client identity in a + * disco request. The valid types are defined by the category client. Follow this link to learn + * the possible types: <a href="http://xmpp.org/registrar/disco-categories.html#client">Jabber::Registrar</a>. + * + * @param type the type of client that will be returned when asked for the client identity in a + * disco request. + */ + public static void setIdentityType(String type) { + identityType = type; + } + + /** + * Enables caching of non caps entities to reduce traffic. If enabled discover infos of + * entities without xep-0115 are store in a String,DiscoverInfo map and + * discoverInfo(String) queries this map before sending a real discover info to the + * remote entity. Enabled by default. + */ + public static void setNonCapsCaching(boolean set){ + cacheNonCaps = set; + } + + /** + * Check if caching of non caps entities is enabled + */ + + public static boolean isNonCapsCachingEnabled(){ + return cacheNonCaps; + } + + /** + * Add discover info response data. + * + * @param response the discover info response packet + */ + public void addDiscoverInfoTo(DiscoverInfo response) { + // Set this client identity + DiscoverInfo.Identity identity = new DiscoverInfo.Identity("client", + getIdentityName()); + identity.setType(getIdentityType()); + response.addIdentity(identity); + // Add the registered features to the response + synchronized (features) { + for (Iterator<String> it = getFeatures(); it.hasNext();) { + response.addFeature(it.next()); + } + if (extendedInfo != null) { + response.addExtension(extendedInfo); + } + } + } + + /** + * Get a DiscoverInfo for the current entity caps node. + * + * @return a DiscoverInfo for the current entity caps node + */ + public DiscoverInfo getOwnDiscoverInfo() { + DiscoverInfo di = new DiscoverInfo(); + di.setType(IQ.Type.RESULT); + di.setNode(capsManager.getNode() + "#" + getEntityCapsVersion()); + + // Add discover info + addDiscoverInfoTo(di); + + return di; + } + + /** + * Initializes the packet listeners of the connection that will answer to any + * service discovery request. + */ + private void init() { + // Register the new instance and associate it with the connection + instances.put(connection, this); + // Add a listener to the connection that removes the registered instance when + // the connection is closed + connection.addConnectionListener(new ConnectionListener() { + public void connectionClosed() { + // Unregister this instance since the connection has been closed + instances.remove(connection); + } + + public void connectionClosedOnError(Exception e) { + // ignore + } + + public void reconnectionFailed(Exception e) { + // ignore + } + + public void reconnectingIn(int seconds) { + // ignore + } + + public void reconnectionSuccessful() { + // ignore + } + }); + + // Intercept presence packages and add caps data when intended. + // XEP-0115 specifies that a client SHOULD include entity capabilities + // with every presence notification it sends. + PacketFilter capsPacketFilter = new PacketTypeFilter(Presence.class); + PacketInterceptor packetInterceptor = new PacketInterceptor() { + public void interceptPacket(Packet packet) { + if (capsManager != null) { + String ver = getEntityCapsVersion(); + CapsExtension caps = new CapsExtension(capsManager.getNode(), ver, "sha-1"); + packet.addExtension(caps); + } + } + }; + connection.addPacketInterceptor(packetInterceptor, capsPacketFilter); + + // Listen for disco#items requests and answer with an empty result + PacketFilter packetFilter = new PacketTypeFilter(DiscoverItems.class); + PacketListener packetListener = new PacketListener() { + public void processPacket(Packet packet) { + DiscoverItems discoverItems = (DiscoverItems) packet; + // Send back the items defined in the client if the request is of type GET + if (discoverItems != null && discoverItems.getType() == IQ.Type.GET) { + DiscoverItems response = new DiscoverItems(); + response.setType(IQ.Type.RESULT); + response.setTo(discoverItems.getFrom()); + response.setPacketID(discoverItems.getPacketID()); + response.setNode(discoverItems.getNode()); + + // Add the defined items related to the requested node. Look for + // the NodeInformationProvider associated with the requested node. + NodeInformationProvider nodeInformationProvider = + getNodeInformationProvider(discoverItems.getNode()); + if (nodeInformationProvider != null) { + // Specified node was found + List<DiscoverItems.Item> items = nodeInformationProvider.getNodeItems(); + if (items != null) { + for (DiscoverItems.Item item : items) { + response.addItem(item); + } + } + } else if(discoverItems.getNode() != null) { + // Return <item-not-found/> error since client doesn't contain + // the specified node + response.setType(IQ.Type.ERROR); + response.setError(new XMPPError(XMPPError.Condition.item_not_found)); + } + connection.sendPacket(response); + } + } + }; + connection.addPacketListener(packetListener, packetFilter); + + // Listen for disco#info requests and answer the client's supported features + // To add a new feature as supported use the #addFeature message + packetFilter = new PacketTypeFilter(DiscoverInfo.class); + packetListener = new PacketListener() { + public void processPacket(Packet packet) { + DiscoverInfo discoverInfo = (DiscoverInfo) packet; + // Answer the client's supported features if the request is of the GET type + if (discoverInfo != null && discoverInfo.getType() == IQ.Type.GET) { + DiscoverInfo response = new DiscoverInfo(); + response.setType(IQ.Type.RESULT); + response.setTo(discoverInfo.getFrom()); + response.setPacketID(discoverInfo.getPacketID()); + response.setNode(discoverInfo.getNode()); + // Add the client's identity and features if "node" is + // null or our entity caps version. + if (discoverInfo.getNode() == null || + capsManager == null || + (capsManager.getNode() + "#" + + getEntityCapsVersion()).equals(discoverInfo.getNode())) { + addDiscoverInfoTo(response); + } + else { + // Disco#info was sent to a node. Check if we have information of the + // specified node + NodeInformationProvider nodeInformationProvider = + getNodeInformationProvider(discoverInfo.getNode()); + if (nodeInformationProvider != null) { + // Node was found. Add node features + List<String> features = nodeInformationProvider.getNodeFeatures(); + if (features != null) { + for(String feature : features) { + response.addFeature(feature); + } + } + // Add node identities + List<DiscoverInfo.Identity> identities = + nodeInformationProvider.getNodeIdentities(); + if (identities != null) { + for (DiscoverInfo.Identity identity : identities) { + response.addIdentity(identity); + } + } + } + else { + // Return <item-not-found/> error since specified node was not found + response.setType(IQ.Type.ERROR); + response.setError(new XMPPError(XMPPError.Condition.item_not_found)); + } + } + connection.sendPacket(response); + } + } + }; + connection.addPacketListener(packetListener, packetFilter); + } + + /** + * Returns the NodeInformationProvider responsible for providing information + * (ie items) related to a given node or <tt>null</null> if none. + * + * In MUC, a node could be 'http://jabber.org/protocol/muc#rooms' which means that the + * NodeInformationProvider will provide information about the rooms where the user has joined. + * + * @param node the node that contains items associated with an entity not addressable as a JID. + * @return the NodeInformationProvider responsible for providing information related + * to a given node. + */ + private NodeInformationProvider getNodeInformationProvider(String node) { + if (node == null) { + return null; + } + return nodeInformationProviders.get(node); + } + + /** + * Sets the NodeInformationProvider responsible for providing information + * (ie items) related to a given node. Every time this client receives a disco request + * regarding the items of a given node, the provider associated to that node will be the + * responsible for providing the requested information. + * + * In MUC, a node could be 'http://jabber.org/protocol/muc#rooms' which means that the + * NodeInformationProvider will provide information about the rooms where the user has joined. + * + * @param node the node whose items will be provided by the NodeInformationProvider. + * @param listener the NodeInformationProvider responsible for providing items related + * to the node. + */ + public void setNodeInformationProvider(String node, NodeInformationProvider listener) { + nodeInformationProviders.put(node, listener); + } + + /** + * Removes the NodeInformationProvider responsible for providing information + * (ie items) related to a given node. This means that no more information will be + * available for the specified node. + * + * In MUC, a node could be 'http://jabber.org/protocol/muc#rooms' which means that the + * NodeInformationProvider will provide information about the rooms where the user has joined. + * + * @param node the node to remove the associated NodeInformationProvider. + */ + public void removeNodeInformationProvider(String node) { + nodeInformationProviders.remove(node); + } + + /** + * Returns the supported features by this XMPP entity. + * + * @return an Iterator on the supported features by this XMPP entity. + */ + public Iterator<String> getFeatures() { + synchronized (features) { + return Collections.unmodifiableList(new ArrayList<String>(features)).iterator(); + } + } + + /** + * Registers that a new feature is supported by this XMPP entity. When this client is + * queried for its information the registered features will be answered. + * + * Since no packet is actually sent to the server it is safe to perform this operation + * before logging to the server. In fact, you may want to configure the supported features + * before logging to the server so that the information is already available if it is required + * upon login. + * + * @param feature the feature to register as supported. + */ + public void addFeature(String feature) { + synchronized (features) { + features.add(feature); + renewEntityCapsVersion(); + } + } + + /** + * Removes the specified feature from the supported features by this XMPP entity. + * + * Since no packet is actually sent to the server it is safe to perform this operation + * before logging to the server. + * + * @param feature the feature to remove from the supported features. + */ + public void removeFeature(String feature) { + synchronized (features) { + features.remove(feature); + renewEntityCapsVersion(); + } + } + + /** + * Returns true if the specified feature is registered in the ServiceDiscoveryManager. + * + * @param feature the feature to look for. + * @return a boolean indicating if the specified featured is registered or not. + */ + public boolean includesFeature(String feature) { + synchronized (features) { + return features.contains(feature); + } + } + + /** + * Registers extended discovery information of this XMPP entity. When this + * client is queried for its information this data form will be returned as + * specified by XEP-0128. + * + * + * Since no packet is actually sent to the server it is safe to perform this + * operation before logging to the server. In fact, you may want to + * configure the extended info before logging to the server so that the + * information is already available if it is required upon login. + * + * @param info + * the data form that contains the extend service discovery + * information. + */ + public void setExtendedInfo(DataForm info) { + extendedInfo = info; + renewEntityCapsVersion(); + } + + /** + * Removes the dataform containing extended service discovery information + * from the information returned by this XMPP entity. + * + * Since no packet is actually sent to the server it is safe to perform this + * operation before logging to the server. + */ + public void removeExtendedInfo() { + extendedInfo = null; + renewEntityCapsVersion(); + } + + /** + * Returns the discovered information of a given XMPP entity addressed by its JID + * if it's known by the entity caps manager. + * + * @param entityID the address of the XMPP entity + * @return the disovered info or null if no such info is available from the + * entity caps manager. + * @throws XMPPException if the operation failed for some reason. + */ + public DiscoverInfo discoverInfoByCaps(String entityID) throws XMPPException { + DiscoverInfo info = capsManager.getDiscoverInfoByUser(entityID); + + if (info != null) { + DiscoverInfo newInfo = cloneDiscoverInfo(info); + newInfo.setFrom(entityID); + return newInfo; + } + else { + return null; + } + } + + /** + * Returns the discovered information of a given XMPP entity addressed by its JID. + * + * @param entityID the address of the XMPP entity. + * @return the discovered information. + * @throws XMPPException if the operation failed for some reason. + */ + public DiscoverInfo discoverInfo(String entityID) throws XMPPException { + // Check if the have it cached in the Entity Capabilities Manager + DiscoverInfo info = discoverInfoByCaps(entityID); + + if (info != null) { + return info; + } else { + // If the caps node is known, use it in the request. + String node = null; + + if (capsManager != null) { + // Get the newest node#version + node = capsManager.getNodeVersionByUser(entityID); + } + + // Check if we cached DiscoverInfo for nonCaps entity + if (cacheNonCaps + && node == null + && nonCapsCache.containsKey(entityID)) { + return nonCapsCache.get(entityID); + } + // Discover by requesting from the remote client + info = discoverInfo(entityID, node); + + // If the node version is known, store the new entry. + if (node != null && capsManager != null) { + EntityCapsManager.addDiscoverInfoByNode(node, info); + } + // If this is a non caps entity store the discover in nonCapsCache map + else if (cacheNonCaps && node == null) { + nonCapsCache.put(entityID, info); + } + return info; + } + } + + /** + * Returns the discovered information of a given XMPP entity addressed by its JID and + * note attribute. Use this message only when trying to query information which is not + * directly addressable. + * + * @param entityID the address of the XMPP entity. + * @param node the attribute that supplements the 'jid' attribute. + * @return the discovered information. + * @throws XMPPException if the operation failed for some reason. + */ + public DiscoverInfo discoverInfo(String entityID, String node) throws XMPPException { + // Discover the entity's info + DiscoverInfo disco = new DiscoverInfo(); + disco.setType(IQ.Type.GET); + disco.setTo(entityID); + disco.setNode(node); + + // Create a packet collector to listen for a response. + PacketCollector collector = + connection.createPacketCollector(new PacketIDFilter(disco.getPacketID())); + + connection.sendPacket(disco); + + // Wait up to 5 seconds for a result. + IQ result = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + collector.cancel(); + if (result == null) { + throw new XMPPException("No response from the server."); + } + if (result.getType() == IQ.Type.ERROR) { + throw new XMPPException(result.getError()); + } + return (DiscoverInfo) result; + } + + /** + * Returns the discovered items of a given XMPP entity addressed by its JID. + * + * @param entityID the address of the XMPP entity. + * @return the discovered information. + * @throws XMPPException if the operation failed for some reason. + */ + public DiscoverItems discoverItems(String entityID) throws XMPPException { + return discoverItems(entityID, null); + } + + /** + * Returns the discovered items of a given XMPP entity addressed by its JID and + * note attribute. Use this message only when trying to query information which is not + * directly addressable. + * + * @param entityID the address of the XMPP entity. + * @param node the attribute that supplements the 'jid' attribute. + * @return the discovered items. + * @throws XMPPException if the operation failed for some reason. + */ + public DiscoverItems discoverItems(String entityID, String node) throws XMPPException { + // Discover the entity's items + DiscoverItems disco = new DiscoverItems(); + disco.setType(IQ.Type.GET); + disco.setTo(entityID); + disco.setNode(node); + + // Create a packet collector to listen for a response. + PacketCollector collector = + connection.createPacketCollector(new PacketIDFilter(disco.getPacketID())); + + connection.sendPacket(disco); + + // Wait up to 5 seconds for a result. + IQ result = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + collector.cancel(); + if (result == null) { + throw new XMPPException("No response from the server."); + } + if (result.getType() == IQ.Type.ERROR) { + throw new XMPPException(result.getError()); + } + return (DiscoverItems) result; + } + + /** + * Returns true if the server supports publishing of items. A client may wish to publish items + * to the server so that the server can provide items associated to the client. These items will + * be returned by the server whenever the server receives a disco request targeted to the bare + * address of the client (i.e. user@host.com). + * + * @param entityID the address of the XMPP entity. + * @return true if the server supports publishing of items. + * @throws XMPPException if the operation failed for some reason. + */ + public boolean canPublishItems(String entityID) throws XMPPException { + DiscoverInfo info = discoverInfo(entityID); + return canPublishItems(info); + } + + /** + * Returns true if the server supports publishing of items. A client may wish to publish items + * to the server so that the server can provide items associated to the client. These items will + * be returned by the server whenever the server receives a disco request targeted to the bare + * address of the client (i.e. user@host.com). + * + * @param DiscoverInfo the discover info packet to check. + * @return true if the server supports publishing of items. + */ + public static boolean canPublishItems(DiscoverInfo info) { + return info.containsFeature("http://jabber.org/protocol/disco#publish"); + } + + /** + * Publishes new items to a parent entity. The item elements to publish MUST have at least + * a 'jid' attribute specifying the Entity ID of the item, and an action attribute which + * specifies the action being taken for that item. Possible action values are: "update" and + * "remove". + * + * @param entityID the address of the XMPP entity. + * @param discoverItems the DiscoveryItems to publish. + * @throws XMPPException if the operation failed for some reason. + */ + public void publishItems(String entityID, DiscoverItems discoverItems) + throws XMPPException { + publishItems(entityID, null, discoverItems); + } + + /** + * Publishes new items to a parent entity and node. The item elements to publish MUST have at + * least a 'jid' attribute specifying the Entity ID of the item, and an action attribute which + * specifies the action being taken for that item. Possible action values are: "update" and + * "remove". + * + * @param entityID the address of the XMPP entity. + * @param node the attribute that supplements the 'jid' attribute. + * @param discoverItems the DiscoveryItems to publish. + * @throws XMPPException if the operation failed for some reason. + */ + public void publishItems(String entityID, String node, DiscoverItems discoverItems) + throws XMPPException { + discoverItems.setType(IQ.Type.SET); + discoverItems.setTo(entityID); + discoverItems.setNode(node); + + // Create a packet collector to listen for a response. + PacketCollector collector = + connection.createPacketCollector(new PacketIDFilter(discoverItems.getPacketID())); + + connection.sendPacket(discoverItems); + + // Wait up to 5 seconds for a result. + IQ result = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + collector.cancel(); + if (result == null) { + throw new XMPPException("No response from the server."); + } + if (result.getType() == IQ.Type.ERROR) { + throw new XMPPException(result.getError()); + } + } + + private DiscoverInfo cloneDiscoverInfo(DiscoverInfo disco) { + return disco.clone(); + } + + /** + * Entity Capabilities + */ + + public void setEntityCapsManager(EntityCapsManager manager) { + capsManager = manager; + if (connection.getCapsNode() != null + && connection.getHost() != null) { + capsManager.addUserCapsNode(connection.getHost(), connection.getCapsNode()); + } + capsManager.addPacketListener(connection); + } + + /** + * Updates the Entity Capabilities Verification String + * if EntityCaps is enabled + */ + private void renewEntityCapsVersion() { + // If a XMPPConnection is the managed one, see that the new + // version is updated + if (connection instanceof XMPPConnection) { + if (capsManager != null) { + capsManager.calculateEntityCapsVersion(getOwnDiscoverInfo(), + identityType, identityName, extendedInfo); + //capsManager.notifyCapsVerListeners(); + } + } + } + + private String getEntityCapsVersion() { + if (capsManager != null) { + return capsManager.getCapsVersion(); + } + else { + return null; + } + } + + public EntityCapsManager getEntityCapsManager(){ + return capsManager; + } + + private void setSendPresence() { + sendPresence = true; + } + + private boolean isSendPresence() { + return sendPresence; + } + + + private class CapsPresenceRenewer implements CapsVerListener { + public void capsVerUpdated(String ver) { + // Send an empty presence, and let the packet interceptor + // add a <c/> node to it. + if (((Connection)connection).isAuthenticated() && + (((Connection)connection).isSendPresence() || + isSendPresence())) { + Presence presence = new Presence(Presence.Type.available); + connection.sendPacket(presence); + } + } + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/ServiceDiscoveryManagerInterface.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/ServiceDiscoveryManagerInterface.java new file mode 100644 index 0000000..a59381a --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/ServiceDiscoveryManagerInterface.java @@ -0,0 +1,5 @@ +package org.jivesoftware.smackx; + +public interface ServiceDiscoveryManagerInterface { + public void addFeature(String feature); +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/SharedGroupManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/SharedGroupManager.java new file mode 100644 index 0000000..c973730 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/SharedGroupManager.java @@ -0,0 +1,53 @@ +package org.jivesoftware.smackx; + +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.PacketCollector; +import org.jivesoftware.smack.SmackConfiguration; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.filter.PacketIDFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smackx.packet.SharedGroupsInfo; + +import java.util.List; + +/** + * A SharedGroupManager provides services for discovering the shared groups where a user belongs. + * + * Important note: This functionality is not part of the XMPP spec and it will only work + * with Wildfire. + * + * @author Gaston Dombiak + */ +public class SharedGroupManager { + + /** + * Returns the collection that will contain the name of the shared groups where the user + * logged in with the specified session belongs. + * + * @param connection connection to use to get the user's shared groups. + * @return collection with the shared groups' name of the logged user. + */ + public static List getSharedGroups(Connection connection) throws XMPPException { + // Discover the shared groups of the logged user + SharedGroupsInfo info = new SharedGroupsInfo(); + info.setType(IQ.Type.GET); + + // Create a packet collector to listen for a response. + PacketCollector collector = + connection.createPacketCollector(new PacketIDFilter(info.getPacketID())); + + connection.sendPacket(info); + + // Wait up to 5 seconds for a result. + IQ result = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + collector.cancel(); + if (result == null) { + throw new XMPPException("No response from the server."); + } + if (result.getType() == IQ.Type.ERROR) { + throw new XMPPException(result.getError()); + } + return ((SharedGroupsInfo) result).getGroups(); + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/XHTMLManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/XHTMLManager.java new file mode 100644 index 0000000..f0c102c --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/XHTMLManager.java @@ -0,0 +1,144 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +import org.jivesoftware.smack.ConnectionCreationListener; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smackx.packet.DiscoverInfo; +import org.jivesoftware.smackx.packet.XHTMLExtension; + +import java.util.Iterator; + +/** + * Manages XHTML formatted texts within messages. A XHTMLManager provides a high level access to + * get and set XHTML bodies to messages, enable and disable XHTML support and check if remote XMPP + * clients support XHTML. + * + * @author Gaston Dombiak + */ +public class XHTMLManager { + + private final static String namespace = "http://jabber.org/protocol/xhtml-im"; + + // Enable the XHTML support on every established connection + // The ServiceDiscoveryManager class should have been already initialized + static { + Connection.addConnectionCreationListener(new ConnectionCreationListener() { + public void connectionCreated(Connection connection) { + XHTMLManager.setServiceEnabled(connection, true); + } + }); + } + + /** + * Returns an Iterator for the XHTML bodies in the message. Returns null if + * the message does not contain an XHTML extension. + * + * @param message an XHTML message + * @return an Iterator for the bodies in the message or null if none. + */ + public static Iterator getBodies(Message message) { + XHTMLExtension xhtmlExtension = (XHTMLExtension) message.getExtension("html", namespace); + if (xhtmlExtension != null) + return xhtmlExtension.getBodies(); + else + return null; + } + + /** + * Adds an XHTML body to the message. + * + * @param message the message that will receive the XHTML body + * @param body the string to add as an XHTML body to the message + */ + public static void addBody(Message message, String body) { + XHTMLExtension xhtmlExtension = (XHTMLExtension) message.getExtension("html", namespace); + if (xhtmlExtension == null) { + // Create an XHTMLExtension and add it to the message + xhtmlExtension = new XHTMLExtension(); + message.addExtension(xhtmlExtension); + } + // Add the required bodies to the message + xhtmlExtension.addBody(body); + } + + /** + * Returns true if the message contains an XHTML extension. + * + * @param message the message to check if contains an XHTML extentsion or not + * @return a boolean indicating whether the message is an XHTML message + */ + public static boolean isXHTMLMessage(Message message) { + return message.getExtension("html", namespace) != null; + } + + /** + * Enables or disables the XHTML support on a given connection. + * + * Before starting to send XHTML messages to a user, check that the user can handle XHTML + * messages. Enable the XHTML support to indicate that this client handles XHTML messages. + * + * @param connection the connection where the service will be enabled or disabled + * @param enabled indicates if the service will be enabled or disabled + */ + public synchronized static void setServiceEnabled(Connection connection, boolean enabled) { + if (isServiceEnabled(connection) == enabled) + return; + + if (enabled) { + ServiceDiscoveryManager.getInstanceFor(connection).addFeature(namespace); + } + else { + ServiceDiscoveryManager.getInstanceFor(connection).removeFeature(namespace); + } + } + + /** + * Returns true if the XHTML support is enabled for the given connection. + * + * @param connection the connection to look for XHTML support + * @return a boolean indicating if the XHTML support is enabled for the given connection + */ + public static boolean isServiceEnabled(Connection connection) { + return ServiceDiscoveryManager.getInstanceFor(connection).includesFeature(namespace); + } + + /** + * Returns true if the specified user handles XHTML messages. + * + * @param connection the connection to use to perform the service discovery + * @param userID the user to check. A fully qualified xmpp ID, e.g. jdoe@example.com + * @return a boolean indicating whether the specified user handles XHTML messages + */ + public static boolean isServiceEnabled(Connection connection, String userID) { + try { + DiscoverInfo result = + ServiceDiscoveryManager.getInstanceFor(connection).discoverInfo(userID); + return result.containsFeature(namespace); + } + catch (XMPPException e) { + e.printStackTrace(); + return false; + } + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/XHTMLText.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/XHTMLText.java new file mode 100644 index 0000000..201e530 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/XHTMLText.java @@ -0,0 +1,429 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx; + +import org.jivesoftware.smack.util.StringUtils; + +/** + * An XHTMLText represents formatted text. This class also helps to build valid + * XHTML tags. + * + * @author Gaston Dombiak + */ +public class XHTMLText { + + private StringBuilder text = new StringBuilder(30); + + /** + * Creates a new XHTMLText with body tag params. + * + * @param style the XHTML style of the body + * @param lang the language of the body + */ + public XHTMLText(String style, String lang) { + appendOpenBodyTag(style, lang); + } + + /** + * Appends a tag that indicates that an anchor section begins. + * + * @param href indicates the URL being linked to + * @param style the XHTML style of the anchor + */ + public void appendOpenAnchorTag(String href, String style) { + StringBuilder sb = new StringBuilder("<a"); + if (href != null) { + sb.append(" href=\""); + sb.append(href); + sb.append("\""); + } + if (style != null) { + sb.append(" style=\""); + sb.append(style); + sb.append("\""); + } + sb.append(">"); + text.append(sb.toString()); + } + + /** + * Appends a tag that indicates that an anchor section ends. + * + */ + public void appendCloseAnchorTag() { + text.append("</a>"); + } + + /** + * Appends a tag that indicates that a blockquote section begins. + * + * @param style the XHTML style of the blockquote + */ + public void appendOpenBlockQuoteTag(String style) { + StringBuilder sb = new StringBuilder("<blockquote"); + if (style != null) { + sb.append(" style=\""); + sb.append(style); + sb.append("\""); + } + sb.append(">"); + text.append(sb.toString()); + } + + /** + * Appends a tag that indicates that a blockquote section ends. + * + */ + public void appendCloseBlockQuoteTag() { + text.append("</blockquote>"); + } + + /** + * Appends a tag that indicates that a body section begins. + * + * @param style the XHTML style of the body + * @param lang the language of the body + */ + private void appendOpenBodyTag(String style, String lang) { + StringBuilder sb = new StringBuilder("<body"); + if (style != null) { + sb.append(" style=\""); + sb.append(style); + sb.append("\""); + } + if (lang != null) { + sb.append(" xml:lang=\""); + sb.append(lang); + sb.append("\""); + } + sb.append(">"); + text.append(sb.toString()); + } + + /** + * Appends a tag that indicates that a body section ends. + * + */ + private String closeBodyTag() { + return "</body>"; + } + + /** + * Appends a tag that inserts a single carriage return. + * + */ + public void appendBrTag() { + text.append(" "); + } + + /** + * Appends a tag that indicates a reference to work, such as a book, report or web site. + * + */ + public void appendOpenCiteTag() { + text.append("<cite>"); + } + + /** + * Appends a tag that indicates text that is the code for a program. + * + */ + public void appendOpenCodeTag() { + text.append("<code>"); + } + + /** + * Appends a tag that indicates end of text that is the code for a program. + * + */ + public void appendCloseCodeTag() { + text.append("</code>"); + } + + /** + * Appends a tag that indicates emphasis. + * + */ + public void appendOpenEmTag() { + text.append(""); + } + + /** + * Appends a tag that indicates end of emphasis. + * + */ + public void appendCloseEmTag() { + text.append(""); + } + + /** + * Appends a tag that indicates a header, a title of a section of the message. + * + * @param level the level of the Header. It should be a value between 1 and 3 + * @param style the XHTML style of the blockquote + */ + public void appendOpenHeaderTag(int level, String style) { + if (level > 3 || level < 1) { + return; + } + StringBuilder sb = new StringBuilder("<h"); + sb.append(level); + if (style != null) { + sb.append(" style=\""); + sb.append(style); + sb.append("\""); + } + sb.append(">"); + text.append(sb.toString()); + } + + /** + * Appends a tag that indicates that a header section ends. + * + * @param level the level of the Header. It should be a value between 1 and 3 + */ + public void appendCloseHeaderTag(int level) { + if (level > 3 || level < 1) { + return; + } + StringBuilder sb = new StringBuilder("</h"); + sb.append(level); + sb.append(">"); + text.append(sb.toString()); + } + + /** + * Appends a tag that indicates an image. + * + * @param align how text should flow around the picture + * @param alt the text to show if you don't show the picture + * @param height how tall is the picture + * @param src where to get the picture + * @param width how wide is the picture + */ + public void appendImageTag(String align, String alt, String height, String src, String width) { + StringBuilder sb = new StringBuilder("<img"); + if (align != null) { + sb.append(" align=\""); + sb.append(align); + sb.append("\""); + } + if (alt != null) { + sb.append(" alt=\""); + sb.append(alt); + sb.append("\""); + } + if (height != null) { + sb.append(" height=\""); + sb.append(height); + sb.append("\""); + } + if (src != null) { + sb.append(" src=\""); + sb.append(src); + sb.append("\""); + } + if (width != null) { + sb.append(" width=\""); + sb.append(width); + sb.append("\""); + } + sb.append(">"); + text.append(sb.toString()); + } + + /** + * Appends a tag that indicates the start of a new line item within a list. + * + * @param style the style of the line item + */ + public void appendLineItemTag(String style) { + StringBuilder sb = new StringBuilder("<li"); + if (style != null) { + sb.append(" style=\""); + sb.append(style); + sb.append("\""); + } + sb.append(">"); + text.append(sb.toString()); + } + + /** + * Appends a tag that creates an ordered list. "Ordered" means that the order of the items + * in the list is important. To show this, browsers automatically number the list. + * + * @param style the style of the ordered list + */ + public void appendOpenOrderedListTag(String style) { + StringBuilder sb = new StringBuilder("<ol"); + if (style != null) { + sb.append(" style=\""); + sb.append(style); + sb.append("\""); + } + sb.append(">"); + text.append(sb.toString()); + } + + /** + * Appends a tag that indicates that an ordered list section ends. + * + */ + public void appendCloseOrderedListTag() { + text.append("</ol>"); + } + + /** + * Appends a tag that creates an unordered list. The unordered part means that the items + * in the list are not in any particular order. + * + * @param style the style of the unordered list + */ + public void appendOpenUnorderedListTag(String style) { + StringBuilder sb = new StringBuilder("<ul"); + if (style != null) { + sb.append(" style=\""); + sb.append(style); + sb.append("\""); + } + sb.append(">"); + text.append(sb.toString()); + } + + /** + * Appends a tag that indicates that an unordered list section ends. + * + */ + public void appendCloseUnorderedListTag() { + text.append("</ul>"); + } + + /** + * Appends a tag that indicates the start of a new paragraph. This is usually rendered + * with two carriage returns, producing a single blank line in between the two paragraphs. + * + * @param style the style of the paragraph + */ + public void appendOpenParagraphTag(String style) { + StringBuilder sb = new StringBuilder("<p"); + if (style != null) { + sb.append(" style=\""); + sb.append(style); + sb.append("\""); + } + sb.append(">"); + text.append(sb.toString()); + } + + /** + * Appends a tag that indicates the end of a new paragraph. This is usually rendered + * with two carriage returns, producing a single blank line in between the two paragraphs. + * + */ + public void appendCloseParagraphTag() { + text.append(""); + } + + /** + * Appends a tag that indicates that an inlined quote section begins. + * + * @param style the style of the inlined quote + */ + public void appendOpenInlinedQuoteTag(String style) { + StringBuilder sb = new StringBuilder("<q"); + if (style != null) { + sb.append(" style=\""); + sb.append(style); + sb.append("\""); + } + sb.append(">"); + text.append(sb.toString()); + } + + /** + * Appends a tag that indicates that an inlined quote section ends. + * + */ + public void appendCloseInlinedQuoteTag() { + text.append("</q>"); + } + + /** + * Appends a tag that allows to set the fonts for a span of text. + * + * @param style the style for a span of text + */ + public void appendOpenSpanTag(String style) { + StringBuilder sb = new StringBuilder("<span"); + if (style != null) { + sb.append(" style=\""); + sb.append(style); + sb.append("\""); + } + sb.append(">"); + text.append(sb.toString()); + } + + /** + * Appends a tag that indicates that a span section ends. + * + */ + public void appendCloseSpanTag() { + text.append(""); + } + + /** + * Appends a tag that indicates text which should be more forceful than surrounding text. + * + */ + public void appendOpenStrongTag() { + text.append(""); + } + + /** + * Appends a tag that indicates that a strong section ends. + * + */ + public void appendCloseStrongTag() { + text.append(""); + } + + /** + * Appends a given text to the XHTMLText. + * + * @param textToAppend the text to append + */ + public void append(String textToAppend) { + text.append(StringUtils.escapeForXML(textToAppend)); + } + + /** + * Returns the text of the XHTMLText. + * + * Note: Automatically adds the closing body tag. + * + * @return the text of the XHTMLText + */ + public String toString() { + return text.toString().concat(closeBodyTag()); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/XmppStreamHandler.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/XmppStreamHandler.java new file mode 100644 index 0000000..1e836b1 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/XmppStreamHandler.java @@ -0,0 +1,258 @@ +/** + * Copyright 2012 Miron Cuperman. + * + * 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.smackx; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.jivesoftware.smack.ConnectionListener; +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.XMPPConnection; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.packet.PacketExtension; +import org.jivesoftware.smack.packet.UnknownPacket; +import org.jivesoftware.smack.provider.PacketExtensionProvider; +import org.jivesoftware.smack.provider.ProviderManager; +import org.jivesoftware.smack.util.StringUtils; +import org.xmlpull.v1.XmlPullParser; + +public class XmppStreamHandler { + private static final String URN_SM_2 = "urn:xmpp:sm:2"; + private XMPPConnection mConnection; + private boolean isSmAvailable = false; + private boolean isSmEnabled = false; + private long previousIncomingStanzaCount = -1; + private String sessionId; + private long incomingStanzaCount = 0; + private long outgoingStanzaCount = 0; + private List<ManagedPacket> sendList = null; + + public static class ManagedPacket { + Packet packet; + long stanzaCount; + } + + public XmppStreamHandler(XMPPConnection connection) { + mConnection = connection; + startListening(); + } + + public boolean isResumePossible() { + return sessionId != null; + } + + public static void addExtensionProviders() { + addSimplePacketExtension("sm", URN_SM_2); + addSimplePacketExtension("r", URN_SM_2); + addSimplePacketExtension("a", URN_SM_2); + addSimplePacketExtension("enabled", URN_SM_2); + addSimplePacketExtension("resumed", URN_SM_2); + addSimplePacketExtension("failed", URN_SM_2); + } + + public void notifyInitialLogin() { + if (isSmAvailable) { + sendEnablePacket(); + } + } + + private void sendEnablePacket() { + if (sessionId != null) { + // TODO binding + StreamHandlingPacket resumePacket = new StreamHandlingPacket("resume", URN_SM_2); + resumePacket.addAttribute("h", String.valueOf(previousIncomingStanzaCount)); + resumePacket.addAttribute("previd", sessionId); + mConnection.sendPacket(resumePacket); + } + else { + StreamHandlingPacket enablePacket = new StreamHandlingPacket("enable", URN_SM_2); + enablePacket.addAttribute("resume", "true"); + mConnection.sendPacket(enablePacket); + } + } + + private void startListening() { + mConnection.addConnectionListener(new ConnectionListener() { + public void reconnectionSuccessful() { + if (isSmAvailable) { + sendEnablePacket(); + } + else { + isSmEnabled = false; + sessionId = null; + } + } + + public void reconnectionFailed(Exception e) { + } + + public void reconnectingIn(int seconds) { + } + + public void connectionClosedOnError(Exception e) { + if (isSmEnabled && sessionId != null) { + previousIncomingStanzaCount = incomingStanzaCount; + } + isSmEnabled = false; + isSmAvailable = false; + } + + public void connectionClosed() { + previousIncomingStanzaCount = -1; + } + }); + + mConnection.addPacketSendingListener(new PacketListener() { + public void processPacket(Packet packet) { + if (isSmAvailable) { + // for packets sent directly after <enable/>, before + // <enabled/> is received. + outgoingStanzaCount++; + } + if (isSmEnabled) { + StreamHandlingPacket reqPacket = new StreamHandlingPacket("r", URN_SM_2); + mConnection.sendPacket(reqPacket); + ManagedPacket managedPacket = new ManagedPacket(); + managedPacket.packet = packet; + managedPacket.stanzaCount = outgoingStanzaCount; + sendList.add(managedPacket); + } + } + }, new PacketFilter() { + public boolean accept(Packet packet) { + return (!(packet instanceof StreamHandlingPacket)); + } + }); + + mConnection.addPacketListener(new PacketListener() { + public void processPacket(Packet packet) { + incomingStanzaCount++; + if (packet instanceof StreamHandlingPacket) { + StreamHandlingPacket shPacket = (StreamHandlingPacket) packet; + String name = shPacket.getElementName(); + if ("sm".equals(name)) { + isSmAvailable = true; + } + else if ("r".equals(name)) { + incomingStanzaCount--; + StreamHandlingPacket ackPacket = new StreamHandlingPacket("a", URN_SM_2); + ackPacket.addAttribute("h", String.valueOf(incomingStanzaCount)); + mConnection.sendPacket(ackPacket); + } + else if ("a".equals(name)) { + for (ManagedPacket mp : sendList) { + long ackedCount = Long.valueOf(((StreamHandlingPacket) packet).getAttribute("h")); + if (mp.stanzaCount <= ackedCount) { + sendList.remove(mp); + } + } + } + else if ("enabled".equals(name)) { + incomingStanzaCount = 0; + isSmEnabled = true; + mConnection.getRoster().setOfflineOnError(false); + String resume = shPacket.getAttribute("resume"); + if ("true".equals(resume) || "1".equals(resume)) { + sessionId = shPacket.getAttribute("id"); + } + sendList = new ArrayList<ManagedPacket>(); + } + else if ("resumed".equals(name)) { + incomingStanzaCount = previousIncomingStanzaCount; + isSmEnabled = true; + } + else if ("failed".equals(name)) { + // Failed, shutdown and the parent will retry + mConnection.getRoster().setOfflineOnError(true); + mConnection.getRoster().setOfflinePresences(); + sessionId = null; + mConnection.quickShutdown(); + // isSmEnabled is already false + } + } + } + }, new PacketFilter() { + public boolean accept(Packet packet) { + return true; + } + }); + } + + private static void addSimplePacketExtension(final String name, final String namespace) { + ProviderManager.getInstance().addExtensionProvider(name, namespace, new PacketExtensionProvider() { + public PacketExtension parseExtension(XmlPullParser parser) throws Exception { + StreamHandlingPacket packet = new StreamHandlingPacket(name, namespace); + int attributeCount = parser.getAttributeCount(); + for (int i = 0; i < attributeCount; i++) { + packet.addAttribute(parser.getAttributeName(i), parser.getAttributeValue(i)); + } + return packet; + } + }); + } + + static class StreamHandlingPacket extends UnknownPacket { + private String name; + private String namespace; + Map<String, String> attributes; + + StreamHandlingPacket(String name, String namespace) { + this.name = name; + this.namespace = namespace; + attributes = Collections.emptyMap(); + } + + public void addAttribute(String name, String value) { + if (attributes == Collections.EMPTY_MAP) + attributes = new HashMap<String, String>(); + attributes.put(name, value); + } + + public String getAttribute(String name) { + return attributes.get(name); + } + + public String getNamespace() { + return namespace; + } + + public String getElementName() { + return name; + } + + public String toXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<").append(getElementName()); + + // TODO Xmlns?? + if (getNamespace() != null) { + buf.append(" xmlns=\"").append(getNamespace()).append("\""); + } + for (String key : attributes.keySet()) { + buf.append(" ").append(key).append("=\"").append(StringUtils.escapeForXML(attributes.get(key))) + .append("\""); + } + buf.append("/>"); + return buf.toString(); + } + + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/BookmarkManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/BookmarkManager.java new file mode 100644 index 0000000..f85cc9c --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/BookmarkManager.java @@ -0,0 +1,224 @@ +/** + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.bookmark; + +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smackx.PrivateDataManager; + +import java.util.*; + +/** + * Provides methods to manage bookmarks in accordance with JEP-0048. Methods for managing URLs and + * Conferences are provided. + * + * It should be noted that some extensions have been made to the JEP. There is an attribute on URLs + * that marks a url as a news feed and also a sub-element can be added to either a URL or conference + * indicated that it is shared amongst all users on a server. + * + * @author Alexander Wenckus + */ +public class BookmarkManager { + private static final Map<Connection, BookmarkManager> bookmarkManagerMap = new HashMap<Connection, BookmarkManager>(); + static { + PrivateDataManager.addPrivateDataProvider("storage", "storage:bookmarks", + new Bookmarks.Provider()); + } + + /** + * Returns the BookmarkManager for a connection, if it doesn't exist it is created. + * + * @param connection the connection for which the manager is desired. + * @return Returns the BookmarkManager for a connection, if it doesn't + * exist it is created. + * @throws XMPPException Thrown if the connection is null or has not yet been authenticated. + */ + public synchronized static BookmarkManager getBookmarkManager(Connection connection) + throws XMPPException + { + BookmarkManager manager = (BookmarkManager) bookmarkManagerMap.get(connection); + if(manager == null) { + manager = new BookmarkManager(connection); + bookmarkManagerMap.put(connection, manager); + } + return manager; + } + + private PrivateDataManager privateDataManager; + private Bookmarks bookmarks; + private final Object bookmarkLock = new Object(); + + /** + * Default constructor. Registers the data provider with the private data manager in the + * storage:bookmarks namespace. + * + * @param connection the connection for persisting and retrieving bookmarks. + * @throws XMPPException thrown when the connection is null or has not been authenticated. + */ + private BookmarkManager(Connection connection) throws XMPPException { + if(connection == null || !connection.isAuthenticated()) { + throw new XMPPException("Invalid connection."); + } + this.privateDataManager = new PrivateDataManager(connection); + } + + /** + * Returns all currently bookmarked conferences. + * + * @return returns all currently bookmarked conferences + * @throws XMPPException thrown when there was an error retrieving the current bookmarks from + * the server. + * @see BookmarkedConference + */ + public Collection<BookmarkedConference> getBookmarkedConferences() throws XMPPException { + retrieveBookmarks(); + return Collections.unmodifiableCollection(bookmarks.getBookmarkedConferences()); + } + + /** + * Adds or updates a conference in the bookmarks. + * + * @param name the name of the conference + * @param jid the jid of the conference + * @param isAutoJoin whether or not to join this conference automatically on login + * @param nickname the nickname to use for the user when joining the conference + * @param password the password to use for the user when joining the conference + * @throws XMPPException thrown when there is an issue retrieving the current bookmarks from + * the server. + */ + public void addBookmarkedConference(String name, String jid, boolean isAutoJoin, + String nickname, String password) throws XMPPException + { + retrieveBookmarks(); + BookmarkedConference bookmark + = new BookmarkedConference(name, jid, isAutoJoin, nickname, password); + List<BookmarkedConference> conferences = bookmarks.getBookmarkedConferences(); + if(conferences.contains(bookmark)) { + BookmarkedConference oldConference = conferences.get(conferences.indexOf(bookmark)); + if(oldConference.isShared()) { + throw new IllegalArgumentException("Cannot modify shared bookmark"); + } + oldConference.setAutoJoin(isAutoJoin); + oldConference.setName(name); + oldConference.setNickname(nickname); + oldConference.setPassword(password); + } + else { + bookmarks.addBookmarkedConference(bookmark); + } + privateDataManager.setPrivateData(bookmarks); + } + + /** + * Removes a conference from the bookmarks. + * + * @param jid the jid of the conference to be removed. + * @throws XMPPException thrown when there is a problem with the connection attempting to + * retrieve the bookmarks or persist the bookmarks. + * @throws IllegalArgumentException thrown when the conference being removed is a shared + * conference + */ + public void removeBookmarkedConference(String jid) throws XMPPException { + retrieveBookmarks(); + Iterator<BookmarkedConference> it = bookmarks.getBookmarkedConferences().iterator(); + while(it.hasNext()) { + BookmarkedConference conference = it.next(); + if(conference.getJid().equalsIgnoreCase(jid)) { + if(conference.isShared()) { + throw new IllegalArgumentException("Conference is shared and can't be removed"); + } + it.remove(); + privateDataManager.setPrivateData(bookmarks); + return; + } + } + } + + /** + * Returns an unmodifiable collection of all bookmarked urls. + * + * @return returns an unmodifiable collection of all bookmarked urls. + * @throws XMPPException thrown when there is a problem retriving bookmarks from the server. + */ + public Collection<BookmarkedURL> getBookmarkedURLs() throws XMPPException { + retrieveBookmarks(); + return Collections.unmodifiableCollection(bookmarks.getBookmarkedURLS()); + } + + /** + * Adds a new url or updates an already existing url in the bookmarks. + * + * @param URL the url of the bookmark + * @param name the name of the bookmark + * @param isRSS whether or not the url is an rss feed + * @throws XMPPException thrown when there is an error retriving or saving bookmarks from or to + * the server + */ + public void addBookmarkedURL(String URL, String name, boolean isRSS) throws XMPPException { + retrieveBookmarks(); + BookmarkedURL bookmark = new BookmarkedURL(URL, name, isRSS); + List<BookmarkedURL> urls = bookmarks.getBookmarkedURLS(); + if(urls.contains(bookmark)) { + BookmarkedURL oldURL = urls.get(urls.indexOf(bookmark)); + if(oldURL.isShared()) { + throw new IllegalArgumentException("Cannot modify shared bookmarks"); + } + oldURL.setName(name); + oldURL.setRss(isRSS); + } + else { + bookmarks.addBookmarkedURL(bookmark); + } + privateDataManager.setPrivateData(bookmarks); + } + + /** + * Removes a url from the bookmarks. + * + * @param bookmarkURL the url of the bookmark to remove + * @throws XMPPException thrown if there is an error retriving or saving bookmarks from or to + * the server. + */ + public void removeBookmarkedURL(String bookmarkURL) throws XMPPException { + retrieveBookmarks(); + Iterator<BookmarkedURL> it = bookmarks.getBookmarkedURLS().iterator(); + while(it.hasNext()) { + BookmarkedURL bookmark = it.next(); + if(bookmark.getURL().equalsIgnoreCase(bookmarkURL)) { + if(bookmark.isShared()) { + throw new IllegalArgumentException("Cannot delete a shared bookmark."); + } + it.remove(); + privateDataManager.setPrivateData(bookmarks); + return; + } + } + } + + private Bookmarks retrieveBookmarks() throws XMPPException { + synchronized(bookmarkLock) { + if(bookmarks == null) { + bookmarks = (Bookmarks) privateDataManager.getPrivateData("storage", + "storage:bookmarks"); + } + return bookmarks; + } + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/BookmarkedConference.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/BookmarkedConference.java new file mode 100644 index 0000000..5dac202 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/BookmarkedConference.java @@ -0,0 +1,130 @@ +/** + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.bookmark; + +/** + * Respresents a Conference Room bookmarked on the server using JEP-0048 Bookmark Storage JEP. + * + * @author Derek DeMoro + */ +public class BookmarkedConference implements SharedBookmark { + + private String name; + private boolean autoJoin; + private final String jid; + + private String nickname; + private String password; + private boolean isShared; + + protected BookmarkedConference(String jid) { + this.jid = jid; + } + + protected BookmarkedConference(String name, String jid, boolean autoJoin, String nickname, + String password) + { + this.name = name; + this.jid = jid; + this.autoJoin = autoJoin; + this.nickname = nickname; + this.password = password; + } + + + /** + * Returns the display label representing the Conference room. + * + * @return the name of the conference room. + */ + public String getName() { + return name; + } + + protected void setName(String name) { + this.name = name; + } + + /** + * Returns true if this conference room should be auto-joined on startup. + * + * @return true if room should be joined on startup, otherwise false. + */ + public boolean isAutoJoin() { + return autoJoin; + } + + protected void setAutoJoin(boolean autoJoin) { + this.autoJoin = autoJoin; + } + + /** + * Returns the full JID of this conference room. (ex.dev@conference.jivesoftware.com) + * + * @return the full JID of this conference room. + */ + public String getJid() { + return jid; + } + + /** + * Returns the nickname to use when joining this conference room. This is an optional + * value and may return null. + * + * @return the nickname to use when joining, null may be returned. + */ + public String getNickname() { + return nickname; + } + + protected void setNickname(String nickname) { + this.nickname = nickname; + } + + /** + * Returns the password to use when joining this conference room. This is an optional + * value and may return null. + * + * @return the password to use when joining this conference room, null may be returned. + */ + public String getPassword() { + return password; + } + + protected void setPassword(String password) { + this.password = password; + } + + public boolean equals(Object obj) { + if(obj == null || !(obj instanceof BookmarkedConference)) { + return false; + } + BookmarkedConference conference = (BookmarkedConference)obj; + return conference.getJid().equalsIgnoreCase(jid); + } + + protected void setShared(boolean isShared) { + this.isShared = isShared; + } + + public boolean isShared() { + return isShared; + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/BookmarkedURL.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/BookmarkedURL.java new file mode 100644 index 0000000..f3d6d9d --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/BookmarkedURL.java @@ -0,0 +1,104 @@ +/** + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.bookmark; + +/** + * Respresents one instance of a URL defined using JEP-0048 Bookmark Storage JEP. + * + * @author Derek DeMoro + */ +public class BookmarkedURL implements SharedBookmark { + + private String name; + private final String URL; + private boolean isRss; + private boolean isShared; + + protected BookmarkedURL(String URL) { + this.URL = URL; + } + + protected BookmarkedURL(String URL, String name, boolean isRss) { + this.URL = URL; + this.name = name; + this.isRss = isRss; + } + + /** + * Returns the name representing the URL (eg. Jive Software). This can be used in as a label, or + * identifer in applications. + * + * @return the name reprenting the URL. + */ + public String getName() { + return name; + } + + /** + * Sets the name representing the URL. + * + * @param name the name. + */ + protected void setName(String name) { + this.name = name; + } + + /** + * Returns the URL. + * + * @return the url. + */ + public String getURL() { + return URL; + } + /** + * Set to true if this URL is an RSS or news feed. + * + * @param isRss True if the URL is a news feed and false if it is not. + */ + protected void setRss(boolean isRss) { + this.isRss = isRss; + } + + /** + * Returns true if this URL is a news feed. + * + * @return Returns true if this URL is a news feed. + */ + public boolean isRss() { + return isRss; + } + + public boolean equals(Object obj) { + if(!(obj instanceof BookmarkedURL)) { + return false; + } + BookmarkedURL url = (BookmarkedURL)obj; + return url.getURL().equalsIgnoreCase(URL); + } + + protected void setShared(boolean shared) { + this.isShared = shared; + } + + public boolean isShared() { + return isShared; + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/Bookmarks.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/Bookmarks.java new file mode 100644 index 0000000..100fa46 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/Bookmarks.java @@ -0,0 +1,310 @@ +/** + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.bookmark; + +import org.jivesoftware.smackx.packet.PrivateData; +import org.jivesoftware.smackx.provider.PrivateDataProvider; +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +/** + * Bookmarks is used for storing and retrieving URLS and Conference rooms. + * Bookmark Storage (JEP-0048) defined a protocol for the storage of bookmarks to conference rooms and other entities + * in a Jabber user's account. + * See the following code sample for saving Bookmarks: + * + * <pre> + * Connection con = new XMPPConnection("jabber.org"); + * con.login("john", "doe"); + * Bookmarks bookmarks = new Bookmarks(); + * + * // Bookmark a URL + * BookmarkedURL url = new BookmarkedURL(); + * url.setName("Google"); + * url.setURL("http://www.jivesoftware.com"); + * bookmarks.addURL(url); + * // Bookmark a Conference room. + * BookmarkedConference conference = new BookmarkedConference(); + * conference.setName("My Favorite Room"); + * conference.setAutoJoin("true"); + * conference.setJID("dev@conference.jivesoftware.com"); + * bookmarks.addConference(conference); + * // Save Bookmarks using PrivateDataManager. + * PrivateDataManager manager = new PrivateDataManager(con); + * manager.setPrivateData(bookmarks); + * + * + * LastActivity activity = LastActivity.getLastActivity(con, "xray@jabber.org"); + * </pre> + * + * @author Derek DeMoro + */ +public class Bookmarks implements PrivateData { + + private List<BookmarkedURL> bookmarkedURLS; + private List<BookmarkedConference> bookmarkedConferences; + + /** + * Required Empty Constructor to use Bookmarks. + */ + public Bookmarks() { + bookmarkedURLS = new ArrayList<BookmarkedURL>(); + bookmarkedConferences = new ArrayList<BookmarkedConference>(); + } + + /** + * Adds a BookmarkedURL. + * + * @param bookmarkedURL the bookmarked bookmarkedURL. + */ + public void addBookmarkedURL(BookmarkedURL bookmarkedURL) { + bookmarkedURLS.add(bookmarkedURL); + } + + /** + * Removes a bookmarked bookmarkedURL. + * + * @param bookmarkedURL the bookmarked bookmarkedURL to remove. + */ + public void removeBookmarkedURL(BookmarkedURL bookmarkedURL) { + bookmarkedURLS.remove(bookmarkedURL); + } + + /** + * Removes all BookmarkedURLs from user's bookmarks. + */ + public void clearBookmarkedURLS() { + bookmarkedURLS.clear(); + } + + /** + * Add a BookmarkedConference to bookmarks. + * + * @param bookmarkedConference the conference to remove. + */ + public void addBookmarkedConference(BookmarkedConference bookmarkedConference) { + bookmarkedConferences.add(bookmarkedConference); + } + + /** + * Removes a BookmarkedConference. + * + * @param bookmarkedConference the BookmarkedConference to remove. + */ + public void removeBookmarkedConference(BookmarkedConference bookmarkedConference) { + bookmarkedConferences.remove(bookmarkedConference); + } + + /** + * Removes all BookmarkedConferences from Bookmarks. + */ + public void clearBookmarkedConferences() { + bookmarkedConferences.clear(); + } + + /** + * Returns a Collection of all Bookmarked URLs for this user. + * + * @return a collection of all Bookmarked URLs. + */ + public List<BookmarkedURL> getBookmarkedURLS() { + return bookmarkedURLS; + } + + /** + * Returns a Collection of all Bookmarked Conference for this user. + * + * @return a collection of all Bookmarked Conferences. + */ + public List<BookmarkedConference> getBookmarkedConferences() { + return bookmarkedConferences; + } + + + /** + * Returns the root element name. + * + * @return the element name. + */ + public String getElementName() { + return "storage"; + } + + /** + * Returns the root element XML namespace. + * + * @return the namespace. + */ + public String getNamespace() { + return "storage:bookmarks"; + } + + /** + * Returns the XML reppresentation of the PrivateData. + * + * @return the private data as XML. + */ + public String toXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<storage xmlns=\"storage:bookmarks\">"); + + final Iterator<BookmarkedURL> urls = getBookmarkedURLS().iterator(); + while (urls.hasNext()) { + BookmarkedURL urlStorage = urls.next(); + if(urlStorage.isShared()) { + continue; + } + buf.append("<url name=\"").append(urlStorage.getName()). + append("\" url=\"").append(urlStorage.getURL()).append("\""); + if(urlStorage.isRss()) { + buf.append(" rss=\"").append(true).append("\""); + } + buf.append(" />"); + } + + // Add Conference additions + final Iterator<BookmarkedConference> conferences = getBookmarkedConferences().iterator(); + while (conferences.hasNext()) { + BookmarkedConference conference = conferences.next(); + if(conference.isShared()) { + continue; + } + buf.append("<conference "); + buf.append("name=\"").append(conference.getName()).append("\" "); + buf.append("autojoin=\"").append(conference.isAutoJoin()).append("\" "); + buf.append("jid=\"").append(conference.getJid()).append("\" "); + buf.append(">"); + + if (conference.getNickname() != null) { + buf.append("<nick>").append(conference.getNickname()).append("</nick>"); + } + + + if (conference.getPassword() != null) { + buf.append("<password>").append(conference.getPassword()).append("</password>"); + } + buf.append("</conference>"); + } + + + buf.append("</storage>"); + return buf.toString(); + } + + /** + * The IQ Provider for BookmarkStorage. + * + * @author Derek DeMoro + */ + public static class Provider implements PrivateDataProvider { + + /** + * Empty Constructor for PrivateDataProvider. + */ + public Provider() { + super(); + } + + public PrivateData parsePrivateData(XmlPullParser parser) throws Exception { + Bookmarks storage = new Bookmarks(); + + boolean done = false; + while (!done) { + int eventType = parser.next(); + if (eventType == XmlPullParser.START_TAG && "url".equals(parser.getName())) { + final BookmarkedURL urlStorage = getURLStorage(parser); + if (urlStorage != null) { + storage.addBookmarkedURL(urlStorage); + } + } + else if (eventType == XmlPullParser.START_TAG && + "conference".equals(parser.getName())) + { + final BookmarkedConference conference = getConferenceStorage(parser); + storage.addBookmarkedConference(conference); + } + else if (eventType == XmlPullParser.END_TAG && "storage".equals(parser.getName())) + { + done = true; + } + } + + + return storage; + } + } + + private static BookmarkedURL getURLStorage(XmlPullParser parser) throws IOException, XmlPullParserException { + String name = parser.getAttributeValue("", "name"); + String url = parser.getAttributeValue("", "url"); + String rssString = parser.getAttributeValue("", "rss"); + boolean rss = rssString != null && "true".equals(rssString); + + BookmarkedURL urlStore = new BookmarkedURL(url, name, rss); + boolean done = false; + while (!done) { + int eventType = parser.next(); + if(eventType == XmlPullParser.START_TAG + && "shared_bookmark".equals(parser.getName())) { + urlStore.setShared(true); + } + else if (eventType == XmlPullParser.END_TAG && "url".equals(parser.getName())) { + done = true; + } + } + return urlStore; + } + + private static BookmarkedConference getConferenceStorage(XmlPullParser parser) throws Exception { + String name = parser.getAttributeValue("", "name"); + String autojoin = parser.getAttributeValue("", "autojoin"); + String jid = parser.getAttributeValue("", "jid"); + + BookmarkedConference conf = new BookmarkedConference(jid); + conf.setName(name); + conf.setAutoJoin(Boolean.valueOf(autojoin).booleanValue()); + + // Check for nickname + boolean done = false; + while (!done) { + int eventType = parser.next(); + if (eventType == XmlPullParser.START_TAG && "nick".equals(parser.getName())) { + conf.setNickname(parser.nextText()); + } + else if (eventType == XmlPullParser.START_TAG && "password".equals(parser.getName())) { + conf.setPassword(parser.nextText()); + } + else if(eventType == XmlPullParser.START_TAG + && "shared_bookmark".equals(parser.getName())) { + conf.setShared(true); + } + else if (eventType == XmlPullParser.END_TAG && "conference".equals(parser.getName())) { + done = true; + } + } + + + return conf; + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/SharedBookmark.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/SharedBookmark.java new file mode 100644 index 0000000..f672bc1 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bookmark/SharedBookmark.java @@ -0,0 +1,35 @@ +/** + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.bookmark; + +/** + * Interface to indicate if a bookmark is shared across the server. + * + * @author Alexander Wenckus + */ +public interface SharedBookmark { + + /** + * Returns true if this bookmark is shared. + * + * @return returns true if this bookmark is shared. + */ + public boolean isShared(); +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/BytestreamListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/BytestreamListener.java new file mode 100644 index 0000000..be78255 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/BytestreamListener.java @@ -0,0 +1,47 @@ +/** + * 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.smackx.bytestreams; + +import org.jivesoftware.smackx.bytestreams.ibb.InBandBytestreamListener; +import org.jivesoftware.smackx.bytestreams.ibb.InBandBytestreamManager; +import org.jivesoftware.smackx.bytestreams.socks5.Socks5BytestreamListener; +import org.jivesoftware.smackx.bytestreams.socks5.Socks5BytestreamManager; + +/** + * BytestreamListener are notified if a remote user wants to initiate a bytestream. Implement this + * interface to handle incoming bytestream requests. + * + * BytestreamListener can be registered at the {@link Socks5BytestreamManager} or the + * {@link InBandBytestreamManager}. + * + * There are two ways to add this listener. See + * {@link BytestreamManager#addIncomingBytestreamListener(BytestreamListener)} and + * {@link BytestreamManager#addIncomingBytestreamListener(BytestreamListener, String)} for further + * details. + * + * {@link Socks5BytestreamListener} or {@link InBandBytestreamListener} provide a more specific + * interface of the BytestreamListener. + * + * @author Henning Staib + */ +public interface BytestreamListener { + + /** + * This listener is notified if a bytestream request from another user has been received. + * + * @param request the incoming bytestream request + */ + public void incomingBytestreamRequest(BytestreamRequest request); + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/BytestreamManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/BytestreamManager.java new file mode 100644 index 0000000..ca6bbc6 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/BytestreamManager.java @@ -0,0 +1,114 @@ +/** + * 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.smackx.bytestreams; + +import java.io.IOException; + +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smackx.bytestreams.ibb.InBandBytestreamManager; +import org.jivesoftware.smackx.bytestreams.socks5.Socks5BytestreamManager; + +/** + * BytestreamManager provides a generic interface for bytestream managers. + * + * There are two implementations of the interface. See {@link Socks5BytestreamManager} and + * {@link InBandBytestreamManager}. + * + * @author Henning Staib + */ +public interface BytestreamManager { + + /** + * Adds {@link BytestreamListener} that is called for every incoming bytestream request unless + * there is a user specific {@link BytestreamListener} registered. + * + * See {@link Socks5BytestreamManager#addIncomingBytestreamListener(BytestreamListener)} and + * {@link InBandBytestreamManager#addIncomingBytestreamListener(BytestreamListener)} for further + * details. + * + * @param listener the listener to register + */ + public void addIncomingBytestreamListener(BytestreamListener listener); + + /** + * Removes the given listener from the list of listeners for all incoming bytestream requests. + * + * @param listener the listener to remove + */ + public void removeIncomingBytestreamListener(BytestreamListener listener); + + /** + * Adds {@link BytestreamListener} that is called for every incoming bytestream request unless + * there is a user specific {@link BytestreamListener} registered. + * + * Use this method if you are awaiting an incoming bytestream request from a specific user. + * + * See {@link Socks5BytestreamManager#addIncomingBytestreamListener(BytestreamListener, String)} + * and {@link InBandBytestreamManager#addIncomingBytestreamListener(BytestreamListener, String)} + * for further details. + * + * @param listener the listener to register + * @param initiatorJID the JID of the user that wants to establish a bytestream + */ + public void addIncomingBytestreamListener(BytestreamListener listener, String initiatorJID); + + /** + * Removes the listener for the given user. + * + * @param initiatorJID the JID of the user the listener should be removed + */ + public void removeIncomingBytestreamListener(String initiatorJID); + + /** + * Establishes a bytestream with the given user and returns the session to send/receive data + * to/from the user. + * + * Use this method to establish bytestreams to users accepting all incoming bytestream requests + * since this method doesn't provide a way to tell the user something about the data to be sent. + * + * To establish a bytestream after negotiation the kind of data to be sent (e.g. file transfer) + * use {@link #establishSession(String, String)}. + * + * See {@link Socks5BytestreamManager#establishSession(String)} and + * {@link InBandBytestreamManager#establishSession(String)} for further details. + * + * @param targetJID the JID of the user a bytestream should be established + * @return the session to send/receive data to/from the user + * @throws XMPPException if an error occurred while establishing the session + * @throws IOException if an IO error occurred while establishing the session + * @throws InterruptedException if the thread was interrupted while waiting in a blocking + * operation + */ + public BytestreamSession establishSession(String targetJID) throws XMPPException, IOException, + InterruptedException; + + /** + * Establishes a bytestream with the given user and returns the session to send/receive data + * to/from the user. + * + * See {@link Socks5BytestreamManager#establishSession(String)} and + * {@link InBandBytestreamManager#establishSession(String)} for further details. + * + * @param targetJID the JID of the user a bytestream should be established + * @param sessionID the session ID for the bytestream request + * @return the session to send/receive data to/from the user + * @throws XMPPException if an error occurred while establishing the session + * @throws IOException if an IO error occurred while establishing the session + * @throws InterruptedException if the thread was interrupted while waiting in a blocking + * operation + */ + public BytestreamSession establishSession(String targetJID, String sessionID) + throws XMPPException, IOException, InterruptedException; + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/BytestreamRequest.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/BytestreamRequest.java new file mode 100644 index 0000000..e368bad --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/BytestreamRequest.java @@ -0,0 +1,59 @@ +/** + * 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.smackx.bytestreams; + +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smackx.bytestreams.ibb.InBandBytestreamRequest; +import org.jivesoftware.smackx.bytestreams.socks5.Socks5BytestreamRequest; + +/** + * BytestreamRequest provides an interface to handle incoming bytestream requests. + * + * There are two implementations of the interface. See {@link Socks5BytestreamRequest} and + * {@link InBandBytestreamRequest}. + * + * @author Henning Staib + */ +public interface BytestreamRequest { + + /** + * Returns the sender of the bytestream open request. + * + * @return the sender of the bytestream open request + */ + public String getFrom(); + + /** + * Returns the session ID of the bytestream open request. + * + * @return the session ID of the bytestream open request + */ + public String getSessionID(); + + /** + * Accepts the bytestream open request and returns the session to send/receive data. + * + * @return the session to send/receive data + * @throws XMPPException if an error occurred while accepting the bytestream request + * @throws InterruptedException if the thread was interrupted while waiting in a blocking + * operation + */ + public BytestreamSession accept() throws XMPPException, InterruptedException; + + /** + * Rejects the bytestream request by sending a reject error to the initiator. + */ + public void reject(); + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/BytestreamSession.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/BytestreamSession.java new file mode 100644 index 0000000..7aafc35 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/BytestreamSession.java @@ -0,0 +1,81 @@ +/** + * 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.smackx.bytestreams; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; + +import org.jivesoftware.smackx.bytestreams.ibb.InBandBytestreamSession; +import org.jivesoftware.smackx.bytestreams.socks5.Socks5BytestreamSession; + +/** + * BytestreamSession provides an interface for established bytestream sessions. + * + * There are two implementations of the interface. See {@link Socks5BytestreamSession} and + * {@link InBandBytestreamSession}. + * + * @author Henning Staib + */ +public interface BytestreamSession { + + /** + * Returns the InputStream associated with this session to send data. + * + * @return the InputStream associated with this session to send data + * @throws IOException if an error occurs while retrieving the input stream + */ + public InputStream getInputStream() throws IOException; + + /** + * Returns the OutputStream associated with this session to receive data. + * + * @return the OutputStream associated with this session to receive data + * @throws IOException if an error occurs while retrieving the output stream + */ + public OutputStream getOutputStream() throws IOException; + + /** + * Closes the bytestream session. + * + * Closing the session will also close the input stream and the output stream associated to this + * session. + * + * @throws IOException if an error occurs while closing the session + */ + public void close() throws IOException; + + /** + * Returns the timeout for read operations of the input stream associated with this session. 0 + * returns implies that the option is disabled (i.e., timeout of infinity). Default is 0. + * + * @return the timeout for read operations + * @throws IOException if there is an error in the underlying protocol + */ + public int getReadTimeout() throws IOException; + + /** + * Sets the specified timeout, in milliseconds. With this option set to a non-zero timeout, a + * read() call on the input stream associated with this session will block for only this amount + * of time. If the timeout expires, a java.net.SocketTimeoutException is raised, though the + * session is still valid. The option must be enabled prior to entering the blocking operation + * to have effect. The timeout must be > 0. A timeout of zero is interpreted as an infinite + * timeout. Default is 0. + * + * @param timeout the specified timeout, in milliseconds + * @throws IOException if there is an error in the underlying protocol + */ + public void setReadTimeout(int timeout) throws IOException; + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/CloseListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/CloseListener.java new file mode 100644 index 0000000..7690e95 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/CloseListener.java @@ -0,0 +1,75 @@ +/** + * 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.smackx.bytestreams.ibb; + +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.filter.AndFilter; +import org.jivesoftware.smack.filter.IQTypeFilter; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smackx.bytestreams.ibb.packet.Close; + +/** + * CloseListener handles all In-Band Bytestream close requests. + * + * If a close request is received it looks if a stored In-Band Bytestream + * session exists and closes it. If no session with the given session ID exists + * an <item-not-found/> error is returned to the sender. + * + * @author Henning Staib + */ +class CloseListener implements PacketListener { + + /* manager containing the listeners and the XMPP connection */ + private final InBandBytestreamManager manager; + + /* packet filter for all In-Band Bytestream close requests */ + private final PacketFilter closeFilter = new AndFilter(new PacketTypeFilter( + Close.class), new IQTypeFilter(IQ.Type.SET)); + + /** + * Constructor. + * + * @param manager the In-Band Bytestream manager + */ + protected CloseListener(InBandBytestreamManager manager) { + this.manager = manager; + } + + public void processPacket(Packet packet) { + Close closeRequest = (Close) packet; + InBandBytestreamSession ibbSession = this.manager.getSessions().get( + closeRequest.getSessionID()); + if (ibbSession == null) { + this.manager.replyItemNotFoundPacket(closeRequest); + } + else { + ibbSession.closeByPeer(closeRequest); + this.manager.getSessions().remove(closeRequest.getSessionID()); + } + + } + + /** + * Returns the packet filter for In-Band Bytestream close requests. + * + * @return the packet filter for In-Band Bytestream close requests + */ + protected PacketFilter getFilter() { + return this.closeFilter; + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/DataListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/DataListener.java new file mode 100644 index 0000000..166c146 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/DataListener.java @@ -0,0 +1,73 @@ +/** + * 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.smackx.bytestreams.ibb; + +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.filter.AndFilter; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smackx.bytestreams.ibb.packet.Data; + +/** + * DataListener handles all In-Band Bytestream IQ stanzas containing a data + * packet extension that don't belong to an existing session. + * + * If a data packet is received it looks if a stored In-Band Bytestream session + * exists. If no session with the given session ID exists an + * <item-not-found/> error is returned to the sender. + * + * Data packets belonging to a running In-Band Bytestream session are processed + * by more specific listeners registered when an {@link InBandBytestreamSession} + * is created. + * + * @author Henning Staib + */ +class DataListener implements PacketListener { + + /* manager containing the listeners and the XMPP connection */ + private final InBandBytestreamManager manager; + + /* packet filter for all In-Band Bytestream data packets */ + private final PacketFilter dataFilter = new AndFilter( + new PacketTypeFilter(Data.class)); + + /** + * Constructor. + * + * @param manager the In-Band Bytestream manager + */ + public DataListener(InBandBytestreamManager manager) { + this.manager = manager; + } + + public void processPacket(Packet packet) { + Data data = (Data) packet; + InBandBytestreamSession ibbSession = this.manager.getSessions().get( + data.getDataPacketExtension().getSessionID()); + if (ibbSession == null) { + this.manager.replyItemNotFoundPacket(data); + } + } + + /** + * Returns the packet filter for In-Band Bytestream data packets. + * + * @return the packet filter for In-Band Bytestream data packets + */ + protected PacketFilter getFilter() { + return this.dataFilter; + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamListener.java new file mode 100644 index 0000000..68791a6 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamListener.java @@ -0,0 +1,46 @@ +/** + * 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.smackx.bytestreams.ibb; + +import org.jivesoftware.smackx.bytestreams.BytestreamListener; +import org.jivesoftware.smackx.bytestreams.BytestreamRequest; + +/** + * InBandBytestreamListener are informed if a remote user wants to initiate an In-Band Bytestream. + * Implement this interface to handle incoming In-Band Bytestream requests. + * + * There are two ways to add this listener. See + * {@link InBandBytestreamManager#addIncomingBytestreamListener(BytestreamListener)} and + * {@link InBandBytestreamManager#addIncomingBytestreamListener(BytestreamListener, String)} for + * further details. + * + * @author Henning Staib + */ +public abstract class InBandBytestreamListener implements BytestreamListener { + + + + public void incomingBytestreamRequest(BytestreamRequest request) { + incomingBytestreamRequest((InBandBytestreamRequest) request); + } + + /** + * This listener is notified if an In-Band Bytestream request from another user has been + * received. + * + * @param request the incoming In-Band Bytestream request + */ + public abstract void incomingBytestreamRequest(InBandBytestreamRequest request); + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamManager.java new file mode 100644 index 0000000..ef52531 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamManager.java @@ -0,0 +1,546 @@ +/** + * 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.smackx.bytestreams.ibb; + +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Random; +import java.util.concurrent.ConcurrentHashMap; + +import org.jivesoftware.smack.AbstractConnectionListener; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.ConnectionCreationListener; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.XMPPError; +import org.jivesoftware.smack.util.SyncPacketSend; +import org.jivesoftware.smackx.bytestreams.BytestreamListener; +import org.jivesoftware.smackx.bytestreams.BytestreamManager; +import org.jivesoftware.smackx.bytestreams.ibb.packet.Open; +import org.jivesoftware.smackx.filetransfer.FileTransferManager; + +/** + * The InBandBytestreamManager class handles establishing In-Band Bytestreams as specified in the <a + * href="http://xmpp.org/extensions/xep-0047.html">XEP-0047</a>. + * + * The In-Band Bytestreams (IBB) enables two entities to establish a virtual bytestream over which + * they can exchange Base64-encoded chunks of data over XMPP itself. It is the fall-back mechanism + * in case the Socks5 bytestream method of transferring data is not available. + * + * There are two ways to send data over an In-Band Bytestream. It could either use IQ stanzas to + * send data packets or message stanzas. If IQ stanzas are used every data packet is acknowledged by + * the receiver. This is the recommended way to avoid possible rate-limiting penalties. Message + * stanzas are not acknowledged because most XMPP server implementation don't support stanza + * flow-control method like <a href="http://xmpp.org/extensions/xep-0079.html">Advanced Message + * Processing</a>. To set the stanza that should be used invoke {@link #setStanza(StanzaType)}. + * + * To establish an In-Band Bytestream invoke the {@link #establishSession(String)} method. This will + * negotiate an in-band bytestream with the given target JID and return a session. + * + * If a session ID for the In-Band Bytestream was already negotiated (e.g. while negotiating a file + * transfer) invoke {@link #establishSession(String, String)}. + * + * To handle incoming In-Band Bytestream requests add an {@link InBandBytestreamListener} to the + * manager. There are two ways to add this listener. If you want to be informed about incoming + * In-Band Bytestreams from a specific user add the listener by invoking + * {@link #addIncomingBytestreamListener(BytestreamListener, String)}. If the listener should + * respond to all In-Band Bytestream requests invoke + * {@link #addIncomingBytestreamListener(BytestreamListener)}. + * + * Note that the registered {@link InBandBytestreamListener} will NOT be notified on incoming + * In-Band bytestream requests sent in the context of <a + * href="http://xmpp.org/extensions/xep-0096.html">XEP-0096</a> file transfer. (See + * {@link FileTransferManager}) + * + * If no {@link InBandBytestreamListener}s are registered, all incoming In-Band bytestream requests + * will be rejected by returning a <not-acceptable/> error to the initiator. + * + * @author Henning Staib + */ +public class InBandBytestreamManager implements BytestreamManager { + + /** + * Stanzas that can be used to encapsulate In-Band Bytestream data packets. + */ + public enum StanzaType { + + /** + * IQ stanza. + */ + IQ, + + /** + * Message stanza. + */ + MESSAGE + } + + /* + * create a new InBandBytestreamManager and register its shutdown listener on every established + * connection + */ + static { + Connection.addConnectionCreationListener(new ConnectionCreationListener() { + public void connectionCreated(Connection connection) { + final InBandBytestreamManager manager; + manager = InBandBytestreamManager.getByteStreamManager(connection); + + // register shutdown listener + connection.addConnectionListener(new AbstractConnectionListener() { + + public void connectionClosed() { + manager.disableService(); + } + + }); + + } + }); + } + + /** + * The XMPP namespace of the In-Band Bytestream + */ + public static final String NAMESPACE = "http://jabber.org/protocol/ibb"; + + /** + * Maximum block size that is allowed for In-Band Bytestreams + */ + public static final int MAXIMUM_BLOCK_SIZE = 65535; + + /* prefix used to generate session IDs */ + private static final String SESSION_ID_PREFIX = "jibb_"; + + /* random generator to create session IDs */ + private final static Random randomGenerator = new Random(); + + /* stores one InBandBytestreamManager for each XMPP connection */ + private final static Map<Connection, InBandBytestreamManager> managers = new HashMap<Connection, InBandBytestreamManager>(); + + /* XMPP connection */ + private final Connection connection; + + /* + * assigns a user to a listener that is informed if an In-Band Bytestream request for this user + * is received + */ + private final Map<String, BytestreamListener> userListeners = new ConcurrentHashMap<String, BytestreamListener>(); + + /* + * list of listeners that respond to all In-Band Bytestream requests if there are no user + * specific listeners for that request + */ + private final List<BytestreamListener> allRequestListeners = Collections.synchronizedList(new LinkedList<BytestreamListener>()); + + /* listener that handles all incoming In-Band Bytestream requests */ + private final InitiationListener initiationListener; + + /* listener that handles all incoming In-Band Bytestream IQ data packets */ + private final DataListener dataListener; + + /* listener that handles all incoming In-Band Bytestream close requests */ + private final CloseListener closeListener; + + /* assigns a session ID to the In-Band Bytestream session */ + private final Map<String, InBandBytestreamSession> sessions = new ConcurrentHashMap<String, InBandBytestreamSession>(); + + /* block size used for new In-Band Bytestreams */ + private int defaultBlockSize = 4096; + + /* maximum block size allowed for this connection */ + private int maximumBlockSize = MAXIMUM_BLOCK_SIZE; + + /* the stanza used to send data packets */ + private StanzaType stanza = StanzaType.IQ; + + /* + * list containing session IDs of In-Band Bytestream open packets that should be ignored by the + * InitiationListener + */ + private List<String> ignoredBytestreamRequests = Collections.synchronizedList(new LinkedList<String>()); + + /** + * Returns the InBandBytestreamManager to handle In-Band Bytestreams for a given + * {@link Connection}. + * + * @param connection the XMPP connection + * @return the InBandBytestreamManager for the given XMPP connection + */ + public static synchronized InBandBytestreamManager getByteStreamManager(Connection connection) { + if (connection == null) + return null; + InBandBytestreamManager manager = managers.get(connection); + if (manager == null) { + manager = new InBandBytestreamManager(connection); + managers.put(connection, manager); + } + return manager; + } + + /** + * Constructor. + * + * @param connection the XMPP connection + */ + private InBandBytestreamManager(Connection connection) { + this.connection = connection; + + // register bytestream open packet listener + this.initiationListener = new InitiationListener(this); + this.connection.addPacketListener(this.initiationListener, + this.initiationListener.getFilter()); + + // register bytestream data packet listener + this.dataListener = new DataListener(this); + this.connection.addPacketListener(this.dataListener, this.dataListener.getFilter()); + + // register bytestream close packet listener + this.closeListener = new CloseListener(this); + this.connection.addPacketListener(this.closeListener, this.closeListener.getFilter()); + + } + + /** + * Adds InBandBytestreamListener that is called for every incoming in-band bytestream request + * unless there is a user specific InBandBytestreamListener registered. + * + * If no listeners are registered all In-Band Bytestream request are rejected with a + * <not-acceptable/> error. + * + * Note that the registered {@link InBandBytestreamListener} will NOT be notified on incoming + * Socks5 bytestream requests sent in the context of <a + * href="http://xmpp.org/extensions/xep-0096.html">XEP-0096</a> file transfer. (See + * {@link FileTransferManager}) + * + * @param listener the listener to register + */ + public void addIncomingBytestreamListener(BytestreamListener listener) { + this.allRequestListeners.add(listener); + } + + /** + * Removes the given listener from the list of listeners for all incoming In-Band Bytestream + * requests. + * + * @param listener the listener to remove + */ + public void removeIncomingBytestreamListener(BytestreamListener listener) { + this.allRequestListeners.remove(listener); + } + + /** + * Adds InBandBytestreamListener that is called for every incoming in-band bytestream request + * from the given user. + * + * Use this method if you are awaiting an incoming Socks5 bytestream request from a specific + * user. + * + * If no listeners are registered all In-Band Bytestream request are rejected with a + * <not-acceptable/> error. + * + * Note that the registered {@link InBandBytestreamListener} will NOT be notified on incoming + * Socks5 bytestream requests sent in the context of <a + * href="http://xmpp.org/extensions/xep-0096.html">XEP-0096</a> file transfer. (See + * {@link FileTransferManager}) + * + * @param listener the listener to register + * @param initiatorJID the JID of the user that wants to establish an In-Band Bytestream + */ + public void addIncomingBytestreamListener(BytestreamListener listener, String initiatorJID) { + this.userListeners.put(initiatorJID, listener); + } + + /** + * Removes the listener for the given user. + * + * @param initiatorJID the JID of the user the listener should be removed + */ + public void removeIncomingBytestreamListener(String initiatorJID) { + this.userListeners.remove(initiatorJID); + } + + /** + * Use this method to ignore the next incoming In-Band Bytestream request containing the given + * session ID. No listeners will be notified for this request and and no error will be returned + * to the initiator. + * + * This method should be used if you are awaiting an In-Band Bytestream request as a reply to + * another packet (e.g. file transfer). + * + * @param sessionID to be ignored + */ + public void ignoreBytestreamRequestOnce(String sessionID) { + this.ignoredBytestreamRequests.add(sessionID); + } + + /** + * Returns the default block size that is used for all outgoing in-band bytestreams for this + * connection. + * + * The recommended default block size is 4096 bytes. See <a + * href="http://xmpp.org/extensions/xep-0047.html#usage">XEP-0047</a> Section 5. + * + * @return the default block size + */ + public int getDefaultBlockSize() { + return defaultBlockSize; + } + + /** + * Sets the default block size that is used for all outgoing in-band bytestreams for this + * connection. + * + * The default block size must be between 1 and 65535 bytes. The recommended default block size + * is 4096 bytes. See <a href="http://xmpp.org/extensions/xep-0047.html#usage">XEP-0047</a> + * Section 5. + * + * @param defaultBlockSize the default block size to set + */ + public void setDefaultBlockSize(int defaultBlockSize) { + if (defaultBlockSize <= 0 || defaultBlockSize > MAXIMUM_BLOCK_SIZE) { + throw new IllegalArgumentException("Default block size must be between 1 and " + + MAXIMUM_BLOCK_SIZE); + } + this.defaultBlockSize = defaultBlockSize; + } + + /** + * Returns the maximum block size that is allowed for In-Band Bytestreams for this connection. + * + * Incoming In-Band Bytestream open request will be rejected with an + * <resource-constraint/> error if the block size is greater then the maximum allowed + * block size. + * + * The default maximum block size is 65535 bytes. + * + * @return the maximum block size + */ + public int getMaximumBlockSize() { + return maximumBlockSize; + } + + /** + * Sets the maximum block size that is allowed for In-Band Bytestreams for this connection. + * + * The maximum block size must be between 1 and 65535 bytes. + * + * Incoming In-Band Bytestream open request will be rejected with an + * <resource-constraint/> error if the block size is greater then the maximum allowed + * block size. + * + * @param maximumBlockSize the maximum block size to set + */ + public void setMaximumBlockSize(int maximumBlockSize) { + if (maximumBlockSize <= 0 || maximumBlockSize > MAXIMUM_BLOCK_SIZE) { + throw new IllegalArgumentException("Maximum block size must be between 1 and " + + MAXIMUM_BLOCK_SIZE); + } + this.maximumBlockSize = maximumBlockSize; + } + + /** + * Returns the stanza used to send data packets. + * + * Default is {@link StanzaType#IQ}. See <a + * href="http://xmpp.org/extensions/xep-0047.html#message">XEP-0047</a> Section 4. + * + * @return the stanza used to send data packets + */ + public StanzaType getStanza() { + return stanza; + } + + /** + * Sets the stanza used to send data packets. + * + * The use of {@link StanzaType#IQ} is recommended. See <a + * href="http://xmpp.org/extensions/xep-0047.html#message">XEP-0047</a> Section 4. + * + * @param stanza the stanza to set + */ + public void setStanza(StanzaType stanza) { + this.stanza = stanza; + } + + /** + * Establishes an In-Band Bytestream with the given user and returns the session to send/receive + * data to/from the user. + * + * Use this method to establish In-Band Bytestreams to users accepting all incoming In-Band + * Bytestream requests since this method doesn't provide a way to tell the user something about + * the data to be sent. + * + * To establish an In-Band Bytestream after negotiation the kind of data to be sent (e.g. file + * transfer) use {@link #establishSession(String, String)}. + * + * @param targetJID the JID of the user an In-Band Bytestream should be established + * @return the session to send/receive data to/from the user + * @throws XMPPException if the user doesn't support or accept in-band bytestreams, or if the + * user prefers smaller block sizes + */ + public InBandBytestreamSession establishSession(String targetJID) throws XMPPException { + String sessionID = getNextSessionID(); + return establishSession(targetJID, sessionID); + } + + /** + * Establishes an In-Band Bytestream with the given user using the given session ID and returns + * the session to send/receive data to/from the user. + * + * @param targetJID the JID of the user an In-Band Bytestream should be established + * @param sessionID the session ID for the In-Band Bytestream request + * @return the session to send/receive data to/from the user + * @throws XMPPException if the user doesn't support or accept in-band bytestreams, or if the + * user prefers smaller block sizes + */ + public InBandBytestreamSession establishSession(String targetJID, String sessionID) + throws XMPPException { + Open byteStreamRequest = new Open(sessionID, this.defaultBlockSize, this.stanza); + byteStreamRequest.setTo(targetJID); + + // sending packet will throw exception on timeout or error reply + SyncPacketSend.getReply(this.connection, byteStreamRequest); + + InBandBytestreamSession inBandBytestreamSession = new InBandBytestreamSession( + this.connection, byteStreamRequest, targetJID); + this.sessions.put(sessionID, inBandBytestreamSession); + + return inBandBytestreamSession; + } + + /** + * Responses to the given IQ packet's sender with an XMPP error that an In-Band Bytestream is + * not accepted. + * + * @param request IQ packet that should be answered with a not-acceptable error + */ + protected void replyRejectPacket(IQ request) { + XMPPError xmppError = new XMPPError(XMPPError.Condition.no_acceptable); + IQ error = IQ.createErrorResponse(request, xmppError); + this.connection.sendPacket(error); + } + + /** + * Responses to the given IQ packet's sender with an XMPP error that an In-Band Bytestream open + * request is rejected because its block size is greater than the maximum allowed block size. + * + * @param request IQ packet that should be answered with a resource-constraint error + */ + protected void replyResourceConstraintPacket(IQ request) { + XMPPError xmppError = new XMPPError(XMPPError.Condition.resource_constraint); + IQ error = IQ.createErrorResponse(request, xmppError); + this.connection.sendPacket(error); + } + + /** + * Responses to the given IQ packet's sender with an XMPP error that an In-Band Bytestream + * session could not be found. + * + * @param request IQ packet that should be answered with a item-not-found error + */ + protected void replyItemNotFoundPacket(IQ request) { + XMPPError xmppError = new XMPPError(XMPPError.Condition.item_not_found); + IQ error = IQ.createErrorResponse(request, xmppError); + this.connection.sendPacket(error); + } + + /** + * Returns a new unique session ID. + * + * @return a new unique session ID + */ + private String getNextSessionID() { + StringBuilder buffer = new StringBuilder(); + buffer.append(SESSION_ID_PREFIX); + buffer.append(Math.abs(randomGenerator.nextLong())); + return buffer.toString(); + } + + /** + * Returns the XMPP connection. + * + * @return the XMPP connection + */ + protected Connection getConnection() { + return this.connection; + } + + /** + * Returns the {@link InBandBytestreamListener} that should be informed if a In-Band Bytestream + * request from the given initiator JID is received. + * + * @param initiator the initiator's JID + * @return the listener + */ + protected BytestreamListener getUserListener(String initiator) { + return this.userListeners.get(initiator); + } + + /** + * Returns a list of {@link InBandBytestreamListener} that are informed if there are no + * listeners for a specific initiator. + * + * @return list of listeners + */ + protected List<BytestreamListener> getAllRequestListeners() { + return this.allRequestListeners; + } + + /** + * Returns the sessions map. + * + * @return the sessions map + */ + protected Map<String, InBandBytestreamSession> getSessions() { + return sessions; + } + + /** + * Returns the list of session IDs that should be ignored by the InitialtionListener + * + * @return list of session IDs + */ + protected List<String> getIgnoredBytestreamRequests() { + return ignoredBytestreamRequests; + } + + /** + * Disables the InBandBytestreamManager by removing its packet listeners and resetting its + * internal status. + */ + private void disableService() { + + // remove manager from static managers map + managers.remove(connection); + + // remove all listeners registered by this manager + this.connection.removePacketListener(this.initiationListener); + this.connection.removePacketListener(this.dataListener); + this.connection.removePacketListener(this.closeListener); + + // shutdown threads + this.initiationListener.shutdown(); + + // reset internal status + this.userListeners.clear(); + this.allRequestListeners.clear(); + this.sessions.clear(); + this.ignoredBytestreamRequests.clear(); + + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamRequest.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamRequest.java new file mode 100644 index 0000000..5bc689a --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamRequest.java @@ -0,0 +1,92 @@ +/** + * 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.smackx.bytestreams.ibb; + +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smackx.bytestreams.BytestreamRequest; +import org.jivesoftware.smackx.bytestreams.ibb.packet.Open; + +/** + * InBandBytestreamRequest class handles incoming In-Band Bytestream requests. + * + * @author Henning Staib + */ +public class InBandBytestreamRequest implements BytestreamRequest { + + /* the bytestream initialization request */ + private final Open byteStreamRequest; + + /* + * In-Band Bytestream manager containing the XMPP connection and helper + * methods + */ + private final InBandBytestreamManager manager; + + protected InBandBytestreamRequest(InBandBytestreamManager manager, + Open byteStreamRequest) { + this.manager = manager; + this.byteStreamRequest = byteStreamRequest; + } + + /** + * Returns the sender of the In-Band Bytestream open request. + * + * @return the sender of the In-Band Bytestream open request + */ + public String getFrom() { + return this.byteStreamRequest.getFrom(); + } + + /** + * Returns the session ID of the In-Band Bytestream open request. + * + * @return the session ID of the In-Band Bytestream open request + */ + public String getSessionID() { + return this.byteStreamRequest.getSessionID(); + } + + /** + * Accepts the In-Band Bytestream open request and returns the session to + * send/receive data. + * + * @return the session to send/receive data + * @throws XMPPException if stream is invalid. + */ + public InBandBytestreamSession accept() throws XMPPException { + Connection connection = this.manager.getConnection(); + + // create In-Band Bytestream session and store it + InBandBytestreamSession ibbSession = new InBandBytestreamSession(connection, + this.byteStreamRequest, this.byteStreamRequest.getFrom()); + this.manager.getSessions().put(this.byteStreamRequest.getSessionID(), ibbSession); + + // acknowledge request + IQ resultIQ = IQ.createResultIQ(this.byteStreamRequest); + connection.sendPacket(resultIQ); + + return ibbSession; + } + + /** + * Rejects the In-Band Bytestream request by sending a reject error to the + * initiator. + */ + public void reject() { + this.manager.replyRejectPacket(this.byteStreamRequest); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamSession.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamSession.java new file mode 100644 index 0000000..1cced78 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InBandBytestreamSession.java @@ -0,0 +1,795 @@ +/** + * 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.smackx.bytestreams.ibb; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.SocketTimeoutException; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.TimeUnit; + +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.filter.AndFilter; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.packet.PacketExtension; +import org.jivesoftware.smack.packet.XMPPError; +import org.jivesoftware.smack.util.StringUtils; +import org.jivesoftware.smack.util.SyncPacketSend; +import org.jivesoftware.smackx.bytestreams.BytestreamSession; +import org.jivesoftware.smackx.bytestreams.ibb.packet.Close; +import org.jivesoftware.smackx.bytestreams.ibb.packet.Data; +import org.jivesoftware.smackx.bytestreams.ibb.packet.DataPacketExtension; +import org.jivesoftware.smackx.bytestreams.ibb.packet.Open; + +/** + * InBandBytestreamSession class represents an In-Band Bytestream session. + * + * In-band bytestreams are bidirectional and this session encapsulates the streams for both + * directions. + * + * Note that closing the In-Band Bytestream session will close both streams. If both streams are + * closed individually the session will be closed automatically once the second stream is closed. + * Use the {@link #setCloseBothStreamsEnabled(boolean)} method if both streams should be closed + * automatically if one of them is closed. + * + * @author Henning Staib + */ +public class InBandBytestreamSession implements BytestreamSession { + + /* XMPP connection */ + private final Connection connection; + + /* the In-Band Bytestream open request for this session */ + private final Open byteStreamRequest; + + /* + * the input stream for this session (either IQIBBInputStream or MessageIBBInputStream) + */ + private IBBInputStream inputStream; + + /* + * the output stream for this session (either IQIBBOutputStream or MessageIBBOutputStream) + */ + private IBBOutputStream outputStream; + + /* JID of the remote peer */ + private String remoteJID; + + /* flag to close both streams if one of them is closed */ + private boolean closeBothStreamsEnabled = false; + + /* flag to indicate if session is closed */ + private boolean isClosed = false; + + /** + * Constructor. + * + * @param connection the XMPP connection + * @param byteStreamRequest the In-Band Bytestream open request for this session + * @param remoteJID JID of the remote peer + */ + protected InBandBytestreamSession(Connection connection, Open byteStreamRequest, + String remoteJID) { + this.connection = connection; + this.byteStreamRequest = byteStreamRequest; + this.remoteJID = remoteJID; + + // initialize streams dependent to the uses stanza type + switch (byteStreamRequest.getStanza()) { + case IQ: + this.inputStream = new IQIBBInputStream(); + this.outputStream = new IQIBBOutputStream(); + break; + case MESSAGE: + this.inputStream = new MessageIBBInputStream(); + this.outputStream = new MessageIBBOutputStream(); + break; + } + + } + + public InputStream getInputStream() { + return this.inputStream; + } + + public OutputStream getOutputStream() { + return this.outputStream; + } + + public int getReadTimeout() { + return this.inputStream.readTimeout; + } + + public void setReadTimeout(int timeout) { + if (timeout < 0) { + throw new IllegalArgumentException("Timeout must be >= 0"); + } + this.inputStream.readTimeout = timeout; + } + + /** + * Returns whether both streams should be closed automatically if one of the streams is closed. + * Default is <code>false</code>. + * + * @return <code>true</code> if both streams will be closed if one of the streams is closed, + * <code>false</code> if both streams can be closed independently. + */ + public boolean isCloseBothStreamsEnabled() { + return closeBothStreamsEnabled; + } + + /** + * Sets whether both streams should be closed automatically if one of the streams is closed. + * Default is <code>false</code>. + * + * @param closeBothStreamsEnabled <code>true</code> if both streams should be closed if one of + * the streams is closed, <code>false</code> if both streams should be closed + * independently + */ + public void setCloseBothStreamsEnabled(boolean closeBothStreamsEnabled) { + this.closeBothStreamsEnabled = closeBothStreamsEnabled; + } + + public void close() throws IOException { + closeByLocal(true); // close input stream + closeByLocal(false); // close output stream + } + + /** + * This method is invoked if a request to close the In-Band Bytestream has been received. + * + * @param closeRequest the close request from the remote peer + */ + protected void closeByPeer(Close closeRequest) { + + /* + * close streams without flushing them, because stream is already considered closed on the + * remote peers side + */ + this.inputStream.closeInternal(); + this.inputStream.cleanup(); + this.outputStream.closeInternal(false); + + // acknowledge close request + IQ confirmClose = IQ.createResultIQ(closeRequest); + this.connection.sendPacket(confirmClose); + + } + + /** + * This method is invoked if one of the streams has been closed locally, if an error occurred + * locally or if the whole session should be closed. + * + * @throws IOException if an error occurs while sending the close request + */ + protected synchronized void closeByLocal(boolean in) throws IOException { + if (this.isClosed) { + return; + } + + if (this.closeBothStreamsEnabled) { + this.inputStream.closeInternal(); + this.outputStream.closeInternal(true); + } + else { + if (in) { + this.inputStream.closeInternal(); + } + else { + // close stream but try to send any data left + this.outputStream.closeInternal(true); + } + } + + if (this.inputStream.isClosed && this.outputStream.isClosed) { + this.isClosed = true; + + // send close request + Close close = new Close(this.byteStreamRequest.getSessionID()); + close.setTo(this.remoteJID); + try { + SyncPacketSend.getReply(this.connection, close); + } + catch (XMPPException e) { + throw new IOException("Error while closing stream: " + e.getMessage()); + } + + this.inputStream.cleanup(); + + // remove session from manager + InBandBytestreamManager.getByteStreamManager(this.connection).getSessions().remove(this); + } + + } + + /** + * IBBInputStream class is the base implementation of an In-Band Bytestream input stream. + * Subclasses of this input stream must provide a packet listener along with a packet filter to + * collect the In-Band Bytestream data packets. + */ + private abstract class IBBInputStream extends InputStream { + + /* the data packet listener to fill the data queue */ + private final PacketListener dataPacketListener; + + /* queue containing received In-Band Bytestream data packets */ + protected final BlockingQueue<DataPacketExtension> dataQueue = new LinkedBlockingQueue<DataPacketExtension>(); + + /* buffer containing the data from one data packet */ + private byte[] buffer; + + /* pointer to the next byte to read from buffer */ + private int bufferPointer = -1; + + /* data packet sequence (range from 0 to 65535) */ + private long seq = -1; + + /* flag to indicate if input stream is closed */ + private boolean isClosed = false; + + /* flag to indicate if close method was invoked */ + private boolean closeInvoked = false; + + /* timeout for read operations */ + private int readTimeout = 0; + + /** + * Constructor. + */ + public IBBInputStream() { + // add data packet listener to connection + this.dataPacketListener = getDataPacketListener(); + connection.addPacketListener(this.dataPacketListener, getDataPacketFilter()); + } + + /** + * Returns the packet listener that processes In-Band Bytestream data packets. + * + * @return the data packet listener + */ + protected abstract PacketListener getDataPacketListener(); + + /** + * Returns the packet filter that accepts In-Band Bytestream data packets. + * + * @return the data packet filter + */ + protected abstract PacketFilter getDataPacketFilter(); + + public synchronized int read() throws IOException { + checkClosed(); + + // if nothing read yet or whole buffer has been read fill buffer + if (bufferPointer == -1 || bufferPointer >= buffer.length) { + // if no data available and stream was closed return -1 + if (!loadBuffer()) { + return -1; + } + } + + // return byte and increment buffer pointer + return (int) buffer[bufferPointer++]; + } + + public synchronized int read(byte[] b, int off, int len) throws IOException { + if (b == null) { + throw new NullPointerException(); + } + else if ((off < 0) || (off > b.length) || (len < 0) || ((off + len) > b.length) + || ((off + len) < 0)) { + throw new IndexOutOfBoundsException(); + } + else if (len == 0) { + return 0; + } + + checkClosed(); + + // if nothing read yet or whole buffer has been read fill buffer + if (bufferPointer == -1 || bufferPointer >= buffer.length) { + // if no data available and stream was closed return -1 + if (!loadBuffer()) { + return -1; + } + } + + // if more bytes wanted than available return all available + int bytesAvailable = buffer.length - bufferPointer; + if (len > bytesAvailable) { + len = bytesAvailable; + } + + System.arraycopy(buffer, bufferPointer, b, off, len); + bufferPointer += len; + return len; + } + + public synchronized int read(byte[] b) throws IOException { + return read(b, 0, b.length); + } + + /** + * This method blocks until a data packet is received, the stream is closed or the current + * thread is interrupted. + * + * @return <code>true</code> if data was received, otherwise <code>false</code> + * @throws IOException if data packets are out of sequence + */ + private synchronized boolean loadBuffer() throws IOException { + + // wait until data is available or stream is closed + DataPacketExtension data = null; + try { + if (this.readTimeout == 0) { + while (data == null) { + if (isClosed && this.dataQueue.isEmpty()) { + return false; + } + data = this.dataQueue.poll(1000, TimeUnit.MILLISECONDS); + } + } + else { + data = this.dataQueue.poll(this.readTimeout, TimeUnit.MILLISECONDS); + if (data == null) { + throw new SocketTimeoutException(); + } + } + } + catch (InterruptedException e) { + // Restore the interrupted status + Thread.currentThread().interrupt(); + return false; + } + + // handle sequence overflow + if (this.seq == 65535) { + this.seq = -1; + } + + // check if data packets sequence is successor of last seen sequence + long seq = data.getSeq(); + if (seq - 1 != this.seq) { + // packets out of order; close stream/session + InBandBytestreamSession.this.close(); + throw new IOException("Packets out of sequence"); + } + else { + this.seq = seq; + } + + // set buffer to decoded data + buffer = data.getDecodedData(); + bufferPointer = 0; + return true; + } + + /** + * Checks if this stream is closed and throws an IOException if necessary + * + * @throws IOException if stream is closed and no data should be read anymore + */ + private void checkClosed() throws IOException { + /* throw no exception if there is data available, but not if close method was invoked */ + if ((isClosed && this.dataQueue.isEmpty()) || closeInvoked) { + // clear data queue in case additional data was received after stream was closed + this.dataQueue.clear(); + throw new IOException("Stream is closed"); + } + } + + public boolean markSupported() { + return false; + } + + public void close() throws IOException { + if (isClosed) { + return; + } + + this.closeInvoked = true; + + InBandBytestreamSession.this.closeByLocal(true); + } + + /** + * This method sets the close flag and removes the data packet listener. + */ + private void closeInternal() { + if (isClosed) { + return; + } + isClosed = true; + } + + /** + * Invoked if the session is closed. + */ + private void cleanup() { + connection.removePacketListener(this.dataPacketListener); + } + + } + + /** + * IQIBBInputStream class implements IBBInputStream to be used with IQ stanzas encapsulating the + * data packets. + */ + private class IQIBBInputStream extends IBBInputStream { + + protected PacketListener getDataPacketListener() { + return new PacketListener() { + + private long lastSequence = -1; + + public void processPacket(Packet packet) { + // get data packet extension + DataPacketExtension data = (DataPacketExtension) packet.getExtension( + DataPacketExtension.ELEMENT_NAME, + InBandBytestreamManager.NAMESPACE); + + /* + * check if sequence was not used already (see XEP-0047 Section 2.2) + */ + if (data.getSeq() <= this.lastSequence) { + IQ unexpectedRequest = IQ.createErrorResponse((IQ) packet, new XMPPError( + XMPPError.Condition.unexpected_request)); + connection.sendPacket(unexpectedRequest); + return; + + } + + // check if encoded data is valid (see XEP-0047 Section 2.2) + if (data.getDecodedData() == null) { + // data is invalid; respond with bad-request error + IQ badRequest = IQ.createErrorResponse((IQ) packet, new XMPPError( + XMPPError.Condition.bad_request)); + connection.sendPacket(badRequest); + return; + } + + // data is valid; add to data queue + dataQueue.offer(data); + + // confirm IQ + IQ confirmData = IQ.createResultIQ((IQ) packet); + connection.sendPacket(confirmData); + + // set last seen sequence + this.lastSequence = data.getSeq(); + if (this.lastSequence == 65535) { + this.lastSequence = -1; + } + + } + + }; + } + + protected PacketFilter getDataPacketFilter() { + /* + * filter all IQ stanzas having type 'SET' (represented by Data class), containing a + * data packet extension, matching session ID and recipient + */ + return new AndFilter(new PacketTypeFilter(Data.class), new IBBDataPacketFilter()); + } + + } + + /** + * MessageIBBInputStream class implements IBBInputStream to be used with message stanzas + * encapsulating the data packets. + */ + private class MessageIBBInputStream extends IBBInputStream { + + protected PacketListener getDataPacketListener() { + return new PacketListener() { + + public void processPacket(Packet packet) { + // get data packet extension + DataPacketExtension data = (DataPacketExtension) packet.getExtension( + DataPacketExtension.ELEMENT_NAME, + InBandBytestreamManager.NAMESPACE); + + // check if encoded data is valid + if (data.getDecodedData() == null) { + /* + * TODO once a majority of XMPP server implementation support XEP-0079 + * Advanced Message Processing the invalid message could be answered with an + * appropriate error. For now we just ignore the packet. Subsequent packets + * with an increased sequence will cause the input stream to close the + * stream/session. + */ + return; + } + + // data is valid; add to data queue + dataQueue.offer(data); + + // TODO confirm packet once XMPP servers support XEP-0079 + } + + }; + } + + @Override + protected PacketFilter getDataPacketFilter() { + /* + * filter all message stanzas containing a data packet extension, matching session ID + * and recipient + */ + return new AndFilter(new PacketTypeFilter(Message.class), new IBBDataPacketFilter()); + } + + } + + /** + * IBBDataPacketFilter class filters all packets from the remote peer of this session, + * containing an In-Band Bytestream data packet extension whose session ID matches this sessions + * ID. + */ + private class IBBDataPacketFilter implements PacketFilter { + + public boolean accept(Packet packet) { + // sender equals remote peer + if (!packet.getFrom().equalsIgnoreCase(remoteJID)) { + return false; + } + + // stanza contains data packet extension + PacketExtension packetExtension = packet.getExtension(DataPacketExtension.ELEMENT_NAME, + InBandBytestreamManager.NAMESPACE); + if (packetExtension == null || !(packetExtension instanceof DataPacketExtension)) { + return false; + } + + // session ID equals this session ID + DataPacketExtension data = (DataPacketExtension) packetExtension; + if (!data.getSessionID().equals(byteStreamRequest.getSessionID())) { + return false; + } + + return true; + } + + } + + /** + * IBBOutputStream class is the base implementation of an In-Band Bytestream output stream. + * Subclasses of this output stream must provide a method to send data over XMPP stream. + */ + private abstract class IBBOutputStream extends OutputStream { + + /* buffer with the size of this sessions block size */ + protected final byte[] buffer; + + /* pointer to next byte to write to buffer */ + protected int bufferPointer = 0; + + /* data packet sequence (range from 0 to 65535) */ + protected long seq = 0; + + /* flag to indicate if output stream is closed */ + protected boolean isClosed = false; + + /** + * Constructor. + */ + public IBBOutputStream() { + this.buffer = new byte[(byteStreamRequest.getBlockSize()/4)*3]; + } + + /** + * Writes the given data packet to the XMPP stream. + * + * @param data the data packet + * @throws IOException if an I/O error occurred while sending or if the stream is closed + */ + protected abstract void writeToXML(DataPacketExtension data) throws IOException; + + public synchronized void write(int b) throws IOException { + if (this.isClosed) { + throw new IOException("Stream is closed"); + } + + // if buffer is full flush buffer + if (bufferPointer >= buffer.length) { + flushBuffer(); + } + + buffer[bufferPointer++] = (byte) b; + } + + public synchronized void write(byte b[], int off, int len) throws IOException { + if (b == null) { + throw new NullPointerException(); + } + else if ((off < 0) || (off > b.length) || (len < 0) || ((off + len) > b.length) + || ((off + len) < 0)) { + throw new IndexOutOfBoundsException(); + } + else if (len == 0) { + return; + } + + if (this.isClosed) { + throw new IOException("Stream is closed"); + } + + // is data to send greater than buffer size + if (len >= buffer.length) { + + // "byte" off the first chunk to write out + writeOut(b, off, buffer.length); + + // recursively call this method with the lesser amount + write(b, off + buffer.length, len - buffer.length); + } + else { + writeOut(b, off, len); + } + } + + public synchronized void write(byte[] b) throws IOException { + write(b, 0, b.length); + } + + /** + * Fills the buffer with the given data and sends it over the XMPP stream if the buffers + * capacity has been reached. This method is only called from this class so it is assured + * that the amount of data to send is <= buffer capacity + * + * @param b the data + * @param off the data + * @param len the number of bytes to write + * @throws IOException if an I/O error occurred while sending or if the stream is closed + */ + private synchronized void writeOut(byte b[], int off, int len) throws IOException { + if (this.isClosed) { + throw new IOException("Stream is closed"); + } + + // set to 0 in case the next 'if' block is not executed + int available = 0; + + // is data to send greater that buffer space left + if (len > buffer.length - bufferPointer) { + // fill buffer to capacity and send it + available = buffer.length - bufferPointer; + System.arraycopy(b, off, buffer, bufferPointer, available); + bufferPointer += available; + flushBuffer(); + } + + // copy the data left to buffer + System.arraycopy(b, off + available, buffer, bufferPointer, len - available); + bufferPointer += len - available; + } + + public synchronized void flush() throws IOException { + if (this.isClosed) { + throw new IOException("Stream is closed"); + } + flushBuffer(); + } + + private synchronized void flushBuffer() throws IOException { + + // do nothing if no data to send available + if (bufferPointer == 0) { + return; + } + + // create data packet + String enc = StringUtils.encodeBase64(buffer, 0, bufferPointer, false); + DataPacketExtension data = new DataPacketExtension(byteStreamRequest.getSessionID(), + this.seq, enc); + + // write to XMPP stream + writeToXML(data); + + // reset buffer pointer + bufferPointer = 0; + + // increment sequence, considering sequence overflow + this.seq = (this.seq + 1 == 65535 ? 0 : this.seq + 1); + + } + + public void close() throws IOException { + if (isClosed) { + return; + } + InBandBytestreamSession.this.closeByLocal(false); + } + + /** + * Sets the close flag and optionally flushes the stream. + * + * @param flush if <code>true</code> flushes the stream + */ + protected void closeInternal(boolean flush) { + if (this.isClosed) { + return; + } + this.isClosed = true; + + try { + if (flush) { + flushBuffer(); + } + } + catch (IOException e) { + /* + * ignore, because writeToXML() will not throw an exception if stream is already + * closed + */ + } + } + + } + + /** + * IQIBBOutputStream class implements IBBOutputStream to be used with IQ stanzas encapsulating + * the data packets. + */ + private class IQIBBOutputStream extends IBBOutputStream { + + @Override + protected synchronized void writeToXML(DataPacketExtension data) throws IOException { + // create IQ stanza containing data packet + IQ iq = new Data(data); + iq.setTo(remoteJID); + + try { + SyncPacketSend.getReply(connection, iq); + } + catch (XMPPException e) { + // close session unless it is already closed + if (!this.isClosed) { + InBandBytestreamSession.this.close(); + throw new IOException("Error while sending Data: " + e.getMessage()); + } + } + + } + + } + + /** + * MessageIBBOutputStream class implements IBBOutputStream to be used with message stanzas + * encapsulating the data packets. + */ + private class MessageIBBOutputStream extends IBBOutputStream { + + @Override + protected synchronized void writeToXML(DataPacketExtension data) { + // create message stanza containing data packet + Message message = new Message(remoteJID); + message.addExtension(data); + + connection.sendPacket(message); + + } + + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InitiationListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InitiationListener.java new file mode 100644 index 0000000..0ecb081 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/InitiationListener.java @@ -0,0 +1,127 @@ +/** + * 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.smackx.bytestreams.ibb; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.filter.AndFilter; +import org.jivesoftware.smack.filter.IQTypeFilter; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smackx.bytestreams.BytestreamListener; +import org.jivesoftware.smackx.bytestreams.ibb.packet.Open; + +/** + * InitiationListener handles all incoming In-Band Bytestream open requests. If there are no + * listeners for a In-Band Bytestream request InitiationListener will always refuse the request and + * reply with a <not-acceptable/> error (<a + * href="http://xmpp.org/extensions/xep-0047.html#example-5" >XEP-0047</a> Section 2.1). + * + * All In-Band Bytestream request having a block size greater than the maximum allowed block size + * for this connection are rejected with an <resource-constraint/> error. The maximum block + * size can be set by invoking {@link InBandBytestreamManager#setMaximumBlockSize(int)}. + * + * @author Henning Staib + */ +class InitiationListener implements PacketListener { + + /* manager containing the listeners and the XMPP connection */ + private final InBandBytestreamManager manager; + + /* packet filter for all In-Band Bytestream requests */ + private final PacketFilter initFilter = new AndFilter(new PacketTypeFilter(Open.class), + new IQTypeFilter(IQ.Type.SET)); + + /* executor service to process incoming requests concurrently */ + private final ExecutorService initiationListenerExecutor; + + /** + * Constructor. + * + * @param manager the In-Band Bytestream manager + */ + protected InitiationListener(InBandBytestreamManager manager) { + this.manager = manager; + initiationListenerExecutor = Executors.newCachedThreadPool(); + } + + public void processPacket(final Packet packet) { + initiationListenerExecutor.execute(new Runnable() { + + public void run() { + processRequest(packet); + } + }); + } + + private void processRequest(Packet packet) { + Open ibbRequest = (Open) packet; + + // validate that block size is within allowed range + if (ibbRequest.getBlockSize() > this.manager.getMaximumBlockSize()) { + this.manager.replyResourceConstraintPacket(ibbRequest); + return; + } + + // ignore request if in ignore list + if (this.manager.getIgnoredBytestreamRequests().remove(ibbRequest.getSessionID())) + return; + + // build bytestream request from packet + InBandBytestreamRequest request = new InBandBytestreamRequest(this.manager, ibbRequest); + + // notify listeners for bytestream initiation from a specific user + BytestreamListener userListener = this.manager.getUserListener(ibbRequest.getFrom()); + if (userListener != null) { + userListener.incomingBytestreamRequest(request); + + } + else if (!this.manager.getAllRequestListeners().isEmpty()) { + /* + * if there is no user specific listener inform listeners for all initiation requests + */ + for (BytestreamListener listener : this.manager.getAllRequestListeners()) { + listener.incomingBytestreamRequest(request); + } + + } + else { + /* + * if there is no listener for this initiation request, reply with reject message + */ + this.manager.replyRejectPacket(ibbRequest); + } + } + + /** + * Returns the packet filter for In-Band Bytestream open requests. + * + * @return the packet filter for In-Band Bytestream open requests + */ + protected PacketFilter getFilter() { + return this.initFilter; + } + + /** + * Shuts down the listeners executor service. + */ + protected void shutdown() { + this.initiationListenerExecutor.shutdownNow(); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/packet/Close.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/packet/Close.java new file mode 100644 index 0000000..9a78d73 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/packet/Close.java @@ -0,0 +1,65 @@ +/** + * 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.smackx.bytestreams.ibb.packet; + +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smackx.bytestreams.ibb.InBandBytestreamManager; + +/** + * Represents a request to close an In-Band Bytestream. + * + * @author Henning Staib + */ +public class Close extends IQ { + + /* unique session ID identifying this In-Band Bytestream */ + private final String sessionID; + + /** + * Creates a new In-Band Bytestream close request packet. + * + * @param sessionID unique session ID identifying this In-Band Bytestream + */ + public Close(String sessionID) { + if (sessionID == null || "".equals(sessionID)) { + throw new IllegalArgumentException("Session ID must not be null or empty"); + } + this.sessionID = sessionID; + setType(Type.SET); + } + + /** + * Returns the unique session ID identifying this In-Band Bytestream. + * + * @return the unique session ID identifying this In-Band Bytestream + */ + public String getSessionID() { + return sessionID; + } + + @Override + public String getChildElementXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<close "); + buf.append("xmlns=\""); + buf.append(InBandBytestreamManager.NAMESPACE); + buf.append("\" "); + buf.append("sid=\""); + buf.append(sessionID); + buf.append("\""); + buf.append("/>"); + return buf.toString(); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/packet/Data.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/packet/Data.java new file mode 100644 index 0000000..696fa75 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/packet/Data.java @@ -0,0 +1,64 @@ +/** + * 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.smackx.bytestreams.ibb.packet; + +import org.jivesoftware.smack.packet.IQ; + +/** + * Represents a chunk of data sent over an In-Band Bytestream encapsulated in an + * IQ stanza. + * + * @author Henning Staib + */ +public class Data extends IQ { + + /* the data packet extension */ + private final DataPacketExtension dataPacketExtension; + + /** + * Constructor. + * + * @param data data packet extension containing the encoded data + */ + public Data(DataPacketExtension data) { + if (data == null) { + throw new IllegalArgumentException("Data must not be null"); + } + this.dataPacketExtension = data; + + /* + * also set as packet extension so that data packet extension can be + * retrieved from IQ stanza and message stanza in the same way + */ + addExtension(data); + setType(IQ.Type.SET); + } + + /** + * Returns the data packet extension. + * + * Convenience method for <code>packet.getExtension("data", + * "http://jabber.org/protocol/ibb")</code>. + * + * @return the data packet extension + */ + public DataPacketExtension getDataPacketExtension() { + return this.dataPacketExtension; + } + + public String getChildElementXML() { + return this.dataPacketExtension.toXML(); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/packet/DataPacketExtension.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/packet/DataPacketExtension.java new file mode 100644 index 0000000..80ed1e1 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/packet/DataPacketExtension.java @@ -0,0 +1,149 @@ +/** + * 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.smackx.bytestreams.ibb.packet; + +import org.jivesoftware.smack.packet.PacketExtension; +import org.jivesoftware.smack.util.StringUtils; +import org.jivesoftware.smackx.bytestreams.ibb.InBandBytestreamManager; + +/** + * Represents a chunk of data of an In-Band Bytestream within an IQ stanza or a + * message stanza + * + * @author Henning Staib + */ +public class DataPacketExtension implements PacketExtension { + + /** + * The element name of the data packet extension. + */ + public final static String ELEMENT_NAME = "data"; + + /* unique session ID identifying this In-Band Bytestream */ + private final String sessionID; + + /* sequence of this packet in regard to the other data packets */ + private final long seq; + + /* the data contained in this packet */ + private final String data; + + private byte[] decodedData; + + /** + * Creates a new In-Band Bytestream data packet. + * + * @param sessionID unique session ID identifying this In-Band Bytestream + * @param seq sequence of this packet in regard to the other data packets + * @param data the base64 encoded data contained in this packet + */ + public DataPacketExtension(String sessionID, long seq, String data) { + if (sessionID == null || "".equals(sessionID)) { + throw new IllegalArgumentException("Session ID must not be null or empty"); + } + if (seq < 0 || seq > 65535) { + throw new IllegalArgumentException("Sequence must not be between 0 and 65535"); + } + if (data == null) { + throw new IllegalArgumentException("Data must not be null"); + } + this.sessionID = sessionID; + this.seq = seq; + this.data = data; + } + + /** + * Returns the unique session ID identifying this In-Band Bytestream. + * + * @return the unique session ID identifying this In-Band Bytestream + */ + public String getSessionID() { + return sessionID; + } + + /** + * Returns the sequence of this packet in regard to the other data packets. + * + * @return the sequence of this packet in regard to the other data packets. + */ + public long getSeq() { + return seq; + } + + /** + * Returns the data contained in this packet. + * + * @return the data contained in this packet. + */ + public String getData() { + return data; + } + + /** + * Returns the decoded data or null if data could not be decoded. + * + * The encoded data is invalid if it contains bad Base64 input characters or + * if it contains the pad ('=') character on a position other than the last + * character(s) of the data. See <a + * href="http://xmpp.org/extensions/xep-0047.html#sec">XEP-0047</a> Section + * 6. + * + * @return the decoded data + */ + public byte[] getDecodedData() { + // return cached decoded data + if (this.decodedData != null) { + return this.decodedData; + } + + // data must not contain the pad (=) other than end of data + if (data.matches(".*={1,2}+.+")) { + return null; + } + + // decodeBase64 will return null if bad characters are included + this.decodedData = StringUtils.decodeBase64(data); + return this.decodedData; + } + + public String getElementName() { + return ELEMENT_NAME; + } + + public String getNamespace() { + return InBandBytestreamManager.NAMESPACE; + } + + public String toXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<"); + buf.append(getElementName()); + buf.append(" "); + buf.append("xmlns=\""); + buf.append(InBandBytestreamManager.NAMESPACE); + buf.append("\" "); + buf.append("seq=\""); + buf.append(seq); + buf.append("\" "); + buf.append("sid=\""); + buf.append(sessionID); + buf.append("\">"); + buf.append(data); + buf.append("</"); + buf.append(getElementName()); + buf.append(">"); + return buf.toString(); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/packet/Open.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/packet/Open.java new file mode 100644 index 0000000..94a7a9b --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/packet/Open.java @@ -0,0 +1,126 @@ +/** + * 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.smackx.bytestreams.ibb.packet; + +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smackx.bytestreams.ibb.InBandBytestreamManager; +import org.jivesoftware.smackx.bytestreams.ibb.InBandBytestreamManager.StanzaType; + +/** + * Represents a request to open an In-Band Bytestream. + * + * @author Henning Staib + */ +public class Open extends IQ { + + /* unique session ID identifying this In-Band Bytestream */ + private final String sessionID; + + /* block size in which the data will be fragmented */ + private final int blockSize; + + /* stanza type used to encapsulate the data */ + private final StanzaType stanza; + + /** + * Creates a new In-Band Bytestream open request packet. + * + * The data sent over this In-Band Bytestream will be fragmented in blocks + * with the given block size. The block size should not be greater than + * 65535. A recommended default value is 4096. + * + * The data can be sent using IQ stanzas or message stanzas. + * + * @param sessionID unique session ID identifying this In-Band Bytestream + * @param blockSize block size in which the data will be fragmented + * @param stanza stanza type used to encapsulate the data + */ + public Open(String sessionID, int blockSize, StanzaType stanza) { + if (sessionID == null || "".equals(sessionID)) { + throw new IllegalArgumentException("Session ID must not be null or empty"); + } + if (blockSize <= 0) { + throw new IllegalArgumentException("Block size must be greater than zero"); + } + + this.sessionID = sessionID; + this.blockSize = blockSize; + this.stanza = stanza; + setType(Type.SET); + } + + /** + * Creates a new In-Band Bytestream open request packet. + * + * The data sent over this In-Band Bytestream will be fragmented in blocks + * with the given block size. The block size should not be greater than + * 65535. A recommended default value is 4096. + * + * The data will be sent using IQ stanzas. + * + * @param sessionID unique session ID identifying this In-Band Bytestream + * @param blockSize block size in which the data will be fragmented + */ + public Open(String sessionID, int blockSize) { + this(sessionID, blockSize, StanzaType.IQ); + } + + /** + * Returns the unique session ID identifying this In-Band Bytestream. + * + * @return the unique session ID identifying this In-Band Bytestream + */ + public String getSessionID() { + return sessionID; + } + + /** + * Returns the block size in which the data will be fragmented. + * + * @return the block size in which the data will be fragmented + */ + public int getBlockSize() { + return blockSize; + } + + /** + * Returns the stanza type used to encapsulate the data. + * + * @return the stanza type used to encapsulate the data + */ + public StanzaType getStanza() { + return stanza; + } + + @Override + public String getChildElementXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<open "); + buf.append("xmlns=\""); + buf.append(InBandBytestreamManager.NAMESPACE); + buf.append("\" "); + buf.append("block-size=\""); + buf.append(blockSize); + buf.append("\" "); + buf.append("sid=\""); + buf.append(sessionID); + buf.append("\" "); + buf.append("stanza=\""); + buf.append(stanza.toString().toLowerCase()); + buf.append("\""); + buf.append("/>"); + return buf.toString(); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/provider/CloseIQProvider.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/provider/CloseIQProvider.java new file mode 100644 index 0000000..566724c --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/provider/CloseIQProvider.java @@ -0,0 +1,33 @@ +/** + * 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.smackx.bytestreams.ibb.provider; + +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.provider.IQProvider; +import org.jivesoftware.smackx.bytestreams.ibb.packet.Close; +import org.xmlpull.v1.XmlPullParser; + +/** + * Parses a close In-Band Bytestream packet. + * + * @author Henning Staib + */ +public class CloseIQProvider implements IQProvider { + + public IQ parseIQ(XmlPullParser parser) throws Exception { + String sid = parser.getAttributeValue("", "sid"); + return new Close(sid); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/provider/DataPacketProvider.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/provider/DataPacketProvider.java new file mode 100644 index 0000000..5abed08 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/provider/DataPacketProvider.java @@ -0,0 +1,45 @@ +/** + * 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.smackx.bytestreams.ibb.provider; + +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.PacketExtension; +import org.jivesoftware.smack.provider.IQProvider; +import org.jivesoftware.smack.provider.PacketExtensionProvider; +import org.jivesoftware.smackx.bytestreams.ibb.packet.Data; +import org.jivesoftware.smackx.bytestreams.ibb.packet.DataPacketExtension; +import org.xmlpull.v1.XmlPullParser; + +/** + * Parses an In-Band Bytestream data packet which can be a packet extension of + * either an IQ stanza or a message stanza. + * + * @author Henning Staib + */ +public class DataPacketProvider implements PacketExtensionProvider, IQProvider { + + public PacketExtension parseExtension(XmlPullParser parser) throws Exception { + String sessionID = parser.getAttributeValue("", "sid"); + long seq = Long.parseLong(parser.getAttributeValue("", "seq")); + String data = parser.nextText(); + return new DataPacketExtension(sessionID, seq, data); + } + + public IQ parseIQ(XmlPullParser parser) throws Exception { + DataPacketExtension data = (DataPacketExtension) parseExtension(parser); + IQ iq = new Data(data); + return iq; + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/provider/OpenIQProvider.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/provider/OpenIQProvider.java new file mode 100644 index 0000000..3cc725a --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/ibb/provider/OpenIQProvider.java @@ -0,0 +1,45 @@ +/** + * 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.smackx.bytestreams.ibb.provider; + +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.provider.IQProvider; +import org.jivesoftware.smackx.bytestreams.ibb.InBandBytestreamManager.StanzaType; +import org.jivesoftware.smackx.bytestreams.ibb.packet.Open; +import org.xmlpull.v1.XmlPullParser; + +/** + * Parses an In-Band Bytestream open packet. + * + * @author Henning Staib + */ +public class OpenIQProvider implements IQProvider { + + public IQ parseIQ(XmlPullParser parser) throws Exception { + String sessionID = parser.getAttributeValue("", "sid"); + int blockSize = Integer.parseInt(parser.getAttributeValue("", "block-size")); + + String stanzaValue = parser.getAttributeValue("", "stanza"); + StanzaType stanza = null; + if (stanzaValue == null) { + stanza = StanzaType.IQ; + } + else { + stanza = StanzaType.valueOf(stanzaValue.toUpperCase()); + } + + return new Open(sessionID, blockSize, stanza); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/InitiationListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/InitiationListener.java new file mode 100644 index 0000000..2a78250 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/InitiationListener.java @@ -0,0 +1,119 @@ +/** + * 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.smackx.bytestreams.socks5; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.filter.AndFilter; +import org.jivesoftware.smack.filter.IQTypeFilter; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smackx.bytestreams.BytestreamListener; +import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream; + +/** + * InitiationListener handles all incoming SOCKS5 Bytestream initiation requests. If there are no + * listeners for a SOCKS5 bytestream request InitiationListener will always refuse the request and + * reply with a <not-acceptable/> error (<a + * href="http://xmpp.org/extensions/xep-0065.html#usecase-alternate">XEP-0065</a> Section 5.2.A2). + * + * @author Henning Staib + */ +final class InitiationListener implements PacketListener { + + /* manager containing the listeners and the XMPP connection */ + private final Socks5BytestreamManager manager; + + /* packet filter for all SOCKS5 Bytestream requests */ + private final PacketFilter initFilter = new AndFilter(new PacketTypeFilter(Bytestream.class), + new IQTypeFilter(IQ.Type.SET)); + + /* executor service to process incoming requests concurrently */ + private final ExecutorService initiationListenerExecutor; + + /** + * Constructor + * + * @param manager the SOCKS5 Bytestream manager + */ + protected InitiationListener(Socks5BytestreamManager manager) { + this.manager = manager; + initiationListenerExecutor = Executors.newCachedThreadPool(); + } + + public void processPacket(final Packet packet) { + initiationListenerExecutor.execute(new Runnable() { + + public void run() { + processRequest(packet); + } + }); + } + + private void processRequest(Packet packet) { + Bytestream byteStreamRequest = (Bytestream) packet; + + // ignore request if in ignore list + if (this.manager.getIgnoredBytestreamRequests().remove(byteStreamRequest.getSessionID())) { + return; + } + + // build bytestream request from packet + Socks5BytestreamRequest request = new Socks5BytestreamRequest(this.manager, + byteStreamRequest); + + // notify listeners for bytestream initiation from a specific user + BytestreamListener userListener = this.manager.getUserListener(byteStreamRequest.getFrom()); + if (userListener != null) { + userListener.incomingBytestreamRequest(request); + + } + else if (!this.manager.getAllRequestListeners().isEmpty()) { + /* + * if there is no user specific listener inform listeners for all initiation requests + */ + for (BytestreamListener listener : this.manager.getAllRequestListeners()) { + listener.incomingBytestreamRequest(request); + } + + } + else { + /* + * if there is no listener for this initiation request, reply with reject message + */ + this.manager.replyRejectPacket(byteStreamRequest); + } + } + + /** + * Returns the packet filter for SOCKS5 Bytestream initialization requests. + * + * @return the packet filter for SOCKS5 Bytestream initialization requests + */ + protected PacketFilter getFilter() { + return this.initFilter; + } + + /** + * Shuts down the listeners executor service. + */ + protected void shutdown() { + this.initiationListenerExecutor.shutdownNow(); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamListener.java new file mode 100644 index 0000000..1430b1d --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamListener.java @@ -0,0 +1,43 @@ +/** + * 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.smackx.bytestreams.socks5; + +import org.jivesoftware.smackx.bytestreams.BytestreamListener; +import org.jivesoftware.smackx.bytestreams.BytestreamRequest; + +/** + * Socks5BytestreamListener are informed if a remote user wants to initiate a SOCKS5 Bytestream. + * Implement this interface to handle incoming SOCKS5 Bytestream requests. + * + * There are two ways to add this listener. See + * {@link Socks5BytestreamManager#addIncomingBytestreamListener(BytestreamListener)} and + * {@link Socks5BytestreamManager#addIncomingBytestreamListener(BytestreamListener, String)} for + * further details. + * + * @author Henning Staib + */ +public abstract class Socks5BytestreamListener implements BytestreamListener { + + public void incomingBytestreamRequest(BytestreamRequest request) { + incomingBytestreamRequest((Socks5BytestreamRequest) request); + } + + /** + * This listener is notified if a SOCKS5 Bytestream request from another user has been received. + * + * @param request the incoming SOCKS5 Bytestream request + */ + public abstract void incomingBytestreamRequest(Socks5BytestreamRequest request); + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamManager.java new file mode 100644 index 0000000..41826df --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamManager.java @@ -0,0 +1,760 @@ +/** + * 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.smackx.bytestreams.socks5; + +import java.io.IOException; +import java.net.Socket; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Random; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.TimeoutException; + +import org.jivesoftware.smack.AbstractConnectionListener; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.ConnectionCreationListener; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.packet.XMPPError; +import org.jivesoftware.smack.util.SyncPacketSend; +import org.jivesoftware.smackx.ServiceDiscoveryManager; +import org.jivesoftware.smackx.bytestreams.BytestreamListener; +import org.jivesoftware.smackx.bytestreams.BytestreamManager; +import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream; +import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream.StreamHost; +import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream.StreamHostUsed; +import org.jivesoftware.smackx.filetransfer.FileTransferManager; +import org.jivesoftware.smackx.packet.DiscoverInfo; +import org.jivesoftware.smackx.packet.DiscoverItems; +import org.jivesoftware.smackx.packet.DiscoverInfo.Identity; +import org.jivesoftware.smackx.packet.DiscoverItems.Item; + +/** + * The Socks5BytestreamManager class handles establishing SOCKS5 Bytestreams as specified in the <a + * href="http://xmpp.org/extensions/xep-0065.html">XEP-0065</a>. + * + * A SOCKS5 Bytestream is negotiated partly over the XMPP XML stream and partly over a separate + * socket. The actual transfer though takes place over a separately created socket. + * + * A SOCKS5 Bytestream generally has three parties, the initiator, the target, and the stream host. + * The stream host is a specialized SOCKS5 proxy setup on a server, or, the initiator can act as the + * stream host. + * + * To establish a SOCKS5 Bytestream invoke the {@link #establishSession(String)} method. This will + * negotiate a SOCKS5 Bytestream with the given target JID and return a socket. + * + * If a session ID for the SOCKS5 Bytestream was already negotiated (e.g. while negotiating a file + * transfer) invoke {@link #establishSession(String, String)}. + * + * To handle incoming SOCKS5 Bytestream requests add an {@link Socks5BytestreamListener} to the + * manager. There are two ways to add this listener. If you want to be informed about incoming + * SOCKS5 Bytestreams from a specific user add the listener by invoking + * {@link #addIncomingBytestreamListener(BytestreamListener, String)}. If the listener should + * respond to all SOCKS5 Bytestream requests invoke + * {@link #addIncomingBytestreamListener(BytestreamListener)}. + * + * Note that the registered {@link Socks5BytestreamListener} will NOT be notified on incoming Socks5 + * bytestream requests sent in the context of <a + * href="http://xmpp.org/extensions/xep-0096.html">XEP-0096</a> file transfer. (See + * {@link FileTransferManager}) + * + * If no {@link Socks5BytestreamListener}s are registered, all incoming SOCKS5 Bytestream requests + * will be rejected by returning a <not-acceptable/> error to the initiator. + * + * @author Henning Staib + */ +public final class Socks5BytestreamManager implements BytestreamManager { + + /* + * create a new Socks5BytestreamManager and register a shutdown listener on every established + * connection + */ + static { + Connection.addConnectionCreationListener(new ConnectionCreationListener() { + + public void connectionCreated(Connection connection) { + final Socks5BytestreamManager manager; + manager = Socks5BytestreamManager.getBytestreamManager(connection); + + // register shutdown listener + connection.addConnectionListener(new AbstractConnectionListener() { + + public void connectionClosed() { + manager.disableService(); + } + + }); + } + + }); + } + + /** + * The XMPP namespace of the SOCKS5 Bytestream + */ + public static final String NAMESPACE = "http://jabber.org/protocol/bytestreams"; + + /* prefix used to generate session IDs */ + private static final String SESSION_ID_PREFIX = "js5_"; + + /* random generator to create session IDs */ + private final static Random randomGenerator = new Random(); + + /* stores one Socks5BytestreamManager for each XMPP connection */ + private final static Map<Connection, Socks5BytestreamManager> managers = new HashMap<Connection, Socks5BytestreamManager>(); + + /* XMPP connection */ + private final Connection connection; + + /* + * assigns a user to a listener that is informed if a bytestream request for this user is + * received + */ + private final Map<String, BytestreamListener> userListeners = new ConcurrentHashMap<String, BytestreamListener>(); + + /* + * list of listeners that respond to all bytestream requests if there are not user specific + * listeners for that request + */ + private final List<BytestreamListener> allRequestListeners = Collections.synchronizedList(new LinkedList<BytestreamListener>()); + + /* listener that handles all incoming bytestream requests */ + private final InitiationListener initiationListener; + + /* timeout to wait for the response to the SOCKS5 Bytestream initialization request */ + private int targetResponseTimeout = 10000; + + /* timeout for connecting to the SOCKS5 proxy selected by the target */ + private int proxyConnectionTimeout = 10000; + + /* blacklist of errornous SOCKS5 proxies */ + private final List<String> proxyBlacklist = Collections.synchronizedList(new LinkedList<String>()); + + /* remember the last proxy that worked to prioritize it */ + private String lastWorkingProxy = null; + + /* flag to enable/disable prioritization of last working proxy */ + private boolean proxyPrioritizationEnabled = true; + + /* + * list containing session IDs of SOCKS5 Bytestream initialization packets that should be + * ignored by the InitiationListener + */ + private List<String> ignoredBytestreamRequests = Collections.synchronizedList(new LinkedList<String>()); + + /** + * Returns the Socks5BytestreamManager to handle SOCKS5 Bytestreams for a given + * {@link Connection}. + * + * If no manager exists a new is created and initialized. + * + * @param connection the XMPP connection or <code>null</code> if given connection is + * <code>null</code> + * @return the Socks5BytestreamManager for the given XMPP connection + */ + public static synchronized Socks5BytestreamManager getBytestreamManager(Connection connection) { + if (connection == null) { + return null; + } + Socks5BytestreamManager manager = managers.get(connection); + if (manager == null) { + manager = new Socks5BytestreamManager(connection); + managers.put(connection, manager); + manager.activate(); + } + return manager; + } + + /** + * Private constructor. + * + * @param connection the XMPP connection + */ + private Socks5BytestreamManager(Connection connection) { + this.connection = connection; + this.initiationListener = new InitiationListener(this); + } + + /** + * Adds BytestreamListener that is called for every incoming SOCKS5 Bytestream request unless + * there is a user specific BytestreamListener registered. + * + * If no listeners are registered all SOCKS5 Bytestream request are rejected with a + * <not-acceptable/> error. + * + * Note that the registered {@link BytestreamListener} will NOT be notified on incoming Socks5 + * bytestream requests sent in the context of <a + * href="http://xmpp.org/extensions/xep-0096.html">XEP-0096</a> file transfer. (See + * {@link FileTransferManager}) + * + * @param listener the listener to register + */ + public void addIncomingBytestreamListener(BytestreamListener listener) { + this.allRequestListeners.add(listener); + } + + /** + * Removes the given listener from the list of listeners for all incoming SOCKS5 Bytestream + * requests. + * + * @param listener the listener to remove + */ + public void removeIncomingBytestreamListener(BytestreamListener listener) { + this.allRequestListeners.remove(listener); + } + + /** + * Adds BytestreamListener that is called for every incoming SOCKS5 Bytestream request from the + * given user. + * + * Use this method if you are awaiting an incoming SOCKS5 Bytestream request from a specific + * user. + * + * If no listeners are registered all SOCKS5 Bytestream request are rejected with a + * <not-acceptable/> error. + * + * Note that the registered {@link BytestreamListener} will NOT be notified on incoming Socks5 + * bytestream requests sent in the context of <a + * href="http://xmpp.org/extensions/xep-0096.html">XEP-0096</a> file transfer. (See + * {@link FileTransferManager}) + * + * @param listener the listener to register + * @param initiatorJID the JID of the user that wants to establish a SOCKS5 Bytestream + */ + public void addIncomingBytestreamListener(BytestreamListener listener, String initiatorJID) { + this.userListeners.put(initiatorJID, listener); + } + + /** + * Removes the listener for the given user. + * + * @param initiatorJID the JID of the user the listener should be removed + */ + public void removeIncomingBytestreamListener(String initiatorJID) { + this.userListeners.remove(initiatorJID); + } + + /** + * Use this method to ignore the next incoming SOCKS5 Bytestream request containing the given + * session ID. No listeners will be notified for this request and and no error will be returned + * to the initiator. + * + * This method should be used if you are awaiting a SOCKS5 Bytestream request as a reply to + * another packet (e.g. file transfer). + * + * @param sessionID to be ignored + */ + public void ignoreBytestreamRequestOnce(String sessionID) { + this.ignoredBytestreamRequests.add(sessionID); + } + + /** + * Disables the SOCKS5 Bytestream manager by removing the SOCKS5 Bytestream feature from the + * service discovery, disabling the listener for SOCKS5 Bytestream initiation requests and + * resetting its internal state. + * + * To re-enable the SOCKS5 Bytestream feature invoke {@link #getBytestreamManager(Connection)}. + * Using the file transfer API will automatically re-enable the SOCKS5 Bytestream feature. + */ + public synchronized void disableService() { + + // remove initiation packet listener + this.connection.removePacketListener(this.initiationListener); + + // shutdown threads + this.initiationListener.shutdown(); + + // clear listeners + this.allRequestListeners.clear(); + this.userListeners.clear(); + + // reset internal state + this.lastWorkingProxy = null; + this.proxyBlacklist.clear(); + this.ignoredBytestreamRequests.clear(); + + // remove manager from static managers map + managers.remove(this.connection); + + // shutdown local SOCKS5 proxy if there are no more managers for other connections + if (managers.size() == 0) { + Socks5Proxy.getSocks5Proxy().stop(); + } + + // remove feature from service discovery + ServiceDiscoveryManager serviceDiscoveryManager = ServiceDiscoveryManager.getInstanceFor(this.connection); + + // check if service discovery is not already disposed by connection shutdown + if (serviceDiscoveryManager != null) { + serviceDiscoveryManager.removeFeature(NAMESPACE); + } + + } + + /** + * Returns the timeout to wait for the response to the SOCKS5 Bytestream initialization request. + * Default is 10000ms. + * + * @return the timeout to wait for the response to the SOCKS5 Bytestream initialization request + */ + public int getTargetResponseTimeout() { + if (this.targetResponseTimeout <= 0) { + this.targetResponseTimeout = 10000; + } + return targetResponseTimeout; + } + + /** + * Sets the timeout to wait for the response to the SOCKS5 Bytestream initialization request. + * Default is 10000ms. + * + * @param targetResponseTimeout the timeout to set + */ + public void setTargetResponseTimeout(int targetResponseTimeout) { + this.targetResponseTimeout = targetResponseTimeout; + } + + /** + * Returns the timeout for connecting to the SOCKS5 proxy selected by the target. Default is + * 10000ms. + * + * @return the timeout for connecting to the SOCKS5 proxy selected by the target + */ + public int getProxyConnectionTimeout() { + if (this.proxyConnectionTimeout <= 0) { + this.proxyConnectionTimeout = 10000; + } + return proxyConnectionTimeout; + } + + /** + * Sets the timeout for connecting to the SOCKS5 proxy selected by the target. Default is + * 10000ms. + * + * @param proxyConnectionTimeout the timeout to set + */ + public void setProxyConnectionTimeout(int proxyConnectionTimeout) { + this.proxyConnectionTimeout = proxyConnectionTimeout; + } + + /** + * Returns if the prioritization of the last working SOCKS5 proxy on successive SOCKS5 + * Bytestream connections is enabled. Default is <code>true</code>. + * + * @return <code>true</code> if prioritization is enabled, <code>false</code> otherwise + */ + public boolean isProxyPrioritizationEnabled() { + return proxyPrioritizationEnabled; + } + + /** + * Enable/disable the prioritization of the last working SOCKS5 proxy on successive SOCKS5 + * Bytestream connections. + * + * @param proxyPrioritizationEnabled enable/disable the prioritization of the last working + * SOCKS5 proxy + */ + public void setProxyPrioritizationEnabled(boolean proxyPrioritizationEnabled) { + this.proxyPrioritizationEnabled = proxyPrioritizationEnabled; + } + + /** + * Establishes a SOCKS5 Bytestream with the given user and returns the Socket to send/receive + * data to/from the user. + * + * Use this method to establish SOCKS5 Bytestreams to users accepting all incoming Socks5 + * bytestream requests since this method doesn't provide a way to tell the user something about + * the data to be sent. + * + * To establish a SOCKS5 Bytestream after negotiation the kind of data to be sent (e.g. file + * transfer) use {@link #establishSession(String, String)}. + * + * @param targetJID the JID of the user a SOCKS5 Bytestream should be established + * @return the Socket to send/receive data to/from the user + * @throws XMPPException if the user doesn't support or accept SOCKS5 Bytestreams, if no Socks5 + * Proxy could be found, if the user couldn't connect to any of the SOCKS5 Proxies + * @throws IOException if the bytestream could not be established + * @throws InterruptedException if the current thread was interrupted while waiting + */ + public Socks5BytestreamSession establishSession(String targetJID) throws XMPPException, + IOException, InterruptedException { + String sessionID = getNextSessionID(); + return establishSession(targetJID, sessionID); + } + + /** + * Establishes a SOCKS5 Bytestream with the given user using the given session ID and returns + * the Socket to send/receive data to/from the user. + * + * @param targetJID the JID of the user a SOCKS5 Bytestream should be established + * @param sessionID the session ID for the SOCKS5 Bytestream request + * @return the Socket to send/receive data to/from the user + * @throws XMPPException if the user doesn't support or accept SOCKS5 Bytestreams, if no Socks5 + * Proxy could be found, if the user couldn't connect to any of the SOCKS5 Proxies + * @throws IOException if the bytestream could not be established + * @throws InterruptedException if the current thread was interrupted while waiting + */ + public Socks5BytestreamSession establishSession(String targetJID, String sessionID) + throws XMPPException, IOException, InterruptedException { + + // check if target supports SOCKS5 Bytestream + if (!supportsSocks5(targetJID)) { + throw new XMPPException(targetJID + " doesn't support SOCKS5 Bytestream"); + } + + // determine SOCKS5 proxies from XMPP-server + List<String> proxies = determineProxies(); + + // determine address and port of each proxy + List<StreamHost> streamHosts = determineStreamHostInfos(proxies); + + // compute digest + String digest = Socks5Utils.createDigest(sessionID, this.connection.getUser(), targetJID); + + if (streamHosts.isEmpty()) { + throw new XMPPException("no SOCKS5 proxies available"); + } + + // prioritize last working SOCKS5 proxy if exists + if (this.proxyPrioritizationEnabled && this.lastWorkingProxy != null) { + StreamHost selectedStreamHost = null; + for (StreamHost streamHost : streamHosts) { + if (streamHost.getJID().equals(this.lastWorkingProxy)) { + selectedStreamHost = streamHost; + break; + } + } + if (selectedStreamHost != null) { + streamHosts.remove(selectedStreamHost); + streamHosts.add(0, selectedStreamHost); + } + + } + + Socks5Proxy socks5Proxy = Socks5Proxy.getSocks5Proxy(); + try { + + // add transfer digest to local proxy to make transfer valid + socks5Proxy.addTransfer(digest); + + // create initiation packet + Bytestream initiation = createBytestreamInitiation(sessionID, targetJID, streamHosts); + + // send initiation packet + Packet response = SyncPacketSend.getReply(this.connection, initiation, + getTargetResponseTimeout()); + + // extract used stream host from response + StreamHostUsed streamHostUsed = ((Bytestream) response).getUsedHost(); + StreamHost usedStreamHost = initiation.getStreamHost(streamHostUsed.getJID()); + + if (usedStreamHost == null) { + throw new XMPPException("Remote user responded with unknown host"); + } + + // build SOCKS5 client + Socks5Client socks5Client = new Socks5ClientForInitiator(usedStreamHost, digest, + this.connection, sessionID, targetJID); + + // establish connection to proxy + Socket socket = socks5Client.getSocket(getProxyConnectionTimeout()); + + // remember last working SOCKS5 proxy to prioritize it for next request + this.lastWorkingProxy = usedStreamHost.getJID(); + + // negotiation successful, return the output stream + return new Socks5BytestreamSession(socket, usedStreamHost.getJID().equals( + this.connection.getUser())); + + } + catch (TimeoutException e) { + throw new IOException("Timeout while connecting to SOCKS5 proxy"); + } + finally { + + // remove transfer digest if output stream is returned or an exception + // occurred + socks5Proxy.removeTransfer(digest); + + } + } + + /** + * Returns <code>true</code> if the given target JID supports feature SOCKS5 Bytestream. + * + * @param targetJID the target JID + * @return <code>true</code> if the given target JID supports feature SOCKS5 Bytestream + * otherwise <code>false</code> + * @throws XMPPException if there was an error querying target for supported features + */ + private boolean supportsSocks5(String targetJID) throws XMPPException { + ServiceDiscoveryManager serviceDiscoveryManager = ServiceDiscoveryManager.getInstanceFor(this.connection); + DiscoverInfo discoverInfo = serviceDiscoveryManager.discoverInfo(targetJID); + return discoverInfo.containsFeature(NAMESPACE); + } + + /** + * Returns a list of JIDs of SOCKS5 proxies by querying the XMPP server. The SOCKS5 proxies are + * in the same order as returned by the XMPP server. + * + * @return list of JIDs of SOCKS5 proxies + * @throws XMPPException if there was an error querying the XMPP server for SOCKS5 proxies + */ + private List<String> determineProxies() throws XMPPException { + ServiceDiscoveryManager serviceDiscoveryManager = ServiceDiscoveryManager.getInstanceFor(this.connection); + + List<String> proxies = new ArrayList<String>(); + + // get all items form XMPP server + DiscoverItems discoverItems = serviceDiscoveryManager.discoverItems(this.connection.getServiceName()); + Iterator<Item> itemIterator = discoverItems.getItems(); + + // query all items if they are SOCKS5 proxies + while (itemIterator.hasNext()) { + Item item = itemIterator.next(); + + // skip blacklisted servers + if (this.proxyBlacklist.contains(item.getEntityID())) { + continue; + } + + try { + DiscoverInfo proxyInfo; + proxyInfo = serviceDiscoveryManager.discoverInfo(item.getEntityID()); + Iterator<Identity> identities = proxyInfo.getIdentities(); + + // item must have category "proxy" and type "bytestream" + while (identities.hasNext()) { + Identity identity = identities.next(); + + if ("proxy".equalsIgnoreCase(identity.getCategory()) + && "bytestreams".equalsIgnoreCase(identity.getType())) { + proxies.add(item.getEntityID()); + break; + } + + /* + * server is not a SOCKS5 proxy, blacklist server to skip next time a Socks5 + * bytestream should be established + */ + this.proxyBlacklist.add(item.getEntityID()); + + } + } + catch (XMPPException e) { + // blacklist errornous server + this.proxyBlacklist.add(item.getEntityID()); + } + } + + return proxies; + } + + /** + * Returns a list of stream hosts containing the IP address an the port for the given list of + * SOCKS5 proxy JIDs. The order of the returned list is the same as the given list of JIDs + * excluding all SOCKS5 proxies who's network settings could not be determined. If a local + * SOCKS5 proxy is running it will be the first item in the list returned. + * + * @param proxies a list of SOCKS5 proxy JIDs + * @return a list of stream hosts containing the IP address an the port + */ + private List<StreamHost> determineStreamHostInfos(List<String> proxies) { + List<StreamHost> streamHosts = new ArrayList<StreamHost>(); + + // add local proxy on first position if exists + List<StreamHost> localProxies = getLocalStreamHost(); + if (localProxies != null) { + streamHosts.addAll(localProxies); + } + + // query SOCKS5 proxies for network settings + for (String proxy : proxies) { + Bytestream streamHostRequest = createStreamHostRequest(proxy); + try { + Bytestream response = (Bytestream) SyncPacketSend.getReply(this.connection, + streamHostRequest); + streamHosts.addAll(response.getStreamHosts()); + } + catch (XMPPException e) { + // blacklist errornous proxies + this.proxyBlacklist.add(proxy); + } + } + + return streamHosts; + } + + /** + * Returns a IQ packet to query a SOCKS5 proxy its network settings. + * + * @param proxy the proxy to query + * @return IQ packet to query a SOCKS5 proxy its network settings + */ + private Bytestream createStreamHostRequest(String proxy) { + Bytestream request = new Bytestream(); + request.setType(IQ.Type.GET); + request.setTo(proxy); + return request; + } + + /** + * Returns the stream host information of the local SOCKS5 proxy containing the IP address and + * the port or null if local SOCKS5 proxy is not running. + * + * @return the stream host information of the local SOCKS5 proxy or null if local SOCKS5 proxy + * is not running + */ + private List<StreamHost> getLocalStreamHost() { + + // get local proxy singleton + Socks5Proxy socks5Server = Socks5Proxy.getSocks5Proxy(); + + if (socks5Server.isRunning()) { + List<String> addresses = socks5Server.getLocalAddresses(); + int port = socks5Server.getPort(); + + if (addresses.size() >= 1) { + List<StreamHost> streamHosts = new ArrayList<StreamHost>(); + for (String address : addresses) { + StreamHost streamHost = new StreamHost(this.connection.getUser(), address); + streamHost.setPort(port); + streamHosts.add(streamHost); + } + return streamHosts; + } + + } + + // server is not running or local address could not be determined + return null; + } + + /** + * Returns a SOCKS5 Bytestream initialization request packet with the given session ID + * containing the given stream hosts for the given target JID. + * + * @param sessionID the session ID for the SOCKS5 Bytestream + * @param targetJID the target JID of SOCKS5 Bytestream request + * @param streamHosts a list of SOCKS5 proxies the target should connect to + * @return a SOCKS5 Bytestream initialization request packet + */ + private Bytestream createBytestreamInitiation(String sessionID, String targetJID, + List<StreamHost> streamHosts) { + Bytestream initiation = new Bytestream(sessionID); + + // add all stream hosts + for (StreamHost streamHost : streamHosts) { + initiation.addStreamHost(streamHost); + } + + initiation.setType(IQ.Type.SET); + initiation.setTo(targetJID); + + return initiation; + } + + /** + * Responses to the given packet's sender with a XMPP error that a SOCKS5 Bytestream is not + * accepted. + * + * @param packet Packet that should be answered with a not-acceptable error + */ + protected void replyRejectPacket(IQ packet) { + XMPPError xmppError = new XMPPError(XMPPError.Condition.no_acceptable); + IQ errorIQ = IQ.createErrorResponse(packet, xmppError); + this.connection.sendPacket(errorIQ); + } + + /** + * Activates the Socks5BytestreamManager by registering the SOCKS5 Bytestream initialization + * listener and enabling the SOCKS5 Bytestream feature. + */ + private void activate() { + // register bytestream initiation packet listener + this.connection.addPacketListener(this.initiationListener, + this.initiationListener.getFilter()); + + // enable SOCKS5 feature + enableService(); + } + + /** + * Adds the SOCKS5 Bytestream feature to the service discovery. + */ + private void enableService() { + ServiceDiscoveryManager manager = ServiceDiscoveryManager.getInstanceFor(this.connection); + if (!manager.includesFeature(NAMESPACE)) { + manager.addFeature(NAMESPACE); + } + } + + /** + * Returns a new unique session ID. + * + * @return a new unique session ID + */ + private String getNextSessionID() { + StringBuilder buffer = new StringBuilder(); + buffer.append(SESSION_ID_PREFIX); + buffer.append(Math.abs(randomGenerator.nextLong())); + return buffer.toString(); + } + + /** + * Returns the XMPP connection. + * + * @return the XMPP connection + */ + protected Connection getConnection() { + return this.connection; + } + + /** + * Returns the {@link BytestreamListener} that should be informed if a SOCKS5 Bytestream request + * from the given initiator JID is received. + * + * @param initiator the initiator's JID + * @return the listener + */ + protected BytestreamListener getUserListener(String initiator) { + return this.userListeners.get(initiator); + } + + /** + * Returns a list of {@link BytestreamListener} that are informed if there are no listeners for + * a specific initiator. + * + * @return list of listeners + */ + protected List<BytestreamListener> getAllRequestListeners() { + return this.allRequestListeners; + } + + /** + * Returns the list of session IDs that should be ignored by the InitialtionListener + * + * @return list of session IDs + */ + protected List<String> getIgnoredBytestreamRequests() { + return ignoredBytestreamRequests; + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamRequest.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamRequest.java new file mode 100644 index 0000000..0b2fdeb --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamRequest.java @@ -0,0 +1,316 @@ +/** + * 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.smackx.bytestreams.socks5; + +import java.io.IOException; +import java.net.Socket; +import java.util.Collection; +import java.util.concurrent.TimeoutException; + +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.XMPPError; +import org.jivesoftware.smack.util.Cache; +import org.jivesoftware.smackx.bytestreams.BytestreamRequest; +import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream; +import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream.StreamHost; + +/** + * Socks5BytestreamRequest class handles incoming SOCKS5 Bytestream requests. + * + * @author Henning Staib + */ +public class Socks5BytestreamRequest implements BytestreamRequest { + + /* lifetime of an Item in the blacklist */ + private static final long BLACKLIST_LIFETIME = 60 * 1000 * 120; + + /* size of the blacklist */ + private static final int BLACKLIST_MAX_SIZE = 100; + + /* blacklist of addresses of SOCKS5 proxies */ + private static final Cache<String, Integer> ADDRESS_BLACKLIST = new Cache<String, Integer>( + BLACKLIST_MAX_SIZE, BLACKLIST_LIFETIME); + + /* + * The number of connection failures it takes for a particular SOCKS5 proxy to be blacklisted. + * When a proxy is blacklisted no more connection attempts will be made to it for a period of 2 + * hours. + */ + private static int CONNECTION_FAILURE_THRESHOLD = 2; + + /* the bytestream initialization request */ + private Bytestream bytestreamRequest; + + /* SOCKS5 Bytestream manager containing the XMPP connection and helper methods */ + private Socks5BytestreamManager manager; + + /* timeout to connect to all SOCKS5 proxies */ + private int totalConnectTimeout = 10000; + + /* minimum timeout to connect to one SOCKS5 proxy */ + private int minimumConnectTimeout = 2000; + + /** + * Returns the number of connection failures it takes for a particular SOCKS5 proxy to be + * blacklisted. When a proxy is blacklisted no more connection attempts will be made to it for a + * period of 2 hours. Default is 2. + * + * @return the number of connection failures it takes for a particular SOCKS5 proxy to be + * blacklisted + */ + public static int getConnectFailureThreshold() { + return CONNECTION_FAILURE_THRESHOLD; + } + + /** + * Sets the number of connection failures it takes for a particular SOCKS5 proxy to be + * blacklisted. When a proxy is blacklisted no more connection attempts will be made to it for a + * period of 2 hours. Default is 2. + * + * Setting the connection failure threshold to zero disables the blacklisting. + * + * @param connectFailureThreshold the number of connection failures it takes for a particular + * SOCKS5 proxy to be blacklisted + */ + public static void setConnectFailureThreshold(int connectFailureThreshold) { + CONNECTION_FAILURE_THRESHOLD = connectFailureThreshold; + } + + /** + * Creates a new Socks5BytestreamRequest. + * + * @param manager the SOCKS5 Bytestream manager + * @param bytestreamRequest the SOCKS5 Bytestream initialization packet + */ + protected Socks5BytestreamRequest(Socks5BytestreamManager manager, Bytestream bytestreamRequest) { + this.manager = manager; + this.bytestreamRequest = bytestreamRequest; + } + + /** + * Returns the maximum timeout to connect to SOCKS5 proxies. Default is 10000ms. + * + * When accepting a SOCKS5 Bytestream request Smack tries to connect to all SOCKS5 proxies given + * by the initiator until a connection is established. This timeout divided by the number of + * SOCKS5 proxies determines the timeout for every connection attempt. + * + * You can set the minimum timeout for establishing a connection to one SOCKS5 proxy by invoking + * {@link #setMinimumConnectTimeout(int)}. + * + * @return the maximum timeout to connect to SOCKS5 proxies + */ + public int getTotalConnectTimeout() { + if (this.totalConnectTimeout <= 0) { + return 10000; + } + return this.totalConnectTimeout; + } + + /** + * Sets the maximum timeout to connect to SOCKS5 proxies. Default is 10000ms. + * + * When accepting a SOCKS5 Bytestream request Smack tries to connect to all SOCKS5 proxies given + * by the initiator until a connection is established. This timeout divided by the number of + * SOCKS5 proxies determines the timeout for every connection attempt. + * + * You can set the minimum timeout for establishing a connection to one SOCKS5 proxy by invoking + * {@link #setMinimumConnectTimeout(int)}. + * + * @param totalConnectTimeout the maximum timeout to connect to SOCKS5 proxies + */ + public void setTotalConnectTimeout(int totalConnectTimeout) { + this.totalConnectTimeout = totalConnectTimeout; + } + + /** + * Returns the timeout to connect to one SOCKS5 proxy while accepting the SOCKS5 Bytestream + * request. Default is 2000ms. + * + * @return the timeout to connect to one SOCKS5 proxy + */ + public int getMinimumConnectTimeout() { + if (this.minimumConnectTimeout <= 0) { + return 2000; + } + return this.minimumConnectTimeout; + } + + /** + * Sets the timeout to connect to one SOCKS5 proxy while accepting the SOCKS5 Bytestream + * request. Default is 2000ms. + * + * @param minimumConnectTimeout the timeout to connect to one SOCKS5 proxy + */ + public void setMinimumConnectTimeout(int minimumConnectTimeout) { + this.minimumConnectTimeout = minimumConnectTimeout; + } + + /** + * Returns the sender of the SOCKS5 Bytestream initialization request. + * + * @return the sender of the SOCKS5 Bytestream initialization request. + */ + public String getFrom() { + return this.bytestreamRequest.getFrom(); + } + + /** + * Returns the session ID of the SOCKS5 Bytestream initialization request. + * + * @return the session ID of the SOCKS5 Bytestream initialization request. + */ + public String getSessionID() { + return this.bytestreamRequest.getSessionID(); + } + + /** + * Accepts the SOCKS5 Bytestream initialization request and returns the socket to send/receive + * data. + * + * Before accepting the SOCKS5 Bytestream request you can set timeouts by invoking + * {@link #setTotalConnectTimeout(int)} and {@link #setMinimumConnectTimeout(int)}. + * + * @return the socket to send/receive data + * @throws XMPPException if connection to all SOCKS5 proxies failed or if stream is invalid. + * @throws InterruptedException if the current thread was interrupted while waiting + */ + public Socks5BytestreamSession accept() throws XMPPException, InterruptedException { + Collection<StreamHost> streamHosts = this.bytestreamRequest.getStreamHosts(); + + // throw exceptions if request contains no stream hosts + if (streamHosts.size() == 0) { + cancelRequest(); + } + + StreamHost selectedHost = null; + Socket socket = null; + + String digest = Socks5Utils.createDigest(this.bytestreamRequest.getSessionID(), + this.bytestreamRequest.getFrom(), this.manager.getConnection().getUser()); + + /* + * determine timeout for each connection attempt; each SOCKS5 proxy has the same amount of + * time so that the first does not consume the whole timeout + */ + int timeout = Math.max(getTotalConnectTimeout() / streamHosts.size(), + getMinimumConnectTimeout()); + + for (StreamHost streamHost : streamHosts) { + String address = streamHost.getAddress() + ":" + streamHost.getPort(); + + // check to see if this address has been blacklisted + int failures = getConnectionFailures(address); + if (CONNECTION_FAILURE_THRESHOLD > 0 && failures >= CONNECTION_FAILURE_THRESHOLD) { + continue; + } + + // establish socket + try { + + // build SOCKS5 client + final Socks5Client socks5Client = new Socks5Client(streamHost, digest); + + // connect to SOCKS5 proxy with a timeout + socket = socks5Client.getSocket(timeout); + + // set selected host + selectedHost = streamHost; + break; + + } + catch (TimeoutException e) { + incrementConnectionFailures(address); + } + catch (IOException e) { + incrementConnectionFailures(address); + } + catch (XMPPException e) { + incrementConnectionFailures(address); + } + + } + + // throw exception if connecting to all SOCKS5 proxies failed + if (selectedHost == null || socket == null) { + cancelRequest(); + } + + // send used-host confirmation + Bytestream response = createUsedHostResponse(selectedHost); + this.manager.getConnection().sendPacket(response); + + return new Socks5BytestreamSession(socket, selectedHost.getJID().equals( + this.bytestreamRequest.getFrom())); + + } + + /** + * Rejects the SOCKS5 Bytestream request by sending a reject error to the initiator. + */ + public void reject() { + this.manager.replyRejectPacket(this.bytestreamRequest); + } + + /** + * Cancels the SOCKS5 Bytestream request by sending an error to the initiator and building a + * XMPP exception. + * + * @throws XMPPException XMPP exception containing the XMPP error + */ + private void cancelRequest() throws XMPPException { + String errorMessage = "Could not establish socket with any provided host"; + XMPPError error = new XMPPError(XMPPError.Condition.item_not_found, errorMessage); + IQ errorIQ = IQ.createErrorResponse(this.bytestreamRequest, error); + this.manager.getConnection().sendPacket(errorIQ); + throw new XMPPException(errorMessage, error); + } + + /** + * Returns the response to the SOCKS5 Bytestream request containing the SOCKS5 proxy used. + * + * @param selectedHost the used SOCKS5 proxy + * @return the response to the SOCKS5 Bytestream request + */ + private Bytestream createUsedHostResponse(StreamHost selectedHost) { + Bytestream response = new Bytestream(this.bytestreamRequest.getSessionID()); + response.setTo(this.bytestreamRequest.getFrom()); + response.setType(IQ.Type.RESULT); + response.setPacketID(this.bytestreamRequest.getPacketID()); + response.setUsedHost(selectedHost.getJID()); + return response; + } + + /** + * Increments the connection failure counter by one for the given address. + * + * @param address the address the connection failure counter should be increased + */ + private void incrementConnectionFailures(String address) { + Integer count = ADDRESS_BLACKLIST.get(address); + ADDRESS_BLACKLIST.put(address, count == null ? 1 : count + 1); + } + + /** + * Returns how often the connection to the given address failed. + * + * @param address the address + * @return number of connection failures + */ + private int getConnectionFailures(String address) { + Integer count = ADDRESS_BLACKLIST.get(address); + return count != null ? count : 0; + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamSession.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamSession.java new file mode 100644 index 0000000..20fbdb1 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5BytestreamSession.java @@ -0,0 +1,81 @@ +package org.jivesoftware.smackx.bytestreams.socks5; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.Socket; +import java.net.SocketException; + +import org.jivesoftware.smackx.bytestreams.BytestreamSession; + +/** + * Socks5BytestreamSession class represents a SOCKS5 Bytestream session. + * + * @author Henning Staib + */ +public class Socks5BytestreamSession implements BytestreamSession { + + /* the underlying socket of the SOCKS5 Bytestream */ + private final Socket socket; + + /* flag to indicate if this session is a direct or mediated connection */ + private final boolean isDirect; + + protected Socks5BytestreamSession(Socket socket, boolean isDirect) { + this.socket = socket; + this.isDirect = isDirect; + } + + /** + * Returns <code>true</code> if the session is established through a direct connection between + * the initiator and target, <code>false</code> if the session is mediated over a SOCKS proxy. + * + * @return <code>true</code> if session is a direct connection, <code>false</code> if session is + * mediated over a SOCKS5 proxy + */ + public boolean isDirect() { + return this.isDirect; + } + + /** + * Returns <code>true</code> if the session is mediated over a SOCKS proxy, <code>false</code> + * if this session is established through a direct connection between the initiator and target. + * + * @return <code>true</code> if session is mediated over a SOCKS5 proxy, <code>false</code> if + * session is a direct connection + */ + public boolean isMediated() { + return !this.isDirect; + } + + public InputStream getInputStream() throws IOException { + return this.socket.getInputStream(); + } + + public OutputStream getOutputStream() throws IOException { + return this.socket.getOutputStream(); + } + + public int getReadTimeout() throws IOException { + try { + return this.socket.getSoTimeout(); + } + catch (SocketException e) { + throw new IOException("Error on underlying Socket"); + } + } + + public void setReadTimeout(int timeout) throws IOException { + try { + this.socket.setSoTimeout(timeout); + } + catch (SocketException e) { + throw new IOException("Error on underlying Socket"); + } + } + + public void close() throws IOException { + this.socket.close(); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5Client.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5Client.java new file mode 100644 index 0000000..664ea59 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5Client.java @@ -0,0 +1,204 @@ +/** + * 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.smackx.bytestreams.socks5; + +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.net.InetSocketAddress; +import java.net.Socket; +import java.net.SocketAddress; +import java.util.Arrays; +import java.util.concurrent.Callable; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.FutureTask; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream.StreamHost; + +/** + * The SOCKS5 client class handles establishing a connection to a SOCKS5 proxy. Connecting to a + * SOCKS5 proxy requires authentication. This implementation only supports the no-authentication + * authentication method. + * + * @author Henning Staib + */ +class Socks5Client { + + /* stream host containing network settings and name of the SOCKS5 proxy */ + protected StreamHost streamHost; + + /* SHA-1 digest identifying the SOCKS5 stream */ + protected String digest; + + /** + * Constructor for a SOCKS5 client. + * + * @param streamHost containing network settings of the SOCKS5 proxy + * @param digest identifying the SOCKS5 Bytestream + */ + public Socks5Client(StreamHost streamHost, String digest) { + this.streamHost = streamHost; + this.digest = digest; + } + + /** + * Returns the initialized socket that can be used to transfer data between peers via the SOCKS5 + * proxy. + * + * @param timeout timeout to connect to SOCKS5 proxy in milliseconds + * @return socket the initialized socket + * @throws IOException if initializing the socket failed due to a network error + * @throws XMPPException if establishing connection to SOCKS5 proxy failed + * @throws TimeoutException if connecting to SOCKS5 proxy timed out + * @throws InterruptedException if the current thread was interrupted while waiting + */ + public Socket getSocket(int timeout) throws IOException, XMPPException, InterruptedException, + TimeoutException { + + // wrap connecting in future for timeout + FutureTask<Socket> futureTask = new FutureTask<Socket>(new Callable<Socket>() { + + public Socket call() throws Exception { + + // initialize socket + Socket socket = new Socket(); + SocketAddress socketAddress = new InetSocketAddress(streamHost.getAddress(), + streamHost.getPort()); + socket.connect(socketAddress); + + // initialize connection to SOCKS5 proxy + if (!establish(socket)) { + + // initialization failed, close socket + socket.close(); + throw new XMPPException("establishing connection to SOCKS5 proxy failed"); + + } + + return socket; + } + + }); + Thread executor = new Thread(futureTask); + executor.start(); + + // get connection to initiator with timeout + try { + return futureTask.get(timeout, TimeUnit.MILLISECONDS); + } + catch (ExecutionException e) { + Throwable cause = e.getCause(); + if (cause != null) { + // case exceptions to comply with method signature + if (cause instanceof IOException) { + throw (IOException) cause; + } + if (cause instanceof XMPPException) { + throw (XMPPException) cause; + } + } + + // throw generic IO exception if unexpected exception was thrown + throw new IOException("Error while connection to SOCKS5 proxy"); + } + + } + + /** + * Initializes the connection to the SOCKS5 proxy by negotiating authentication method and + * requesting a stream for the given digest. Currently only the no-authentication method is + * supported by the Socks5Client. + * + * Returns <code>true</code> if a stream could be established, otherwise <code>false</code>. If + * <code>false</code> is returned the given Socket should be closed. + * + * @param socket connected to a SOCKS5 proxy + * @return <code>true</code> if if a stream could be established, otherwise <code>false</code>. + * If <code>false</code> is returned the given Socket should be closed. + * @throws IOException if a network error occurred + */ + protected boolean establish(Socket socket) throws IOException { + + /* + * use DataInputStream/DataOutpuStream to assure read and write is completed in a single + * statement + */ + DataInputStream in = new DataInputStream(socket.getInputStream()); + DataOutputStream out = new DataOutputStream(socket.getOutputStream()); + + // authentication negotiation + byte[] cmd = new byte[3]; + + cmd[0] = (byte) 0x05; // protocol version 5 + cmd[1] = (byte) 0x01; // number of authentication methods supported + cmd[2] = (byte) 0x00; // authentication method: no-authentication required + + out.write(cmd); + out.flush(); + + byte[] response = new byte[2]; + in.readFully(response); + + // check if server responded with correct version and no-authentication method + if (response[0] != (byte) 0x05 || response[1] != (byte) 0x00) { + return false; + } + + // request SOCKS5 connection with given address/digest + byte[] connectionRequest = createSocks5ConnectRequest(); + out.write(connectionRequest); + out.flush(); + + // receive response + byte[] connectionResponse; + try { + connectionResponse = Socks5Utils.receiveSocks5Message(in); + } + catch (XMPPException e) { + return false; // server answered in an unsupported way + } + + // verify response + connectionRequest[1] = (byte) 0x00; // set expected return status to 0 + return Arrays.equals(connectionRequest, connectionResponse); + } + + /** + * Returns a SOCKS5 connection request message. It contains the command "connect", the address + * type "domain" and the digest as address. + * + * (see <a href="http://tools.ietf.org/html/rfc1928">RFC1928</a>) + * + * @return SOCKS5 connection request message + */ + private byte[] createSocks5ConnectRequest() { + byte addr[] = this.digest.getBytes(); + + byte[] data = new byte[7 + addr.length]; + data[0] = (byte) 0x05; // version (SOCKS5) + data[1] = (byte) 0x01; // command (1 - connect) + data[2] = (byte) 0x00; // reserved byte (always 0) + data[3] = (byte) 0x03; // address type (3 - domain name) + data[4] = (byte) addr.length; // address length + System.arraycopy(addr, 0, data, 5, addr.length); // address + data[data.length - 2] = (byte) 0; // address port (2 bytes always 0) + data[data.length - 1] = (byte) 0; + + return data; + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5ClientForInitiator.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5ClientForInitiator.java new file mode 100644 index 0000000..0d90791 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5ClientForInitiator.java @@ -0,0 +1,117 @@ +/** + * 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.smackx.bytestreams.socks5; + +import java.io.IOException; +import java.net.Socket; +import java.util.concurrent.TimeoutException; + +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.util.SyncPacketSend; +import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream; +import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream.StreamHost; + +/** + * Implementation of a SOCKS5 client used on the initiators side. This is needed because connecting + * to the local SOCKS5 proxy differs form the regular way to connect to a SOCKS5 proxy. Additionally + * a remote SOCKS5 proxy has to be activated by the initiator before data can be transferred between + * the peers. + * + * @author Henning Staib + */ +class Socks5ClientForInitiator extends Socks5Client { + + /* the XMPP connection used to communicate with the SOCKS5 proxy */ + private Connection connection; + + /* the session ID used to activate SOCKS5 stream */ + private String sessionID; + + /* the target JID used to activate SOCKS5 stream */ + private String target; + + /** + * Creates a new SOCKS5 client for the initiators side. + * + * @param streamHost containing network settings of the SOCKS5 proxy + * @param digest identifying the SOCKS5 Bytestream + * @param connection the XMPP connection + * @param sessionID the session ID of the SOCKS5 Bytestream + * @param target the target JID of the SOCKS5 Bytestream + */ + public Socks5ClientForInitiator(StreamHost streamHost, String digest, Connection connection, + String sessionID, String target) { + super(streamHost, digest); + this.connection = connection; + this.sessionID = sessionID; + this.target = target; + } + + public Socket getSocket(int timeout) throws IOException, XMPPException, InterruptedException, + TimeoutException { + Socket socket = null; + + // check if stream host is the local SOCKS5 proxy + if (this.streamHost.getJID().equals(this.connection.getUser())) { + Socks5Proxy socks5Server = Socks5Proxy.getSocks5Proxy(); + socket = socks5Server.getSocket(this.digest); + if (socket == null) { + throw new XMPPException("target is not connected to SOCKS5 proxy"); + } + } + else { + socket = super.getSocket(timeout); + + try { + activate(); + } + catch (XMPPException e) { + socket.close(); + throw new XMPPException("activating SOCKS5 Bytestream failed", e); + } + + } + + return socket; + } + + /** + * Activates the SOCKS5 Bytestream by sending a XMPP SOCKS5 Bytestream activation packet to the + * SOCKS5 proxy. + */ + private void activate() throws XMPPException { + Bytestream activate = createStreamHostActivation(); + // if activation fails #getReply throws an exception + SyncPacketSend.getReply(this.connection, activate); + } + + /** + * Returns a SOCKS5 Bytestream activation packet. + * + * @return SOCKS5 Bytestream activation packet + */ + private Bytestream createStreamHostActivation() { + Bytestream activate = new Bytestream(this.sessionID); + activate.setMode(null); + activate.setType(IQ.Type.SET); + activate.setTo(this.streamHost.getJID()); + + activate.setToActivate(this.target); + + return activate; + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5Proxy.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5Proxy.java new file mode 100644 index 0000000..11ef7a9 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5Proxy.java @@ -0,0 +1,423 @@ +/** + * 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.smackx.bytestreams.socks5; + +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.net.InetAddress; +import java.net.ServerSocket; +import java.net.Socket; +import java.net.SocketException; +import java.net.UnknownHostException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; + +import org.jivesoftware.smack.SmackConfiguration; +import org.jivesoftware.smack.XMPPException; + +/** + * The Socks5Proxy class represents a local SOCKS5 proxy server. It can be enabled/disabled by + * setting the <code>localSocks5ProxyEnabled</code> flag in the <code>smack-config.xml</code> or by + * invoking {@link SmackConfiguration#setLocalSocks5ProxyEnabled(boolean)}. The proxy is enabled by + * default. + * + * The port of the local SOCKS5 proxy can be configured by setting <code>localSocks5ProxyPort</code> + * in the <code>smack-config.xml</code> or by invoking + * {@link SmackConfiguration#setLocalSocks5ProxyPort(int)}. Default port is 7777. If you set the + * port to a negative value Smack tries to the absolute value and all following until it finds an + * open port. + * + * If your application is running on a machine with multiple network interfaces or if you want to + * provide your public address in case you are behind a NAT router, invoke + * {@link #addLocalAddress(String)} or {@link #replaceLocalAddresses(List)} to modify the list of + * local network addresses used for outgoing SOCKS5 Bytestream requests. + * + * The local SOCKS5 proxy server refuses all connections except the ones that are explicitly allowed + * in the process of establishing a SOCKS5 Bytestream ( + * {@link Socks5BytestreamManager#establishSession(String)}). + * + * This Implementation has the following limitations: + * <ul> + * <li>only supports the no-authentication authentication method</li> + * <li>only supports the <code>connect</code> command and will not answer correctly to other + * commands</li> + * <li>only supports requests with the domain address type and will not correctly answer to requests + * with other address types</li> + * </ul> + * (see <a href="http://tools.ietf.org/html/rfc1928">RFC 1928</a>) + * + * @author Henning Staib + */ +public class Socks5Proxy { + + /* SOCKS5 proxy singleton */ + private static Socks5Proxy socks5Server; + + /* reusable implementation of a SOCKS5 proxy server process */ + private Socks5ServerProcess serverProcess; + + /* thread running the SOCKS5 server process */ + private Thread serverThread; + + /* server socket to accept SOCKS5 connections */ + private ServerSocket serverSocket; + + /* assigns a connection to a digest */ + private final Map<String, Socket> connectionMap = new ConcurrentHashMap<String, Socket>(); + + /* list of digests connections should be stored */ + private final List<String> allowedConnections = Collections.synchronizedList(new LinkedList<String>()); + + private final Set<String> localAddresses = Collections.synchronizedSet(new LinkedHashSet<String>()); + + /** + * Private constructor. + */ + private Socks5Proxy() { + this.serverProcess = new Socks5ServerProcess(); + + // add default local address + try { + this.localAddresses.add(InetAddress.getLocalHost().getHostAddress()); + } + catch (UnknownHostException e) { + // do nothing + } + + } + + /** + * Returns the local SOCKS5 proxy server. + * + * @return the local SOCKS5 proxy server + */ + public static synchronized Socks5Proxy getSocks5Proxy() { + if (socks5Server == null) { + socks5Server = new Socks5Proxy(); + } + if (SmackConfiguration.isLocalSocks5ProxyEnabled()) { + socks5Server.start(); + } + return socks5Server; + } + + /** + * Starts the local SOCKS5 proxy server. If it is already running, this method does nothing. + */ + public synchronized void start() { + if (isRunning()) { + return; + } + try { + if (SmackConfiguration.getLocalSocks5ProxyPort() < 0) { + int port = Math.abs(SmackConfiguration.getLocalSocks5ProxyPort()); + for (int i = 0; i < 65535 - port; i++) { + try { + this.serverSocket = new ServerSocket(port + i); + break; + } + catch (IOException e) { + // port is used, try next one + } + } + } + else { + this.serverSocket = new ServerSocket(SmackConfiguration.getLocalSocks5ProxyPort()); + } + + if (this.serverSocket != null) { + this.serverThread = new Thread(this.serverProcess); + this.serverThread.start(); + } + } + catch (IOException e) { + // couldn't setup server + System.err.println("couldn't setup local SOCKS5 proxy on port " + + SmackConfiguration.getLocalSocks5ProxyPort() + ": " + e.getMessage()); + } + } + + /** + * Stops the local SOCKS5 proxy server. If it is not running this method does nothing. + */ + public synchronized void stop() { + if (!isRunning()) { + return; + } + + try { + this.serverSocket.close(); + } + catch (IOException e) { + // do nothing + } + + if (this.serverThread != null && this.serverThread.isAlive()) { + try { + this.serverThread.interrupt(); + this.serverThread.join(); + } + catch (InterruptedException e) { + // do nothing + } + } + this.serverThread = null; + this.serverSocket = null; + + } + + /** + * Adds the given address to the list of local network addresses. + * + * Use this method if you want to provide multiple addresses in a SOCKS5 Bytestream request. + * This may be necessary if your application is running on a machine with multiple network + * interfaces or if you want to provide your public address in case you are behind a NAT router. + * + * The order of the addresses used is determined by the order you add addresses. + * + * Note that the list of addresses initially contains the address returned by + * <code>InetAddress.getLocalHost().getHostAddress()</code>. You can replace the list of + * addresses by invoking {@link #replaceLocalAddresses(List)}. + * + * @param address the local network address to add + */ + public void addLocalAddress(String address) { + if (address == null) { + throw new IllegalArgumentException("address may not be null"); + } + this.localAddresses.add(address); + } + + /** + * Removes the given address from the list of local network addresses. This address will then no + * longer be used of outgoing SOCKS5 Bytestream requests. + * + * @param address the local network address to remove + */ + public void removeLocalAddress(String address) { + this.localAddresses.remove(address); + } + + /** + * Returns an unmodifiable list of the local network addresses that will be used for streamhost + * candidates of outgoing SOCKS5 Bytestream requests. + * + * @return unmodifiable list of the local network addresses + */ + public List<String> getLocalAddresses() { + return Collections.unmodifiableList(new ArrayList<String>(this.localAddresses)); + } + + /** + * Replaces the list of local network addresses. + * + * Use this method if you want to provide multiple addresses in a SOCKS5 Bytestream request and + * want to define their order. This may be necessary if your application is running on a machine + * with multiple network interfaces or if you want to provide your public address in case you + * are behind a NAT router. + * + * @param addresses the new list of local network addresses + */ + public void replaceLocalAddresses(List<String> addresses) { + if (addresses == null) { + throw new IllegalArgumentException("list must not be null"); + } + this.localAddresses.clear(); + this.localAddresses.addAll(addresses); + + } + + /** + * Returns the port of the local SOCKS5 proxy server. If it is not running -1 will be returned. + * + * @return the port of the local SOCKS5 proxy server or -1 if proxy is not running + */ + public int getPort() { + if (!isRunning()) { + return -1; + } + return this.serverSocket.getLocalPort(); + } + + /** + * Returns the socket for the given digest. A socket will be returned if the given digest has + * been in the list of allowed transfers (see {@link #addTransfer(String)}) while the peer + * connected to the SOCKS5 proxy. + * + * @param digest identifying the connection + * @return socket or null if there is no socket for the given digest + */ + protected Socket getSocket(String digest) { + return this.connectionMap.get(digest); + } + + /** + * Add the given digest to the list of allowed transfers. Only connections for allowed transfers + * are stored and can be retrieved by invoking {@link #getSocket(String)}. All connections to + * the local SOCKS5 proxy that don't contain an allowed digest are discarded. + * + * @param digest to be added to the list of allowed transfers + */ + protected void addTransfer(String digest) { + this.allowedConnections.add(digest); + } + + /** + * Removes the given digest from the list of allowed transfers. After invoking this method + * already stored connections with the given digest will be removed. + * + * The digest should be removed after establishing the SOCKS5 Bytestream is finished, an error + * occurred while establishing the connection or if the connection is not allowed anymore. + * + * @param digest to be removed from the list of allowed transfers + */ + protected void removeTransfer(String digest) { + this.allowedConnections.remove(digest); + this.connectionMap.remove(digest); + } + + /** + * Returns <code>true</code> if the local SOCKS5 proxy server is running, otherwise + * <code>false</code>. + * + * @return <code>true</code> if the local SOCKS5 proxy server is running, otherwise + * <code>false</code> + */ + public boolean isRunning() { + return this.serverSocket != null; + } + + /** + * Implementation of a simplified SOCKS5 proxy server. + */ + private class Socks5ServerProcess implements Runnable { + + public void run() { + while (true) { + Socket socket = null; + + try { + + if (Socks5Proxy.this.serverSocket.isClosed() + || Thread.currentThread().isInterrupted()) { + return; + } + + // accept connection + socket = Socks5Proxy.this.serverSocket.accept(); + + // initialize connection + establishConnection(socket); + + } + catch (SocketException e) { + /* + * do nothing, if caused by closing the server socket, thread will terminate in + * next loop + */ + } + catch (Exception e) { + try { + if (socket != null) { + socket.close(); + } + } + catch (IOException e1) { + /* do nothing */ + } + } + } + + } + + /** + * Negotiates a SOCKS5 connection and stores it on success. + * + * @param socket connection to the client + * @throws XMPPException if client requests a connection in an unsupported way + * @throws IOException if a network error occurred + */ + private void establishConnection(Socket socket) throws XMPPException, IOException { + DataOutputStream out = new DataOutputStream(socket.getOutputStream()); + DataInputStream in = new DataInputStream(socket.getInputStream()); + + // first byte is version should be 5 + int b = in.read(); + if (b != 5) { + throw new XMPPException("Only SOCKS5 supported"); + } + + // second byte number of authentication methods supported + b = in.read(); + + // read list of supported authentication methods + byte[] auth = new byte[b]; + in.readFully(auth); + + byte[] authMethodSelectionResponse = new byte[2]; + authMethodSelectionResponse[0] = (byte) 0x05; // protocol version + + // only authentication method 0, no authentication, supported + boolean noAuthMethodFound = false; + for (int i = 0; i < auth.length; i++) { + if (auth[i] == (byte) 0x00) { + noAuthMethodFound = true; + break; + } + } + + if (!noAuthMethodFound) { + authMethodSelectionResponse[1] = (byte) 0xFF; // no acceptable methods + out.write(authMethodSelectionResponse); + out.flush(); + throw new XMPPException("Authentication method not supported"); + } + + authMethodSelectionResponse[1] = (byte) 0x00; // no-authentication method + out.write(authMethodSelectionResponse); + out.flush(); + + // receive connection request + byte[] connectionRequest = Socks5Utils.receiveSocks5Message(in); + + // extract digest + String responseDigest = new String(connectionRequest, 5, connectionRequest[4]); + + // return error if digest is not allowed + if (!Socks5Proxy.this.allowedConnections.contains(responseDigest)) { + connectionRequest[1] = (byte) 0x05; // set return status to 5 (connection refused) + out.write(connectionRequest); + out.flush(); + + throw new XMPPException("Connection is not allowed"); + } + + connectionRequest[1] = (byte) 0x00; // set return status to 0 (success) + out.write(connectionRequest); + out.flush(); + + // store connection + Socks5Proxy.this.connectionMap.put(responseDigest, socket); + } + + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5Utils.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5Utils.java new file mode 100644 index 0000000..9c92563 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/Socks5Utils.java @@ -0,0 +1,73 @@ +/** + * 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.smackx.bytestreams.socks5; + +import java.io.DataInputStream; +import java.io.IOException; + +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.util.StringUtils; + +/** + * A collection of utility methods for SOcKS5 messages. + * + * @author Henning Staib + */ +class Socks5Utils { + + /** + * Returns a SHA-1 digest of the given parameters as specified in <a + * href="http://xmpp.org/extensions/xep-0065.html#impl-socks5">XEP-0065</a>. + * + * @param sessionID for the SOCKS5 Bytestream + * @param initiatorJID JID of the initiator of a SOCKS5 Bytestream + * @param targetJID JID of the target of a SOCKS5 Bytestream + * @return SHA-1 digest of the given parameters + */ + public static String createDigest(String sessionID, String initiatorJID, String targetJID) { + StringBuilder b = new StringBuilder(); + b.append(sessionID).append(initiatorJID).append(targetJID); + return StringUtils.hash(b.toString()); + } + + /** + * Reads a SOCKS5 message from the given InputStream. The message can either be a SOCKS5 request + * message or a SOCKS5 response message. + * + * (see <a href="http://tools.ietf.org/html/rfc1928">RFC1928</a>) + * + * @param in the DataInputStream to read the message from + * @return the SOCKS5 message + * @throws IOException if a network error occurred + * @throws XMPPException if the SOCKS5 message contains an unsupported address type + */ + public static byte[] receiveSocks5Message(DataInputStream in) throws IOException, XMPPException { + byte[] header = new byte[5]; + in.readFully(header, 0, 5); + + if (header[3] != (byte) 0x03) { + throw new XMPPException("Unsupported SOCKS5 address type"); + } + + int addressLength = header[4]; + + byte[] response = new byte[7 + addressLength]; + System.arraycopy(header, 0, response, 0, header.length); + + in.readFully(response, header.length, addressLength + 2); + + return response; + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/packet/Bytestream.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/packet/Bytestream.java new file mode 100644 index 0000000..9e07fc3 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/packet/Bytestream.java @@ -0,0 +1,474 @@ +/** + * 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.smackx.bytestreams.socks5.packet; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.PacketExtension; + +/** + * A packet representing part of a SOCKS5 Bytestream negotiation. + * + * @author Alexander Wenckus + */ +public class Bytestream extends IQ { + + private String sessionID; + + private Mode mode = Mode.tcp; + + private final List<StreamHost> streamHosts = new ArrayList<StreamHost>(); + + private StreamHostUsed usedHost; + + private Activate toActivate; + + /** + * The default constructor + */ + public Bytestream() { + super(); + } + + /** + * A constructor where the session ID can be specified. + * + * @param SID The session ID related to the negotiation. + * @see #setSessionID(String) + */ + public Bytestream(final String SID) { + super(); + setSessionID(SID); + } + + /** + * Set the session ID related to the bytestream. The session ID is a unique identifier used to + * differentiate between stream negotiations. + * + * @param sessionID the unique session ID that identifies the transfer. + */ + public void setSessionID(final String sessionID) { + this.sessionID = sessionID; + } + + /** + * Returns the session ID related to the bytestream negotiation. + * + * @return Returns the session ID related to the bytestream negotiation. + * @see #setSessionID(String) + */ + public String getSessionID() { + return sessionID; + } + + /** + * Set the transport mode. This should be put in the initiation of the interaction. + * + * @param mode the transport mode, either UDP or TCP + * @see Mode + */ + public void setMode(final Mode mode) { + this.mode = mode; + } + + /** + * Returns the transport mode. + * + * @return Returns the transport mode. + * @see #setMode(Mode) + */ + public Mode getMode() { + return mode; + } + + /** + * Adds a potential stream host that the remote user can connect to to receive the file. + * + * @param JID The JID of the stream host. + * @param address The internet address of the stream host. + * @return The added stream host. + */ + public StreamHost addStreamHost(final String JID, final String address) { + return addStreamHost(JID, address, 0); + } + + /** + * Adds a potential stream host that the remote user can connect to to receive the file. + * + * @param JID The JID of the stream host. + * @param address The internet address of the stream host. + * @param port The port on which the remote host is seeking connections. + * @return The added stream host. + */ + public StreamHost addStreamHost(final String JID, final String address, final int port) { + StreamHost host = new StreamHost(JID, address); + host.setPort(port); + addStreamHost(host); + + return host; + } + + /** + * Adds a potential stream host that the remote user can transfer the file through. + * + * @param host The potential stream host. + */ + public void addStreamHost(final StreamHost host) { + streamHosts.add(host); + } + + /** + * Returns the list of stream hosts contained in the packet. + * + * @return Returns the list of stream hosts contained in the packet. + */ + public Collection<StreamHost> getStreamHosts() { + return Collections.unmodifiableCollection(streamHosts); + } + + /** + * Returns the stream host related to the given JID, or null if there is none. + * + * @param JID The JID of the desired stream host. + * @return Returns the stream host related to the given JID, or null if there is none. + */ + public StreamHost getStreamHost(final String JID) { + if (JID == null) { + return null; + } + for (StreamHost host : streamHosts) { + if (host.getJID().equals(JID)) { + return host; + } + } + + return null; + } + + /** + * Returns the count of stream hosts contained in this packet. + * + * @return Returns the count of stream hosts contained in this packet. + */ + public int countStreamHosts() { + return streamHosts.size(); + } + + /** + * Upon connecting to the stream host the target of the stream replies to the initiator with the + * JID of the SOCKS5 host that they used. + * + * @param JID The JID of the used host. + */ + public void setUsedHost(final String JID) { + this.usedHost = new StreamHostUsed(JID); + } + + /** + * Returns the SOCKS5 host connected to by the remote user. + * + * @return Returns the SOCKS5 host connected to by the remote user. + */ + public StreamHostUsed getUsedHost() { + return usedHost; + } + + /** + * Returns the activate element of the packet sent to the proxy host to verify the identity of + * the initiator and match them to the appropriate stream. + * + * @return Returns the activate element of the packet sent to the proxy host to verify the + * identity of the initiator and match them to the appropriate stream. + */ + public Activate getToActivate() { + return toActivate; + } + + /** + * Upon the response from the target of the used host the activate packet is sent to the SOCKS5 + * proxy. The proxy will activate the stream or return an error after verifying the identity of + * the initiator, using the activate packet. + * + * @param targetID The JID of the target of the file transfer. + */ + public void setToActivate(final String targetID) { + this.toActivate = new Activate(targetID); + } + + public String getChildElementXML() { + StringBuilder buf = new StringBuilder(); + + buf.append("<query xmlns=\"http://jabber.org/protocol/bytestreams\""); + if (this.getType().equals(IQ.Type.SET)) { + if (getSessionID() != null) { + buf.append(" sid=\"").append(getSessionID()).append("\""); + } + if (getMode() != null) { + buf.append(" mode = \"").append(getMode()).append("\""); + } + buf.append(">"); + if (getToActivate() == null) { + for (StreamHost streamHost : getStreamHosts()) { + buf.append(streamHost.toXML()); + } + } + else { + buf.append(getToActivate().toXML()); + } + } + else if (this.getType().equals(IQ.Type.RESULT)) { + buf.append(">"); + if (getUsedHost() != null) { + buf.append(getUsedHost().toXML()); + } + // A result from the server can also contain stream hosts + else if (countStreamHosts() > 0) { + for (StreamHost host : streamHosts) { + buf.append(host.toXML()); + } + } + } + else if (this.getType().equals(IQ.Type.GET)) { + return buf.append("/>").toString(); + } + else { + return null; + } + buf.append("</query>"); + + return buf.toString(); + } + + /** + * Packet extension that represents a potential SOCKS5 proxy for the file transfer. Stream hosts + * are forwarded to the target of the file transfer who then chooses and connects to one. + * + * @author Alexander Wenckus + */ + public static class StreamHost implements PacketExtension { + + public static String NAMESPACE = ""; + + public static String ELEMENTNAME = "streamhost"; + + private final String JID; + + private final String addy; + + private int port = 0; + + /** + * Default constructor. + * + * @param JID The JID of the stream host. + * @param address The internet address of the stream host. + */ + public StreamHost(final String JID, final String address) { + this.JID = JID; + this.addy = address; + } + + /** + * Returns the JID of the stream host. + * + * @return Returns the JID of the stream host. + */ + public String getJID() { + return JID; + } + + /** + * Returns the internet address of the stream host. + * + * @return Returns the internet address of the stream host. + */ + public String getAddress() { + return addy; + } + + /** + * Sets the port of the stream host. + * + * @param port The port on which the potential stream host would accept the connection. + */ + public void setPort(final int port) { + this.port = port; + } + + /** + * Returns the port on which the potential stream host would accept the connection. + * + * @return Returns the port on which the potential stream host would accept the connection. + */ + public int getPort() { + return port; + } + + public String getNamespace() { + return NAMESPACE; + } + + public String getElementName() { + return ELEMENTNAME; + } + + public String toXML() { + StringBuilder buf = new StringBuilder(); + + buf.append("<").append(getElementName()).append(" "); + buf.append("jid=\"").append(getJID()).append("\" "); + buf.append("host=\"").append(getAddress()).append("\" "); + if (getPort() != 0) { + buf.append("port=\"").append(getPort()).append("\""); + } + else { + buf.append("zeroconf=\"_jabber.bytestreams\""); + } + buf.append("/>"); + + return buf.toString(); + } + } + + /** + * After selected a SOCKS5 stream host and successfully connecting, the target of the file + * transfer returns a byte stream packet with the stream host used extension. + * + * @author Alexander Wenckus + */ + public static class StreamHostUsed implements PacketExtension { + + public String NAMESPACE = ""; + + public static String ELEMENTNAME = "streamhost-used"; + + private final String JID; + + /** + * Default constructor. + * + * @param JID The JID of the selected stream host. + */ + public StreamHostUsed(final String JID) { + this.JID = JID; + } + + /** + * Returns the JID of the selected stream host. + * + * @return Returns the JID of the selected stream host. + */ + public String getJID() { + return JID; + } + + public String getNamespace() { + return NAMESPACE; + } + + public String getElementName() { + return ELEMENTNAME; + } + + public String toXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<").append(getElementName()).append(" "); + buf.append("jid=\"").append(getJID()).append("\" "); + buf.append("/>"); + return buf.toString(); + } + } + + /** + * The packet sent by the stream initiator to the stream proxy to activate the connection. + * + * @author Alexander Wenckus + */ + public static class Activate implements PacketExtension { + + public String NAMESPACE = ""; + + public static String ELEMENTNAME = "activate"; + + private final String target; + + /** + * Default constructor specifying the target of the stream. + * + * @param target The target of the stream. + */ + public Activate(final String target) { + this.target = target; + } + + /** + * Returns the target of the activation. + * + * @return Returns the target of the activation. + */ + public String getTarget() { + return target; + } + + public String getNamespace() { + return NAMESPACE; + } + + public String getElementName() { + return ELEMENTNAME; + } + + public String toXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<").append(getElementName()).append(">"); + buf.append(getTarget()); + buf.append("</").append(getElementName()).append(">"); + return buf.toString(); + } + } + + /** + * The stream can be either a TCP stream or a UDP stream. + * + * @author Alexander Wenckus + */ + public enum Mode { + + /** + * A TCP based stream. + */ + tcp, + + /** + * A UDP based stream. + */ + udp; + + public static Mode fromName(String name) { + Mode mode; + try { + mode = Mode.valueOf(name); + } + catch (Exception ex) { + mode = tcp; + } + + return mode; + } + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/provider/BytestreamsProvider.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/provider/BytestreamsProvider.java new file mode 100644 index 0000000..76f9b0c --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/bytestreams/socks5/provider/BytestreamsProvider.java @@ -0,0 +1,82 @@ +/** + * 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.smackx.bytestreams.socks5.provider; + +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.provider.IQProvider; +import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream; +import org.xmlpull.v1.XmlPullParser; + +/** + * Parses a bytestream packet. + * + * @author Alexander Wenckus + */ +public class BytestreamsProvider implements IQProvider { + + public IQ parseIQ(XmlPullParser parser) throws Exception { + boolean done = false; + + Bytestream toReturn = new Bytestream(); + + String id = parser.getAttributeValue("", "sid"); + String mode = parser.getAttributeValue("", "mode"); + + // streamhost + String JID = null; + String host = null; + String port = null; + + int eventType; + String elementName; + while (!done) { + eventType = parser.next(); + elementName = parser.getName(); + if (eventType == XmlPullParser.START_TAG) { + if (elementName.equals(Bytestream.StreamHost.ELEMENTNAME)) { + JID = parser.getAttributeValue("", "jid"); + host = parser.getAttributeValue("", "host"); + port = parser.getAttributeValue("", "port"); + } + else if (elementName.equals(Bytestream.StreamHostUsed.ELEMENTNAME)) { + toReturn.setUsedHost(parser.getAttributeValue("", "jid")); + } + else if (elementName.equals(Bytestream.Activate.ELEMENTNAME)) { + toReturn.setToActivate(parser.getAttributeValue("", "jid")); + } + } + else if (eventType == XmlPullParser.END_TAG) { + if (elementName.equals("streamhost")) { + if (port == null) { + toReturn.addStreamHost(JID, host); + } + else { + toReturn.addStreamHost(JID, host, Integer.parseInt(port)); + } + JID = null; + host = null; + port = null; + } + else if (elementName.equals("query")) { + done = true; + } + } + } + + toReturn.setMode((Bytestream.Mode.fromName(mode))); + toReturn.setSessionID(id); + return toReturn; + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/AdHocCommand.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/AdHocCommand.java new file mode 100755 index 0000000..c5d0963 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/AdHocCommand.java @@ -0,0 +1,450 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2005-2007 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.smackx.commands; + +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.packet.XMPPError; +import org.jivesoftware.smackx.Form; +import org.jivesoftware.smackx.packet.AdHocCommandData; + +import java.util.List; + +/** + * An ad-hoc command is responsible for executing the provided service and + * storing the result of the execution. Each new request will create a new + * instance of the command, allowing information related to executions to be + * stored in it. For example suppose that a command that retrieves the list of + * users on a server is implemented. When the command is executed it gets that + * list and the result is stored as a form in the command instance, i.e. the + * <code>getForm</code> method retrieves a form with all the users. + * + * Each command has a <tt>node</tt> that should be unique within a given JID. + * + * Commands may have zero or more stages. Each stage is usually used for + * gathering information required for the command execution. Users are able to + * move forward or backward across the different stages. Commands may not be + * cancelled while they are being executed. However, users may request the + * "cancel" action when submitting a stage response indicating that the command + * execution should be aborted. Thus, releasing any collected information. + * Commands that require user interaction (i.e. have more than one stage) will + * have to provide the data forms the user must complete in each stage and the + * allowed actions the user might perform during each stage (e.g. go to the + * previous stage or go to the next stage). + * + * All the actions may throw an XMPPException if there is a problem executing + * them. The <code>XMPPError</code> of that exception may have some specific + * information about the problem. The possible extensions are: + * + * <li>malformed-action. Extension of a bad-request error.</li> + * <li>bad-action. Extension of a bad-request error.</li> + * <li>bad-locale. Extension of a bad-request error.</li> + * <li>bad-payload. Extension of a bad-request error.</li> + * <li>bad-sessionid. Extension of a bad-request error.</li> + * <li>session-expired. Extension of a not-allowed error.</li> + * + * See the <code>SpecificErrorCondition</code> class for detailed description + * of each one. + * + * Use the <code>getSpecificErrorConditionFrom</code> to obtain the specific + * information from an <code>XMPPError</code>. + * + * @author Gabriel Guardincerri + * + */ +public abstract class AdHocCommand { + // TODO: Analyze the redesign of command by having an ExecutionResponse as a + // TODO: result to the execution of every action. That result should have all the + // TODO: information related to the execution, e.g. the form to fill. Maybe this + // TODO: design is more intuitive and simpler than the current one that has all in + // TODO: one class. + + private AdHocCommandData data; + + public AdHocCommand() { + super(); + data = new AdHocCommandData(); + } + + /** + * Returns the specific condition of the <code>error</code> or <tt>null</tt> if the + * error doesn't have any. + * + * @param error the error the get the specific condition from. + * @return the specific condition of this error, or null if it doesn't have + * any. + */ + public static SpecificErrorCondition getSpecificErrorCondition(XMPPError error) { + // This method is implemented to provide an easy way of getting a packet + // extension of the XMPPError. + for (SpecificErrorCondition condition : SpecificErrorCondition.values()) { + if (error.getExtension(condition.toString(), + AdHocCommandData.SpecificError.namespace) != null) { + return condition; + } + } + return null; + } + + /** + * Set the the human readable name of the command, usually used for + * displaying in a UI. + * + * @param name the name. + */ + public void setName(String name) { + data.setName(name); + } + + /** + * Returns the human readable name of the command. + * + * @return the human readable name of the command + */ + public String getName() { + return data.getName(); + } + + /** + * Sets the unique identifier of the command. This value must be unique for + * the <code>OwnerJID</code>. + * + * @param node the unique identifier of the command. + */ + public void setNode(String node) { + data.setNode(node); + } + + /** + * Returns the unique identifier of the command. It is unique for the + * <code>OwnerJID</code>. + * + * @return the unique identifier of the command. + */ + public String getNode() { + return data.getNode(); + } + + /** + * Returns the full JID of the owner of this command. This JID is the "to" of a + * execution request. + * + * @return the owner JID. + */ + public abstract String getOwnerJID(); + + /** + * Returns the notes that the command has at the current stage. + * + * @return a list of notes. + */ + public List<AdHocCommandNote> getNotes() { + return data.getNotes(); + } + + /** + * Adds a note to the current stage. This should be used when setting a + * response to the execution of an action. All the notes added here are + * returned by the {@link #getNotes} method during the current stage. + * Once the stage changes all the notes are discarded. + * + * @param note the note. + */ + protected void addNote(AdHocCommandNote note) { + data.addNote(note); + } + + public String getRaw() { + return data.getChildElementXML(); + } + + /** + * Returns the form of the current stage. Usually it is the form that must + * be answered to execute the next action. If that is the case it should be + * used by the requester to fill all the information that the executor needs + * to continue to the next stage. It can also be the result of the + * execution. + * + * @return the form of the current stage to fill out or the result of the + * execution. + */ + public Form getForm() { + if (data.getForm() == null) { + return null; + } + else { + return new Form(data.getForm()); + } + } + + /** + * Sets the form of the current stage. This should be used when setting a + * response. It could be a form to fill out the information needed to go to + * the next stage or the result of an execution. + * + * @param form the form of the current stage to fill out or the result of the + * execution. + */ + protected void setForm(Form form) { + data.setForm(form.getDataFormToSend()); + } + + /** + * Executes the command. This is invoked only on the first stage of the + * command. It is invoked on every command. If there is a problem executing + * the command it throws an XMPPException. + * + * @throws XMPPException if there is an error executing the command. + */ + public abstract void execute() throws XMPPException; + + /** + * Executes the next action of the command with the information provided in + * the <code>response</code>. This form must be the answer form of the + * previous stage. This method will be only invoked for commands that have one + * or more stages. If there is a problem executing the command it throws an + * XMPPException. + * + * @param response the form answer of the previous stage. + * @throws XMPPException if there is a problem executing the command. + */ + public abstract void next(Form response) throws XMPPException; + + /** + * Completes the command execution with the information provided in the + * <code>response</code>. This form must be the answer form of the + * previous stage. This method will be only invoked for commands that have one + * or more stages. If there is a problem executing the command it throws an + * XMPPException. + * + * @param response the form answer of the previous stage. + * @throws XMPPException if there is a problem executing the command. + */ + public abstract void complete(Form response) throws XMPPException; + + /** + * Goes to the previous stage. The requester is asking to re-send the + * information of the previous stage. The command must change it state to + * the previous one. If there is a problem executing the command it throws + * an XMPPException. + * + * @throws XMPPException if there is a problem executing the command. + */ + public abstract void prev() throws XMPPException; + + /** + * Cancels the execution of the command. This can be invoked on any stage of + * the execution. If there is a problem executing the command it throws an + * XMPPException. + * + * @throws XMPPException if there is a problem executing the command. + */ + public abstract void cancel() throws XMPPException; + + /** + * Returns a collection with the allowed actions based on the current stage. + * Possible actions are: {@link Action#prev prev}, {@link Action#next next} and + * {@link Action#complete complete}. This method will be only invoked for commands that + * have one or more stages. + * + * @return a collection with the allowed actions based on the current stage + * as defined in the SessionData. + */ + protected List<Action> getActions() { + return data.getActions(); + } + + /** + * Add an action to the current stage available actions. This should be used + * when creating a response. + * + * @param action the action. + */ + protected void addActionAvailable(Action action) { + data.addAction(action); + } + + /** + * Returns the action available for the current stage which is + * considered the equivalent to "execute". When the requester sends his + * reply, if no action was defined in the command then the action will be + * assumed "execute" thus assuming the action returned by this method. This + * method will never be invoked for commands that have no stages. + * + * @return the action available for the current stage which is considered + * the equivalent to "execute". + */ + protected Action getExecuteAction() { + return data.getExecuteAction(); + } + + /** + * Sets which of the actions available for the current stage is + * considered the equivalent to "execute". This should be used when setting + * a response. When the requester sends his reply, if no action was defined + * in the command then the action will be assumed "execute" thus assuming + * the action returned by this method. + * + * @param action the action. + */ + protected void setExecuteAction(Action action) { + data.setExecuteAction(action); + } + + /** + * Returns the status of the current stage. + * + * @return the current status. + */ + public Status getStatus() { + return data.getStatus(); + } + + /** + * Sets the data of the current stage. This should not used. + * + * @param data the data. + */ + void setData(AdHocCommandData data) { + this.data = data; + } + + /** + * Gets the data of the current stage. This should not used. + * + * @return the data. + */ + AdHocCommandData getData() { + return data; + } + + /** + * Returns true if the <code>action</code> is available in the current stage. + * The {@link Action#cancel cancel} action is always allowed. To define the + * available actions use the <code>addActionAvailable</code> method. + * + * @param action + * The action to check if it is available. + * @return True if the action is available for the current stage. + */ + protected boolean isValidAction(Action action) { + return getActions().contains(action) || Action.cancel.equals(action); + } + + /** + * The status of the stage in the adhoc command. + */ + public enum Status { + + /** + * The command is being executed. + */ + executing, + + /** + * The command has completed. The command session has ended. + */ + completed, + + /** + * The command has been canceled. The command session has ended. + */ + canceled + } + + public enum Action { + + /** + * The command should be executed or continue to be executed. This is + * the default value. + */ + execute, + + /** + * The command should be canceled. + */ + cancel, + + /** + * The command should be digress to the previous stage of execution. + */ + prev, + + /** + * The command should progress to the next stage of execution. + */ + next, + + /** + * The command should be completed (if possible). + */ + complete, + + /** + * The action is unknow. This is used when a recieved message has an + * unknown action. It must not be used to send an execution request. + */ + unknown + } + + public enum SpecificErrorCondition { + + /** + * The responding JID cannot accept the specified action. + */ + badAction("bad-action"), + + /** + * The responding JID does not understand the specified action. + */ + malformedAction("malformed-action"), + + /** + * The responding JID cannot accept the specified language/locale. + */ + badLocale("bad-locale"), + + /** + * The responding JID cannot accept the specified payload (e.g. the data + * form did not provide one or more required fields). + */ + badPayload("bad-payload"), + + /** + * The responding JID cannot accept the specified sessionid. + */ + badSessionid("bad-sessionid"), + + /** + * The requesting JID specified a sessionid that is no longer active + * (either because it was completed, canceled, or timed out). + */ + sessionExpired("session-expired"); + + private String value; + + SpecificErrorCondition(String value) { + this.value = value; + } + + public String toString() { + return value; + } + } +} \ No newline at end of file diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/AdHocCommandManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/AdHocCommandManager.java new file mode 100755 index 0000000..7496bf6 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/AdHocCommandManager.java @@ -0,0 +1,740 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 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.smackx.commands; + +import org.jivesoftware.smack.*; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.packet.XMPPError; +import org.jivesoftware.smack.util.StringUtils; +import org.jivesoftware.smackx.Form; +import org.jivesoftware.smackx.NodeInformationProvider; +import org.jivesoftware.smackx.ServiceDiscoveryManager; +import org.jivesoftware.smackx.commands.AdHocCommand.Action; +import org.jivesoftware.smackx.commands.AdHocCommand.Status; +import org.jivesoftware.smackx.packet.AdHocCommandData; +import org.jivesoftware.smackx.packet.DiscoverInfo; +import org.jivesoftware.smackx.packet.DiscoverInfo.Identity; +import org.jivesoftware.smackx.packet.DiscoverItems; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +/** + * An AdHocCommandManager is responsible for keeping the list of available + * commands offered by a service and for processing commands requests. + * + * Pass in a Connection instance to + * {@link #getAddHocCommandsManager(org.jivesoftware.smack.Connection)} in order to + * get an instance of this class. + * + * @author Gabriel Guardincerri + */ +public class AdHocCommandManager { + + private static final String DISCO_NAMESPACE = "http://jabber.org/protocol/commands"; + + private static final String discoNode = DISCO_NAMESPACE; + + /** + * The session time out in seconds. + */ + private static final int SESSION_TIMEOUT = 2 * 60; + + /** + * Map a Connection with it AdHocCommandManager. This map have a key-value + * pair for every active connection. + */ + private static Map<Connection, AdHocCommandManager> instances = + new ConcurrentHashMap<Connection, AdHocCommandManager>(); + + /** + * Register the listener for all the connection creations. When a new + * connection is created a new AdHocCommandManager is also created and + * related to that connection. + */ + static { + Connection.addConnectionCreationListener(new ConnectionCreationListener() { + public void connectionCreated(Connection connection) { + new AdHocCommandManager(connection); + } + }); + } + + /** + * Returns the <code>AdHocCommandManager</code> related to the + * <code>connection</code>. + * + * @param connection the XMPP connection. + * @return the AdHocCommandManager associated with the connection. + */ + public static AdHocCommandManager getAddHocCommandsManager(Connection connection) { + return instances.get(connection); + } + + /** + * Thread that reaps stale sessions. + */ + private Thread sessionsSweeper; + + /** + * The Connection that this instances of AdHocCommandManager manages + */ + private Connection connection; + + /** + * Map a command node with its AdHocCommandInfo. Note: Key=command node, + * Value=command. Command node matches the node attribute sent by command + * requesters. + */ + private Map<String, AdHocCommandInfo> commands = new ConcurrentHashMap<String, AdHocCommandInfo>(); + + /** + * Map a command session ID with the instance LocalCommand. The LocalCommand + * is the an objects that has all the information of the current state of + * the command execution. Note: Key=session ID, Value=LocalCommand. Session + * ID matches the sessionid attribute sent by command responders. + */ + private Map<String, LocalCommand> executingCommands = new ConcurrentHashMap<String, LocalCommand>(); + + private AdHocCommandManager(Connection connection) { + super(); + this.connection = connection; + init(); + } + + /** + * Registers a new command with this command manager, which is related to a + * connection. The <tt>node</tt> is an unique identifier of that command for + * the connection related to this command manager. The <tt>name</tt> is the + * human readable name of the command. The <tt>class</tt> is the class of + * the command, which must extend {@link LocalCommand} and have a default + * constructor. + * + * @param node the unique identifier of the command. + * @param name the human readable name of the command. + * @param clazz the class of the command, which must extend {@link LocalCommand}. + */ + public void registerCommand(String node, String name, final Class clazz) { + registerCommand(node, name, new LocalCommandFactory() { + public LocalCommand getInstance() throws InstantiationException, IllegalAccessException { + return (LocalCommand)clazz.newInstance(); + } + }); + } + + /** + * Registers a new command with this command manager, which is related to a + * connection. The <tt>node</tt> is an unique identifier of that + * command for the connection related to this command manager. The <tt>name</tt> + * is the human readeale name of the command. The <tt>factory</tt> generates + * new instances of the command. + * + * @param node the unique identifier of the command. + * @param name the human readable name of the command. + * @param factory a factory to create new instances of the command. + */ + public void registerCommand(String node, final String name, LocalCommandFactory factory) { + AdHocCommandInfo commandInfo = new AdHocCommandInfo(node, name, connection.getUser(), factory); + + commands.put(node, commandInfo); + // Set the NodeInformationProvider that will provide information about + // the added command + ServiceDiscoveryManager.getInstanceFor(connection).setNodeInformationProvider(node, + new NodeInformationProvider() { + public List<DiscoverItems.Item> getNodeItems() { + return null; + } + + public List<String> getNodeFeatures() { + List<String> answer = new ArrayList<String>(); + answer.add(DISCO_NAMESPACE); + // TODO: check if this service is provided by the + // TODO: current connection. + answer.add("jabber:x:data"); + return answer; + } + + public List<DiscoverInfo.Identity> getNodeIdentities() { + List<DiscoverInfo.Identity> answer = new ArrayList<DiscoverInfo.Identity>(); + DiscoverInfo.Identity identity = new DiscoverInfo.Identity( + "automation", name); + identity.setType("command-node"); + answer.add(identity); + return answer; + } + + }); + } + + /** + * Discover the commands of an specific JID. The <code>jid</code> is a + * full JID. + * + * @param jid the full JID to retrieve the commands for. + * @return the discovered items. + * @throws XMPPException if the operation failed for some reason. + */ + public DiscoverItems discoverCommands(String jid) throws XMPPException { + ServiceDiscoveryManager serviceDiscoveryManager = ServiceDiscoveryManager + .getInstanceFor(connection); + return serviceDiscoveryManager.discoverItems(jid, discoNode); + } + + /** + * Publish the commands to an specific JID. + * + * @param jid the full JID to publish the commands to. + * @throws XMPPException if the operation failed for some reason. + */ + public void publishCommands(String jid) throws XMPPException { + ServiceDiscoveryManager serviceDiscoveryManager = ServiceDiscoveryManager + .getInstanceFor(connection); + + // Collects the commands to publish as items + DiscoverItems discoverItems = new DiscoverItems(); + Collection<AdHocCommandInfo> xCommandsList = getRegisteredCommands(); + + for (AdHocCommandInfo info : xCommandsList) { + DiscoverItems.Item item = new DiscoverItems.Item(info.getOwnerJID()); + item.setName(info.getName()); + item.setNode(info.getNode()); + discoverItems.addItem(item); + } + + serviceDiscoveryManager.publishItems(jid, discoNode, discoverItems); + } + + /** + * Returns a command that represents an instance of a command in a remote + * host. It is used to execute remote commands. The concept is similar to + * RMI. Every invocation on this command is equivalent to an invocation in + * the remote command. + * + * @param jid the full JID of the host of the remote command + * @param node the identifier of the command + * @return a local instance equivalent to the remote command. + */ + public RemoteCommand getRemoteCommand(String jid, String node) { + return new RemoteCommand(connection, node, jid); + } + + /** + * <ul> + * <li>Adds listeners to the connection</li> + * <li>Registers the ad-hoc command feature to the ServiceDiscoveryManager</li> + * <li>Registers the items of the feature</li> + * <li>Adds packet listeners to handle execution requests</li> + * <li>Creates and start the session sweeper</li> + * </ul> + */ + private void init() { + // Register the new instance and associate it with the connection + instances.put(connection, this); + + // Add a listener to the connection that removes the registered instance + // when the connection is closed + connection.addConnectionListener(new ConnectionListener() { + public void connectionClosed() { + // Unregister this instance since the connection has been closed + instances.remove(connection); + } + + public void connectionClosedOnError(Exception e) { + // Unregister this instance since the connection has been closed + instances.remove(connection); + } + + public void reconnectionSuccessful() { + // Register this instance since the connection has been + // reestablished + instances.put(connection, AdHocCommandManager.this); + } + + public void reconnectingIn(int seconds) { + // Nothing to do + } + + public void reconnectionFailed(Exception e) { + // Nothing to do + } + }); + + // Add the feature to the service discovery manage to show that this + // connection supports the AdHoc-Commands protocol. + // This information will be used when another client tries to + // discover whether this client supports AdHoc-Commands or not. + ServiceDiscoveryManager.getInstanceFor(connection).addFeature( + DISCO_NAMESPACE); + + // Set the NodeInformationProvider that will provide information about + // which AdHoc-Commands are registered, whenever a disco request is + // received + ServiceDiscoveryManager.getInstanceFor(connection) + .setNodeInformationProvider(discoNode, + new NodeInformationProvider() { + public List<DiscoverItems.Item> getNodeItems() { + + List<DiscoverItems.Item> answer = new ArrayList<DiscoverItems.Item>(); + Collection<AdHocCommandInfo> commandsList = getRegisteredCommands(); + + for (AdHocCommandInfo info : commandsList) { + DiscoverItems.Item item = new DiscoverItems.Item( + info.getOwnerJID()); + item.setName(info.getName()); + item.setNode(info.getNode()); + answer.add(item); + } + + return answer; + } + + public List<String> getNodeFeatures() { + return null; + } + + public List<Identity> getNodeIdentities() { + return null; + } + }); + + // The packet listener and the filter for processing some AdHoc Commands + // Packets + PacketListener listener = new PacketListener() { + public void processPacket(Packet packet) { + AdHocCommandData requestData = (AdHocCommandData) packet; + processAdHocCommand(requestData); + } + }; + + PacketFilter filter = new PacketTypeFilter(AdHocCommandData.class); + connection.addPacketListener(listener, filter); + + sessionsSweeper = null; + } + + /** + * Process the AdHoc-Command packet that request the execution of some + * action of a command. If this is the first request, this method checks, + * before executing the command, if: + * <ul> + * <li>The requested command exists</li> + * <li>The requester has permissions to execute it</li> + * <li>The command has more than one stage, if so, it saves the command and + * session ID for further use</li> + * </ul> + * + * + * + * If this is not the first request, this method checks, before executing + * the command, if: + * <ul> + * <li>The session ID of the request was stored</li> + * <li>The session life do not exceed the time out</li> + * <li>The action to execute is one of the available actions</li> + * </ul> + * + * @param requestData + * the packet to process. + */ + private void processAdHocCommand(AdHocCommandData requestData) { + // Only process requests of type SET + if (requestData.getType() != IQ.Type.SET) { + return; + } + + // Creates the response with the corresponding data + AdHocCommandData response = new AdHocCommandData(); + response.setTo(requestData.getFrom()); + response.setPacketID(requestData.getPacketID()); + response.setNode(requestData.getNode()); + response.setId(requestData.getTo()); + + String sessionId = requestData.getSessionID(); + String commandNode = requestData.getNode(); + + if (sessionId == null) { + // A new execution request has been received. Check that the + // command exists + if (!commands.containsKey(commandNode)) { + // Requested command does not exist so return + // item_not_found error. + respondError(response, XMPPError.Condition.item_not_found); + return; + } + + // Create new session ID + sessionId = StringUtils.randomString(15); + + try { + // Create a new instance of the command with the + // corresponding sessioid + LocalCommand command = newInstanceOfCmd(commandNode, sessionId); + + response.setType(IQ.Type.RESULT); + command.setData(response); + + // Check that the requester has enough permission. + // Answer forbidden error if requester permissions are not + // enough to execute the requested command + if (!command.hasPermission(requestData.getFrom())) { + respondError(response, XMPPError.Condition.forbidden); + return; + } + + Action action = requestData.getAction(); + + // If the action is unknown then respond an error. + if (action != null && action.equals(Action.unknown)) { + respondError(response, XMPPError.Condition.bad_request, + AdHocCommand.SpecificErrorCondition.malformedAction); + return; + } + + // If the action is not execute, then it is an invalid action. + if (action != null && !action.equals(Action.execute)) { + respondError(response, XMPPError.Condition.bad_request, + AdHocCommand.SpecificErrorCondition.badAction); + return; + } + + // Increase the state number, so the command knows in witch + // stage it is + command.incrementStage(); + // Executes the command + command.execute(); + + if (command.isLastStage()) { + // If there is only one stage then the command is completed + response.setStatus(Status.completed); + } + else { + // Else it is still executing, and is registered to be + // available for the next call + response.setStatus(Status.executing); + executingCommands.put(sessionId, command); + // See if the session reaping thread is started. If not, start it. + if (sessionsSweeper == null) { + sessionsSweeper = new Thread(new Runnable() { + public void run() { + while (true) { + for (String sessionId : executingCommands.keySet()) { + LocalCommand command = executingCommands.get(sessionId); + // Since the command could be removed in the meanwhile + // of getting the key and getting the value - by a + // processed packet. We must check if it still in the + // map. + if (command != null) { + long creationStamp = command.getCreationDate(); + // Check if the Session data has expired (default is + // 10 minutes) + // To remove it from the session list it waits for + // the double of the of time out time. This is to + // let + // the requester know why his execution request is + // not accepted. If the session is removed just + // after the time out, then whe the user request to + // continue the execution he will recieved an + // invalid session error and not a time out error. + if (System.currentTimeMillis() - creationStamp > SESSION_TIMEOUT * 1000 * 2) { + // Remove the expired session + executingCommands.remove(sessionId); + } + } + } + try { + Thread.sleep(1000); + } + catch (InterruptedException ie) { + // Ignore. + } + } + } + + }); + sessionsSweeper.setDaemon(true); + sessionsSweeper.start(); + } + } + + // Sends the response packet + connection.sendPacket(response); + + } + catch (XMPPException e) { + // If there is an exception caused by the next, complete, + // prev or cancel method, then that error is returned to the + // requester. + XMPPError error = e.getXMPPError(); + + // If the error type is cancel, then the execution is + // canceled therefore the status must show that, and the + // command be removed from the executing list. + if (XMPPError.Type.CANCEL.equals(error.getType())) { + response.setStatus(Status.canceled); + executingCommands.remove(sessionId); + } + respondError(response, error); + e.printStackTrace(); + } + } + else { + LocalCommand command = executingCommands.get(sessionId); + + // Check that a command exists for the specified sessionID + // This also handles if the command was removed in the meanwhile + // of getting the key and the value of the map. + if (command == null) { + respondError(response, XMPPError.Condition.bad_request, + AdHocCommand.SpecificErrorCondition.badSessionid); + return; + } + + // Check if the Session data has expired (default is 10 minutes) + long creationStamp = command.getCreationDate(); + if (System.currentTimeMillis() - creationStamp > SESSION_TIMEOUT * 1000) { + // Remove the expired session + executingCommands.remove(sessionId); + + // Answer a not_allowed error (session-expired) + respondError(response, XMPPError.Condition.not_allowed, + AdHocCommand.SpecificErrorCondition.sessionExpired); + return; + } + + /* + * Since the requester could send two requests for the same + * executing command i.e. the same session id, all the execution of + * the action must be synchronized to avoid inconsistencies. + */ + synchronized (command) { + Action action = requestData.getAction(); + + // If the action is unknown the respond an error + if (action != null && action.equals(Action.unknown)) { + respondError(response, XMPPError.Condition.bad_request, + AdHocCommand.SpecificErrorCondition.malformedAction); + return; + } + + // If the user didn't specify an action or specify the execute + // action then follow the actual default execute action + if (action == null || Action.execute.equals(action)) { + action = command.getExecuteAction(); + } + + // Check that the specified action was previously + // offered + if (!command.isValidAction(action)) { + respondError(response, XMPPError.Condition.bad_request, + AdHocCommand.SpecificErrorCondition.badAction); + return; + } + + try { + // TODO: Check that all the requierd fields of the form are + // TODO: filled, if not throw an exception. This will simplify the + // TODO: construction of new commands + + // Since all errors were passed, the response is now a + // result + response.setType(IQ.Type.RESULT); + + // Set the new data to the command. + command.setData(response); + + if (Action.next.equals(action)) { + command.incrementStage(); + command.next(new Form(requestData.getForm())); + if (command.isLastStage()) { + // If it is the last stage then the command is + // completed + response.setStatus(Status.completed); + } + else { + // Otherwise it is still executing + response.setStatus(Status.executing); + } + } + else if (Action.complete.equals(action)) { + command.incrementStage(); + command.complete(new Form(requestData.getForm())); + response.setStatus(Status.completed); + // Remove the completed session + executingCommands.remove(sessionId); + } + else if (Action.prev.equals(action)) { + command.decrementStage(); + command.prev(); + } + else if (Action.cancel.equals(action)) { + command.cancel(); + response.setStatus(Status.canceled); + // Remove the canceled session + executingCommands.remove(sessionId); + } + + connection.sendPacket(response); + } + catch (XMPPException e) { + // If there is an exception caused by the next, complete, + // prev or cancel method, then that error is returned to the + // requester. + XMPPError error = e.getXMPPError(); + + // If the error type is cancel, then the execution is + // canceled therefore the status must show that, and the + // command be removed from the executing list. + if (XMPPError.Type.CANCEL.equals(error.getType())) { + response.setStatus(Status.canceled); + executingCommands.remove(sessionId); + } + respondError(response, error); + + e.printStackTrace(); + } + } + } + } + + /** + * Responds an error with an specific condition. + * + * @param response the response to send. + * @param condition the condition of the error. + */ + private void respondError(AdHocCommandData response, + XMPPError.Condition condition) { + respondError(response, new XMPPError(condition)); + } + + /** + * Responds an error with an specific condition. + * + * @param response the response to send. + * @param condition the condition of the error. + * @param specificCondition the adhoc command error condition. + */ + private void respondError(AdHocCommandData response, XMPPError.Condition condition, + AdHocCommand.SpecificErrorCondition specificCondition) + { + XMPPError error = new XMPPError(condition); + error.addExtension(new AdHocCommandData.SpecificError(specificCondition)); + respondError(response, error); + } + + /** + * Responds an error with an specific error. + * + * @param response the response to send. + * @param error the error to send. + */ + private void respondError(AdHocCommandData response, XMPPError error) { + response.setType(IQ.Type.ERROR); + response.setError(error); + connection.sendPacket(response); + } + + /** + * Creates a new instance of a command to be used by a new execution request + * + * @param commandNode the command node that identifies it. + * @param sessionID the session id of this execution. + * @return the command instance to execute. + * @throws XMPPException if there is problem creating the new instance. + */ + private LocalCommand newInstanceOfCmd(String commandNode, String sessionID) + throws XMPPException + { + AdHocCommandInfo commandInfo = commands.get(commandNode); + LocalCommand command; + try { + command = (LocalCommand) commandInfo.getCommandInstance(); + command.setSessionID(sessionID); + command.setName(commandInfo.getName()); + command.setNode(commandInfo.getNode()); + } + catch (InstantiationException e) { + e.printStackTrace(); + throw new XMPPException(new XMPPError( + XMPPError.Condition.interna_server_error)); + } + catch (IllegalAccessException e) { + e.printStackTrace(); + throw new XMPPException(new XMPPError( + XMPPError.Condition.interna_server_error)); + } + return command; + } + + /** + * Returns the registered commands of this command manager, which is related + * to a connection. + * + * @return the registered commands. + */ + private Collection<AdHocCommandInfo> getRegisteredCommands() { + return commands.values(); + } + + /** + * Stores ad-hoc command information. + */ + private static class AdHocCommandInfo { + + private String node; + private String name; + private String ownerJID; + private LocalCommandFactory factory; + + public AdHocCommandInfo(String node, String name, String ownerJID, + LocalCommandFactory factory) + { + this.node = node; + this.name = name; + this.ownerJID = ownerJID; + this.factory = factory; + } + + public LocalCommand getCommandInstance() throws InstantiationException, + IllegalAccessException + { + return factory.getInstance(); + } + + public String getName() { + return name; + } + + public String getNode() { + return node; + } + + public String getOwnerJID() { + return ownerJID; + } + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/AdHocCommandNote.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/AdHocCommandNote.java new file mode 100755 index 0000000..d3f487f --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/AdHocCommandNote.java @@ -0,0 +1,86 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2005-2007 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.smackx.commands; + +/** + * Notes can be added to a command execution response. A note has a type and value. + * + * @author Gabriel Guardincerri + */ +public class AdHocCommandNote { + + private Type type; + private String value; + + /** + * Creates a new adhoc command note with the specified type and value. + * + * @param type the type of the note. + * @param value the value of the note. + */ + public AdHocCommandNote(Type type, String value) { + this.type = type; + this.value = value; + } + + /** + * Returns the value or message of the note. + * + * @return the value or message of the note. + */ + public String getValue() { + return value; + } + + /** + * Return the type of the note. + * + * @return the type of the note. + */ + public Type getType() { + return type; + } + + /** + * Represents a note type. + */ + public enum Type { + + /** + * The note is informational only. This is not really an exceptional + * condition. + */ + info, + + /** + * The note indicates a warning. Possibly due to illogical (yet valid) + * data. + */ + warn, + + /** + * The note indicates an error. The text should indicate the reason for + * the error. + */ + error + } + +} \ No newline at end of file diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/LocalCommand.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/LocalCommand.java new file mode 100755 index 0000000..36d5154 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/LocalCommand.java @@ -0,0 +1,169 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2005-2007 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.smackx.commands; + +import org.jivesoftware.smackx.packet.AdHocCommandData; + +/** + * Represents a command that can be executed locally from a remote location. This + * class must be extended to implement an specific ad-hoc command. This class + * provides some useful tools:<ul> + * <li>Node</li> + * <li>Name</li> + * <li>Session ID</li> + * <li>Current Stage</li> + * <li>Available actions</li> + * <li>Default action</li> + * </ul> + * To implement a new command extend this class and implement all the abstract + * methods. When implementing the actions remember that they could be invoked + * several times, and that you must use the current stage number to know what to + * do. + * + * @author Gabriel Guardincerri + */ +public abstract class LocalCommand extends AdHocCommand { + + /** + * The time stamp of first invokation of the command. Used to implement the session timeout. + */ + private long creationDate; + + /** + * The unique ID of the execution of the command. + */ + private String sessionID; + + /** + * The full JID of the host of the command. + */ + private String ownerJID; + + /** + * The number of the current stage. + */ + private int currenStage; + + public LocalCommand() { + super(); + this.creationDate = System.currentTimeMillis(); + currenStage = -1; + } + + /** + * The sessionID is an unique identifier of an execution request. This is + * automatically handled and should not be called. + * + * @param sessionID the unique session id of this execution + */ + public void setSessionID(String sessionID) { + this.sessionID = sessionID; + getData().setSessionID(sessionID); + } + + /** + * Returns the session ID of this execution. + * + * @return the unique session id of this execution + */ + public String getSessionID() { + return sessionID; + } + + /** + * Sets the JID of the command host. This is automatically handled and should + * not be called. + * + * @param ownerJID the JID of the owner. + */ + public void setOwnerJID(String ownerJID) { + this.ownerJID = ownerJID; + } + + @Override + public String getOwnerJID() { + return ownerJID; + } + + /** + * Returns the date the command was created. + * + * @return the date the command was created. + */ + public long getCreationDate() { + return creationDate; + } + + /** + * Returns true if the current stage is the last one. If it is then the + * execution of some action will complete the execution of the command. + * Commands that don't have multiple stages can always return <tt>true</tt>. + * + * @return true if the command is in the last stage. + */ + public abstract boolean isLastStage(); + + /** + * Returns true if the specified requester has permission to execute all the + * stages of this action. This is checked when the first request is received, + * if the permission is grant then the requester will be able to execute + * all the stages of the command. It is not checked again during the + * execution. + * + * @param jid the JID to check permissions on. + * @return true if the user has permission to execute this action. + */ + public abstract boolean hasPermission(String jid); + + /** + * Returns the currently executing stage number. The first stage number is + * 0. During the execution of the first action this method will answer 0. + * + * @return the current stage number. + */ + public int getCurrentStage() { + return currenStage; + } + + @Override + void setData(AdHocCommandData data) { + data.setSessionID(sessionID); + super.setData(data); + } + + /** + * Increase the current stage number. This is automatically handled and should + * not be called. + * + */ + void incrementStage() { + currenStage++; + } + + /** + * Decrease the current stage number. This is automatically handled and should + * not be called. + * + */ + void decrementStage() { + currenStage--; + } +} \ No newline at end of file diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/LocalCommandFactory.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/LocalCommandFactory.java new file mode 100644 index 0000000..11efd2b --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/LocalCommandFactory.java @@ -0,0 +1,24 @@ +package org.jivesoftware.smackx.commands; + +/** + * A factory for creating local commands. It's useful in cases where instantiation + * of a command is more complicated than just using the default constructor. For example, + * when arguments must be passed into the constructor or when using a dependency injection + * framework. When a LocalCommandFactory isn't used, you can provide the AdHocCommandManager + * a Class object instead. For more details, see + * {@link AdHocCommandManager#registerCommand(String, String, LocalCommandFactory)}. + * + * @author Matt Tucker + */ +public interface LocalCommandFactory { + + /** + * Returns an instance of a LocalCommand. + * + * @return a LocalCommand instance. + * @throws InstantiationException if creating an instance failed. + * @throws IllegalAccessException if creating an instance is not allowed. + */ + public LocalCommand getInstance() throws InstantiationException, IllegalAccessException; + +} \ No newline at end of file diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/RemoteCommand.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/RemoteCommand.java new file mode 100755 index 0000000..a32d267 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/commands/RemoteCommand.java @@ -0,0 +1,201 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2005-2007 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.smackx.commands; + +import org.jivesoftware.smack.PacketCollector; +import org.jivesoftware.smack.SmackConfiguration; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.filter.PacketIDFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smackx.Form; +import org.jivesoftware.smackx.packet.AdHocCommandData; + +/** + * Represents a command that is in a remote location. Invoking one of the + * {@link AdHocCommand.Action#execute execute}, {@link AdHocCommand.Action#next next}, + * {@link AdHocCommand.Action#prev prev}, {@link AdHocCommand.Action#cancel cancel} or + * {@link AdHocCommand.Action#complete complete} actions results in executing that + * action in the remote location. In response to that action the internal state + * of the this command instance will change. For example, if the command is a + * single stage command, then invoking the execute action will execute this + * action in the remote location. After that the local instance will have a + * state of "completed" and a form or notes that applies. + * + * @author Gabriel Guardincerri + * + */ +public class RemoteCommand extends AdHocCommand { + + /** + * The connection that is used to execute this command + */ + private Connection connection; + + /** + * The full JID of the command host + */ + private String jid; + + /** + * The session ID of this execution. + */ + private String sessionID; + + + /** + * The number of milliseconds to wait for a response from the server + * The default value is the default packet reply timeout (5000 ms). + */ + private long packetReplyTimeout; + + /** + * Creates a new RemoteCommand that uses an specific connection to execute a + * command identified by <code>node</code> in the host identified by + * <code>jid</code> + * + * @param connection the connection to use for the execution. + * @param node the identifier of the command. + * @param jid the JID of the host. + */ + protected RemoteCommand(Connection connection, String node, String jid) { + super(); + this.connection = connection; + this.jid = jid; + this.setNode(node); + this.packetReplyTimeout = SmackConfiguration.getPacketReplyTimeout(); + } + + @Override + public void cancel() throws XMPPException { + executeAction(Action.cancel, packetReplyTimeout); + } + + @Override + public void complete(Form form) throws XMPPException { + executeAction(Action.complete, form, packetReplyTimeout); + } + + @Override + public void execute() throws XMPPException { + executeAction(Action.execute, packetReplyTimeout); + } + + /** + * Executes the default action of the command with the information provided + * in the Form. This form must be the anwser form of the previous stage. If + * there is a problem executing the command it throws an XMPPException. + * + * @param form the form anwser of the previous stage. + * @throws XMPPException if an error occurs. + */ + public void execute(Form form) throws XMPPException { + executeAction(Action.execute, form, packetReplyTimeout); + } + + @Override + public void next(Form form) throws XMPPException { + executeAction(Action.next, form, packetReplyTimeout); + } + + @Override + public void prev() throws XMPPException { + executeAction(Action.prev, packetReplyTimeout); + } + + private void executeAction(Action action, long packetReplyTimeout) throws XMPPException { + executeAction(action, null, packetReplyTimeout); + } + + /** + * Executes the <code>action</codo> with the <code>form</code>. + * The action could be any of the available actions. The form must + * be the anwser of the previous stage. It can be <tt>null</tt> if it is the first stage. + * + * @param action the action to execute. + * @param form the form with the information. + * @param timeout the amount of time to wait for a reply. + * @throws XMPPException if there is a problem executing the command. + */ + private void executeAction(Action action, Form form, long timeout) throws XMPPException { + // TODO: Check that all the required fields of the form were filled, if + // TODO: not throw the corresponding exeption. This will make a faster response, + // TODO: since the request is stoped before it's sent. + AdHocCommandData data = new AdHocCommandData(); + data.setType(IQ.Type.SET); + data.setTo(getOwnerJID()); + data.setNode(getNode()); + data.setSessionID(sessionID); + data.setAction(action); + + if (form != null) { + data.setForm(form.getDataFormToSend()); + } + + PacketCollector collector = connection.createPacketCollector( + new PacketIDFilter(data.getPacketID())); + + connection.sendPacket(data); + + Packet response = collector.nextResult(timeout); + + // Cancel the collector. + collector.cancel(); + if (response == null) { + throw new XMPPException("No response from server on status set."); + } + if (response.getError() != null) { + throw new XMPPException(response.getError()); + } + + AdHocCommandData responseData = (AdHocCommandData) response; + this.sessionID = responseData.getSessionID(); + super.setData(responseData); + } + + @Override + public String getOwnerJID() { + return jid; + } + + /** + * Returns the number of milliseconds to wait for a respone. The + * {@link SmackConfiguration#getPacketReplyTimeout default} value + * should be adjusted for commands that can take a long time to execute. + * + * @return the number of milliseconds to wait for responses. + */ + public long getPacketReplyTimeout() { + return packetReplyTimeout; + } + + /** + * Returns the number of milliseconds to wait for a respone. The + * {@link SmackConfiguration#getPacketReplyTimeout default} value + * should be adjusted for commands that can take a long time to execute. + * + * @param packetReplyTimeout the number of milliseconds to wait for responses. + */ + public void setPacketReplyTimeout(long packetReplyTimeout) { + this.packetReplyTimeout = packetReplyTimeout; + } +} \ No newline at end of file diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/debugger/package.html b/external/asmack/build/src/trunk/org/jivesoftware/smackx/debugger/package.html new file mode 100644 index 0000000..8ea20e0 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/debugger/package.html @@ -0,0 +1 @@ +<body>Smack optional Debuggers.</body> \ No newline at end of file diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/CapsPacketListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/CapsPacketListener.java new file mode 100644 index 0000000..a29de33 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/CapsPacketListener.java @@ -0,0 +1,24 @@ +package org.jivesoftware.smackx.entitycaps; + +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smackx.packet.CapsExtension; + +class CapsPacketListener implements PacketListener { + + private EntityCapsManager manager; + + protected CapsPacketListener(EntityCapsManager manager) { + this.manager = manager; + } + + public void processPacket(Packet packet) { + CapsExtension ext = + (CapsExtension) packet.getExtension(CapsExtension.NODE_NAME, CapsExtension.XMLNS); + + String nodeVer = ext.getNode() + "#" + ext.getVersion(); + String user = packet.getFrom(); + + manager.addUserCapsNode(user, nodeVer); + } +} \ No newline at end of file diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/CapsVerListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/CapsVerListener.java new file mode 100644 index 0000000..2a72dbb --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/CapsVerListener.java @@ -0,0 +1,5 @@ +package org.jivesoftware.smackx.entitycaps; + +public interface CapsVerListener { + public void capsVerUpdated(String capsVer); +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/EntityCapsManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/EntityCapsManager.java new file mode 100644 index 0000000..036c7c7 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/EntityCapsManager.java @@ -0,0 +1,326 @@ +/* + * Copyright 2009 Jonas Ådahl. + * Copyright 2011 Florian Schmaus + * + * 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.smackx.entitycaps; + +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.packet.Presence; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.filter.AndFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.filter.PacketExtensionFilter; +import org.jivesoftware.smack.provider.ProviderManager; +import org.jivesoftware.smack.util.Base64; +import org.jivesoftware.smackx.FormField; +import org.jivesoftware.smackx.ServiceDiscoveryManager; +import org.jivesoftware.smackx.ServiceDiscoveryManagerInterface; +import org.jivesoftware.smackx.provider.CapsExtensionProvider; +import org.jivesoftware.smackx.packet.DiscoverInfo; +import org.jivesoftware.smackx.packet.CapsExtension; +import org.jivesoftware.smackx.packet.DataForm; +import org.jivesoftware.smackx.packet.DiscoverInfo.Feature; + +import java.util.Comparator; +import java.util.Iterator; +import java.util.Map; +import java.util.Set; +import java.util.SortedSet; +import java.util.TreeSet; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.CopyOnWriteArraySet; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; + + +/** + * Keeps track of entity capabilities. + */ +public class EntityCapsManager { + + public static final String HASH_METHOD = "sha-1"; + public static final String HASH_METHOD_CAPS = "SHA-1"; + + // TODO entityNode should become a constant (final) + private static String entityNode = "http://www.igniterealtime.org/projects/smack/"; + private static EntityCapsPersistentCache persistentCache; + + /** + * Map of (node, hash algorithm) -> DiscoverInfo. + */ + private static Map<String,DiscoverInfo> caps = + new ConcurrentHashMap<String,DiscoverInfo>(); + + /** + * Map of Full JID -> DiscoverInfo/null. + * In case of c2s connection the key is formed as user@server/resource (resource is required) + * In case of link-local connection the key is formed as user@host (no resource) + * In case of a server or component the key is formed as domain + */ + private Map<String,String> userCaps = + new ConcurrentHashMap<String,String>(); + + // CapsVerListeners gets notified when the version string is changed. + private Set<CapsVerListener> capsVerListeners = + new CopyOnWriteArraySet<CapsVerListener>(); + + private String currentCapsVersion = null; + + static { + ProviderManager.getInstance().addExtensionProvider(CapsExtension.NODE_NAME, + CapsExtension.XMLNS, new CapsExtensionProvider()); + } + + /** + * Add DiscoverInfo to the database. + * + * @param node The node name. Could be for example "http://psi-im.org#q07IKJEyjvHSyhy//CH0CxmKi8w=". + * @param info DiscoverInfo for the specified node. + */ + public static void addDiscoverInfoByNode(String node, DiscoverInfo info) { + cleanupDicsoverInfo(info); + + caps.put(node, info); + + if (persistentCache != null) + persistentCache.addDiscoverInfoByNodePersistent(node, info); + } + + public EntityCapsManager(ServiceDiscoveryManagerInterface sdm) { + // Add Entity Capabilities (XEP-0115) feature node. + sdm.addFeature("http://jabber.org/protocol/caps"); + } + + /** + * Add a record telling what entity caps node a user has. The entity caps + * node has the format node#ver. + * + * @param user the user (Full JID) + * @param node the entity caps node#ver + */ + public void addUserCapsNode(String user, String node) { + if (user != null && node != null) { + userCaps.put(user, node); + } + } + + /** + * Remove a record telling what entity caps node a user has. + * + * @param user the user (Full JID) + */ + public void removeUserCapsNode(String user) { + userCaps.remove(user); + } + + /** + * Get the Node version (node#ver) of a user. + * + * @param user the user (Full JID) + * @return the node version. + */ + public String getNodeVersionByUser(String user) { + return userCaps.get(user); + } + + /** + * Get the discover info given a user name. The discover + * info is returned if the user has a node#ver associated with + * it and the node#ver has a discover info associated with it. + * + * @param user user name (Full JID) + * @return the discovered info + */ + public DiscoverInfo getDiscoverInfoByUser(String user) { + String capsNode = userCaps.get(user); + if (capsNode == null) + return null; + + return getDiscoverInfoByNode(capsNode); + } + + /** + * Get our own caps version. + * + * @return our own caps version + */ + public String getCapsVersion() { + return currentCapsVersion; + } + + /** + * Get our own entity node. + * + * @return our own entity node. + */ + public String getNode() { + return entityNode; + } + + /** + * Set our own entity node. + * + * @param node the new node + */ + public void setNode(String node) { + entityNode = node; + } + + /** + * Retrieve DiscoverInfo for a specific node. + * + * @param node The node name. + * @return The corresponding DiscoverInfo or null if none is known. + */ + public static DiscoverInfo getDiscoverInfoByNode(String node) { + return caps.get(node); + } + + private static void cleanupDicsoverInfo(DiscoverInfo info) { + info.setFrom(null); + info.setTo(null); + info.setPacketID(null); + } + + public void addPacketListener(Connection connection) { + PacketFilter f = + new AndFilter( + new PacketTypeFilter(Presence.class), + new PacketExtensionFilter(CapsExtension.NODE_NAME, CapsExtension.XMLNS)); + connection.addPacketListener(new CapsPacketListener(this), f); + } + + public void addCapsVerListener(CapsVerListener listener) { + capsVerListeners.add(listener); + + if (currentCapsVersion != null) + listener.capsVerUpdated(currentCapsVersion); + } + + public void removeCapsVerListener(CapsVerListener listener) { + capsVerListeners.remove(listener); + } + + private void notifyCapsVerListeners() { + for (CapsVerListener listener : capsVerListeners) { + listener.capsVerUpdated(currentCapsVersion); + } + } + + /** + * Calculate Entity Caps version string + * + * @param capsString + * @return + */ + private static String capsToHash(String capsString) { + try { + MessageDigest md = MessageDigest.getInstance(HASH_METHOD_CAPS); + byte[] digest = md.digest(capsString.getBytes()); + return Base64.encodeBytes(digest); + } + catch (NoSuchAlgorithmException nsae) { + return null; + } + } + + private static String formFieldValuesToCaps(Iterator<String> i) { + String s = ""; + SortedSet<String> fvs = new TreeSet<String>(); + for (; i.hasNext();) { + fvs.add(i.next()); + } + for (String fv : fvs) { + s += fv + "<"; + } + return s; + } + + public void calculateEntityCapsVersion(DiscoverInfo discoverInfo, + String identityType, + String identityName, + DataForm extendedInfo) { + String s = ""; + + // Add identity + // FIXME language + s += "client/" + identityType + "//" + identityName + "<"; + + // Add features + SortedSet<String> features = new TreeSet<String>(); + for (Iterator<Feature> it = discoverInfo.getFeatures(); it.hasNext();) + features.add(it.next().getVar()); + + for (String f : features) { + s += f + "<"; + } + + if (extendedInfo != null) { + synchronized (extendedInfo) { + SortedSet<FormField> fs = new TreeSet<FormField>( + new Comparator<FormField>() { + public int compare(FormField f1, FormField f2) { + return f1.getVariable().compareTo(f2.getVariable()); + } + }); + + FormField ft = null; + + for (Iterator<FormField> i = extendedInfo.getFields(); i.hasNext();) { + FormField f = i.next(); + if (!f.getVariable().equals("FORM_TYPE")) { + fs.add(f); + } + else { + ft = f; + } + } + + // Add FORM_TYPE values + if (ft != null) { + s += formFieldValuesToCaps(ft.getValues()); + } + + // Add the other values + for (FormField f : fs) { + s += f.getVariable() + "<"; + s += formFieldValuesToCaps(f.getValues()); + } + } + } + + + setCurrentCapsVersion(discoverInfo, capsToHash(s)); + } + + /** + * Set our own caps version. + * + * @param capsVersion the new caps version + */ + public void setCurrentCapsVersion(DiscoverInfo discoverInfo, String capsVersion) { + currentCapsVersion = capsVersion; + addDiscoverInfoByNode(getNode() + "#" + capsVersion, discoverInfo); + notifyCapsVerListeners(); + } + + public static void setPersistentCache(EntityCapsPersistentCache cache) { + if (persistentCache != null) + throw new IllegalStateException("Entity Caps Persistent Cache was already set"); + persistentCache = cache; + persistentCache.replay(); + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/EntityCapsPersistentCache.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/EntityCapsPersistentCache.java new file mode 100644 index 0000000..6dcca6f --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/EntityCapsPersistentCache.java @@ -0,0 +1,23 @@ +package org.jivesoftware.smackx.entitycaps; + +import org.jivesoftware.smackx.packet.DiscoverInfo; + +public interface EntityCapsPersistentCache { + /** + * Add an DiscoverInfo to the persistent Cache + * + * @param node + * @param info + */ + abstract void addDiscoverInfoByNodePersistent(String node, DiscoverInfo info); + + /** + * Replay the Caches data into EntityCapsManager + */ + abstract void replay(); + + /** + * Empty the Cache + */ + abstract void emptyCache(); +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/SimpleDirectoryPersistentCache.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/SimpleDirectoryPersistentCache.java new file mode 100644 index 0000000..e0a559a --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/entitycaps/SimpleDirectoryPersistentCache.java @@ -0,0 +1,166 @@ +/** + * Copyright 2011 Florian Schmaus + * + * 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.smackx.entitycaps; + + +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.Reader; +import java.io.StringReader; + +import org.jivesoftware.smack.provider.IQProvider; +import org.jivesoftware.smack.provider.ProviderManager; +import org.jivesoftware.smack.util.Base64; +import org.jivesoftware.smackx.packet.DiscoverInfo; +import org.xmlpull.v1.XmlPullParserFactory; +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +/** + * Simples implementation of an EntityCapsPersistentCache that uses a + * directory to store the Caps information for every known node. Every node + * is represented by an file. + * + * @author Florian Schmaus + * + */ +public class SimpleDirectoryPersistentCache implements + EntityCapsPersistentCache { + + private File cacheDir; + + /** + * Creates a new SimpleDirectoryPersistentCache Object. Make sure that the + * cacheDir exists and that it's an directory. + * + * @param cacheDir + */ + public SimpleDirectoryPersistentCache(File cacheDir) { + if (!cacheDir.exists()) + throw new IllegalStateException("Cache directory \"" + cacheDir + "\" does not exist"); + if (!cacheDir.isDirectory()) + throw new IllegalStateException("Cache directory \"" + cacheDir + "\" is not a directory"); + + this.cacheDir = cacheDir; + } + + @Override + public void addDiscoverInfoByNodePersistent(String node, DiscoverInfo info) { + String base64Node = Base64.encodeBytes(node.getBytes()); + File nodeFile = new File(cacheDir, base64Node); + + try { + if (nodeFile.createNewFile()) + writeInfoToFile(nodeFile, info); + } catch (IOException e) { + e.printStackTrace(); + } + } + + @Override + public void replay() { + File[] files = cacheDir.listFiles(); + for (File f : files) { + String nodeBase64 = f.getName(); + String node = new String(Base64.decode(nodeBase64)); + DiscoverInfo info; + try { + info = restoreInfoFromFile(f); + } catch (IOException e) { + e.printStackTrace(); + continue; + } + if (info == null) + continue; + + EntityCapsManager.addDiscoverInfoByNode(node, info); + } + } + + public void emptyCache() { + File[] files = cacheDir.listFiles(); + for (File f : files) { + f.delete(); + } + } + + /** + * Writes the DiscoverInfo packet to an file + * + * @param file + * @param info + * @throws IOException + */ + private static void writeInfoToFile(File file, DiscoverInfo info) throws IOException { + DataOutputStream dos = new DataOutputStream(new FileOutputStream(file)); + dos.writeUTF(info.toXML()); + } + + /** + * Tries to restore an DiscoverInfo packet from a file. + * + * @param file + * @return + * @throws IOException + */ + private static DiscoverInfo restoreInfoFromFile(File file) throws IOException { + DataInputStream dis = new DataInputStream(new FileInputStream(file)); + String fileContent = dis.readUTF(); + Reader reader = new StringReader(fileContent); + XmlPullParser parser; + try { + parser = XmlPullParserFactory.newInstance().newPullParser(); + parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true); + parser.setInput(reader); + } catch (XmlPullParserException xppe) { + xppe.printStackTrace(); + return null; + } + + DiscoverInfo iqPacket; + IQProvider provider = (IQProvider) ProviderManager.getInstance().getIQProvider("query", "http://jabber.org/protocol/disco#info"); + + // Skip the first <iq id=....> tag + try { + parser.next(); + } catch (XmlPullParserException e1) { + e1.printStackTrace(); + return null; + } + + // Point parser to the query tag + try { + parser.next(); + } catch (XmlPullParserException e1) { + e1.printStackTrace(); + return null; + } + + try { + iqPacket = (DiscoverInfo) provider.parseIQ(parser); + } catch (Exception e) { + e.printStackTrace(); + return null; + } + + return iqPacket; + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FaultTolerantNegotiator.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FaultTolerantNegotiator.java new file mode 100644 index 0000000..ef18606 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FaultTolerantNegotiator.java @@ -0,0 +1,186 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2003-2006 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.smackx.filetransfer; + +import org.jivesoftware.smack.PacketCollector; +import org.jivesoftware.smack.SmackConfiguration; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.filter.OrFilter; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smackx.packet.StreamInitiation; + +import java.io.InputStream; +import java.io.OutputStream; +import java.util.concurrent.*; +import java.util.List; +import java.util.ArrayList; + + +/** + * The fault tolerant negotiator takes two stream negotiators, the primary and the secondary + * negotiator. If the primary negotiator fails during the stream negotiaton process, the second + * negotiator is used. + */ +public class FaultTolerantNegotiator extends StreamNegotiator { + + private StreamNegotiator primaryNegotiator; + private StreamNegotiator secondaryNegotiator; + private Connection connection; + private PacketFilter primaryFilter; + private PacketFilter secondaryFilter; + + public FaultTolerantNegotiator(Connection connection, StreamNegotiator primary, + StreamNegotiator secondary) { + this.primaryNegotiator = primary; + this.secondaryNegotiator = secondary; + this.connection = connection; + } + + public PacketFilter getInitiationPacketFilter(String from, String streamID) { + if (primaryFilter == null || secondaryFilter == null) { + primaryFilter = primaryNegotiator.getInitiationPacketFilter(from, streamID); + secondaryFilter = secondaryNegotiator.getInitiationPacketFilter(from, streamID); + } + return new OrFilter(primaryFilter, secondaryFilter); + } + + InputStream negotiateIncomingStream(Packet streamInitiation) throws XMPPException { + throw new UnsupportedOperationException("Negotiation only handled by create incoming " + + "stream method."); + } + + final Packet initiateIncomingStream(Connection connection, StreamInitiation initiation) { + throw new UnsupportedOperationException("Initiation handled by createIncomingStream " + + "method"); + } + + public InputStream createIncomingStream(StreamInitiation initiation) throws XMPPException { + PacketCollector collector = connection.createPacketCollector( + getInitiationPacketFilter(initiation.getFrom(), initiation.getSessionID())); + + connection.sendPacket(super.createInitiationAccept(initiation, getNamespaces())); + + ExecutorService threadPoolExecutor = Executors.newFixedThreadPool(2); + CompletionService<InputStream> service + = new ExecutorCompletionService<InputStream>(threadPoolExecutor); + List<Future<InputStream>> futures = new ArrayList<Future<InputStream>>(); + InputStream stream = null; + XMPPException exception = null; + try { + futures.add(service.submit(new NegotiatorService(collector))); + futures.add(service.submit(new NegotiatorService(collector))); + + int i = 0; + while (stream == null && i < futures.size()) { + Future<InputStream> future; + try { + i++; + future = service.poll(10, TimeUnit.SECONDS); + } + catch (InterruptedException e) { + continue; + } + + if (future == null) { + continue; + } + + try { + stream = future.get(); + } + catch (InterruptedException e) { + /* Do Nothing */ + } + catch (ExecutionException e) { + exception = new XMPPException(e.getCause()); + } + } + } + finally { + for (Future<InputStream> future : futures) { + future.cancel(true); + } + collector.cancel(); + threadPoolExecutor.shutdownNow(); + } + if (stream == null) { + if (exception != null) { + throw exception; + } + else { + throw new XMPPException("File transfer negotiation failed."); + } + } + + return stream; + } + + private StreamNegotiator determineNegotiator(Packet streamInitiation) { + return primaryFilter.accept(streamInitiation) ? primaryNegotiator : secondaryNegotiator; + } + + public OutputStream createOutgoingStream(String streamID, String initiator, String target) + throws XMPPException { + OutputStream stream; + try { + stream = primaryNegotiator.createOutgoingStream(streamID, initiator, target); + } + catch (XMPPException ex) { + stream = secondaryNegotiator.createOutgoingStream(streamID, initiator, target); + } + + return stream; + } + + public String[] getNamespaces() { + String[] primary = primaryNegotiator.getNamespaces(); + String[] secondary = secondaryNegotiator.getNamespaces(); + + String[] namespaces = new String[primary.length + secondary.length]; + System.arraycopy(primary, 0, namespaces, 0, primary.length); + System.arraycopy(secondary, 0, namespaces, primary.length, secondary.length); + + return namespaces; + } + + public void cleanup() { + } + + private class NegotiatorService implements Callable<InputStream> { + + private PacketCollector collector; + + NegotiatorService(PacketCollector collector) { + this.collector = collector; + } + + public InputStream call() throws Exception { + Packet streamInitiation = collector.nextResult( + SmackConfiguration.getPacketReplyTimeout() * 2); + if (streamInitiation == null) { + throw new XMPPException("No response from remote client"); + } + StreamNegotiator negotiator = determineNegotiator(streamInitiation); + return negotiator.negotiateIncomingStream(streamInitiation); + } + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransfer.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransfer.java new file mode 100644 index 0000000..f7c2ad9 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransfer.java @@ -0,0 +1,380 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2003-2006 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.smackx.filetransfer; + +import org.jivesoftware.smack.XMPPException; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; + +/** + * Contains the generic file information and progress related to a particular + * file transfer. + * + * @author Alexander Wenckus + * + */ +public abstract class FileTransfer { + + private String fileName; + + private String filePath; + + private long fileSize; + + private String peer; + + private Status status = Status.initial; + + private final Object statusMonitor = new Object(); + + protected FileTransferNegotiator negotiator; + + protected String streamID; + + protected long amountWritten = -1; + + private Error error; + + private Exception exception; + + /** + * Buffer size between input and output + */ + private static final int BUFFER_SIZE = 8192; + + protected FileTransfer(String peer, String streamID, + FileTransferNegotiator negotiator) { + this.peer = peer; + this.streamID = streamID; + this.negotiator = negotiator; + } + + protected void setFileInfo(String fileName, long fileSize) { + this.fileName = fileName; + this.fileSize = fileSize; + } + + protected void setFileInfo(String path, String fileName, long fileSize) { + this.filePath = path; + this.fileName = fileName; + this.fileSize = fileSize; + } + + /** + * Returns the size of the file being transfered. + * + * @return Returns the size of the file being transfered. + */ + public long getFileSize() { + return fileSize; + } + + /** + * Returns the name of the file being transfered. + * + * @return Returns the name of the file being transfered. + */ + public String getFileName() { + return fileName; + } + + /** + * Returns the local path of the file. + * + * @return Returns the local path of the file. + */ + public String getFilePath() { + return filePath; + } + + /** + * Returns the JID of the peer for this file transfer. + * + * @return Returns the JID of the peer for this file transfer. + */ + public String getPeer() { + return peer; + } + + /** + * Returns the progress of the file transfer as a number between 0 and 1. + * + * @return Returns the progress of the file transfer as a number between 0 + * and 1. + */ + public double getProgress() { + if (amountWritten <= 0 || fileSize <= 0) { + return 0; + } + return (double) amountWritten / (double) fileSize; + } + + /** + * Returns true if the transfer has been cancelled, if it has stopped because + * of a an error, or the transfer completed succesfully. + * + * @return Returns true if the transfer has been cancelled, if it has stopped + * because of a an error, or the transfer completed succesfully. + */ + public boolean isDone() { + return status == Status.cancelled || status == Status.error + || status == Status.complete || status == Status.refused; + } + + /** + * Retuns the current status of the file transfer. + * + * @return Retuns the current status of the file transfer. + */ + public Status getStatus() { + return status; + } + + protected void setError(Error type) { + this.error = type; + } + + /** + * When {@link #getStatus()} returns that there was an {@link Status#error} + * during the transfer, the type of error can be retrieved through this + * method. + * + * @return Returns the type of error that occured if one has occured. + */ + public Error getError() { + return error; + } + + /** + * If an exception occurs asynchronously it will be stored for later + * retrival. If there is an error there maybe an exception set. + * + * @return The exception that occured or null if there was no exception. + * @see #getError() + */ + public Exception getException() { + return exception; + } + + public String getStreamID() { + return streamID; + } + + /** + * Cancels the file transfer. + */ + public abstract void cancel(); + + protected void setException(Exception exception) { + this.exception = exception; + } + + protected void setStatus(Status status) { + synchronized (statusMonitor) { + this.status = status; + } + } + + protected boolean updateStatus(Status oldStatus, Status newStatus) { + synchronized (statusMonitor) { + if (oldStatus != status) { + return false; + } + status = newStatus; + return true; + } + } + + protected void writeToStream(final InputStream in, final OutputStream out) + throws XMPPException + { + final byte[] b = new byte[BUFFER_SIZE]; + int count = 0; + amountWritten = 0; + + do { + // write to the output stream + try { + out.write(b, 0, count); + } catch (IOException e) { + throw new XMPPException("error writing to output stream", e); + } + + amountWritten += count; + + // read more bytes from the input stream + try { + count = in.read(b); + } catch (IOException e) { + throw new XMPPException("error reading from input stream", e); + } + } while (count != -1 && !getStatus().equals(Status.cancelled)); + + // the connection was likely terminated abrubtly if these are not equal + if (!getStatus().equals(Status.cancelled) && getError() == Error.none + && amountWritten != fileSize) { + setStatus(Status.error); + this.error = Error.connection; + } + } + + /** + * A class to represent the current status of the file transfer. + * + * @author Alexander Wenckus + * + */ + public enum Status { + + /** + * An error occured during the transfer. + * + * @see FileTransfer#getError() + */ + error("Error"), + + /** + * The initial status of the file transfer. + */ + initial("Initial"), + + /** + * The file transfer is being negotiated with the peer. The party + * recieving the file has the option to accept or refuse a file transfer + * request. If they accept, then the process of stream negotiation will + * begin. If they refuse the file will not be transfered. + * + * @see #negotiating_stream + */ + negotiating_transfer("Negotiating Transfer"), + + /** + * The peer has refused the file transfer request halting the file + * transfer negotiation process. + */ + refused("Refused"), + + /** + * The stream to transfer the file is being negotiated over the chosen + * stream type. After the stream negotiating process is complete the + * status becomes negotiated. + * + * @see #negotiated + */ + negotiating_stream("Negotiating Stream"), + + /** + * After the stream negotitation has completed the intermediate state + * between the time when the negotiation is finished and the actual + * transfer begins. + */ + negotiated("Negotiated"), + + /** + * The transfer is in progress. + * + * @see FileTransfer#getProgress() + */ + in_progress("In Progress"), + + /** + * The transfer has completed successfully. + */ + complete("Complete"), + + /** + * The file transfer was canceled + */ + cancelled("Cancelled"); + + private String status; + + private Status(String status) { + this.status = status; + } + + public String toString() { + return status; + } + } + + /** + * Return the length of bytes written out to the stream. + * @return the amount in bytes written out. + */ + public long getAmountWritten(){ + return amountWritten; + } + + public enum Error { + /** + * No error + */ + none("No error"), + + /** + * The peer did not find any of the provided stream mechanisms + * acceptable. + */ + not_acceptable("The peer did not find any of the provided stream mechanisms acceptable."), + + /** + * The provided file to transfer does not exist or could not be read. + */ + bad_file("The provided file to transfer does not exist or could not be read."), + + /** + * The remote user did not respond or the connection timed out. + */ + no_response("The remote user did not respond or the connection timed out."), + + /** + * An error occured over the socket connected to send the file. + */ + connection("An error occured over the socket connected to send the file."), + + /** + * An error occured while sending or recieving the file + */ + stream("An error occured while sending or recieving the file."); + + private final String msg; + + private Error(String msg) { + this.msg = msg; + } + + /** + * Returns a String representation of this error. + * + * @return Returns a String representation of this error. + */ + public String getMessage() { + return msg; + } + + public String toString() { + return msg; + } + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransferListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransferListener.java new file mode 100644 index 0000000..69b5c10 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransferListener.java @@ -0,0 +1,36 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2003-2006 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.smackx.filetransfer; + +/** + * File transfers can cause several events to be raised. These events can be + * monitored through this interface. + * + * @author Alexander Wenckus + */ +public interface FileTransferListener { + /** + * A request to send a file has been recieved from another user. + * + * @param request + * The request from the other user. + */ + public void fileTransferRequest(final FileTransferRequest request); +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransferManager.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransferManager.java new file mode 100644 index 0000000..25498a6 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransferManager.java @@ -0,0 +1,178 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2003-2006 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.smackx.filetransfer; + +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.filter.AndFilter; +import org.jivesoftware.smack.filter.IQTypeFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.packet.XMPPError; +import org.jivesoftware.smackx.packet.StreamInitiation; + +import java.util.ArrayList; +import java.util.List; + +/** + * The file transfer manager class handles the sending and recieving of files. + * To send a file invoke the {@link #createOutgoingFileTransfer(String)} method. + * + * And to recieve a file add a file transfer listener to the manager. The + * listener will notify you when there is a new file transfer request. To create + * the {@link IncomingFileTransfer} object accept the transfer, or, if the + * transfer is not desirable reject it. + * + * @author Alexander Wenckus + * + */ +public class FileTransferManager { + + private final FileTransferNegotiator fileTransferNegotiator; + + private List<FileTransferListener> listeners; + + private Connection connection; + + /** + * Creates a file transfer manager to initiate and receive file transfers. + * + * @param connection + * The Connection that the file transfers will use. + */ + public FileTransferManager(Connection connection) { + this.connection = connection; + this.fileTransferNegotiator = FileTransferNegotiator + .getInstanceFor(connection); + } + + /** + * Add a file transfer listener to listen to incoming file transfer + * requests. + * + * @param li + * The listener + * @see #removeFileTransferListener(FileTransferListener) + * @see FileTransferListener + */ + public void addFileTransferListener(final FileTransferListener li) { + if (listeners == null) { + initListeners(); + } + synchronized (this.listeners) { + listeners.add(li); + } + } + + private void initListeners() { + listeners = new ArrayList<FileTransferListener>(); + + connection.addPacketListener(new PacketListener() { + public void processPacket(Packet packet) { + fireNewRequest((StreamInitiation) packet); + } + }, new AndFilter(new PacketTypeFilter(StreamInitiation.class), + new IQTypeFilter(IQ.Type.SET))); + } + + protected void fireNewRequest(StreamInitiation initiation) { + FileTransferListener[] listeners = null; + synchronized (this.listeners) { + listeners = new FileTransferListener[this.listeners.size()]; + this.listeners.toArray(listeners); + } + FileTransferRequest request = new FileTransferRequest(this, initiation); + for (int i = 0; i < listeners.length; i++) { + listeners[i].fileTransferRequest(request); + } + } + + /** + * Removes a file transfer listener. + * + * @param li + * The file transfer listener to be removed + * @see FileTransferListener + */ + public void removeFileTransferListener(final FileTransferListener li) { + if (listeners == null) { + return; + } + synchronized (this.listeners) { + listeners.remove(li); + } + } + + /** + * Creates an OutgoingFileTransfer to send a file to another user. + * + * @param userID + * The fully qualified jabber ID with resource of the user to + * send the file to. + * @return The send file object on which the negotiated transfer can be run. + */ + public OutgoingFileTransfer createOutgoingFileTransfer(String userID) { +// Why is this only accepting fully qualified JID? +// if (userID == null || StringUtils.parseName(userID).length() <= 0 +// || StringUtils.parseServer(userID).length() <= 0 +// || StringUtils.parseResource(userID).length() <= 0) { +// throw new IllegalArgumentException( +// "The provided user id was not fully qualified"); +// } + + return new OutgoingFileTransfer(connection.getUser(), userID, + fileTransferNegotiator.getNextStreamID(), + fileTransferNegotiator); + } + + /** + * When the file transfer request is acceptable, this method should be + * invoked. It will create an IncomingFileTransfer which allows the + * transmission of the file to procede. + * + * @param request + * The remote request that is being accepted. + * @return The IncomingFileTransfer which manages the download of the file + * from the transfer initiator. + */ + protected IncomingFileTransfer createIncomingFileTransfer( + FileTransferRequest request) { + if (request == null) { + throw new NullPointerException("RecieveRequest cannot be null"); + } + + IncomingFileTransfer transfer = new IncomingFileTransfer(request, + fileTransferNegotiator); + transfer.setFileInfo(request.getFileName(), request.getFileSize()); + + return transfer; + } + + protected void rejectIncomingFileTransfer(FileTransferRequest request) { + StreamInitiation initiation = request.getStreamInitiation(); + + IQ rejection = FileTransferNegotiator.createIQ( + initiation.getPacketID(), initiation.getFrom(), initiation + .getTo(), IQ.Type.ERROR); + rejection.setError(new XMPPError(XMPPError.Condition.no_acceptable)); + connection.sendPacket(rejection); + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransferNegotiator.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransferNegotiator.java new file mode 100644 index 0000000..290d69c --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransferNegotiator.java @@ -0,0 +1,485 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2003-2006 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.smackx.filetransfer; + +import java.net.URLConnection; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Random; +import java.util.concurrent.ConcurrentHashMap; + +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.ConnectionListener; +import org.jivesoftware.smack.PacketCollector; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.filter.PacketIDFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.packet.XMPPError; +import org.jivesoftware.smackx.Form; +import org.jivesoftware.smackx.FormField; +import org.jivesoftware.smackx.ServiceDiscoveryManager; +import org.jivesoftware.smackx.bytestreams.ibb.InBandBytestreamManager; +import org.jivesoftware.smackx.bytestreams.socks5.Socks5BytestreamManager; +import org.jivesoftware.smackx.packet.DataForm; +import org.jivesoftware.smackx.packet.StreamInitiation; + +/** + * Manages the negotiation of file transfers according to JEP-0096. If a file is + * being sent the remote user chooses the type of stream under which the file + * will be sent. + * + * @author Alexander Wenckus + * @see <a href="http://xmpp.org/extensions/xep-0096.html">XEP-0096: SI File Transfer</a> + */ +public class FileTransferNegotiator { + + // Static + + private static final String[] NAMESPACE = { + "http://jabber.org/protocol/si/profile/file-transfer", + "http://jabber.org/protocol/si"}; + + private static final Map<Connection, FileTransferNegotiator> transferObject = + new ConcurrentHashMap<Connection, FileTransferNegotiator>(); + + private static final String STREAM_INIT_PREFIX = "jsi_"; + + protected static final String STREAM_DATA_FIELD_NAME = "stream-method"; + + private static final Random randomGenerator = new Random(); + + /** + * A static variable to use only offer IBB for file transfer. It is generally recommend to only + * set this variable to true for testing purposes as IBB is the backup file transfer method + * and shouldn't be used as the only transfer method in production systems. + */ + public static boolean IBB_ONLY = (System.getProperty("ibb") != null);//true; + + /** + * Returns the file transfer negotiator related to a particular connection. + * When this class is requested on a particular connection the file transfer + * service is automatically enabled. + * + * @param connection The connection for which the transfer manager is desired + * @return The IMFileTransferManager + */ + public static FileTransferNegotiator getInstanceFor( + final Connection connection) { + if (connection == null) { + throw new IllegalArgumentException("Connection cannot be null"); + } + if (!connection.isConnected()) { + return null; + } + + if (transferObject.containsKey(connection)) { + return transferObject.get(connection); + } + else { + FileTransferNegotiator transfer = new FileTransferNegotiator( + connection); + setServiceEnabled(connection, true); + transferObject.put(connection, transfer); + return transfer; + } + } + + /** + * Enable the Jabber services related to file transfer on the particular + * connection. + * + * @param connection The connection on which to enable or disable the services. + * @param isEnabled True to enable, false to disable. + */ + public static void setServiceEnabled(final Connection connection, + final boolean isEnabled) { + ServiceDiscoveryManager manager = ServiceDiscoveryManager + .getInstanceFor(connection); + + List<String> namespaces = new ArrayList<String>(); + namespaces.addAll(Arrays.asList(NAMESPACE)); + namespaces.add(InBandBytestreamManager.NAMESPACE); + if (!IBB_ONLY) { + namespaces.add(Socks5BytestreamManager.NAMESPACE); + } + + for (String namespace : namespaces) { + if (isEnabled) { + if (!manager.includesFeature(namespace)) { + manager.addFeature(namespace); + } + } else { + manager.removeFeature(namespace); + } + } + + } + + /** + * Checks to see if all file transfer related services are enabled on the + * connection. + * + * @param connection The connection to check + * @return True if all related services are enabled, false if they are not. + */ + public static boolean isServiceEnabled(final Connection connection) { + ServiceDiscoveryManager manager = ServiceDiscoveryManager + .getInstanceFor(connection); + + List<String> namespaces = new ArrayList<String>(); + namespaces.addAll(Arrays.asList(NAMESPACE)); + namespaces.add(InBandBytestreamManager.NAMESPACE); + if (!IBB_ONLY) { + namespaces.add(Socks5BytestreamManager.NAMESPACE); + } + + for (String namespace : namespaces) { + if (!manager.includesFeature(namespace)) { + return false; + } + } + return true; + } + + /** + * A convenience method to create an IQ packet. + * + * @param ID The packet ID of the + * @param to To whom the packet is addressed. + * @param from From whom the packet is sent. + * @param type The IQ type of the packet. + * @return The created IQ packet. + */ + public static IQ createIQ(final String ID, final String to, + final String from, final IQ.Type type) { + IQ iqPacket = new IQ() { + public String getChildElementXML() { + return null; + } + }; + iqPacket.setPacketID(ID); + iqPacket.setTo(to); + iqPacket.setFrom(from); + iqPacket.setType(type); + + return iqPacket; + } + + /** + * Returns a collection of the supported transfer protocols. + * + * @return Returns a collection of the supported transfer protocols. + */ + public static Collection<String> getSupportedProtocols() { + List<String> protocols = new ArrayList<String>(); + protocols.add(InBandBytestreamManager.NAMESPACE); + if (!IBB_ONLY) { + protocols.add(Socks5BytestreamManager.NAMESPACE); + } + return Collections.unmodifiableList(protocols); + } + + // non-static + + private final Connection connection; + + private final StreamNegotiator byteStreamTransferManager; + + private final StreamNegotiator inbandTransferManager; + + private FileTransferNegotiator(final Connection connection) { + configureConnection(connection); + + this.connection = connection; + byteStreamTransferManager = new Socks5TransferNegotiator(connection); + inbandTransferManager = new IBBTransferNegotiator(connection); + } + + private void configureConnection(final Connection connection) { + connection.addConnectionListener(new ConnectionListener() { + public void connectionClosed() { + cleanup(connection); + } + + public void connectionClosedOnError(Exception e) { + cleanup(connection); + } + + public void reconnectionFailed(Exception e) { + // ignore + } + + public void reconnectionSuccessful() { + // ignore + } + + public void reconnectingIn(int seconds) { + // ignore + } + }); + } + + private void cleanup(final Connection connection) { + if (transferObject.remove(connection) != null) { + inbandTransferManager.cleanup(); + } + } + + /** + * Selects an appropriate stream negotiator after examining the incoming file transfer request. + * + * @param request The related file transfer request. + * @return The file transfer object that handles the transfer + * @throws XMPPException If there are either no stream methods contained in the packet, or + * there is not an appropriate stream method. + */ + public StreamNegotiator selectStreamNegotiator( + FileTransferRequest request) throws XMPPException { + StreamInitiation si = request.getStreamInitiation(); + FormField streamMethodField = getStreamMethodField(si + .getFeatureNegotiationForm()); + + if (streamMethodField == null) { + String errorMessage = "No stream methods contained in packet."; + XMPPError error = new XMPPError(XMPPError.Condition.bad_request, errorMessage); + IQ iqPacket = createIQ(si.getPacketID(), si.getFrom(), si.getTo(), + IQ.Type.ERROR); + iqPacket.setError(error); + connection.sendPacket(iqPacket); + throw new XMPPException(errorMessage, error); + } + + // select the appropriate protocol + + StreamNegotiator selectedStreamNegotiator; + try { + selectedStreamNegotiator = getNegotiator(streamMethodField); + } + catch (XMPPException e) { + IQ iqPacket = createIQ(si.getPacketID(), si.getFrom(), si.getTo(), + IQ.Type.ERROR); + iqPacket.setError(e.getXMPPError()); + connection.sendPacket(iqPacket); + throw e; + } + + // return the appropriate negotiator + + return selectedStreamNegotiator; + } + + private FormField getStreamMethodField(DataForm form) { + FormField field = null; + for (Iterator<FormField> it = form.getFields(); it.hasNext();) { + field = it.next(); + if (field.getVariable().equals(STREAM_DATA_FIELD_NAME)) { + break; + } + field = null; + } + return field; + } + + private StreamNegotiator getNegotiator(final FormField field) + throws XMPPException { + String variable; + boolean isByteStream = false; + boolean isIBB = false; + for (Iterator<FormField.Option> it = field.getOptions(); it.hasNext();) { + variable = it.next().getValue(); + if (variable.equals(Socks5BytestreamManager.NAMESPACE) && !IBB_ONLY) { + isByteStream = true; + } + else if (variable.equals(InBandBytestreamManager.NAMESPACE)) { + isIBB = true; + } + } + + if (!isByteStream && !isIBB) { + XMPPError error = new XMPPError(XMPPError.Condition.bad_request, + "No acceptable transfer mechanism"); + throw new XMPPException(error.getMessage(), error); + } + + //if (isByteStream && isIBB && field.getType().equals(FormField.TYPE_LIST_MULTI)) { + if (isByteStream && isIBB) { + return new FaultTolerantNegotiator(connection, + byteStreamTransferManager, + inbandTransferManager); + } + else if (isByteStream) { + return byteStreamTransferManager; + } + else { + return inbandTransferManager; + } + } + + /** + * Reject a stream initiation request from a remote user. + * + * @param si The Stream Initiation request to reject. + */ + public void rejectStream(final StreamInitiation si) { + XMPPError error = new XMPPError(XMPPError.Condition.forbidden, "Offer Declined"); + IQ iqPacket = createIQ(si.getPacketID(), si.getFrom(), si.getTo(), + IQ.Type.ERROR); + iqPacket.setError(error); + connection.sendPacket(iqPacket); + } + + /** + * Returns a new, unique, stream ID to identify a file transfer. + * + * @return Returns a new, unique, stream ID to identify a file transfer. + */ + public String getNextStreamID() { + StringBuilder buffer = new StringBuilder(); + buffer.append(STREAM_INIT_PREFIX); + buffer.append(Math.abs(randomGenerator.nextLong())); + + return buffer.toString(); + } + + /** + * Send a request to another user to send them a file. The other user has + * the option of, accepting, rejecting, or not responding to a received file + * transfer request. + * + * If they accept, the packet will contain the other user's chosen stream + * type to send the file across. The two choices this implementation + * provides to the other user for file transfer are <a + * href="http://www.jabber.org/jeps/jep-0065.html">SOCKS5 Bytestreams</a>, + * which is the preferred method of transfer, and <a + * href="http://www.jabber.org/jeps/jep-0047.html">In-Band Bytestreams</a>, + * which is the fallback mechanism. + * + * The other user may choose to decline the file request if they do not + * desire the file, their client does not support JEP-0096, or if there are + * no acceptable means to transfer the file. + * + * Finally, if the other user does not respond this method will return null + * after the specified timeout. + * + * @param userID The userID of the user to whom the file will be sent. + * @param streamID The unique identifier for this file transfer. + * @param fileName The name of this file. Preferably it should include an + * extension as it is used to determine what type of file it is. + * @param size The size, in bytes, of the file. + * @param desc A description of the file. + * @param responseTimeout The amount of time, in milliseconds, to wait for the remote + * user to respond. If they do not respond in time, this + * @return Returns the stream negotiator selected by the peer. + * @throws XMPPException Thrown if there is an error negotiating the file transfer. + */ + public StreamNegotiator negotiateOutgoingTransfer(final String userID, + final String streamID, final String fileName, final long size, + final String desc, int responseTimeout) throws XMPPException { + StreamInitiation si = new StreamInitiation(); + si.setSesssionID(streamID); + si.setMimeType(URLConnection.guessContentTypeFromName(fileName)); + + StreamInitiation.File siFile = new StreamInitiation.File(fileName, size); + siFile.setDesc(desc); + si.setFile(siFile); + + si.setFeatureNegotiationForm(createDefaultInitiationForm()); + + si.setFrom(connection.getUser()); + si.setTo(userID); + si.setType(IQ.Type.SET); + + PacketCollector collector = connection + .createPacketCollector(new PacketIDFilter(si.getPacketID())); + connection.sendPacket(si); + Packet siResponse = collector.nextResult(responseTimeout); + collector.cancel(); + + if (siResponse instanceof IQ) { + IQ iqResponse = (IQ) siResponse; + if (iqResponse.getType().equals(IQ.Type.RESULT)) { + StreamInitiation response = (StreamInitiation) siResponse; + return getOutgoingNegotiator(getStreamMethodField(response + .getFeatureNegotiationForm())); + + } + else if (iqResponse.getType().equals(IQ.Type.ERROR)) { + throw new XMPPException(iqResponse.getError()); + } + else { + throw new XMPPException("File transfer response unreadable"); + } + } + else { + return null; + } + } + + private StreamNegotiator getOutgoingNegotiator(final FormField field) + throws XMPPException { + String variable; + boolean isByteStream = false; + boolean isIBB = false; + for (Iterator<String> it = field.getValues(); it.hasNext();) { + variable = it.next(); + if (variable.equals(Socks5BytestreamManager.NAMESPACE) && !IBB_ONLY) { + isByteStream = true; + } + else if (variable.equals(InBandBytestreamManager.NAMESPACE)) { + isIBB = true; + } + } + + if (!isByteStream && !isIBB) { + XMPPError error = new XMPPError(XMPPError.Condition.bad_request, + "No acceptable transfer mechanism"); + throw new XMPPException(error.getMessage(), error); + } + + if (isByteStream && isIBB) { + return new FaultTolerantNegotiator(connection, + byteStreamTransferManager, inbandTransferManager); + } + else if (isByteStream) { + return byteStreamTransferManager; + } + else { + return inbandTransferManager; + } + } + + private DataForm createDefaultInitiationForm() { + DataForm form = new DataForm(Form.TYPE_FORM); + FormField field = new FormField(STREAM_DATA_FIELD_NAME); + field.setType(FormField.TYPE_LIST_SINGLE); + if (!IBB_ONLY) { + field.addOption(new FormField.Option(Socks5BytestreamManager.NAMESPACE)); + } + field.addOption(new FormField.Option(InBandBytestreamManager.NAMESPACE)); + form.addField(field); + return form; + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransferRequest.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransferRequest.java new file mode 100644 index 0000000..d202dca --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/FileTransferRequest.java @@ -0,0 +1,138 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2003-2006 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.smackx.filetransfer; + +import org.jivesoftware.smackx.packet.StreamInitiation; + +/** + * A request to send a file recieved from another user. + * + * @author Alexander Wenckus + * + */ +public class FileTransferRequest { + private final StreamInitiation streamInitiation; + + private final FileTransferManager manager; + + /** + * A recieve request is constructed from the Stream Initiation request + * received from the initator. + * + * @param manager + * The manager handling this file transfer + * + * @param si + * The Stream initiaton recieved from the initiator. + */ + public FileTransferRequest(FileTransferManager manager, StreamInitiation si) { + this.streamInitiation = si; + this.manager = manager; + } + + /** + * Returns the name of the file. + * + * @return Returns the name of the file. + */ + public String getFileName() { + return streamInitiation.getFile().getName(); + } + + /** + * Returns the size in bytes of the file. + * + * @return Returns the size in bytes of the file. + */ + public long getFileSize() { + return streamInitiation.getFile().getSize(); + } + + /** + * Returns the description of the file provided by the requestor. + * + * @return Returns the description of the file provided by the requestor. + */ + public String getDescription() { + return streamInitiation.getFile().getDesc(); + } + + /** + * Returns the mime-type of the file. + * + * @return Returns the mime-type of the file. + */ + public String getMimeType() { + return streamInitiation.getMimeType(); + } + + /** + * Returns the fully-qualified jabber ID of the user that requested this + * file transfer. + * + * @return Returns the fully-qualified jabber ID of the user that requested + * this file transfer. + */ + public String getRequestor() { + return streamInitiation.getFrom(); + } + + /** + * Returns the stream ID that uniquely identifies this file transfer. + * + * @return Returns the stream ID that uniquely identifies this file + * transfer. + */ + public String getStreamID() { + return streamInitiation.getSessionID(); + } + + /** + * Returns the stream initiation packet that was sent by the requestor which + * contains the parameters of the file transfer being transfer and also the + * methods available to transfer the file. + * + * @return Returns the stream initiation packet that was sent by the + * requestor which contains the parameters of the file transfer + * being transfer and also the methods available to transfer the + * file. + */ + protected StreamInitiation getStreamInitiation() { + return streamInitiation; + } + + /** + * Accepts this file transfer and creates the incoming file transfer. + * + * @return Returns the IncomingFileTransfer on which the + * file transfer can be carried out. + */ + public IncomingFileTransfer accept() { + return manager.createIncomingFileTransfer(this); + } + + /** + * Rejects the file transfer request. + */ + public void reject() { + manager.rejectIncomingFileTransfer(this); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/IBBTransferNegotiator.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/IBBTransferNegotiator.java new file mode 100644 index 0000000..df0f67e --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/IBBTransferNegotiator.java @@ -0,0 +1,152 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2003-2006 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.smackx.filetransfer; + +import java.io.InputStream; +import java.io.OutputStream; + +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.filter.AndFilter; +import org.jivesoftware.smack.filter.FromContainsFilter; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smackx.bytestreams.ibb.InBandBytestreamManager; +import org.jivesoftware.smackx.bytestreams.ibb.InBandBytestreamRequest; +import org.jivesoftware.smackx.bytestreams.ibb.InBandBytestreamSession; +import org.jivesoftware.smackx.bytestreams.ibb.packet.Open; +import org.jivesoftware.smackx.packet.StreamInitiation; + +/** + * The In-Band Bytestream file transfer method, or IBB for short, transfers the + * file over the same XML Stream used by XMPP. It is the fall-back mechanism in + * case the SOCKS5 bytestream method of transferring files is not available. + * + * @author Alexander Wenckus + * @author Henning Staib + * @see <a href="http://xmpp.org/extensions/xep-0047.html">XEP-0047: In-Band + * Bytestreams (IBB)</a> + */ +public class IBBTransferNegotiator extends StreamNegotiator { + + private Connection connection; + + private InBandBytestreamManager manager; + + /** + * The default constructor for the In-Band Bytestream Negotiator. + * + * @param connection The connection which this negotiator works on. + */ + protected IBBTransferNegotiator(Connection connection) { + this.connection = connection; + this.manager = InBandBytestreamManager.getByteStreamManager(connection); + } + + public OutputStream createOutgoingStream(String streamID, String initiator, + String target) throws XMPPException { + InBandBytestreamSession session = this.manager.establishSession(target, streamID); + session.setCloseBothStreamsEnabled(true); + return session.getOutputStream(); + } + + public InputStream createIncomingStream(StreamInitiation initiation) + throws XMPPException { + /* + * In-Band Bytestream initiation listener must ignore next in-band + * bytestream request with given session ID + */ + this.manager.ignoreBytestreamRequestOnce(initiation.getSessionID()); + + Packet streamInitiation = initiateIncomingStream(this.connection, initiation); + return negotiateIncomingStream(streamInitiation); + } + + public PacketFilter getInitiationPacketFilter(String from, String streamID) { + /* + * this method is always called prior to #negotiateIncomingStream() so + * the In-Band Bytestream initiation listener must ignore the next + * In-Band Bytestream request with the given session ID + */ + this.manager.ignoreBytestreamRequestOnce(streamID); + + return new AndFilter(new FromContainsFilter(from), new IBBOpenSidFilter(streamID)); + } + + public String[] getNamespaces() { + return new String[] { InBandBytestreamManager.NAMESPACE }; + } + + InputStream negotiateIncomingStream(Packet streamInitiation) throws XMPPException { + // build In-Band Bytestream request + InBandBytestreamRequest request = new ByteStreamRequest(this.manager, + (Open) streamInitiation); + + // always accept the request + InBandBytestreamSession session = request.accept(); + session.setCloseBothStreamsEnabled(true); + return session.getInputStream(); + } + + public void cleanup() { + } + + /** + * This PacketFilter accepts an incoming In-Band Bytestream open request + * with a specified session ID. + */ + private static class IBBOpenSidFilter extends PacketTypeFilter { + + private String sessionID; + + public IBBOpenSidFilter(String sessionID) { + super(Open.class); + if (sessionID == null) { + throw new IllegalArgumentException("StreamID cannot be null"); + } + this.sessionID = sessionID; + } + + public boolean accept(Packet packet) { + if (super.accept(packet)) { + Open bytestream = (Open) packet; + + // packet must by of type SET and contains the given session ID + return this.sessionID.equals(bytestream.getSessionID()) + && IQ.Type.SET.equals(bytestream.getType()); + } + return false; + } + } + + /** + * Derive from InBandBytestreamRequest to access protected constructor. + */ + private static class ByteStreamRequest extends InBandBytestreamRequest { + + private ByteStreamRequest(InBandBytestreamManager manager, Open byteStreamRequest) { + super(manager, byteStreamRequest); + } + + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/IncomingFileTransfer.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/IncomingFileTransfer.java new file mode 100644 index 0000000..3973d44 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/IncomingFileTransfer.java @@ -0,0 +1,215 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2003-2006 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.smackx.filetransfer; + +import org.jivesoftware.smack.XMPPException; + +import java.io.*; +import java.util.concurrent.*; + +/** + * An incoming file transfer is created when the + * {@link FileTransferManager#createIncomingFileTransfer(FileTransferRequest)} + * method is invoked. It is a file being sent to the local user from another + * user on the jabber network. There are two stages of the file transfer to be + * concerned with and they can be handled in different ways depending upon the + * method that is invoked on this class. + * + * The first way that a file is recieved is by calling the + * {@link #recieveFile()} method. This method, negotiates the appropriate stream + * method and then returns the InputStream to read the file + * data from. + * + * The second way that a file can be recieved through this class is by invoking + * the {@link #recieveFile(File)} method. This method returns immediatly and + * takes as its parameter a file on the local file system where the file + * recieved from the transfer will be put. + * + * @author Alexander Wenckus + */ +public class IncomingFileTransfer extends FileTransfer { + + private FileTransferRequest recieveRequest; + + private InputStream inputStream; + + protected IncomingFileTransfer(FileTransferRequest request, + FileTransferNegotiator transferNegotiator) { + super(request.getRequestor(), request.getStreamID(), transferNegotiator); + this.recieveRequest = request; + } + + /** + * Negotiates the stream method to transfer the file over and then returns + * the negotiated stream. + * + * @return The negotiated InputStream from which to read the data. + * @throws XMPPException If there is an error in the negotiation process an exception + * is thrown. + */ + public InputStream recieveFile() throws XMPPException { + if (inputStream != null) { + throw new IllegalStateException("Transfer already negotiated!"); + } + + try { + inputStream = negotiateStream(); + } + catch (XMPPException e) { + setException(e); + throw e; + } + + return inputStream; + } + + /** + * This method negotitates the stream and then transfer's the file over the + * negotiated stream. The transfered file will be saved at the provided + * location. + * + * This method will return immedialtly, file transfer progress can be + * monitored through several methods: + * + * <UL> + * <LI>{@link FileTransfer#getStatus()} + * <LI>{@link FileTransfer#getProgress()} + * <LI>{@link FileTransfer#isDone()} + * </UL> + * + * @param file The location to save the file. + * @throws XMPPException when the file transfer fails + * @throws IllegalArgumentException This exception is thrown when the the provided file is + * either null, or cannot be written to. + */ + public void recieveFile(final File file) throws XMPPException { + if (file != null) { + if (!file.exists()) { + try { + file.createNewFile(); + } + catch (IOException e) { + throw new XMPPException( + "Could not create file to write too", e); + } + } + if (!file.canWrite()) { + throw new IllegalArgumentException("Cannot write to provided file"); + } + } + else { + throw new IllegalArgumentException("File cannot be null"); + } + + Thread transferThread = new Thread(new Runnable() { + public void run() { + try { + inputStream = negotiateStream(); + } + catch (XMPPException e) { + handleXMPPException(e); + return; + } + + OutputStream outputStream = null; + try { + outputStream = new FileOutputStream(file); + setStatus(Status.in_progress); + writeToStream(inputStream, outputStream); + } + catch (XMPPException e) { + setStatus(Status.error); + setError(Error.stream); + setException(e); + } + catch (FileNotFoundException e) { + setStatus(Status.error); + setError(Error.bad_file); + setException(e); + } + + if (getStatus().equals(Status.in_progress)) { + setStatus(Status.complete); + } + if (inputStream != null) { + try { + inputStream.close(); + } + catch (Throwable io) { + /* Ignore */ + } + } + if (outputStream != null) { + try { + outputStream.close(); + } + catch (Throwable io) { + /* Ignore */ + } + } + } + }, "File Transfer " + streamID); + transferThread.start(); + } + + private void handleXMPPException(XMPPException e) { + setStatus(FileTransfer.Status.error); + setException(e); + } + + private InputStream negotiateStream() throws XMPPException { + setStatus(Status.negotiating_transfer); + final StreamNegotiator streamNegotiator = negotiator + .selectStreamNegotiator(recieveRequest); + setStatus(Status.negotiating_stream); + FutureTask<InputStream> streamNegotiatorTask = new FutureTask<InputStream>( + new Callable<InputStream>() { + + public InputStream call() throws Exception { + return streamNegotiator + .createIncomingStream(recieveRequest.getStreamInitiation()); + } + }); + streamNegotiatorTask.run(); + InputStream inputStream; + try { + inputStream = streamNegotiatorTask.get(15, TimeUnit.SECONDS); + } + catch (InterruptedException e) { + throw new XMPPException("Interruption while executing", e); + } + catch (ExecutionException e) { + throw new XMPPException("Error in execution", e); + } + catch (TimeoutException e) { + throw new XMPPException("Request timed out", e); + } + finally { + streamNegotiatorTask.cancel(true); + } + setStatus(Status.negotiated); + return inputStream; + } + + public void cancel() { + setStatus(Status.cancelled); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/OutgoingFileTransfer.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/OutgoingFileTransfer.java new file mode 100644 index 0000000..0bc1d77 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/OutgoingFileTransfer.java @@ -0,0 +1,453 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2003-2006 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.smackx.filetransfer; + +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.packet.XMPPError; + +import java.io.*; + +/** + * Handles the sending of a file to another user. File transfer's in jabber have + * several steps and there are several methods in this class that handle these + * steps differently. + * + * @author Alexander Wenckus + * + */ +public class OutgoingFileTransfer extends FileTransfer { + + private static int RESPONSE_TIMEOUT = 60 * 1000; + private NegotiationProgress callback; + + /** + * Returns the time in milliseconds after which the file transfer + * negotiation process will timeout if the other user has not responded. + * + * @return Returns the time in milliseconds after which the file transfer + * negotiation process will timeout if the remote user has not + * responded. + */ + public static int getResponseTimeout() { + return RESPONSE_TIMEOUT; + } + + /** + * Sets the time in milliseconds after which the file transfer negotiation + * process will timeout if the other user has not responded. + * + * @param responseTimeout + * The timeout time in milliseconds. + */ + public static void setResponseTimeout(int responseTimeout) { + RESPONSE_TIMEOUT = responseTimeout; + } + + private OutputStream outputStream; + + private String initiator; + + private Thread transferThread; + + protected OutgoingFileTransfer(String initiator, String target, + String streamID, FileTransferNegotiator transferNegotiator) { + super(target, streamID, transferNegotiator); + this.initiator = initiator; + } + + protected void setOutputStream(OutputStream stream) { + if (outputStream == null) { + this.outputStream = stream; + } + } + + /** + * Returns the output stream connected to the peer to transfer the file. It + * is only available after it has been succesfully negotiated by the + * {@link StreamNegotiator}. + * + * @return Returns the output stream connected to the peer to transfer the + * file. + */ + protected OutputStream getOutputStream() { + if (getStatus().equals(FileTransfer.Status.negotiated)) { + return outputStream; + } else { + return null; + } + } + + /** + * This method handles the negotiation of the file transfer and the stream, + * it only returns the created stream after the negotiation has been completed. + * + * @param fileName + * The name of the file that will be transmitted. It is + * preferable for this name to have an extension as it will be + * used to determine the type of file it is. + * @param fileSize + * The size in bytes of the file that will be transmitted. + * @param description + * A description of the file that will be transmitted. + * @return The OutputStream that is connected to the peer to transmit the + * file. + * @throws XMPPException + * Thrown if an error occurs during the file transfer + * negotiation process. + */ + public synchronized OutputStream sendFile(String fileName, long fileSize, + String description) throws XMPPException { + if (isDone() || outputStream != null) { + throw new IllegalStateException( + "The negotation process has already" + + " been attempted on this file transfer"); + } + try { + this.outputStream = negotiateStream(fileName, fileSize, description); + } catch (XMPPException e) { + handleXMPPException(e); + throw e; + } + return outputStream; + } + + /** + * This methods handles the transfer and stream negotiation process. It + * returns immediately and its progress will be updated through the + * {@link NegotiationProgress} callback. + * + * @param fileName + * The name of the file that will be transmitted. It is + * preferable for this name to have an extension as it will be + * used to determine the type of file it is. + * @param fileSize + * The size in bytes of the file that will be transmitted. + * @param description + * A description of the file that will be transmitted. + * @param progress + * A callback to monitor the progress of the file transfer + * negotiation process and to retrieve the OutputStream when it + * is complete. + */ + public synchronized void sendFile(final String fileName, + final long fileSize, final String description, + final NegotiationProgress progress) + { + if(progress == null) { + throw new IllegalArgumentException("Callback progress cannot be null."); + } + checkTransferThread(); + if (isDone() || outputStream != null) { + throw new IllegalStateException( + "The negotation process has already" + + " been attempted for this file transfer"); + } + this.callback = progress; + transferThread = new Thread(new Runnable() { + public void run() { + try { + OutgoingFileTransfer.this.outputStream = negotiateStream( + fileName, fileSize, description); + progress.outputStreamEstablished(OutgoingFileTransfer.this.outputStream); + } + catch (XMPPException e) { + handleXMPPException(e); + } + } + }, "File Transfer Negotiation " + streamID); + transferThread.start(); + } + + private void checkTransferThread() { + if (transferThread != null && transferThread.isAlive() || isDone()) { + throw new IllegalStateException( + "File transfer in progress or has already completed."); + } + } + + /** + * This method handles the stream negotiation process and transmits the file + * to the remote user. It returns immediatly and the progress of the file + * transfer can be monitored through several methods: + * + * <UL> + * <LI>{@link FileTransfer#getStatus()} + * <LI>{@link FileTransfer#getProgress()} + * <LI>{@link FileTransfer#isDone()} + * </UL> + * + * @param file the file to transfer to the remote entity. + * @param description a description for the file to transfer. + * @throws XMPPException + * If there is an error during the negotiation process or the + * sending of the file. + */ + public synchronized void sendFile(final File file, final String description) + throws XMPPException { + checkTransferThread(); + if (file == null || !file.exists() || !file.canRead()) { + throw new IllegalArgumentException("Could not read file"); + } else { + setFileInfo(file.getAbsolutePath(), file.getName(), file.length()); + } + + transferThread = new Thread(new Runnable() { + public void run() { + try { + outputStream = negotiateStream(file.getName(), file + .length(), description); + } catch (XMPPException e) { + handleXMPPException(e); + return; + } + if (outputStream == null) { + return; + } + + if (!updateStatus(Status.negotiated, Status.in_progress)) { + return; + } + + InputStream inputStream = null; + try { + inputStream = new FileInputStream(file); + writeToStream(inputStream, outputStream); + } catch (FileNotFoundException e) { + setStatus(FileTransfer.Status.error); + setError(Error.bad_file); + setException(e); + } catch (XMPPException e) { + setStatus(FileTransfer.Status.error); + setException(e); + } finally { + try { + if (inputStream != null) { + inputStream.close(); + } + + outputStream.flush(); + outputStream.close(); + } catch (IOException e) { + /* Do Nothing */ + } + } + updateStatus(Status.in_progress, FileTransfer.Status.complete); + } + + }, "File Transfer " + streamID); + transferThread.start(); + } + + /** + * This method handles the stream negotiation process and transmits the file + * to the remote user. It returns immediatly and the progress of the file + * transfer can be monitored through several methods: + * + * <UL> + * <LI>{@link FileTransfer#getStatus()} + * <LI>{@link FileTransfer#getProgress()} + * <LI>{@link FileTransfer#isDone()} + * </UL> + * + * @param in the stream to transfer to the remote entity. + * @param fileName the name of the file that is transferred + * @param fileSize the size of the file that is transferred + * @param description a description for the file to transfer. + */ + public synchronized void sendStream(final InputStream in, final String fileName, final long fileSize, final String description){ + checkTransferThread(); + + transferThread = new Thread(new Runnable() { + public void run() { + setFileInfo(fileName, fileSize); + //Create packet filter + try { + outputStream = negotiateStream(fileName, fileSize, description); + } catch (XMPPException e) { + handleXMPPException(e); + return; + } catch (IllegalStateException e) { + setStatus(FileTransfer.Status.error); + setException(e); + } + if (outputStream == null) { + return; + } + + if (!updateStatus(Status.negotiated, Status.in_progress)) { + return; + } + try { + writeToStream(in, outputStream); + } catch (XMPPException e) { + setStatus(FileTransfer.Status.error); + setException(e); + } catch (IllegalStateException e) { + setStatus(FileTransfer.Status.error); + setException(e); + } finally { + try { + if (in != null) { + in.close(); + } + + outputStream.flush(); + outputStream.close(); + } catch (IOException e) { + /* Do Nothing */ + } + } + updateStatus(Status.in_progress, FileTransfer.Status.complete); + } + + }, "File Transfer " + streamID); + transferThread.start(); + } + + private void handleXMPPException(XMPPException e) { + XMPPError error = e.getXMPPError(); + if (error != null) { + int code = error.getCode(); + if (code == 403) { + setStatus(Status.refused); + return; + } + else if (code == 400) { + setStatus(Status.error); + setError(Error.not_acceptable); + } + else { + setStatus(FileTransfer.Status.error); + } + } + + setException(e); + } + + /** + * Returns the amount of bytes that have been sent for the file transfer. Or + * -1 if the file transfer has not started. + * + * Note: This method is only useful when the {@link #sendFile(File, String)} + * method is called, as it is the only method that actualy transmits the + * file. + * + * @return Returns the amount of bytes that have been sent for the file + * transfer. Or -1 if the file transfer has not started. + */ + public long getBytesSent() { + return amountWritten; + } + + private OutputStream negotiateStream(String fileName, long fileSize, + String description) throws XMPPException { + // Negotiate the file transfer profile + + if (!updateStatus(Status.initial, Status.negotiating_transfer)) { + throw new XMPPException("Illegal state change"); + } + StreamNegotiator streamNegotiator = negotiator.negotiateOutgoingTransfer( + getPeer(), streamID, fileName, fileSize, description, + RESPONSE_TIMEOUT); + + if (streamNegotiator == null) { + setStatus(Status.error); + setError(Error.no_response); + return null; + } + + // Negotiate the stream + if (!updateStatus(Status.negotiating_transfer, Status.negotiating_stream)) { + throw new XMPPException("Illegal state change"); + } + outputStream = streamNegotiator.createOutgoingStream(streamID, + initiator, getPeer()); + + if (!updateStatus(Status.negotiating_stream, Status.negotiated)) { + throw new XMPPException("Illegal state change"); + } + return outputStream; + } + + public void cancel() { + setStatus(Status.cancelled); + } + + @Override + protected boolean updateStatus(Status oldStatus, Status newStatus) { + boolean isUpdated = super.updateStatus(oldStatus, newStatus); + if(callback != null && isUpdated) { + callback.statusUpdated(oldStatus, newStatus); + } + return isUpdated; + } + + @Override + protected void setStatus(Status status) { + Status oldStatus = getStatus(); + super.setStatus(status); + if(callback != null) { + callback.statusUpdated(oldStatus, status); + } + } + + @Override + protected void setException(Exception exception) { + super.setException(exception); + if(callback != null) { + callback.errorEstablishingStream(exception); + } + } + + /** + * A callback class to retrive the status of an outgoing transfer + * negotiation process. + * + * @author Alexander Wenckus + * + */ + public interface NegotiationProgress { + + /** + * Called when the status changes + * + * @param oldStatus the previous status of the file transfer. + * @param newStatus the new status of the file transfer. + */ + void statusUpdated(Status oldStatus, Status newStatus); + + /** + * Once the negotiation process is completed the output stream can be + * retrieved. + * + * @param stream the established stream which can be used to transfer the file to the remote + * entity + */ + void outputStreamEstablished(OutputStream stream); + + /** + * Called when an exception occurs during the negotiation progress. + * + * @param e the exception that occured. + */ + void errorEstablishingStream(Exception e); + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/Socks5TransferNegotiator.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/Socks5TransferNegotiator.java new file mode 100644 index 0000000..3c07fdc --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/Socks5TransferNegotiator.java @@ -0,0 +1,164 @@ +/** + * 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.smackx.filetransfer; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.io.PushbackInputStream; + +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.filter.AndFilter; +import org.jivesoftware.smack.filter.FromMatchesFilter; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smackx.bytestreams.socks5.Socks5BytestreamManager; +import org.jivesoftware.smackx.bytestreams.socks5.Socks5BytestreamRequest; +import org.jivesoftware.smackx.bytestreams.socks5.Socks5BytestreamSession; +import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream; +import org.jivesoftware.smackx.packet.StreamInitiation; + +/** + * Negotiates a SOCKS5 Bytestream to be used for file transfers. The implementation is based on the + * {@link Socks5BytestreamManager} and the {@link Socks5BytestreamRequest}. + * + * @author Henning Staib + * @see <a href="http://xmpp.org/extensions/xep-0065.html">XEP-0065: SOCKS5 Bytestreams</a> + */ +public class Socks5TransferNegotiator extends StreamNegotiator { + + private Connection connection; + + private Socks5BytestreamManager manager; + + Socks5TransferNegotiator(Connection connection) { + this.connection = connection; + this.manager = Socks5BytestreamManager.getBytestreamManager(this.connection); + } + + @Override + public OutputStream createOutgoingStream(String streamID, String initiator, String target) + throws XMPPException { + try { + return this.manager.establishSession(target, streamID).getOutputStream(); + } + catch (IOException e) { + throw new XMPPException("error establishing SOCKS5 Bytestream", e); + } + catch (InterruptedException e) { + throw new XMPPException("error establishing SOCKS5 Bytestream", e); + } + } + + @Override + public InputStream createIncomingStream(StreamInitiation initiation) throws XMPPException, + InterruptedException { + /* + * SOCKS5 initiation listener must ignore next SOCKS5 Bytestream request with given session + * ID + */ + this.manager.ignoreBytestreamRequestOnce(initiation.getSessionID()); + + Packet streamInitiation = initiateIncomingStream(this.connection, initiation); + return negotiateIncomingStream(streamInitiation); + } + + @Override + public PacketFilter getInitiationPacketFilter(final String from, String streamID) { + /* + * this method is always called prior to #negotiateIncomingStream() so the SOCKS5 + * InitiationListener must ignore the next SOCKS5 Bytestream request with the given session + * ID + */ + this.manager.ignoreBytestreamRequestOnce(streamID); + + return new AndFilter(new FromMatchesFilter(from), new BytestreamSIDFilter(streamID)); + } + + @Override + public String[] getNamespaces() { + return new String[] { Socks5BytestreamManager.NAMESPACE }; + } + + @Override + InputStream negotiateIncomingStream(Packet streamInitiation) throws XMPPException, + InterruptedException { + // build SOCKS5 Bytestream request + Socks5BytestreamRequest request = new ByteStreamRequest(this.manager, + (Bytestream) streamInitiation); + + // always accept the request + Socks5BytestreamSession session = request.accept(); + + // test input stream + try { + PushbackInputStream stream = new PushbackInputStream(session.getInputStream()); + int firstByte = stream.read(); + stream.unread(firstByte); + return stream; + } + catch (IOException e) { + throw new XMPPException("Error establishing input stream", e); + } + } + + @Override + public void cleanup() { + /* do nothing */ + } + + /** + * This PacketFilter accepts an incoming SOCKS5 Bytestream request with a specified session ID. + */ + private static class BytestreamSIDFilter extends PacketTypeFilter { + + private String sessionID; + + public BytestreamSIDFilter(String sessionID) { + super(Bytestream.class); + if (sessionID == null) { + throw new IllegalArgumentException("StreamID cannot be null"); + } + this.sessionID = sessionID; + } + + @Override + public boolean accept(Packet packet) { + if (super.accept(packet)) { + Bytestream bytestream = (Bytestream) packet; + + // packet must by of type SET and contains the given session ID + return this.sessionID.equals(bytestream.getSessionID()) + && IQ.Type.SET.equals(bytestream.getType()); + } + return false; + } + + } + + /** + * Derive from Socks5BytestreamRequest to access protected constructor. + */ + private static class ByteStreamRequest extends Socks5BytestreamRequest { + + private ByteStreamRequest(Socks5BytestreamManager manager, Bytestream byteStreamRequest) { + super(manager, byteStreamRequest); + } + + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/StreamNegotiator.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/StreamNegotiator.java new file mode 100644 index 0000000..46ece9c --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/filetransfer/StreamNegotiator.java @@ -0,0 +1,167 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2003-2006 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.smackx.filetransfer; + +import org.jivesoftware.smack.PacketCollector; +import org.jivesoftware.smack.SmackConfiguration; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.packet.XMPPError; +import org.jivesoftware.smackx.Form; +import org.jivesoftware.smackx.FormField; +import org.jivesoftware.smackx.packet.DataForm; +import org.jivesoftware.smackx.packet.StreamInitiation; + +import java.io.InputStream; +import java.io.OutputStream; + +/** + * After the file transfer negotiation process is completed according to + * JEP-0096, the negotiation process is passed off to a particular stream + * negotiator. The stream negotiator will then negotiate the chosen stream and + * return the stream to transfer the file. + * + * @author Alexander Wenckus + */ +public abstract class StreamNegotiator { + + /** + * Creates the initiation acceptance packet to forward to the stream + * initiator. + * + * @param streamInitiationOffer The offer from the stream initiator to connect for a stream. + * @param namespaces The namespace that relates to the accepted means of transfer. + * @return The response to be forwarded to the initiator. + */ + public StreamInitiation createInitiationAccept( + StreamInitiation streamInitiationOffer, String[] namespaces) + { + StreamInitiation response = new StreamInitiation(); + response.setTo(streamInitiationOffer.getFrom()); + response.setFrom(streamInitiationOffer.getTo()); + response.setType(IQ.Type.RESULT); + response.setPacketID(streamInitiationOffer.getPacketID()); + + DataForm form = new DataForm(Form.TYPE_SUBMIT); + FormField field = new FormField( + FileTransferNegotiator.STREAM_DATA_FIELD_NAME); + for (String namespace : namespaces) { + field.addValue(namespace); + } + form.addField(field); + + response.setFeatureNegotiationForm(form); + return response; + } + + + public IQ createError(String from, String to, String packetID, XMPPError xmppError) { + IQ iq = FileTransferNegotiator.createIQ(packetID, to, from, IQ.Type.ERROR); + iq.setError(xmppError); + return iq; + } + + Packet initiateIncomingStream(Connection connection, StreamInitiation initiation) throws XMPPException { + StreamInitiation response = createInitiationAccept(initiation, + getNamespaces()); + + // establish collector to await response + PacketCollector collector = connection + .createPacketCollector(getInitiationPacketFilter(initiation.getFrom(), initiation.getSessionID())); + connection.sendPacket(response); + + Packet streamMethodInitiation = collector + .nextResult(SmackConfiguration.getPacketReplyTimeout()); + collector.cancel(); + if (streamMethodInitiation == null) { + throw new XMPPException("No response from file transfer initiator"); + } + + return streamMethodInitiation; + } + + /** + * Returns the packet filter that will return the initiation packet for the appropriate stream + * initiation. + * + * @param from The initiator of the file transfer. + * @param streamID The stream ID related to the transfer. + * @return The PacketFilter that will return the packet relatable to the stream + * initiation. + */ + public abstract PacketFilter getInitiationPacketFilter(String from, String streamID); + + + abstract InputStream negotiateIncomingStream(Packet streamInitiation) throws XMPPException, + InterruptedException; + + /** + * This method handles the file stream download negotiation process. The + * appropriate stream negotiator's initiate incoming stream is called after + * an appropriate file transfer method is selected. The manager will respond + * to the initiator with the selected means of transfer, then it will handle + * any negotiation specific to the particular transfer method. This method + * returns the InputStream, ready to transfer the file. + * + * @param initiation The initiation that triggered this download. + * @return After the negotiation process is complete, the InputStream to + * write a file to is returned. + * @throws XMPPException If an error occurs during this process an XMPPException is + * thrown. + * @throws InterruptedException If thread is interrupted. + */ + public abstract InputStream createIncomingStream(StreamInitiation initiation) + throws XMPPException, InterruptedException; + + /** + * This method handles the file upload stream negotiation process. The + * particular stream negotiator is determined during the file transfer + * negotiation process. This method returns the OutputStream to transmit the + * file to the remote user. + * + * @param streamID The streamID that uniquely identifies the file transfer. + * @param initiator The fully-qualified JID of the initiator of the file transfer. + * @param target The fully-qualified JID of the target or receiver of the file + * transfer. + * @return The negotiated stream ready for data. + * @throws XMPPException If an error occurs during the negotiation process an + * exception will be thrown. + */ + public abstract OutputStream createOutgoingStream(String streamID, + String initiator, String target) throws XMPPException; + + /** + * Returns the XMPP namespace reserved for this particular type of file + * transfer. + * + * @return Returns the XMPP namespace reserved for this particular type of + * file transfer. + */ + public abstract String[] getNamespaces(); + + /** + * Cleanup any and all resources associated with this negotiator. + */ + public abstract void cleanup(); + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/Affiliate.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/Affiliate.java new file mode 100644 index 0000000..09a04f6 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/Affiliate.java @@ -0,0 +1,98 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.muc; + +import org.jivesoftware.smackx.packet.MUCAdmin; +import org.jivesoftware.smackx.packet.MUCOwner; + +/** + * Represents an affiliation of a user to a given room. The affiliate's information will always have + * the bare jid of the real user and its affiliation. If the affiliate is an occupant of the room + * then we will also have information about the role and nickname of the user in the room. + * + * @author Gaston Dombiak + */ +public class Affiliate { + // Fields that must have a value + private String jid; + private String affiliation; + + // Fields that may have a value + private String role; + private String nick; + + Affiliate(MUCOwner.Item item) { + super(); + this.jid = item.getJid(); + this.affiliation = item.getAffiliation(); + this.role = item.getRole(); + this.nick = item.getNick(); + } + + Affiliate(MUCAdmin.Item item) { + super(); + this.jid = item.getJid(); + this.affiliation = item.getAffiliation(); + this.role = item.getRole(); + this.nick = item.getNick(); + } + + /** + * Returns the bare JID of the affiliated user. This information will always be available. + * + * @return the bare JID of the affiliated user. + */ + public String getJid() { + return jid; + } + + /** + * Returns the affiliation of the afffiliated user. Possible affiliations are: "owner", "admin", + * "member", "outcast". This information will always be available. + * + * @return the affiliation of the afffiliated user. + */ + public String getAffiliation() { + return affiliation; + } + + /** + * Returns the current role of the affiliated user if the user is currently in the room. + * If the user is not present in the room then the answer will be null. + * + * @return the current role of the affiliated user in the room or null if the user is not in + * the room. + */ + public String getRole() { + return role; + } + + /** + * Returns the current nickname of the affiliated user if the user is currently in the room. + * If the user is not present in the room then the answer will be null. + * + * @return the current nickname of the affiliated user in the room or null if the user is not in + * the room. + */ + public String getNick() { + return nick; + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/ConnectionDetachedPacketCollector.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/ConnectionDetachedPacketCollector.java new file mode 100644 index 0000000..2a719f6 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/ConnectionDetachedPacketCollector.java @@ -0,0 +1,145 @@ +/** + * $RCSfile$ + * $Revision: 2779 $ + * $Date: 2005-09-05 17:00:45 -0300 (Mon, 05 Sep 2005) $ + * + * Copyright 2003-2006 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.smackx.muc; + +import org.jivesoftware.smack.SmackConfiguration; +import org.jivesoftware.smack.packet.Packet; + +import java.util.LinkedList; + +/** + * A variant of the {@link org.jivesoftware.smack.PacketCollector} class + * that does not force attachment to a <code>Connection</code> + * on creation and no filter is required. Used to collect message + * packets targeted to a group chat room. + * + * @author Larry Kirschner + */ +class ConnectionDetachedPacketCollector { + /** + * Max number of packets that any one collector can hold. After the max is + * reached, older packets will be automatically dropped from the queue as + * new packets are added. + */ + private int maxPackets = SmackConfiguration.getPacketCollectorSize(); + + private LinkedList<Packet> resultQueue; + + /** + * Creates a new packet collector. If the packet filter is <tt>null</tt>, then + * all packets will match this collector. + */ + public ConnectionDetachedPacketCollector() { + this.resultQueue = new LinkedList<Packet>(); + } + + /** + * Creates a new packet collector. If the packet filter is <tt>null</tt>, then + * all packets will match this collector. + */ + public ConnectionDetachedPacketCollector(int maxSize) { + this.resultQueue = new LinkedList<Packet>(); + maxPackets = maxSize; + } + + /** + * Polls to see if a packet is currently available and returns it, or + * immediately returns <tt>null</tt> if no packets are currently in the + * result queue. + * + * @return the next packet result, or <tt>null</tt> if there are no more + * results. + */ + public synchronized Packet pollResult() { + if (resultQueue.isEmpty()) { + return null; + } + else { + return resultQueue.removeLast(); + } + } + + /** + * Returns the next available packet. The method call will block (not return) + * until a packet is available. + * + * @return the next available packet. + */ + public synchronized Packet nextResult() { + // Wait indefinitely until there is a result to return. + while (resultQueue.isEmpty()) { + try { + wait(); + } + catch (InterruptedException ie) { + // Ignore. + } + } + return resultQueue.removeLast(); + } + + /** + * Returns the next available packet. The method call will block (not return) + * until a packet is available or the <tt>timeout</tt> has elapased. If the + * timeout elapses without a result, <tt>null</tt> will be returned. + * + * @param timeout the amount of time to wait for the next packet (in milleseconds). + * @return the next available packet. + */ + public synchronized Packet nextResult(long timeout) { + // Wait up to the specified amount of time for a result. + if (resultQueue.isEmpty()) { + try { + wait(timeout); + } + catch (InterruptedException ie) { + // Ignore. + } + } + // If still no result, return null. + if (resultQueue.isEmpty()) { + return null; + } + else { + return resultQueue.removeLast(); + } + } + + /** + * Processes a packet to see if it meets the criteria for this packet collector. + * If so, the packet is added to the result queue. + * + * @param packet the packet to process. + */ + protected synchronized void processPacket(Packet packet) { + if (packet == null) { + return; + } + // If the max number of packets has been reached, remove the oldest one. + if (resultQueue.size() == maxPackets) { + resultQueue.removeLast(); + } + // Add the new packet. + resultQueue.addFirst(packet); + // Notify waiting threads a result is available. + notifyAll(); + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/DeafOccupantInterceptor.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/DeafOccupantInterceptor.java new file mode 100644 index 0000000..c0351c9 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/DeafOccupantInterceptor.java @@ -0,0 +1,76 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 2003-2006 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.smackx.muc; + +import org.jivesoftware.smack.PacketInterceptor; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.packet.PacketExtension; +import org.jivesoftware.smack.packet.Presence; + +/** + * Packet interceptor that will intercept presence packets sent to the MUC service to indicate + * that the user wants to be a deaf occupant. A user can only indicate that he wants to be a + * deaf occupant while joining the room. It is not possible to become deaf or stop being deaf + * after the user joined the room. + * + * Deaf occupants will not get messages broadcasted to all room occupants. However, they will + * be able to get private messages, presences, IQ packets or room history. To use this + * functionality you will need to send the message + * {@link MultiUserChat#addPresenceInterceptor(org.jivesoftware.smack.PacketInterceptor)} and + * pass this interceptor as the parameter. + * + * Note that this is a custom extension to the MUC service so it may not work with other servers + * than Wildfire. + * + * @author Gaston Dombiak + */ +public class DeafOccupantInterceptor implements PacketInterceptor { + + public void interceptPacket(Packet packet) { + Presence presence = (Presence) packet; + // Check if user is joining a room + if (Presence.Type.available == presence.getType() && + presence.getExtension("x", "http://jabber.org/protocol/muc") != null) { + // Add extension that indicates that user wants to be a deaf occupant + packet.addExtension(new DeafExtension()); + } + } + + private static class DeafExtension implements PacketExtension { + + public String getElementName() { + return "x"; + } + + public String getNamespace() { + return "http://jivesoftware.org/protocol/muc"; + } + + public String toXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<").append(getElementName()).append(" xmlns=\"").append(getNamespace()) + .append("\">"); + buf.append("<deaf-occupant/>"); + buf.append("</").append(getElementName()).append(">"); + return buf.toString(); + } + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/DefaultParticipantStatusListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/DefaultParticipantStatusListener.java new file mode 100644 index 0000000..6eb9efa --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/DefaultParticipantStatusListener.java @@ -0,0 +1,79 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.muc; + +/** + * Default implementation of the ParticipantStatusListener interface. + * + * This class does not provide any behavior by default. It just avoids having + * to implement all the inteface methods if the user is only interested in implementing + * some of the methods. + * + * @author Gaston Dombiak + */ +public class DefaultParticipantStatusListener implements ParticipantStatusListener { + + public void joined(String participant) { + } + + public void left(String participant) { + } + + public void kicked(String participant, String actor, String reason) { + } + + public void voiceGranted(String participant) { + } + + public void voiceRevoked(String participant) { + } + + public void banned(String participant, String actor, String reason) { + } + + public void membershipGranted(String participant) { + } + + public void membershipRevoked(String participant) { + } + + public void moderatorGranted(String participant) { + } + + public void moderatorRevoked(String participant) { + } + + public void ownershipGranted(String participant) { + } + + public void ownershipRevoked(String participant) { + } + + public void adminGranted(String participant) { + } + + public void adminRevoked(String participant) { + } + + public void nicknameChanged(String participant, String newNickname) { + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/DefaultUserStatusListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/DefaultUserStatusListener.java new file mode 100644 index 0000000..de7cc87 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/DefaultUserStatusListener.java @@ -0,0 +1,70 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.muc; + +/** + * Default implementation of the UserStatusListener interface. + * + * This class does not provide any behavior by default. It just avoids having + * to implement all the inteface methods if the user is only interested in implementing + * some of the methods. + * + * @author Gaston Dombiak + */ +public class DefaultUserStatusListener implements UserStatusListener { + + public void kicked(String actor, String reason) { + } + + public void voiceGranted() { + } + + public void voiceRevoked() { + } + + public void banned(String actor, String reason) { + } + + public void membershipGranted() { + } + + public void membershipRevoked() { + } + + public void moderatorGranted() { + } + + public void moderatorRevoked() { + } + + public void ownershipGranted() { + } + + public void ownershipRevoked() { + } + + public void adminGranted() { + } + + public void adminRevoked() { + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/DiscussionHistory.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/DiscussionHistory.java new file mode 100644 index 0000000..036f6cb --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/DiscussionHistory.java @@ -0,0 +1,173 @@ +/** + * $RCSfile$ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.muc; + +import java.util.Date; + +import org.jivesoftware.smackx.packet.MUCInitialPresence; + +/** + * The DiscussionHistory class controls the number of characters or messages to receive + * when entering a room. The room will decide the amount of history to return if you don't + * specify a DiscussionHistory while joining a room. + * + * You can use some or all of these variable to control the amount of history to receive: + * <ul> + * <li>maxchars -> total number of characters to receive in the history. + * <li>maxstanzas -> total number of messages to receive in the history. + * <li>seconds -> only the messages received in the last "X" seconds will be included in the + * history. + * <li>since -> only the messages received since the datetime specified will be included in + * the history. + * </ul> + * + * Note: Setting maxchars to 0 indicates that the user requests to receive no history. + * + * @author Gaston Dombiak + */ +public class DiscussionHistory { + + private int maxChars = -1; + private int maxStanzas = -1; + private int seconds = -1; + private Date since; + + /** + * Returns the total number of characters to receive in the history. + * + * @return total number of characters to receive in the history. + */ + public int getMaxChars() { + return maxChars; + } + + /** + * Returns the total number of messages to receive in the history. + * + * @return the total number of messages to receive in the history. + */ + public int getMaxStanzas() { + return maxStanzas; + } + + /** + * Returns the number of seconds to use to filter the messages received during that time. + * In other words, only the messages received in the last "X" seconds will be included in + * the history. + * + * @return the number of seconds to use to filter the messages received during that time. + */ + public int getSeconds() { + return seconds; + } + + /** + * Returns the since date to use to filter the messages received during that time. + * In other words, only the messages received since the datetime specified will be + * included in the history. + * + * @return the since date to use to filter the messages received during that time. + */ + public Date getSince() { + return since; + } + + /** + * Sets the total number of characters to receive in the history. + * + * @param maxChars the total number of characters to receive in the history. + */ + public void setMaxChars(int maxChars) { + this.maxChars = maxChars; + } + + /** + * Sets the total number of messages to receive in the history. + * + * @param maxStanzas the total number of messages to receive in the history. + */ + public void setMaxStanzas(int maxStanzas) { + this.maxStanzas = maxStanzas; + } + + /** + * Sets the number of seconds to use to filter the messages received during that time. + * In other words, only the messages received in the last "X" seconds will be included in + * the history. + * + * @param seconds the number of seconds to use to filter the messages received during + * that time. + */ + public void setSeconds(int seconds) { + this.seconds = seconds; + } + + /** + * Sets the since date to use to filter the messages received during that time. + * In other words, only the messages received since the datetime specified will be + * included in the history. + * + * @param since the since date to use to filter the messages received during that time. + */ + public void setSince(Date since) { + this.since = since; + } + + /** + * Returns true if the history has been configured with some values. + * + * @return true if the history has been configured with some values. + */ + private boolean isConfigured() { + return maxChars > -1 || maxStanzas > -1 || seconds > -1 || since != null; + } + + /** + * Returns the History that manages the amount of discussion history provided on entering a + * room. + * + * @return the History that manages the amount of discussion history provided on entering a + * room. + */ + MUCInitialPresence.History getMUCHistory() { + // Return null if the history was not properly configured + if (!isConfigured()) { + return null; + } + + MUCInitialPresence.History mucHistory = new MUCInitialPresence.History(); + if (maxChars > -1) { + mucHistory.setMaxChars(maxChars); + } + if (maxStanzas > -1) { + mucHistory.setMaxStanzas(maxStanzas); + } + if (seconds > -1) { + mucHistory.setSeconds(seconds); + } + if (since != null) { + mucHistory.setSince(since); + } + return mucHistory; + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/HostedRoom.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/HostedRoom.java new file mode 100644 index 0000000..7cd580b --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/HostedRoom.java @@ -0,0 +1,65 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.muc; + +import org.jivesoftware.smackx.packet.DiscoverItems; + +/** + * Hosted rooms by a chat service may be discovered if they are configured to appear in the room + * directory . The information that may be discovered is the XMPP address of the room and the room + * name. The address of the room may be used for obtaining more detailed information + * {@link org.jivesoftware.smackx.muc.MultiUserChat#getRoomInfo(org.jivesoftware.smack.Connection, String)} + * or could be used for joining the room + * {@link org.jivesoftware.smackx.muc.MultiUserChat#MultiUserChat(org.jivesoftware.smack.Connection, String)} + * and {@link org.jivesoftware.smackx.muc.MultiUserChat#join(String)}. + * + * @author Gaston Dombiak + */ +public class HostedRoom { + + private String jid; + + private String name; + + public HostedRoom(DiscoverItems.Item item) { + super(); + jid = item.getEntityID(); + name = item.getName(); + } + + /** + * Returns the XMPP address of the hosted room by the chat service. This address may be used + * when creating a <code>MultiUserChat</code> when joining a room. + * + * @return the XMPP address of the hosted room by the chat service. + */ + public String getJid() { + return jid; + } + + /** + * Returns the name of the room. + * + * @return the name of the room. + */ + public String getName() { + return name; + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/InvitationListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/InvitationListener.java new file mode 100644 index 0000000..34c915d --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/InvitationListener.java @@ -0,0 +1,49 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.muc; + +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.packet.Message; + +/** + * A listener that is fired anytime an invitation to join a MUC room is received. + * + * @author Gaston Dombiak + */ +public interface InvitationListener { + + /** + * Called when the an invitation to join a MUC room is received. + * + * If the room is password-protected, the invitee will receive a password to use to join + * the room. If the room is members-only, the the invitee may be added to the member list. + * + * @param conn the Connection that received the invitation. + * @param room the room that invitation refers to. + * @param inviter the inviter that sent the invitation. (e.g. crone1@shakespeare.lit). + * @param reason the reason why the inviter sent the invitation. + * @param password the password to use when joining the room. + * @param message the message used by the inviter to send the invitation. + */ + public abstract void invitationReceived(Connection conn, String room, String inviter, String reason, + String password, Message message); + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/InvitationRejectionListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/InvitationRejectionListener.java new file mode 100644 index 0000000..1580c6f --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/InvitationRejectionListener.java @@ -0,0 +1,38 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.muc; + +/** + * A listener that is fired anytime an invitee declines or rejects an invitation. + * + * @author Gaston Dombiak + */ +public interface InvitationRejectionListener { + + /** + * Called when the invitee declines the invitation. + * + * @param invitee the invitee that declined the invitation. (e.g. hecate@shakespeare.lit). + * @param reason the reason why the invitee declined the invitation. + */ + public abstract void invitationDeclined(String invitee, String reason); + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/MultiUserChat.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/MultiUserChat.java new file mode 100644 index 0000000..aee90ea --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/MultiUserChat.java @@ -0,0 +1,2717 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.muc; + +import java.lang.ref.WeakReference; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.WeakHashMap; +import java.util.concurrent.ConcurrentHashMap; + +import org.jivesoftware.smack.Chat; +import org.jivesoftware.smack.ConnectionCreationListener; +import org.jivesoftware.smack.ConnectionListener; +import org.jivesoftware.smack.MessageListener; +import org.jivesoftware.smack.PacketCollector; +import org.jivesoftware.smack.PacketInterceptor; +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.SmackConfiguration; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.XMPPException; +import org.jivesoftware.smack.filter.AndFilter; +import org.jivesoftware.smack.filter.FromMatchesFilter; +import org.jivesoftware.smack.filter.MessageTypeFilter; +import org.jivesoftware.smack.filter.PacketExtensionFilter; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.filter.PacketIDFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.packet.Presence; +import org.jivesoftware.smack.packet.Registration; +import org.jivesoftware.smackx.Form; +import org.jivesoftware.smackx.NodeInformationProvider; +import org.jivesoftware.smackx.ServiceDiscoveryManager; +import org.jivesoftware.smackx.packet.DiscoverInfo; +import org.jivesoftware.smackx.packet.DiscoverItems; +import org.jivesoftware.smackx.packet.MUCAdmin; +import org.jivesoftware.smackx.packet.MUCInitialPresence; +import org.jivesoftware.smackx.packet.MUCOwner; +import org.jivesoftware.smackx.packet.MUCUser; + +/** + * A MultiUserChat is a conversation that takes place among many users in a virtual + * room. A room could have many occupants with different affiliation and roles. + * Possible affiliatons are "owner", "admin", "member", and "outcast". Possible roles + * are "moderator", "participant", and "visitor". Each role and affiliation guarantees + * different privileges (e.g. Send messages to all occupants, Kick participants and visitors, + * Grant voice, Edit member list, etc.). + * + * @author Gaston Dombiak, Larry Kirschner + */ +public class MultiUserChat { + + private final static String discoNamespace = "http://jabber.org/protocol/muc"; + private final static String discoNode = "http://jabber.org/protocol/muc#rooms"; + + private static Map<Connection, List<String>> joinedRooms = + new WeakHashMap<Connection, List<String>>(); + + private Connection connection; + private String room; + private String subject; + private String nickname = null; + private boolean joined = false; + private Map<String, Presence> occupantsMap = new ConcurrentHashMap<String, Presence>(); + + private final List<InvitationRejectionListener> invitationRejectionListeners = + new ArrayList<InvitationRejectionListener>(); + private final List<SubjectUpdatedListener> subjectUpdatedListeners = + new ArrayList<SubjectUpdatedListener>(); + private final List<UserStatusListener> userStatusListeners = + new ArrayList<UserStatusListener>(); + private final List<ParticipantStatusListener> participantStatusListeners = + new ArrayList<ParticipantStatusListener>(); + + private PacketFilter presenceFilter; + private List<PacketInterceptor> presenceInterceptors = new ArrayList<PacketInterceptor>(); + private PacketFilter messageFilter; + private RoomListenerMultiplexor roomListenerMultiplexor; + private ConnectionDetachedPacketCollector messageCollector; + private List<PacketListener> connectionListeners = new ArrayList<PacketListener>(); + + static { + Connection.addConnectionCreationListener(new ConnectionCreationListener() { + public void connectionCreated(final Connection connection) { + // Set on every established connection that this client supports the Multi-User + // Chat protocol. This information will be used when another client tries to + // discover whether this client supports MUC or not. + ServiceDiscoveryManager.getInstanceFor(connection).addFeature(discoNamespace); + // Set the NodeInformationProvider that will provide information about the + // joined rooms whenever a disco request is received + ServiceDiscoveryManager.getInstanceFor(connection).setNodeInformationProvider( + discoNode, + new NodeInformationProvider() { + public List<DiscoverItems.Item> getNodeItems() { + List<DiscoverItems.Item> answer = new ArrayList<DiscoverItems.Item>(); + Iterator<String> rooms=MultiUserChat.getJoinedRooms(connection); + while (rooms.hasNext()) { + answer.add(new DiscoverItems.Item(rooms.next())); + } + return answer; + } + + public List<String> getNodeFeatures() { + return null; + } + + public List<DiscoverInfo.Identity> getNodeIdentities() { + return null; + } + }); + } + }); + } + + /** + * Creates a new multi user chat with the specified connection and room name. Note: no + * information is sent to or received from the server until you attempt to + * {@link #join(String) join} the chat room. On some server implementations, + * the room will not be created until the first person joins it. + * + * Most XMPP servers use a sub-domain for the chat service (eg chat.example.com + * for the XMPP server example.com). You must ensure that the room address you're + * trying to connect to includes the proper chat sub-domain. + * + * @param connection the XMPP connection. + * @param room the name of the room in the form "roomName@service", where + * "service" is the hostname at which the multi-user chat + * service is running. Make sure to provide a valid JID. + */ + public MultiUserChat(Connection connection, String room) { + this.connection = connection; + this.room = room.toLowerCase(); + init(); + } + + /** + * Returns true if the specified user supports the Multi-User Chat protocol. + * + * @param connection the connection to use to perform the service discovery. + * @param user the user to check. A fully qualified xmpp ID, e.g. jdoe@example.com. + * @return a boolean indicating whether the specified user supports the MUC protocol. + */ + public static boolean isServiceEnabled(Connection connection, String user) { + try { + DiscoverInfo result = + ServiceDiscoveryManager.getInstanceFor(connection).discoverInfo(user); + return result.containsFeature(discoNamespace); + } + catch (XMPPException e) { + e.printStackTrace(); + return false; + } + } + + /** + * Returns an Iterator on the rooms where the user has joined using a given connection. + * The Iterator will contain Strings where each String represents a room + * (e.g. room@muc.jabber.org). + * + * @param connection the connection used to join the rooms. + * @return an Iterator on the rooms where the user has joined using a given connection. + */ + private static Iterator<String> getJoinedRooms(Connection connection) { + List<String> rooms = joinedRooms.get(connection); + if (rooms != null) { + return rooms.iterator(); + } + // Return an iterator on an empty collection (i.e. the user never joined a room) + return new ArrayList<String>().iterator(); + } + + /** + * Returns an Iterator on the rooms where the requested user has joined. The Iterator will + * contain Strings where each String represents a room (e.g. room@muc.jabber.org). + * + * @param connection the connection to use to perform the service discovery. + * @param user the user to check. A fully qualified xmpp ID, e.g. jdoe@example.com. + * @return an Iterator on the rooms where the requested user has joined. + */ + public static Iterator<String> getJoinedRooms(Connection connection, String user) { + try { + ArrayList<String> answer = new ArrayList<String>(); + // Send the disco packet to the user + DiscoverItems result = + ServiceDiscoveryManager.getInstanceFor(connection).discoverItems(user, discoNode); + // Collect the entityID for each returned item + for (Iterator<DiscoverItems.Item> items=result.getItems(); items.hasNext();) { + answer.add(items.next().getEntityID()); + } + return answer.iterator(); + } + catch (XMPPException e) { + e.printStackTrace(); + // Return an iterator on an empty collection + return new ArrayList<String>().iterator(); + } + } + + /** + * Returns the discovered information of a given room without actually having to join the room. + * The server will provide information only for rooms that are public. + * + * @param connection the XMPP connection to use for discovering information about the room. + * @param room the name of the room in the form "roomName@service" of which we want to discover + * its information. + * @return the discovered information of a given room without actually having to join the room. + * @throws XMPPException if an error occured while trying to discover information of a room. + */ + public static RoomInfo getRoomInfo(Connection connection, String room) + throws XMPPException { + DiscoverInfo info = ServiceDiscoveryManager.getInstanceFor(connection).discoverInfo(room); + return new RoomInfo(info); + } + + /** + * Returns a collection with the XMPP addresses of the Multi-User Chat services. + * + * @param connection the XMPP connection to use for discovering Multi-User Chat services. + * @return a collection with the XMPP addresses of the Multi-User Chat services. + * @throws XMPPException if an error occured while trying to discover MUC services. + */ + public static Collection<String> getServiceNames(Connection connection) throws XMPPException { + final List<String> answer = new ArrayList<String>(); + ServiceDiscoveryManager discoManager = ServiceDiscoveryManager.getInstanceFor(connection); + DiscoverItems items = discoManager.discoverItems(connection.getServiceName()); + for (Iterator<DiscoverItems.Item> it = items.getItems(); it.hasNext();) { + DiscoverItems.Item item = it.next(); + try { + DiscoverInfo info = discoManager.discoverInfo(item.getEntityID()); + if (info.containsFeature("http://jabber.org/protocol/muc")) { + answer.add(item.getEntityID()); + } + } + catch (XMPPException e) { + // Trouble finding info in some cases. This is a workaround for + // discovering info on remote servers. + } + } + return answer; + } + + /** + * Returns a collection of HostedRooms where each HostedRoom has the XMPP address of the room + * and the room's name. Once discovered the rooms hosted by a chat service it is possible to + * discover more detailed room information or join the room. + * + * @param connection the XMPP connection to use for discovering hosted rooms by the MUC service. + * @param serviceName the service that is hosting the rooms to discover. + * @return a collection of HostedRooms. + * @throws XMPPException if an error occured while trying to discover the information. + */ + public static Collection<HostedRoom> getHostedRooms(Connection connection, String serviceName) + throws XMPPException { + List<HostedRoom> answer = new ArrayList<HostedRoom>(); + ServiceDiscoveryManager discoManager = ServiceDiscoveryManager.getInstanceFor(connection); + DiscoverItems items = discoManager.discoverItems(serviceName); + for (Iterator<DiscoverItems.Item> it = items.getItems(); it.hasNext();) { + answer.add(new HostedRoom(it.next())); + } + return answer; + } + + /** + * Returns the name of the room this MultiUserChat object represents. + * + * @return the multi user chat room name. + */ + public String getRoom() { + return room; + } + + /** + * Creates the room according to some default configuration, assign the requesting user + * as the room owner, and add the owner to the room but not allow anyone else to enter + * the room (effectively "locking" the room). The requesting user will join the room + * under the specified nickname as soon as the room has been created. + * + * To create an "Instant Room", that means a room with some default configuration that is + * available for immediate access, the room's owner should send an empty form after creating + * the room. {@link #sendConfigurationForm(Form)} + * + * To create a "Reserved Room", that means a room manually configured by the room creator + * before anyone is allowed to enter, the room's owner should complete and send a form after + * creating the room. Once the completed configutation form is sent to the server, the server + * will unlock the room. {@link #sendConfigurationForm(Form)} + * + * @param nickname the nickname to use. + * @throws XMPPException if the room couldn't be created for some reason + * (e.g. room already exists; user already joined to an existant room or + * 405 error if the user is not allowed to create the room) + */ + public synchronized void create(String nickname) throws XMPPException { + if (nickname == null || nickname.equals("")) { + throw new IllegalArgumentException("Nickname must not be null or blank."); + } + // If we've already joined the room, leave it before joining under a new + // nickname. + if (joined) { + throw new IllegalStateException("Creation failed - User already joined the room."); + } + // We create a room by sending a presence packet to room@service/nick + // and signal support for MUC. The owner will be automatically logged into the room. + Presence joinPresence = new Presence(Presence.Type.available); + joinPresence.setTo(room + "/" + nickname); + // Indicate the the client supports MUC + joinPresence.addExtension(new MUCInitialPresence()); + // Invoke presence interceptors so that extra information can be dynamically added + for (PacketInterceptor packetInterceptor : presenceInterceptors) { + packetInterceptor.interceptPacket(joinPresence); + } + + // Wait for a presence packet back from the server. + PacketFilter responseFilter = + new AndFilter( + new FromMatchesFilter(room + "/" + nickname), + new PacketTypeFilter(Presence.class)); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send create & join packet. + connection.sendPacket(joinPresence); + // Wait up to a certain number of seconds for a reply. + Presence presence = + (Presence) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (presence == null) { + throw new XMPPException("No response from server."); + } + else if (presence.getError() != null) { + throw new XMPPException(presence.getError()); + } + // Whether the room existed before or was created, the user has joined the room + this.nickname = nickname; + joined = true; + userHasJoined(); + + // Look for confirmation of room creation from the server + MUCUser mucUser = getMUCUserExtension(presence); + if (mucUser != null && mucUser.getStatus() != null) { + if ("201".equals(mucUser.getStatus().getCode())) { + // Room was created and the user has joined the room + return; + } + } + // We need to leave the room since it seems that the room already existed + leave(); + throw new XMPPException("Creation failed - Missing acknowledge of room creation."); + } + + /** + * Joins the chat room using the specified nickname. If already joined + * using another nickname, this method will first leave the room and then + * re-join using the new nickname. The default timeout of Smack for a reply + * from the group chat server that the join succeeded will be used. After + * joining the room, the room will decide the amount of history to send. + * + * @param nickname the nickname to use. + * @throws XMPPException if an error occurs joining the room. In particular, a + * 401 error can occur if no password was provided and one is required; or a + * 403 error can occur if the user is banned; or a + * 404 error can occur if the room does not exist or is locked; or a + * 407 error can occur if user is not on the member list; or a + * 409 error can occur if someone is already in the group chat with the same nickname. + */ + public void join(String nickname) throws XMPPException { + join(nickname, null, null, SmackConfiguration.getPacketReplyTimeout()); + } + + /** + * Joins the chat room using the specified nickname and password. If already joined + * using another nickname, this method will first leave the room and then + * re-join using the new nickname. The default timeout of Smack for a reply + * from the group chat server that the join succeeded will be used. After + * joining the room, the room will decide the amount of history to send. + * + * A password is required when joining password protected rooms. If the room does + * not require a password there is no need to provide one. + * + * @param nickname the nickname to use. + * @param password the password to use. + * @throws XMPPException if an error occurs joining the room. In particular, a + * 401 error can occur if no password was provided and one is required; or a + * 403 error can occur if the user is banned; or a + * 404 error can occur if the room does not exist or is locked; or a + * 407 error can occur if user is not on the member list; or a + * 409 error can occur if someone is already in the group chat with the same nickname. + */ + public void join(String nickname, String password) throws XMPPException { + join(nickname, password, null, SmackConfiguration.getPacketReplyTimeout()); + } + + /** + * Joins the chat room using the specified nickname and password. If already joined + * using another nickname, this method will first leave the room and then + * re-join using the new nickname. + * + * To control the amount of history to receive while joining a room you will need to provide + * a configured DiscussionHistory object. + * + * A password is required when joining password protected rooms. If the room does + * not require a password there is no need to provide one. + * + * If the room does not already exist when the user seeks to enter it, the server will + * decide to create a new room or not. + * + * @param nickname the nickname to use. + * @param password the password to use. + * @param history the amount of discussion history to receive while joining a room. + * @param timeout the amount of time to wait for a reply from the MUC service(in milleseconds). + * @throws XMPPException if an error occurs joining the room. In particular, a + * 401 error can occur if no password was provided and one is required; or a + * 403 error can occur if the user is banned; or a + * 404 error can occur if the room does not exist or is locked; or a + * 407 error can occur if user is not on the member list; or a + * 409 error can occur if someone is already in the group chat with the same nickname. + */ + public synchronized void join( + String nickname, + String password, + DiscussionHistory history, + long timeout) + throws XMPPException { + if (nickname == null || nickname.equals("")) { + throw new IllegalArgumentException("Nickname must not be null or blank."); + } + // If we've already joined the room, leave it before joining under a new + // nickname. + if (joined) { + leave(); + } + // We join a room by sending a presence packet where the "to" + // field is in the form "roomName@service/nickname" + Presence joinPresence = new Presence(Presence.Type.available); + joinPresence.setTo(room + "/" + nickname); + + // Indicate the the client supports MUC + MUCInitialPresence mucInitialPresence = new MUCInitialPresence(); + if (password != null) { + mucInitialPresence.setPassword(password); + } + if (history != null) { + mucInitialPresence.setHistory(history.getMUCHistory()); + } + joinPresence.addExtension(mucInitialPresence); + // Invoke presence interceptors so that extra information can be dynamically added + for (PacketInterceptor packetInterceptor : presenceInterceptors) { + packetInterceptor.interceptPacket(joinPresence); + } + + // Wait for a presence packet back from the server. + PacketFilter responseFilter = + new AndFilter( + new FromMatchesFilter(room + "/" + nickname), + new PacketTypeFilter(Presence.class)); + PacketCollector response = null; + Presence presence; + try { + response = connection.createPacketCollector(responseFilter); + // Send join packet. + connection.sendPacket(joinPresence); + // Wait up to a certain number of seconds for a reply. + presence = (Presence) response.nextResult(timeout); + } + finally { + // Stop queuing results + if (response != null) { + response.cancel(); + } + } + + if (presence == null) { + throw new XMPPException("No response from server."); + } + else if (presence.getError() != null) { + throw new XMPPException(presence.getError()); + } + this.nickname = nickname; + joined = true; + userHasJoined(); + } + + /** + * Returns true if currently in the multi user chat (after calling the {@link + * #join(String)} method). + * + * @return true if currently in the multi user chat room. + */ + public boolean isJoined() { + return joined; + } + + /** + * Leave the chat room. + */ + public synchronized void leave() { + // If not joined already, do nothing. + if (!joined) { + return; + } + // We leave a room by sending a presence packet where the "to" + // field is in the form "roomName@service/nickname" + Presence leavePresence = new Presence(Presence.Type.unavailable); + leavePresence.setTo(room + "/" + nickname); + // Invoke presence interceptors so that extra information can be dynamically added + for (PacketInterceptor packetInterceptor : presenceInterceptors) { + packetInterceptor.interceptPacket(leavePresence); + } + connection.sendPacket(leavePresence); + // Reset occupant information. + occupantsMap.clear(); + nickname = null; + joined = false; + userHasLeft(); + } + + /** + * Returns the room's configuration form that the room's owner can use or <tt>null</tt> if + * no configuration is possible. The configuration form allows to set the room's language, + * enable logging, specify room's type, etc.. + * + * @return the Form that contains the fields to complete together with the instrucions or + * <tt>null</tt> if no configuration is possible. + * @throws XMPPException if an error occurs asking the configuration form for the room. + */ + public Form getConfigurationForm() throws XMPPException { + MUCOwner iq = new MUCOwner(); + iq.setTo(room); + iq.setType(IQ.Type.GET); + + // Filter packets looking for an answer from the server. + PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Request the configuration form to the server. + connection.sendPacket(iq); + // Wait up to a certain number of seconds for a reply. + IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } + else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + return Form.getFormFrom(answer); + } + + /** + * Sends the completed configuration form to the server. The room will be configured + * with the new settings defined in the form. If the form is empty then the server + * will create an instant room (will use default configuration). + * + * @param form the form with the new settings. + * @throws XMPPException if an error occurs setting the new rooms' configuration. + */ + public void sendConfigurationForm(Form form) throws XMPPException { + MUCOwner iq = new MUCOwner(); + iq.setTo(room); + iq.setType(IQ.Type.SET); + iq.addExtension(form.getDataFormToSend()); + + // Filter packets looking for an answer from the server. + PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send the completed configuration form to the server. + connection.sendPacket(iq); + // Wait up to a certain number of seconds for a reply. + IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } + else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + } + + /** + * Returns the room's registration form that an unaffiliated user, can use to become a member + * of the room or <tt>null</tt> if no registration is possible. Some rooms may restrict the + * privilege to register members and allow only room admins to add new members. + * + * If the user requesting registration requirements is not allowed to register with the room + * (e.g. because that privilege has been restricted), the room will return a "Not Allowed" + * error to the user (error code 405). + * + * @return the registration Form that contains the fields to complete together with the + * instrucions or <tt>null</tt> if no registration is possible. + * @throws XMPPException if an error occurs asking the registration form for the room or a + * 405 error if the user is not allowed to register with the room. + */ + public Form getRegistrationForm() throws XMPPException { + Registration reg = new Registration(); + reg.setType(IQ.Type.GET); + reg.setTo(room); + + PacketFilter filter = + new AndFilter(new PacketIDFilter(reg.getPacketID()), new PacketTypeFilter(IQ.class)); + PacketCollector collector = connection.createPacketCollector(filter); + connection.sendPacket(reg); + IQ result = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout()); + collector.cancel(); + if (result == null) { + throw new XMPPException("No response from server."); + } + else if (result.getType() == IQ.Type.ERROR) { + throw new XMPPException(result.getError()); + } + return Form.getFormFrom(result); + } + + /** + * Sends the completed registration form to the server. After the user successfully submits + * the form, the room may queue the request for review by the room admins or may immediately + * add the user to the member list by changing the user's affiliation from "none" to "member. + * + * If the desired room nickname is already reserved for that room, the room will return a + * "Conflict" error to the user (error code 409). If the room does not support registration, + * it will return a "Service Unavailable" error to the user (error code 503). + * + * @param form the completed registration form. + * @throws XMPPException if an error occurs submitting the registration form. In particular, a + * 409 error can occur if the desired room nickname is already reserved for that room; + * or a 503 error can occur if the room does not support registration. + */ + public void sendRegistrationForm(Form form) throws XMPPException { + Registration reg = new Registration(); + reg.setType(IQ.Type.SET); + reg.setTo(room); + reg.addExtension(form.getDataFormToSend()); + + PacketFilter filter = + new AndFilter(new PacketIDFilter(reg.getPacketID()), new PacketTypeFilter(IQ.class)); + PacketCollector collector = connection.createPacketCollector(filter); + connection.sendPacket(reg); + IQ result = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout()); + collector.cancel(); + if (result == null) { + throw new XMPPException("No response from server."); + } + else if (result.getType() == IQ.Type.ERROR) { + throw new XMPPException(result.getError()); + } + } + + /** + * Sends a request to the server to destroy the room. The sender of the request + * should be the room's owner. If the sender of the destroy request is not the room's owner + * then the server will answer a "Forbidden" error (403). + * + * @param reason the reason for the room destruction. + * @param alternateJID the JID of an alternate location. + * @throws XMPPException if an error occurs while trying to destroy the room. + * An error can occur which will be wrapped by an XMPPException -- + * XMPP error code 403. The error code can be used to present more + * appropiate error messages to end-users. + */ + public void destroy(String reason, String alternateJID) throws XMPPException { + MUCOwner iq = new MUCOwner(); + iq.setTo(room); + iq.setType(IQ.Type.SET); + + // Create the reason for the room destruction + MUCOwner.Destroy destroy = new MUCOwner.Destroy(); + destroy.setReason(reason); + destroy.setJid(alternateJID); + iq.setDestroy(destroy); + + // Wait for a presence packet back from the server. + PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send the room destruction request. + connection.sendPacket(iq); + // Wait up to a certain number of seconds for a reply. + IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } + else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + // Reset occupant information. + occupantsMap.clear(); + nickname = null; + joined = false; + userHasLeft(); + } + + /** + * Invites another user to the room in which one is an occupant. The invitation + * will be sent to the room which in turn will forward the invitation to the invitee. + * + * If the room is password-protected, the invitee will receive a password to use to join + * the room. If the room is members-only, the the invitee may be added to the member list. + * + * @param user the user to invite to the room.(e.g. hecate@shakespeare.lit) + * @param reason the reason why the user is being invited. + */ + public void invite(String user, String reason) { + invite(new Message(), user, reason); + } + + /** + * Invites another user to the room in which one is an occupant using a given Message. The invitation + * will be sent to the room which in turn will forward the invitation to the invitee. + * + * If the room is password-protected, the invitee will receive a password to use to join + * the room. If the room is members-only, the the invitee may be added to the member list. + * + * @param message the message to use for sending the invitation. + * @param user the user to invite to the room.(e.g. hecate@shakespeare.lit) + * @param reason the reason why the user is being invited. + */ + public void invite(Message message, String user, String reason) { + // TODO listen for 404 error code when inviter supplies a non-existent JID + message.setTo(room); + + // Create the MUCUser packet that will include the invitation + MUCUser mucUser = new MUCUser(); + MUCUser.Invite invite = new MUCUser.Invite(); + invite.setTo(user); + invite.setReason(reason); + mucUser.setInvite(invite); + // Add the MUCUser packet that includes the invitation to the message + message.addExtension(mucUser); + + connection.sendPacket(message); + } + + /** + * Informs the sender of an invitation that the invitee declines the invitation. The rejection + * will be sent to the room which in turn will forward the rejection to the inviter. + * + * @param conn the connection to use for sending the rejection. + * @param room the room that sent the original invitation. + * @param inviter the inviter of the declined invitation. + * @param reason the reason why the invitee is declining the invitation. + */ + public static void decline(Connection conn, String room, String inviter, String reason) { + Message message = new Message(room); + + // Create the MUCUser packet that will include the rejection + MUCUser mucUser = new MUCUser(); + MUCUser.Decline decline = new MUCUser.Decline(); + decline.setTo(inviter); + decline.setReason(reason); + mucUser.setDecline(decline); + // Add the MUCUser packet that includes the rejection + message.addExtension(mucUser); + + conn.sendPacket(message); + } + + /** + * Adds a listener to invitation notifications. The listener will be fired anytime + * an invitation is received. + * + * @param conn the connection where the listener will be applied. + * @param listener an invitation listener. + */ + public static void addInvitationListener(Connection conn, InvitationListener listener) { + InvitationsMonitor.getInvitationsMonitor(conn).addInvitationListener(listener); + } + + /** + * Removes a listener to invitation notifications. The listener will be fired anytime + * an invitation is received. + * + * @param conn the connection where the listener was applied. + * @param listener an invitation listener. + */ + public static void removeInvitationListener(Connection conn, InvitationListener listener) { + InvitationsMonitor.getInvitationsMonitor(conn).removeInvitationListener(listener); + } + + /** + * Adds a listener to invitation rejections notifications. The listener will be fired anytime + * an invitation is declined. + * + * @param listener an invitation rejection listener. + */ + public void addInvitationRejectionListener(InvitationRejectionListener listener) { + synchronized (invitationRejectionListeners) { + if (!invitationRejectionListeners.contains(listener)) { + invitationRejectionListeners.add(listener); + } + } + } + + /** + * Removes a listener from invitation rejections notifications. The listener will be fired + * anytime an invitation is declined. + * + * @param listener an invitation rejection listener. + */ + public void removeInvitationRejectionListener(InvitationRejectionListener listener) { + synchronized (invitationRejectionListeners) { + invitationRejectionListeners.remove(listener); + } + } + + /** + * Fires invitation rejection listeners. + * + * @param invitee the user being invited. + * @param reason the reason for the rejection + */ + private void fireInvitationRejectionListeners(String invitee, String reason) { + InvitationRejectionListener[] listeners; + synchronized (invitationRejectionListeners) { + listeners = new InvitationRejectionListener[invitationRejectionListeners.size()]; + invitationRejectionListeners.toArray(listeners); + } + for (InvitationRejectionListener listener : listeners) { + listener.invitationDeclined(invitee, reason); + } + } + + /** + * Adds a listener to subject change notifications. The listener will be fired anytime + * the room's subject changes. + * + * @param listener a subject updated listener. + */ + public void addSubjectUpdatedListener(SubjectUpdatedListener listener) { + synchronized (subjectUpdatedListeners) { + if (!subjectUpdatedListeners.contains(listener)) { + subjectUpdatedListeners.add(listener); + } + } + } + + /** + * Removes a listener from subject change notifications. The listener will be fired + * anytime the room's subject changes. + * + * @param listener a subject updated listener. + */ + public void removeSubjectUpdatedListener(SubjectUpdatedListener listener) { + synchronized (subjectUpdatedListeners) { + subjectUpdatedListeners.remove(listener); + } + } + + /** + * Fires subject updated listeners. + */ + private void fireSubjectUpdatedListeners(String subject, String from) { + SubjectUpdatedListener[] listeners; + synchronized (subjectUpdatedListeners) { + listeners = new SubjectUpdatedListener[subjectUpdatedListeners.size()]; + subjectUpdatedListeners.toArray(listeners); + } + for (SubjectUpdatedListener listener : listeners) { + listener.subjectUpdated(subject, from); + } + } + + /** + * Adds a new {@link PacketInterceptor} that will be invoked every time a new presence + * is going to be sent by this MultiUserChat to the server. Packet interceptors may + * add new extensions to the presence that is going to be sent to the MUC service. + * + * @param presenceInterceptor the new packet interceptor that will intercept presence packets. + */ + public void addPresenceInterceptor(PacketInterceptor presenceInterceptor) { + presenceInterceptors.add(presenceInterceptor); + } + + /** + * Removes a {@link PacketInterceptor} that was being invoked every time a new presence + * was being sent by this MultiUserChat to the server. Packet interceptors may + * add new extensions to the presence that is going to be sent to the MUC service. + * + * @param presenceInterceptor the packet interceptor to remove. + */ + public void removePresenceInterceptor(PacketInterceptor presenceInterceptor) { + presenceInterceptors.remove(presenceInterceptor); + } + + /** + * Returns the last known room's subject or <tt>null</tt> if the user hasn't joined the room + * or the room does not have a subject yet. In case the room has a subject, as soon as the + * user joins the room a message with the current room's subject will be received. + * + * To be notified every time the room's subject change you should add a listener + * to this room. {@link #addSubjectUpdatedListener(SubjectUpdatedListener)} + * + * To change the room's subject use {@link #changeSubject(String)}. + * + * @return the room's subject or <tt>null</tt> if the user hasn't joined the room or the + * room does not have a subject yet. + */ + public String getSubject() { + return subject; + } + + /** + * Returns the reserved room nickname for the user in the room. A user may have a reserved + * nickname, for example through explicit room registration or database integration. In such + * cases it may be desirable for the user to discover the reserved nickname before attempting + * to enter the room. + * + * @return the reserved room nickname or <tt>null</tt> if none. + */ + public String getReservedNickname() { + try { + DiscoverInfo result = + ServiceDiscoveryManager.getInstanceFor(connection).discoverInfo( + room, + "x-roomuser-item"); + // Look for an Identity that holds the reserved nickname and return its name + for (Iterator<DiscoverInfo.Identity> identities = result.getIdentities(); + identities.hasNext();) { + DiscoverInfo.Identity identity = identities.next(); + return identity.getName(); + } + // If no Identity was found then the user does not have a reserved room nickname + return null; + } + catch (XMPPException e) { + e.printStackTrace(); + return null; + } + } + + /** + * Returns the nickname that was used to join the room, or <tt>null</tt> if not + * currently joined. + * + * @return the nickname currently being used. + */ + public String getNickname() { + return nickname; + } + + /** + * Changes the occupant's nickname to a new nickname within the room. Each room occupant + * will receive two presence packets. One of type "unavailable" for the old nickname and one + * indicating availability for the new nickname. The unavailable presence will contain the new + * nickname and an appropriate status code (namely 303) as extended presence information. The + * status code 303 indicates that the occupant is changing his/her nickname. + * + * @param nickname the new nickname within the room. + * @throws XMPPException if the new nickname is already in use by another occupant. + */ + public void changeNickname(String nickname) throws XMPPException { + if (nickname == null || nickname.equals("")) { + throw new IllegalArgumentException("Nickname must not be null or blank."); + } + // Check that we already have joined the room before attempting to change the + // nickname. + if (!joined) { + throw new IllegalStateException("Must be logged into the room to change nickname."); + } + // We change the nickname by sending a presence packet where the "to" + // field is in the form "roomName@service/nickname" + // We don't have to signal the MUC support again + Presence joinPresence = new Presence(Presence.Type.available); + joinPresence.setTo(room + "/" + nickname); + // Invoke presence interceptors so that extra information can be dynamically added + for (PacketInterceptor packetInterceptor : presenceInterceptors) { + packetInterceptor.interceptPacket(joinPresence); + } + + // Wait for a presence packet back from the server. + PacketFilter responseFilter = + new AndFilter( + new FromMatchesFilter(room + "/" + nickname), + new PacketTypeFilter(Presence.class)); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send join packet. + connection.sendPacket(joinPresence); + // Wait up to a certain number of seconds for a reply. + Presence presence = + (Presence) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (presence == null) { + throw new XMPPException("No response from server."); + } + else if (presence.getError() != null) { + throw new XMPPException(presence.getError()); + } + this.nickname = nickname; + } + + /** + * Changes the occupant's availability status within the room. The presence type + * will remain available but with a new status that describes the presence update and + * a new presence mode (e.g. Extended away). + * + * @param status a text message describing the presence update. + * @param mode the mode type for the presence update. + */ + public void changeAvailabilityStatus(String status, Presence.Mode mode) { + if (nickname == null || nickname.equals("")) { + throw new IllegalArgumentException("Nickname must not be null or blank."); + } + // Check that we already have joined the room before attempting to change the + // availability status. + if (!joined) { + throw new IllegalStateException( + "Must be logged into the room to change the " + "availability status."); + } + // We change the availability status by sending a presence packet to the room with the + // new presence status and mode + Presence joinPresence = new Presence(Presence.Type.available); + joinPresence.setStatus(status); + joinPresence.setMode(mode); + joinPresence.setTo(room + "/" + nickname); + // Invoke presence interceptors so that extra information can be dynamically added + for (PacketInterceptor packetInterceptor : presenceInterceptors) { + packetInterceptor.interceptPacket(joinPresence); + } + + // Send join packet. + connection.sendPacket(joinPresence); + } + + /** + * Kicks a visitor or participant from the room. The kicked occupant will receive a presence + * of type "unavailable" including a status code 307 and optionally along with the reason + * (if provided) and the bare JID of the user who initiated the kick. After the occupant + * was kicked from the room, the rest of the occupants will receive a presence of type + * "unavailable". The presence will include a status code 307 which means that the occupant + * was kicked from the room. + * + * @param nickname the nickname of the participant or visitor to kick from the room + * (e.g. "john"). + * @param reason the reason why the participant or visitor is being kicked from the room. + * @throws XMPPException if an error occurs kicking the occupant. In particular, a + * 405 error can occur if a moderator or a user with an affiliation of "owner" or "admin" + * was intended to be kicked (i.e. Not Allowed error); or a + * 403 error can occur if the occupant that intended to kick another occupant does + * not have kicking privileges (i.e. Forbidden error); or a + * 400 error can occur if the provided nickname is not present in the room. + */ + public void kickParticipant(String nickname, String reason) throws XMPPException { + changeRole(nickname, "none", reason); + } + + /** + * Grants voice to visitors in the room. In a moderated room, a moderator may want to manage + * who does and does not have "voice" in the room. To have voice means that a room occupant + * is able to send messages to the room occupants. + * + * @param nicknames the nicknames of the visitors to grant voice in the room (e.g. "john"). + * @throws XMPPException if an error occurs granting voice to a visitor. In particular, a + * 403 error can occur if the occupant that intended to grant voice is not + * a moderator in this room (i.e. Forbidden error); or a + * 400 error can occur if the provided nickname is not present in the room. + */ + public void grantVoice(Collection<String> nicknames) throws XMPPException { + changeRole(nicknames, "participant"); + } + + /** + * Grants voice to a visitor in the room. In a moderated room, a moderator may want to manage + * who does and does not have "voice" in the room. To have voice means that a room occupant + * is able to send messages to the room occupants. + * + * @param nickname the nickname of the visitor to grant voice in the room (e.g. "john"). + * @throws XMPPException if an error occurs granting voice to a visitor. In particular, a + * 403 error can occur if the occupant that intended to grant voice is not + * a moderator in this room (i.e. Forbidden error); or a + * 400 error can occur if the provided nickname is not present in the room. + */ + public void grantVoice(String nickname) throws XMPPException { + changeRole(nickname, "participant", null); + } + + /** + * Revokes voice from participants in the room. In a moderated room, a moderator may want to + * revoke an occupant's privileges to speak. To have voice means that a room occupant + * is able to send messages to the room occupants. + * + * @param nicknames the nicknames of the participants to revoke voice (e.g. "john"). + * @throws XMPPException if an error occurs revoking voice from a participant. In particular, a + * 405 error can occur if a moderator or a user with an affiliation of "owner" or "admin" + * was tried to revoke his voice (i.e. Not Allowed error); or a + * 400 error can occur if the provided nickname is not present in the room. + */ + public void revokeVoice(Collection<String> nicknames) throws XMPPException { + changeRole(nicknames, "visitor"); + } + + /** + * Revokes voice from a participant in the room. In a moderated room, a moderator may want to + * revoke an occupant's privileges to speak. To have voice means that a room occupant + * is able to send messages to the room occupants. + * + * @param nickname the nickname of the participant to revoke voice (e.g. "john"). + * @throws XMPPException if an error occurs revoking voice from a participant. In particular, a + * 405 error can occur if a moderator or a user with an affiliation of "owner" or "admin" + * was tried to revoke his voice (i.e. Not Allowed error); or a + * 400 error can occur if the provided nickname is not present in the room. + */ + public void revokeVoice(String nickname) throws XMPPException { + changeRole(nickname, "visitor", null); + } + + /** + * Bans users from the room. An admin or owner of the room can ban users from a room. This + * means that the banned user will no longer be able to join the room unless the ban has been + * removed. If the banned user was present in the room then he/she will be removed from the + * room and notified that he/she was banned along with the reason (if provided) and the bare + * XMPP user ID of the user who initiated the ban. + * + * @param jids the bare XMPP user IDs of the users to ban. + * @throws XMPPException if an error occurs banning a user. In particular, a + * 405 error can occur if a moderator or a user with an affiliation of "owner" or "admin" + * was tried to be banned (i.e. Not Allowed error). + */ + public void banUsers(Collection<String> jids) throws XMPPException { + changeAffiliationByAdmin(jids, "outcast"); + } + + /** + * Bans a user from the room. An admin or owner of the room can ban users from a room. This + * means that the banned user will no longer be able to join the room unless the ban has been + * removed. If the banned user was present in the room then he/she will be removed from the + * room and notified that he/she was banned along with the reason (if provided) and the bare + * XMPP user ID of the user who initiated the ban. + * + * @param jid the bare XMPP user ID of the user to ban (e.g. "user@host.org"). + * @param reason the reason why the user was banned. + * @throws XMPPException if an error occurs banning a user. In particular, a + * 405 error can occur if a moderator or a user with an affiliation of "owner" or "admin" + * was tried to be banned (i.e. Not Allowed error). + */ + public void banUser(String jid, String reason) throws XMPPException { + changeAffiliationByAdmin(jid, "outcast", reason); + } + + /** + * Grants membership to other users. Only administrators are able to grant membership. A user + * that becomes a room member will be able to enter a room of type Members-Only (i.e. a room + * that a user cannot enter without being on the member list). + * + * @param jids the XMPP user IDs of the users to grant membership. + * @throws XMPPException if an error occurs granting membership to a user. + */ + public void grantMembership(Collection<String> jids) throws XMPPException { + changeAffiliationByAdmin(jids, "member"); + } + + /** + * Grants membership to a user. Only administrators are able to grant membership. A user + * that becomes a room member will be able to enter a room of type Members-Only (i.e. a room + * that a user cannot enter without being on the member list). + * + * @param jid the XMPP user ID of the user to grant membership (e.g. "user@host.org"). + * @throws XMPPException if an error occurs granting membership to a user. + */ + public void grantMembership(String jid) throws XMPPException { + changeAffiliationByAdmin(jid, "member", null); + } + + /** + * Revokes users' membership. Only administrators are able to revoke membership. A user + * that becomes a room member will be able to enter a room of type Members-Only (i.e. a room + * that a user cannot enter without being on the member list). If the user is in the room and + * the room is of type members-only then the user will be removed from the room. + * + * @param jids the bare XMPP user IDs of the users to revoke membership. + * @throws XMPPException if an error occurs revoking membership to a user. + */ + public void revokeMembership(Collection<String> jids) throws XMPPException { + changeAffiliationByAdmin(jids, "none"); + } + + /** + * Revokes a user's membership. Only administrators are able to revoke membership. A user + * that becomes a room member will be able to enter a room of type Members-Only (i.e. a room + * that a user cannot enter without being on the member list). If the user is in the room and + * the room is of type members-only then the user will be removed from the room. + * + * @param jid the bare XMPP user ID of the user to revoke membership (e.g. "user@host.org"). + * @throws XMPPException if an error occurs revoking membership to a user. + */ + public void revokeMembership(String jid) throws XMPPException { + changeAffiliationByAdmin(jid, "none", null); + } + + /** + * Grants moderator privileges to participants or visitors. Room administrators may grant + * moderator privileges. A moderator is allowed to kick users, grant and revoke voice, invite + * other users, modify room's subject plus all the partcipants privileges. + * + * @param nicknames the nicknames of the occupants to grant moderator privileges. + * @throws XMPPException if an error occurs granting moderator privileges to a user. + */ + public void grantModerator(Collection<String> nicknames) throws XMPPException { + changeRole(nicknames, "moderator"); + } + + /** + * Grants moderator privileges to a participant or visitor. Room administrators may grant + * moderator privileges. A moderator is allowed to kick users, grant and revoke voice, invite + * other users, modify room's subject plus all the partcipants privileges. + * + * @param nickname the nickname of the occupant to grant moderator privileges. + * @throws XMPPException if an error occurs granting moderator privileges to a user. + */ + public void grantModerator(String nickname) throws XMPPException { + changeRole(nickname, "moderator", null); + } + + /** + * Revokes moderator privileges from other users. The occupant that loses moderator + * privileges will become a participant. Room administrators may revoke moderator privileges + * only to occupants whose affiliation is member or none. This means that an administrator is + * not allowed to revoke moderator privileges from other room administrators or owners. + * + * @param nicknames the nicknames of the occupants to revoke moderator privileges. + * @throws XMPPException if an error occurs revoking moderator privileges from a user. + */ + public void revokeModerator(Collection<String> nicknames) throws XMPPException { + changeRole(nicknames, "participant"); + } + + /** + * Revokes moderator privileges from another user. The occupant that loses moderator + * privileges will become a participant. Room administrators may revoke moderator privileges + * only to occupants whose affiliation is member or none. This means that an administrator is + * not allowed to revoke moderator privileges from other room administrators or owners. + * + * @param nickname the nickname of the occupant to revoke moderator privileges. + * @throws XMPPException if an error occurs revoking moderator privileges from a user. + */ + public void revokeModerator(String nickname) throws XMPPException { + changeRole(nickname, "participant", null); + } + + /** + * Grants ownership privileges to other users. Room owners may grant ownership privileges. + * Some room implementations will not allow to grant ownership privileges to other users. + * An owner is allowed to change defining room features as well as perform all administrative + * functions. + * + * @param jids the collection of bare XMPP user IDs of the users to grant ownership. + * @throws XMPPException if an error occurs granting ownership privileges to a user. + */ + public void grantOwnership(Collection<String> jids) throws XMPPException { + changeAffiliationByAdmin(jids, "owner"); + } + + /** + * Grants ownership privileges to another user. Room owners may grant ownership privileges. + * Some room implementations will not allow to grant ownership privileges to other users. + * An owner is allowed to change defining room features as well as perform all administrative + * functions. + * + * @param jid the bare XMPP user ID of the user to grant ownership (e.g. "user@host.org"). + * @throws XMPPException if an error occurs granting ownership privileges to a user. + */ + public void grantOwnership(String jid) throws XMPPException { + changeAffiliationByAdmin(jid, "owner", null); + } + + /** + * Revokes ownership privileges from other users. The occupant that loses ownership + * privileges will become an administrator. Room owners may revoke ownership privileges. + * Some room implementations will not allow to grant ownership privileges to other users. + * + * @param jids the bare XMPP user IDs of the users to revoke ownership. + * @throws XMPPException if an error occurs revoking ownership privileges from a user. + */ + public void revokeOwnership(Collection<String> jids) throws XMPPException { + changeAffiliationByAdmin(jids, "admin"); + } + + /** + * Revokes ownership privileges from another user. The occupant that loses ownership + * privileges will become an administrator. Room owners may revoke ownership privileges. + * Some room implementations will not allow to grant ownership privileges to other users. + * + * @param jid the bare XMPP user ID of the user to revoke ownership (e.g. "user@host.org"). + * @throws XMPPException if an error occurs revoking ownership privileges from a user. + */ + public void revokeOwnership(String jid) throws XMPPException { + changeAffiliationByAdmin(jid, "admin", null); + } + + /** + * Grants administrator privileges to other users. Room owners may grant administrator + * privileges to a member or unaffiliated user. An administrator is allowed to perform + * administrative functions such as banning users and edit moderator list. + * + * @param jids the bare XMPP user IDs of the users to grant administrator privileges. + * @throws XMPPException if an error occurs granting administrator privileges to a user. + */ + public void grantAdmin(Collection<String> jids) throws XMPPException { + changeAffiliationByOwner(jids, "admin"); + } + + /** + * Grants administrator privileges to another user. Room owners may grant administrator + * privileges to a member or unaffiliated user. An administrator is allowed to perform + * administrative functions such as banning users and edit moderator list. + * + * @param jid the bare XMPP user ID of the user to grant administrator privileges + * (e.g. "user@host.org"). + * @throws XMPPException if an error occurs granting administrator privileges to a user. + */ + public void grantAdmin(String jid) throws XMPPException { + changeAffiliationByOwner(jid, "admin"); + } + + /** + * Revokes administrator privileges from users. The occupant that loses administrator + * privileges will become a member. Room owners may revoke administrator privileges from + * a member or unaffiliated user. + * + * @param jids the bare XMPP user IDs of the user to revoke administrator privileges. + * @throws XMPPException if an error occurs revoking administrator privileges from a user. + */ + public void revokeAdmin(Collection<String> jids) throws XMPPException { + changeAffiliationByOwner(jids, "member"); + } + + /** + * Revokes administrator privileges from a user. The occupant that loses administrator + * privileges will become a member. Room owners may revoke administrator privileges from + * a member or unaffiliated user. + * + * @param jid the bare XMPP user ID of the user to revoke administrator privileges + * (e.g. "user@host.org"). + * @throws XMPPException if an error occurs revoking administrator privileges from a user. + */ + public void revokeAdmin(String jid) throws XMPPException { + changeAffiliationByOwner(jid, "member"); + } + + private void changeAffiliationByOwner(String jid, String affiliation) throws XMPPException { + MUCOwner iq = new MUCOwner(); + iq.setTo(room); + iq.setType(IQ.Type.SET); + // Set the new affiliation. + MUCOwner.Item item = new MUCOwner.Item(affiliation); + item.setJid(jid); + iq.addItem(item); + + // Wait for a response packet back from the server. + PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send the change request to the server. + connection.sendPacket(iq); + // Wait up to a certain number of seconds for a reply. + IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } + else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + } + + private void changeAffiliationByOwner(Collection<String> jids, String affiliation) + throws XMPPException { + MUCOwner iq = new MUCOwner(); + iq.setTo(room); + iq.setType(IQ.Type.SET); + for (String jid : jids) { + // Set the new affiliation. + MUCOwner.Item item = new MUCOwner.Item(affiliation); + item.setJid(jid); + iq.addItem(item); + } + + // Wait for a response packet back from the server. + PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send the change request to the server. + connection.sendPacket(iq); + // Wait up to a certain number of seconds for a reply. + IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } + else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + } + + private void changeAffiliationByAdmin(String jid, String affiliation, String reason) + throws XMPPException { + MUCAdmin iq = new MUCAdmin(); + iq.setTo(room); + iq.setType(IQ.Type.SET); + // Set the new affiliation. + MUCAdmin.Item item = new MUCAdmin.Item(affiliation, null); + item.setJid(jid); + if(reason != null) + item.setReason(reason); + iq.addItem(item); + + // Wait for a response packet back from the server. + PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send the change request to the server. + connection.sendPacket(iq); + // Wait up to a certain number of seconds for a reply. + IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } + else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + } + + private void changeAffiliationByAdmin(Collection<String> jids, String affiliation) + throws XMPPException { + MUCAdmin iq = new MUCAdmin(); + iq.setTo(room); + iq.setType(IQ.Type.SET); + for (String jid : jids) { + // Set the new affiliation. + MUCAdmin.Item item = new MUCAdmin.Item(affiliation, null); + item.setJid(jid); + iq.addItem(item); + } + + // Wait for a response packet back from the server. + PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send the change request to the server. + connection.sendPacket(iq); + // Wait up to a certain number of seconds for a reply. + IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } + else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + } + + private void changeRole(String nickname, String role, String reason) throws XMPPException { + MUCAdmin iq = new MUCAdmin(); + iq.setTo(room); + iq.setType(IQ.Type.SET); + // Set the new role. + MUCAdmin.Item item = new MUCAdmin.Item(null, role); + item.setNick(nickname); + item.setReason(reason); + iq.addItem(item); + + // Wait for a response packet back from the server. + PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send the change request to the server. + connection.sendPacket(iq); + // Wait up to a certain number of seconds for a reply. + IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } + else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + } + + private void changeRole(Collection<String> nicknames, String role) throws XMPPException { + MUCAdmin iq = new MUCAdmin(); + iq.setTo(room); + iq.setType(IQ.Type.SET); + for (String nickname : nicknames) { + // Set the new role. + MUCAdmin.Item item = new MUCAdmin.Item(null, role); + item.setNick(nickname); + iq.addItem(item); + } + + // Wait for a response packet back from the server. + PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send the change request to the server. + connection.sendPacket(iq); + // Wait up to a certain number of seconds for a reply. + IQ answer = (IQ) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } + else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + } + + /** + * Returns the number of occupants in the group chat. + * + * Note: this value will only be accurate after joining the group chat, and + * may fluctuate over time. If you query this value directly after joining the + * group chat it may not be accurate, as it takes a certain amount of time for + * the server to send all presence packets to this client. + * + * @return the number of occupants in the group chat. + */ + public int getOccupantsCount() { + return occupantsMap.size(); + } + + /** + * Returns an Iterator (of Strings) for the list of fully qualified occupants + * in the group chat. For example, "conference@chat.jivesoftware.com/SomeUser". + * Typically, a client would only display the nickname of the occupant. To + * get the nickname from the fully qualified name, use the + * {@link org.jivesoftware.smack.util.StringUtils#parseResource(String)} method. + * Note: this value will only be accurate after joining the group chat, and may + * fluctuate over time. + * + * @return an Iterator for the occupants in the group chat. + */ + public Iterator<String> getOccupants() { + return Collections.unmodifiableList(new ArrayList<String>(occupantsMap.keySet())) + .iterator(); + } + + /** + * Returns the presence info for a particular user, or <tt>null</tt> if the user + * is not in the room. + * + * @param user the room occupant to search for his presence. The format of user must + * be: roomName@service/nickname (e.g. darkcave@macbeth.shakespeare.lit/thirdwitch). + * @return the occupant's current presence, or <tt>null</tt> if the user is unavailable + * or if no presence information is available. + */ + public Presence getOccupantPresence(String user) { + return occupantsMap.get(user); + } + + /** + * Returns the Occupant information for a particular occupant, or <tt>null</tt> if the + * user is not in the room. The Occupant object may include information such as full + * JID of the user as well as the role and affiliation of the user in the room. + * + * @param user the room occupant to search for his presence. The format of user must + * be: roomName@service/nickname (e.g. darkcave@macbeth.shakespeare.lit/thirdwitch). + * @return the Occupant or <tt>null</tt> if the user is unavailable (i.e. not in the room). + */ + public Occupant getOccupant(String user) { + Presence presence = occupantsMap.get(user); + if (presence != null) { + return new Occupant(presence); + } + return null; + } + + /** + * Adds a packet listener that will be notified of any new Presence packets + * sent to the group chat. Using a listener is a suitable way to know when the list + * of occupants should be re-loaded due to any changes. + * + * @param listener a packet listener that will be notified of any presence packets + * sent to the group chat. + */ + public void addParticipantListener(PacketListener listener) { + connection.addPacketListener(listener, presenceFilter); + connectionListeners.add(listener); + } + + /** + * Remoces a packet listener that was being notified of any new Presence packets + * sent to the group chat. + * + * @param listener a packet listener that was being notified of any presence packets + * sent to the group chat. + */ + public void removeParticipantListener(PacketListener listener) { + connection.removePacketListener(listener); + connectionListeners.remove(listener); + } + + /** + * Returns a collection of <code>Affiliate</code> with the room owners. + * + * @return a collection of <code>Affiliate</code> with the room owners. + * @throws XMPPException if an error occured while performing the request to the server or you + * don't have enough privileges to get this information. + */ + public Collection<Affiliate> getOwners() throws XMPPException { + return getAffiliatesByAdmin("owner"); + } + + /** + * Returns a collection of <code>Affiliate</code> with the room administrators. + * + * @return a collection of <code>Affiliate</code> with the room administrators. + * @throws XMPPException if an error occured while performing the request to the server or you + * don't have enough privileges to get this information. + */ + public Collection<Affiliate> getAdmins() throws XMPPException { + return getAffiliatesByOwner("admin"); + } + + /** + * Returns a collection of <code>Affiliate</code> with the room members. + * + * @return a collection of <code>Affiliate</code> with the room members. + * @throws XMPPException if an error occured while performing the request to the server or you + * don't have enough privileges to get this information. + */ + public Collection<Affiliate> getMembers() throws XMPPException { + return getAffiliatesByAdmin("member"); + } + + /** + * Returns a collection of <code>Affiliate</code> with the room outcasts. + * + * @return a collection of <code>Affiliate</code> with the room outcasts. + * @throws XMPPException if an error occured while performing the request to the server or you + * don't have enough privileges to get this information. + */ + public Collection<Affiliate> getOutcasts() throws XMPPException { + return getAffiliatesByAdmin("outcast"); + } + + /** + * Returns a collection of <code>Affiliate</code> that have the specified room affiliation + * sending a request in the owner namespace. + * + * @param affiliation the affiliation of the users in the room. + * @return a collection of <code>Affiliate</code> that have the specified room affiliation. + * @throws XMPPException if an error occured while performing the request to the server or you + * don't have enough privileges to get this information. + */ + private Collection<Affiliate> getAffiliatesByOwner(String affiliation) throws XMPPException { + MUCOwner iq = new MUCOwner(); + iq.setTo(room); + iq.setType(IQ.Type.GET); + // Set the specified affiliation. This may request the list of owners/admins/members/outcasts. + MUCOwner.Item item = new MUCOwner.Item(affiliation); + iq.addItem(item); + + // Wait for a response packet back from the server. + PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send the request to the server. + connection.sendPacket(iq); + // Wait up to a certain number of seconds for a reply. + MUCOwner answer = (MUCOwner) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } + else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + // Get the list of affiliates from the server's answer + List<Affiliate> affiliates = new ArrayList<Affiliate>(); + for (Iterator it = answer.getItems(); it.hasNext();) { + affiliates.add(new Affiliate((MUCOwner.Item) it.next())); + } + return affiliates; + } + + /** + * Returns a collection of <code>Affiliate</code> that have the specified room affiliation + * sending a request in the admin namespace. + * + * @param affiliation the affiliation of the users in the room. + * @return a collection of <code>Affiliate</code> that have the specified room affiliation. + * @throws XMPPException if an error occured while performing the request to the server or you + * don't have enough privileges to get this information. + */ + private Collection<Affiliate> getAffiliatesByAdmin(String affiliation) throws XMPPException { + MUCAdmin iq = new MUCAdmin(); + iq.setTo(room); + iq.setType(IQ.Type.GET); + // Set the specified affiliation. This may request the list of owners/admins/members/outcasts. + MUCAdmin.Item item = new MUCAdmin.Item(affiliation, null); + iq.addItem(item); + + // Wait for a response packet back from the server. + PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send the request to the server. + connection.sendPacket(iq); + // Wait up to a certain number of seconds for a reply. + MUCAdmin answer = (MUCAdmin) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } + else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + // Get the list of affiliates from the server's answer + List<Affiliate> affiliates = new ArrayList<Affiliate>(); + for (Iterator it = answer.getItems(); it.hasNext();) { + affiliates.add(new Affiliate((MUCAdmin.Item) it.next())); + } + return affiliates; + } + + /** + * Returns a collection of <code>Occupant</code> with the room moderators. + * + * @return a collection of <code>Occupant</code> with the room moderators. + * @throws XMPPException if an error occured while performing the request to the server or you + * don't have enough privileges to get this information. + */ + public Collection<Occupant> getModerators() throws XMPPException { + return getOccupants("moderator"); + } + + /** + * Returns a collection of <code>Occupant</code> with the room participants. + * + * @return a collection of <code>Occupant</code> with the room participants. + * @throws XMPPException if an error occured while performing the request to the server or you + * don't have enough privileges to get this information. + */ + public Collection<Occupant> getParticipants() throws XMPPException { + return getOccupants("participant"); + } + + /** + * Returns a collection of <code>Occupant</code> that have the specified room role. + * + * @param role the role of the occupant in the room. + * @return a collection of <code>Occupant</code> that have the specified room role. + * @throws XMPPException if an error occured while performing the request to the server or you + * don't have enough privileges to get this information. + */ + private Collection<Occupant> getOccupants(String role) throws XMPPException { + MUCAdmin iq = new MUCAdmin(); + iq.setTo(room); + iq.setType(IQ.Type.GET); + // Set the specified role. This may request the list of moderators/participants. + MUCAdmin.Item item = new MUCAdmin.Item(null, role); + iq.addItem(item); + + // Wait for a response packet back from the server. + PacketFilter responseFilter = new PacketIDFilter(iq.getPacketID()); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send the request to the server. + connection.sendPacket(iq); + // Wait up to a certain number of seconds for a reply. + MUCAdmin answer = (MUCAdmin) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } + else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + // Get the list of participants from the server's answer + List<Occupant> participants = new ArrayList<Occupant>(); + for (Iterator it = answer.getItems(); it.hasNext();) { + participants.add(new Occupant((MUCAdmin.Item) it.next())); + } + return participants; + } + + /** + * Sends a message to the chat room. + * + * @param text the text of the message to send. + * @throws XMPPException if sending the message fails. + */ + public void sendMessage(String text) throws XMPPException { + Message message = new Message(room, Message.Type.groupchat); + message.setBody(text); + connection.sendPacket(message); + } + + /** + * Returns a new Chat for sending private messages to a given room occupant. + * The Chat's occupant address is the room's JID (i.e. roomName@service/nick). The server + * service will change the 'from' address to the sender's room JID and delivering the message + * to the intended recipient's full JID. + * + * @param occupant occupant unique room JID (e.g. 'darkcave@macbeth.shakespeare.lit/Paul'). + * @param listener the listener is a message listener that will handle messages for the newly + * created chat. + * @return new Chat for sending private messages to a given room occupant. + */ + public Chat createPrivateChat(String occupant, MessageListener listener) { + return connection.getChatManager().createChat(occupant, listener); + } + + /** + * Creates a new Message to send to the chat room. + * + * @return a new Message addressed to the chat room. + */ + public Message createMessage() { + return new Message(room, Message.Type.groupchat); + } + + /** + * Sends a Message to the chat room. + * + * @param message the message. + * @throws XMPPException if sending the message fails. + */ + public void sendMessage(Message message) throws XMPPException { + connection.sendPacket(message); + } + + /** + * Polls for and returns the next message, or <tt>null</tt> if there isn't + * a message immediately available. This method provides significantly different + * functionalty than the {@link #nextMessage()} method since it's non-blocking. + * In other words, the method call will always return immediately, whereas the + * nextMessage method will return only when a message is available (or after + * a specific timeout). + * + * @return the next message if one is immediately available and + * <tt>null</tt> otherwise. + */ + public Message pollMessage() { + return (Message) messageCollector.pollResult(); + } + + /** + * Returns the next available message in the chat. The method call will block + * (not return) until a message is available. + * + * @return the next message. + */ + public Message nextMessage() { + return (Message) messageCollector.nextResult(); + } + + /** + * Returns the next available message in the chat. The method call will block + * (not return) until a packet is available or the <tt>timeout</tt> has elapased. + * If the timeout elapses without a result, <tt>null</tt> will be returned. + * + * @param timeout the maximum amount of time to wait for the next message. + * @return the next message, or <tt>null</tt> if the timeout elapses without a + * message becoming available. + */ + public Message nextMessage(long timeout) { + return (Message) messageCollector.nextResult(timeout); + } + + /** + * Adds a packet listener that will be notified of any new messages in the + * group chat. Only "group chat" messages addressed to this group chat will + * be delivered to the listener. If you wish to listen for other packets + * that may be associated with this group chat, you should register a + * PacketListener directly with the Connection with the appropriate + * PacketListener. + * + * @param listener a packet listener. + */ + public void addMessageListener(PacketListener listener) { + connection.addPacketListener(listener, messageFilter); + connectionListeners.add(listener); + } + + /** + * Removes a packet listener that was being notified of any new messages in the + * multi user chat. Only "group chat" messages addressed to this multi user chat were + * being delivered to the listener. + * + * @param listener a packet listener. + */ + public void removeMessageListener(PacketListener listener) { + connection.removePacketListener(listener); + connectionListeners.remove(listener); + } + + /** + * Changes the subject within the room. As a default, only users with a role of "moderator" + * are allowed to change the subject in a room. Although some rooms may be configured to + * allow a mere participant or even a visitor to change the subject. + * + * @param subject the new room's subject to set. + * @throws XMPPException if someone without appropriate privileges attempts to change the + * room subject will throw an error with code 403 (i.e. Forbidden) + */ + public void changeSubject(final String subject) throws XMPPException { + Message message = new Message(room, Message.Type.groupchat); + message.setSubject(subject); + // Wait for an error or confirmation message back from the server. + PacketFilter responseFilter = + new AndFilter( + new FromMatchesFilter(room), + new PacketTypeFilter(Message.class)); + responseFilter = new AndFilter(responseFilter, new PacketFilter() { + public boolean accept(Packet packet) { + Message msg = (Message) packet; + return subject.equals(msg.getSubject()); + } + }); + PacketCollector response = connection.createPacketCollector(responseFilter); + // Send change subject packet. + connection.sendPacket(message); + // Wait up to a certain number of seconds for a reply. + Message answer = + (Message) response.nextResult(SmackConfiguration.getPacketReplyTimeout()); + // Stop queuing results + response.cancel(); + + if (answer == null) { + throw new XMPPException("No response from server."); + } + else if (answer.getError() != null) { + throw new XMPPException(answer.getError()); + } + } + + /** + * Notification message that the user has joined the room. + */ + private synchronized void userHasJoined() { + // Update the list of joined rooms through this connection + List<String> rooms = joinedRooms.get(connection); + if (rooms == null) { + rooms = new ArrayList<String>(); + joinedRooms.put(connection, rooms); + } + rooms.add(room); + } + + /** + * Notification message that the user has left the room. + */ + private synchronized void userHasLeft() { + // Update the list of joined rooms through this connection + List<String> rooms = joinedRooms.get(connection); + if (rooms == null) { + return; + } + rooms.remove(room); + } + + /** + * Returns the MUCUser packet extension included in the packet or <tt>null</tt> if none. + * + * @param packet the packet that may include the MUCUser extension. + * @return the MUCUser found in the packet. + */ + private MUCUser getMUCUserExtension(Packet packet) { + if (packet != null) { + // Get the MUC User extension + return (MUCUser) packet.getExtension("x", "http://jabber.org/protocol/muc#user"); + } + return null; + } + + /** + * Adds a listener that will be notified of changes in your status in the room + * such as the user being kicked, banned, or granted admin permissions. + * + * @param listener a user status listener. + */ + public void addUserStatusListener(UserStatusListener listener) { + synchronized (userStatusListeners) { + if (!userStatusListeners.contains(listener)) { + userStatusListeners.add(listener); + } + } + } + + /** + * Removes a listener that was being notified of changes in your status in the room + * such as the user being kicked, banned, or granted admin permissions. + * + * @param listener a user status listener. + */ + public void removeUserStatusListener(UserStatusListener listener) { + synchronized (userStatusListeners) { + userStatusListeners.remove(listener); + } + } + + private void fireUserStatusListeners(String methodName, Object[] params) { + UserStatusListener[] listeners; + synchronized (userStatusListeners) { + listeners = new UserStatusListener[userStatusListeners.size()]; + userStatusListeners.toArray(listeners); + } + // Get the classes of the method parameters + Class[] paramClasses = new Class[params.length]; + for (int i = 0; i < params.length; i++) { + paramClasses[i] = params[i].getClass(); + } + try { + // Get the method to execute based on the requested methodName and parameters classes + Method method = UserStatusListener.class.getDeclaredMethod(methodName, paramClasses); + for (UserStatusListener listener : listeners) { + method.invoke(listener, params); + } + } catch (NoSuchMethodException e) { + e.printStackTrace(); + } catch (InvocationTargetException e) { + e.printStackTrace(); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } + + /** + * Adds a listener that will be notified of changes in occupants status in the room + * such as the user being kicked, banned, or granted admin permissions. + * + * @param listener a participant status listener. + */ + public void addParticipantStatusListener(ParticipantStatusListener listener) { + synchronized (participantStatusListeners) { + if (!participantStatusListeners.contains(listener)) { + participantStatusListeners.add(listener); + } + } + } + + /** + * Removes a listener that was being notified of changes in occupants status in the room + * such as the user being kicked, banned, or granted admin permissions. + * + * @param listener a participant status listener. + */ + public void removeParticipantStatusListener(ParticipantStatusListener listener) { + synchronized (participantStatusListeners) { + participantStatusListeners.remove(listener); + } + } + + private void fireParticipantStatusListeners(String methodName, List<String> params) { + ParticipantStatusListener[] listeners; + synchronized (participantStatusListeners) { + listeners = new ParticipantStatusListener[participantStatusListeners.size()]; + participantStatusListeners.toArray(listeners); + } + try { + // Get the method to execute based on the requested methodName and parameter + Class[] classes = new Class[params.size()]; + for (int i=0;i<params.size(); i++) { + classes[i] = String.class; + } + Method method = ParticipantStatusListener.class.getDeclaredMethod(methodName, classes); + for (ParticipantStatusListener listener : listeners) { + method.invoke(listener, params.toArray()); + } + } catch (NoSuchMethodException e) { + e.printStackTrace(); + } catch (InvocationTargetException e) { + e.printStackTrace(); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } + + private void init() { + // Create filters + messageFilter = + new AndFilter( + new FromMatchesFilter(room), + new MessageTypeFilter(Message.Type.groupchat)); + messageFilter = new AndFilter(messageFilter, new PacketFilter() { + public boolean accept(Packet packet) { + Message msg = (Message) packet; + return msg.getBody() != null; + } + }); + presenceFilter = + new AndFilter(new FromMatchesFilter(room), new PacketTypeFilter(Presence.class)); + + // Create a collector for incoming messages. + messageCollector = new ConnectionDetachedPacketCollector(); + + // Create a listener for subject updates. + PacketListener subjectListener = new PacketListener() { + public void processPacket(Packet packet) { + Message msg = (Message) packet; + // Update the room subject + subject = msg.getSubject(); + // Fire event for subject updated listeners + fireSubjectUpdatedListeners( + msg.getSubject(), + msg.getFrom()); + + } + }; + + // Create a listener for all presence updates. + PacketListener presenceListener = new PacketListener() { + public void processPacket(Packet packet) { + Presence presence = (Presence) packet; + String from = presence.getFrom(); + String myRoomJID = room + "/" + nickname; + boolean isUserStatusModification = presence.getFrom().equals(myRoomJID); + if (presence.getType() == Presence.Type.available) { + Presence oldPresence = occupantsMap.put(from, presence); + if (oldPresence != null) { + // Get the previous occupant's affiliation & role + MUCUser mucExtension = getMUCUserExtension(oldPresence); + String oldAffiliation = mucExtension.getItem().getAffiliation(); + String oldRole = mucExtension.getItem().getRole(); + // Get the new occupant's affiliation & role + mucExtension = getMUCUserExtension(presence); + String newAffiliation = mucExtension.getItem().getAffiliation(); + String newRole = mucExtension.getItem().getRole(); + // Fire role modification events + checkRoleModifications(oldRole, newRole, isUserStatusModification, from); + // Fire affiliation modification events + checkAffiliationModifications( + oldAffiliation, + newAffiliation, + isUserStatusModification, + from); + } + else { + // A new occupant has joined the room + if (!isUserStatusModification) { + List<String> params = new ArrayList<String>(); + params.add(from); + fireParticipantStatusListeners("joined", params); + } + } + } + else if (presence.getType() == Presence.Type.unavailable) { + occupantsMap.remove(from); + MUCUser mucUser = getMUCUserExtension(presence); + if (mucUser != null && mucUser.getStatus() != null) { + // Fire events according to the received presence code + checkPresenceCode( + mucUser.getStatus().getCode(), + presence.getFrom().equals(myRoomJID), + mucUser, + from); + } else { + // An occupant has left the room + if (!isUserStatusModification) { + List<String> params = new ArrayList<String>(); + params.add(from); + fireParticipantStatusListeners("left", params); + } + } + } + } + }; + + // Listens for all messages that include a MUCUser extension and fire the invitation + // rejection listeners if the message includes an invitation rejection. + PacketListener declinesListener = new PacketListener() { + public void processPacket(Packet packet) { + // Get the MUC User extension + MUCUser mucUser = getMUCUserExtension(packet); + // Check if the MUCUser informs that the invitee has declined the invitation + if (mucUser.getDecline() != null && + ((Message) packet).getType() != Message.Type.error) { + // Fire event for invitation rejection listeners + fireInvitationRejectionListeners( + mucUser.getDecline().getFrom(), + mucUser.getDecline().getReason()); + } + } + }; + + PacketMultiplexListener packetMultiplexor = new PacketMultiplexListener( + messageCollector, presenceListener, subjectListener, + declinesListener); + + roomListenerMultiplexor = RoomListenerMultiplexor.getRoomMultiplexor(connection); + + roomListenerMultiplexor.addRoom(room, packetMultiplexor); + } + + /** + * Fires notification events if the role of a room occupant has changed. If the occupant that + * changed his role is your occupant then the <code>UserStatusListeners</code> added to this + * <code>MultiUserChat</code> will be fired. On the other hand, if the occupant that changed + * his role is not yours then the <code>ParticipantStatusListeners</code> added to this + * <code>MultiUserChat</code> will be fired. The following table shows the events that will + * be fired depending on the previous and new role of the occupant. + * + * <pre> + * <table border="1"> + * <tr><td>Old</td><td>New</td><td>Events</td></tr> + * + * <tr><td>None</td><td>Visitor</td><td>--</td></tr> + * <tr><td>Visitor</td><td>Participant</td><td>voiceGranted</td></tr> + * <tr><td>Participant</td><td>Moderator</td><td>moderatorGranted</td></tr> + * + * <tr><td>None</td><td>Participant</td><td>voiceGranted</td></tr> + * <tr><td>None</td><td>Moderator</td><td>voiceGranted + moderatorGranted</td></tr> + * <tr><td>Visitor</td><td>Moderator</td><td>voiceGranted + moderatorGranted</td></tr> + * + * <tr><td>Moderator</td><td>Participant</td><td>moderatorRevoked</td></tr> + * <tr><td>Participant</td><td>Visitor</td><td>voiceRevoked</td></tr> + * <tr><td>Visitor</td><td>None</td><td>kicked</td></tr> + * + * <tr><td>Moderator</td><td>Visitor</td><td>voiceRevoked + moderatorRevoked</td></tr> + * <tr><td>Moderator</td><td>None</td><td>kicked</td></tr> + * <tr><td>Participant</td><td>None</td><td>kicked</td></tr> + * </table> + * </pre> + * + * @param oldRole the previous role of the user in the room before receiving the new presence + * @param newRole the new role of the user in the room after receiving the new presence + * @param isUserModification whether the received presence is about your user in the room or not + * @param from the occupant whose role in the room has changed + * (e.g. room@conference.jabber.org/nick). + */ + private void checkRoleModifications( + String oldRole, + String newRole, + boolean isUserModification, + String from) { + // Voice was granted to a visitor + if (("visitor".equals(oldRole) || "none".equals(oldRole)) + && "participant".equals(newRole)) { + if (isUserModification) { + fireUserStatusListeners("voiceGranted", new Object[] {}); + } + else { + List<String> params = new ArrayList<String>(); + params.add(from); + fireParticipantStatusListeners("voiceGranted", params); + } + } + // The participant's voice was revoked from the room + else if ( + "participant".equals(oldRole) + && ("visitor".equals(newRole) || "none".equals(newRole))) { + if (isUserModification) { + fireUserStatusListeners("voiceRevoked", new Object[] {}); + } + else { + List<String> params = new ArrayList<String>(); + params.add(from); + fireParticipantStatusListeners("voiceRevoked", params); + } + } + // Moderator privileges were granted to a participant + if (!"moderator".equals(oldRole) && "moderator".equals(newRole)) { + if ("visitor".equals(oldRole) || "none".equals(oldRole)) { + if (isUserModification) { + fireUserStatusListeners("voiceGranted", new Object[] {}); + } + else { + List<String> params = new ArrayList<String>(); + params.add(from); + fireParticipantStatusListeners("voiceGranted", params); + } + } + if (isUserModification) { + fireUserStatusListeners("moderatorGranted", new Object[] {}); + } + else { + List<String> params = new ArrayList<String>(); + params.add(from); + fireParticipantStatusListeners("moderatorGranted", params); + } + } + // Moderator privileges were revoked from a participant + else if ("moderator".equals(oldRole) && !"moderator".equals(newRole)) { + if ("visitor".equals(newRole) || "none".equals(newRole)) { + if (isUserModification) { + fireUserStatusListeners("voiceRevoked", new Object[] {}); + } + else { + List<String> params = new ArrayList<String>(); + params.add(from); + fireParticipantStatusListeners("voiceRevoked", params); + } + } + if (isUserModification) { + fireUserStatusListeners("moderatorRevoked", new Object[] {}); + } + else { + List<String> params = new ArrayList<String>(); + params.add(from); + fireParticipantStatusListeners("moderatorRevoked", params); + } + } + } + + /** + * Fires notification events if the affiliation of a room occupant has changed. If the + * occupant that changed his affiliation is your occupant then the + * <code>UserStatusListeners</code> added to this <code>MultiUserChat</code> will be fired. + * On the other hand, if the occupant that changed his affiliation is not yours then the + * <code>ParticipantStatusListeners</code> added to this <code>MultiUserChat</code> will be + * fired. The following table shows the events that will be fired depending on the previous + * and new affiliation of the occupant. + * + * <pre> + * <table border="1"> + * <tr><td>Old</td><td>New</td><td>Events</td></tr> + * + * <tr><td>None</td><td>Member</td><td>membershipGranted</td></tr> + * <tr><td>Member</td><td>Admin</td><td>membershipRevoked + adminGranted</td></tr> + * <tr><td>Admin</td><td>Owner</td><td>adminRevoked + ownershipGranted</td></tr> + * + * <tr><td>None</td><td>Admin</td><td>adminGranted</td></tr> + * <tr><td>None</td><td>Owner</td><td>ownershipGranted</td></tr> + * <tr><td>Member</td><td>Owner</td><td>membershipRevoked + ownershipGranted</td></tr> + * + * <tr><td>Owner</td><td>Admin</td><td>ownershipRevoked + adminGranted</td></tr> + * <tr><td>Admin</td><td>Member</td><td>adminRevoked + membershipGranted</td></tr> + * <tr><td>Member</td><td>None</td><td>membershipRevoked</td></tr> + * + * <tr><td>Owner</td><td>Member</td><td>ownershipRevoked + membershipGranted</td></tr> + * <tr><td>Owner</td><td>None</td><td>ownershipRevoked</td></tr> + * <tr><td>Admin</td><td>None</td><td>adminRevoked</td></tr> + * <tr><td>Anyone</td><td>Outcast</td><td>banned</td></tr> + * </table> + * </pre> + * + * @param oldAffiliation the previous affiliation of the user in the room before receiving the + * new presence + * @param newAffiliation the new affiliation of the user in the room after receiving the new + * presence + * @param isUserModification whether the received presence is about your user in the room or not + * @param from the occupant whose role in the room has changed + * (e.g. room@conference.jabber.org/nick). + */ + private void checkAffiliationModifications( + String oldAffiliation, + String newAffiliation, + boolean isUserModification, + String from) { + // First check for revoked affiliation and then for granted affiliations. The idea is to + // first fire the "revoke" events and then fire the "grant" events. + + // The user's ownership to the room was revoked + if ("owner".equals(oldAffiliation) && !"owner".equals(newAffiliation)) { + if (isUserModification) { + fireUserStatusListeners("ownershipRevoked", new Object[] {}); + } + else { + List<String> params = new ArrayList<String>(); + params.add(from); + fireParticipantStatusListeners("ownershipRevoked", params); + } + } + // The user's administrative privileges to the room were revoked + else if ("admin".equals(oldAffiliation) && !"admin".equals(newAffiliation)) { + if (isUserModification) { + fireUserStatusListeners("adminRevoked", new Object[] {}); + } + else { + List<String> params = new ArrayList<String>(); + params.add(from); + fireParticipantStatusListeners("adminRevoked", params); + } + } + // The user's membership to the room was revoked + else if ("member".equals(oldAffiliation) && !"member".equals(newAffiliation)) { + if (isUserModification) { + fireUserStatusListeners("membershipRevoked", new Object[] {}); + } + else { + List<String> params = new ArrayList<String>(); + params.add(from); + fireParticipantStatusListeners("membershipRevoked", params); + } + } + + // The user was granted ownership to the room + if (!"owner".equals(oldAffiliation) && "owner".equals(newAffiliation)) { + if (isUserModification) { + fireUserStatusListeners("ownershipGranted", new Object[] {}); + } + else { + List<String> params = new ArrayList<String>(); + params.add(from); + fireParticipantStatusListeners("ownershipGranted", params); + } + } + // The user was granted administrative privileges to the room + else if (!"admin".equals(oldAffiliation) && "admin".equals(newAffiliation)) { + if (isUserModification) { + fireUserStatusListeners("adminGranted", new Object[] {}); + } + else { + List<String> params = new ArrayList<String>(); + params.add(from); + fireParticipantStatusListeners("adminGranted", params); + } + } + // The user was granted membership to the room + else if (!"member".equals(oldAffiliation) && "member".equals(newAffiliation)) { + if (isUserModification) { + fireUserStatusListeners("membershipGranted", new Object[] {}); + } + else { + List<String> params = new ArrayList<String>(); + params.add(from); + fireParticipantStatusListeners("membershipGranted", params); + } + } + } + + /** + * Fires events according to the received presence code. + * + * @param code + * @param isUserModification + * @param mucUser + * @param from + */ + private void checkPresenceCode( + String code, + boolean isUserModification, + MUCUser mucUser, + String from) { + // Check if an occupant was kicked from the room + if ("307".equals(code)) { + // Check if this occupant was kicked + if (isUserModification) { + joined = false; + + fireUserStatusListeners( + "kicked", + new Object[] { mucUser.getItem().getActor(), mucUser.getItem().getReason()}); + + // Reset occupant information. + occupantsMap.clear(); + nickname = null; + userHasLeft(); + } + else { + List<String> params = new ArrayList<String>(); + params.add(from); + params.add(mucUser.getItem().getActor()); + params.add(mucUser.getItem().getReason()); + fireParticipantStatusListeners("kicked", params); + } + } + // A user was banned from the room + else if ("301".equals(code)) { + // Check if this occupant was banned + if (isUserModification) { + joined = false; + + fireUserStatusListeners( + "banned", + new Object[] { mucUser.getItem().getActor(), mucUser.getItem().getReason()}); + + // Reset occupant information. + occupantsMap.clear(); + nickname = null; + userHasLeft(); + } + else { + List<String> params = new ArrayList<String>(); + params.add(from); + params.add(mucUser.getItem().getActor()); + params.add(mucUser.getItem().getReason()); + fireParticipantStatusListeners("banned", params); + } + } + // A user's membership was revoked from the room + else if ("321".equals(code)) { + // Check if this occupant's membership was revoked + if (isUserModification) { + joined = false; + + fireUserStatusListeners("membershipRevoked", new Object[] {}); + + // Reset occupant information. + occupantsMap.clear(); + nickname = null; + userHasLeft(); + } + } + // A occupant has changed his nickname in the room + else if ("303".equals(code)) { + List<String> params = new ArrayList<String>(); + params.add(from); + params.add(mucUser.getItem().getNick()); + fireParticipantStatusListeners("nicknameChanged", params); + } + } + + protected void finalize() throws Throwable { + try { + if (connection != null) { + roomListenerMultiplexor.removeRoom(room); + // Remove all the PacketListeners added to the connection by this chat + for (PacketListener connectionListener : connectionListeners) { + connection.removePacketListener(connectionListener); + } + } + } + catch (Exception e) { + // Do nothing + } + super.finalize(); + } + + /** + * An InvitationsMonitor monitors a given connection to detect room invitations. Every + * time the InvitationsMonitor detects a new invitation it will fire the invitation listeners. + * + * @author Gaston Dombiak + */ + private static class InvitationsMonitor implements ConnectionListener { + // We use a WeakHashMap so that the GC can collect the monitor when the + // connection is no longer referenced by any object. + private final static Map<Connection, WeakReference<InvitationsMonitor>> monitors = + new WeakHashMap<Connection, WeakReference<InvitationsMonitor>>(); + + private final List<InvitationListener> invitationsListeners = + new ArrayList<InvitationListener>(); + private Connection connection; + private PacketFilter invitationFilter; + private PacketListener invitationPacketListener; + + /** + * Returns a new or existing InvitationsMonitor for a given connection. + * + * @param conn the connection to monitor for room invitations. + * @return a new or existing InvitationsMonitor for a given connection. + */ + public static InvitationsMonitor getInvitationsMonitor(Connection conn) { + synchronized (monitors) { + if (!monitors.containsKey(conn)) { + // We need to use a WeakReference because the monitor references the + // connection and this could prevent the GC from collecting the monitor + // when no other object references the monitor + monitors.put(conn, new WeakReference<InvitationsMonitor>(new InvitationsMonitor(conn))); + } + // Return the InvitationsMonitor that monitors the connection + return monitors.get(conn).get(); + } + } + + /** + * Creates a new InvitationsMonitor that will monitor invitations received + * on a given connection. + * + * @param connection the connection to monitor for possible room invitations + */ + private InvitationsMonitor(Connection connection) { + this.connection = connection; + } + + /** + * Adds a listener to invitation notifications. The listener will be fired anytime + * an invitation is received. + * + * If this is the first monitor's listener then the monitor will be initialized in + * order to start listening to room invitations. + * + * @param listener an invitation listener. + */ + public void addInvitationListener(InvitationListener listener) { + synchronized (invitationsListeners) { + // If this is the first monitor's listener then initialize the listeners + // on the connection to detect room invitations + if (invitationsListeners.size() == 0) { + init(); + } + if (!invitationsListeners.contains(listener)) { + invitationsListeners.add(listener); + } + } + } + + /** + * Removes a listener to invitation notifications. The listener will be fired anytime + * an invitation is received. + * + * If there are no more listeners to notifiy for room invitations then the monitor will + * be stopped. As soon as a new listener is added to the monitor, the monitor will resume + * monitoring the connection for new room invitations. + * + * @param listener an invitation listener. + */ + public void removeInvitationListener(InvitationListener listener) { + synchronized (invitationsListeners) { + if (invitationsListeners.contains(listener)) { + invitationsListeners.remove(listener); + } + // If there are no more listeners to notifiy for room invitations + // then proceed to cancel/release this monitor + if (invitationsListeners.size() == 0) { + cancel(); + } + } + } + + /** + * Fires invitation listeners. + */ + private void fireInvitationListeners(String room, String inviter, String reason, String password, + Message message) { + InvitationListener[] listeners; + synchronized (invitationsListeners) { + listeners = new InvitationListener[invitationsListeners.size()]; + invitationsListeners.toArray(listeners); + } + for (InvitationListener listener : listeners) { + listener.invitationReceived(connection, room, inviter, reason, password, message); + } + } + + public void connectionClosed() { + cancel(); + } + + public void connectionClosedOnError(Exception e) { + // ignore + } + + public void reconnectingIn(int seconds) { + // ignore + } + + public void reconnectionSuccessful() { + // ignore + } + + public void reconnectionFailed(Exception e) { + // ignore + } + + /** + * Initializes the listeners to detect received room invitations and to detect when the + * connection gets closed. As soon as a room invitation is received the invitations + * listeners will be fired. When the connection gets closed the monitor will remove + * his listeners on the connection. + */ + private void init() { + // Listens for all messages that include a MUCUser extension and fire the invitation + // listeners if the message includes an invitation. + invitationFilter = + new PacketExtensionFilter("x", "http://jabber.org/protocol/muc#user"); + invitationPacketListener = new PacketListener() { + public void processPacket(Packet packet) { + // Get the MUCUser extension + MUCUser mucUser = + (MUCUser) packet.getExtension("x", "http://jabber.org/protocol/muc#user"); + // Check if the MUCUser extension includes an invitation + if (mucUser.getInvite() != null && + ((Message) packet).getType() != Message.Type.error) { + // Fire event for invitation listeners + fireInvitationListeners(packet.getFrom(), mucUser.getInvite().getFrom(), + mucUser.getInvite().getReason(), mucUser.getPassword(), (Message) packet); + } + } + }; + connection.addPacketListener(invitationPacketListener, invitationFilter); + // Add a listener to detect when the connection gets closed in order to + // cancel/release this monitor + connection.addConnectionListener(this); + } + + /** + * Cancels all the listeners that this InvitationsMonitor has added to the connection. + */ + private void cancel() { + connection.removePacketListener(invitationPacketListener); + connection.removeConnectionListener(this); + } + + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/Occupant.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/Occupant.java new file mode 100644 index 0000000..3b199a5 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/Occupant.java @@ -0,0 +1,121 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.muc; + +import org.jivesoftware.smackx.packet.MUCAdmin; +import org.jivesoftware.smackx.packet.MUCUser; +import org.jivesoftware.smack.packet.Presence; +import org.jivesoftware.smack.util.StringUtils; + +/** + * Represents the information about an occupant in a given room. The information will always have + * the affiliation and role of the occupant in the room. The full JID and nickname are optional. + * + * @author Gaston Dombiak + */ +public class Occupant { + // Fields that must have a value + private String affiliation; + private String role; + // Fields that may have a value + private String jid; + private String nick; + + Occupant(MUCAdmin.Item item) { + super(); + this.jid = item.getJid(); + this.affiliation = item.getAffiliation(); + this.role = item.getRole(); + this.nick = item.getNick(); + } + + Occupant(Presence presence) { + super(); + MUCUser mucUser = (MUCUser) presence.getExtension("x", + "http://jabber.org/protocol/muc#user"); + MUCUser.Item item = mucUser.getItem(); + this.jid = item.getJid(); + this.affiliation = item.getAffiliation(); + this.role = item.getRole(); + // Get the nickname from the FROM attribute of the presence + this.nick = StringUtils.parseResource(presence.getFrom()); + } + + /** + * Returns the full JID of the occupant. If this information was extracted from a presence and + * the room is semi or full-anonymous then the answer will be null. On the other hand, if this + * information was obtained while maintaining the voice list or the moderator list then we will + * always have a full JID. + * + * @return the full JID of the occupant. + */ + public String getJid() { + return jid; + } + + /** + * Returns the affiliation of the occupant. Possible affiliations are: "owner", "admin", + * "member", "outcast". This information will always be available. + * + * @return the affiliation of the occupant. + */ + public String getAffiliation() { + return affiliation; + } + + /** + * Returns the current role of the occupant in the room. This information will always be + * available. + * + * @return the current role of the occupant in the room. + */ + public String getRole() { + return role; + } + + /** + * Returns the current nickname of the occupant in the room. If this information was extracted + * from a presence then the answer will be null. + * + * @return the current nickname of the occupant in the room or null if this information was + * obtained from a presence. + */ + public String getNick() { + return nick; + } + + public boolean equals(Object obj) { + if(!(obj instanceof Occupant)) { + return false; + } + Occupant occupant = (Occupant)obj; + return jid.equals(occupant.jid); + } + + public int hashCode() { + int result; + result = affiliation.hashCode(); + result = 17 * result + role.hashCode(); + result = 17 * result + jid.hashCode(); + result = 17 * result + (nick != null ? nick.hashCode() : 0); + return result; + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/PacketMultiplexListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/PacketMultiplexListener.java new file mode 100644 index 0000000..c1863c2 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/PacketMultiplexListener.java @@ -0,0 +1,96 @@ +/** + * $RCSfile$ + * $Revision: 2779 $ + * $Date: 2005-09-05 17:00:45 -0300 (Mon, 05 Sep 2005) $ + * + * Copyright 2003-2006 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.smackx.muc; + +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.filter.MessageTypeFilter; +import org.jivesoftware.smack.filter.PacketExtensionFilter; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.filter.PacketTypeFilter; +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.packet.Presence; + +/** + * The single <code>PacketListener</code> used by each {@link MultiUserChat} + * for all basic processing of presence, and message packets targeted to that chat. + * + * @author Larry Kirschner + */ +class PacketMultiplexListener implements PacketListener { + + private static final PacketFilter MESSAGE_FILTER = + new MessageTypeFilter(Message.Type.groupchat); + private static final PacketFilter PRESENCE_FILTER = new PacketTypeFilter(Presence.class); + private static final PacketFilter SUBJECT_FILTER = new PacketFilter() { + public boolean accept(Packet packet) { + Message msg = (Message) packet; + return msg.getSubject() != null; + } + }; + private static final PacketFilter DECLINES_FILTER = + new PacketExtensionFilter("x", + "http://jabber.org/protocol/muc#user"); + + private ConnectionDetachedPacketCollector messageCollector; + private PacketListener presenceListener; + private PacketListener subjectListener; + private PacketListener declinesListener; + + public PacketMultiplexListener( + ConnectionDetachedPacketCollector messageCollector, + PacketListener presenceListener, + PacketListener subjectListener, PacketListener declinesListener) { + if (messageCollector == null) { + throw new IllegalArgumentException("MessageCollector is null"); + } + if (presenceListener == null) { + throw new IllegalArgumentException("Presence listener is null"); + } + if (subjectListener == null) { + throw new IllegalArgumentException("Subject listener is null"); + } + if (declinesListener == null) { + throw new IllegalArgumentException("Declines listener is null"); + } + this.messageCollector = messageCollector; + this.presenceListener = presenceListener; + this.subjectListener = subjectListener; + this.declinesListener = declinesListener; + } + + public void processPacket(Packet p) { + if (PRESENCE_FILTER.accept(p)) { + presenceListener.processPacket(p); + } + else if (MESSAGE_FILTER.accept(p)) { + messageCollector.processPacket(p); + + if (SUBJECT_FILTER.accept(p)) { + subjectListener.processPacket(p); + } + } + else if (DECLINES_FILTER.accept(p)) { + declinesListener.processPacket(p); + } + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/ParticipantStatusListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/ParticipantStatusListener.java new file mode 100644 index 0000000..c3e248d --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/ParticipantStatusListener.java @@ -0,0 +1,179 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.muc; + +/** + * A listener that is fired anytime a participant's status in a room is changed, such as the + * user being kicked, banned, or granted admin permissions. + * + * @author Gaston Dombiak + */ +public interface ParticipantStatusListener { + + /** + * Called when a new room occupant has joined the room. Note: Take in consideration that when + * you join a room you will receive the list of current occupants in the room. This message will + * be sent for each occupant. + * + * @param participant the participant that has just joined the room + * (e.g. room@conference.jabber.org/nick). + */ + public abstract void joined(String participant); + + /** + * Called when a room occupant has left the room on its own. This means that the occupant was + * neither kicked nor banned from the room. + * + * @param participant the participant that has left the room on its own. + * (e.g. room@conference.jabber.org/nick). + */ + public abstract void left(String participant); + + /** + * Called when a room participant has been kicked from the room. This means that the kicked + * participant is no longer participating in the room. + * + * @param participant the participant that was kicked from the room + * (e.g. room@conference.jabber.org/nick). + * @param actor the moderator that kicked the occupant from the room (e.g. user@host.org). + * @param reason the reason provided by the actor to kick the occupant from the room. + */ + public abstract void kicked(String participant, String actor, String reason); + + /** + * Called when a moderator grants voice to a visitor. This means that the visitor + * can now participate in the moderated room sending messages to all occupants. + * + * @param participant the participant that was granted voice in the room + * (e.g. room@conference.jabber.org/nick). + */ + public abstract void voiceGranted(String participant); + + /** + * Called when a moderator revokes voice from a participant. This means that the participant + * in the room was able to speak and now is a visitor that can't send messages to the room + * occupants. + * + * @param participant the participant that was revoked voice from the room + * (e.g. room@conference.jabber.org/nick). + */ + public abstract void voiceRevoked(String participant); + + /** + * Called when an administrator or owner banned a participant from the room. This means that + * banned participant will no longer be able to join the room unless the ban has been removed. + * + * @param participant the participant that was banned from the room + * (e.g. room@conference.jabber.org/nick). + * @param actor the administrator that banned the occupant (e.g. user@host.org). + * @param reason the reason provided by the administrator to ban the occupant. + */ + public abstract void banned(String participant, String actor, String reason); + + /** + * Called when an administrator grants a user membership to the room. This means that the user + * will be able to join the members-only room. + * + * @param participant the participant that was granted membership in the room + * (e.g. room@conference.jabber.org/nick). + */ + public abstract void membershipGranted(String participant); + + /** + * Called when an administrator revokes a user membership to the room. This means that the + * user will not be able to join the members-only room. + * + * @param participant the participant that was revoked membership from the room + * (e.g. room@conference.jabber.org/nick). + */ + public abstract void membershipRevoked(String participant); + + /** + * Called when an administrator grants moderator privileges to a user. This means that the user + * will be able to kick users, grant and revoke voice, invite other users, modify room's + * subject plus all the partcipants privileges. + * + * @param participant the participant that was granted moderator privileges in the room + * (e.g. room@conference.jabber.org/nick). + */ + public abstract void moderatorGranted(String participant); + + /** + * Called when an administrator revokes moderator privileges from a user. This means that the + * user will no longer be able to kick users, grant and revoke voice, invite other users, + * modify room's subject plus all the partcipants privileges. + * + * @param participant the participant that was revoked moderator privileges in the room + * (e.g. room@conference.jabber.org/nick). + */ + public abstract void moderatorRevoked(String participant); + + /** + * Called when an owner grants a user ownership on the room. This means that the user + * will be able to change defining room features as well as perform all administrative + * functions. + * + * @param participant the participant that was granted ownership on the room + * (e.g. room@conference.jabber.org/nick). + */ + public abstract void ownershipGranted(String participant); + + /** + * Called when an owner revokes a user ownership on the room. This means that the user + * will no longer be able to change defining room features as well as perform all + * administrative functions. + * + * @param participant the participant that was revoked ownership on the room + * (e.g. room@conference.jabber.org/nick). + */ + public abstract void ownershipRevoked(String participant); + + /** + * Called when an owner grants administrator privileges to a user. This means that the user + * will be able to perform administrative functions such as banning users and edit moderator + * list. + * + * @param participant the participant that was granted administrator privileges + * (e.g. room@conference.jabber.org/nick). + */ + public abstract void adminGranted(String participant); + + /** + * Called when an owner revokes administrator privileges from a user. This means that the user + * will no longer be able to perform administrative functions such as banning users and edit + * moderator list. + * + * @param participant the participant that was revoked administrator privileges + * (e.g. room@conference.jabber.org/nick). + */ + public abstract void adminRevoked(String participant); + + /** + * Called when a participant changed his/her nickname in the room. The new participant's + * nickname will be informed with the next available presence. + * + * @param participant the participant that was revoked administrator privileges + * (e.g. room@conference.jabber.org/nick). + * @param newNickname the new nickname that the participant decided to use. + */ + public abstract void nicknameChanged(String participant, String newNickname); + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/RoomInfo.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/RoomInfo.java new file mode 100644 index 0000000..f97f544 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/RoomInfo.java @@ -0,0 +1,190 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.muc; + +import org.jivesoftware.smackx.Form; +import org.jivesoftware.smackx.FormField; +import org.jivesoftware.smackx.packet.DiscoverInfo; + +import java.util.Iterator; + +/** + * Represents the room information that was discovered using Service Discovery. It's possible to + * obtain information about a room before joining the room but only for rooms that are public (i.e. + * rooms that may be discovered). + * + * @author Gaston Dombiak + */ +public class RoomInfo { + + /** + * JID of the room. The node of the JID is commonly used as the ID of the room or name. + */ + private String room; + /** + * Description of the room. + */ + private String description = ""; + /** + * Last known subject of the room. + */ + private String subject = ""; + /** + * Current number of occupants in the room. + */ + private int occupantsCount = -1; + /** + * A room is considered members-only if an invitation is required in order to enter the room. + * Any user that is not a member of the room won't be able to join the room unless the user + * decides to register with the room (thus becoming a member). + */ + private boolean membersOnly; + /** + * Moderated rooms enable only participants to speak. Users that join the room and aren't + * participants can't speak (they are just visitors). + */ + private boolean moderated; + /** + * Every presence packet can include the JID of every occupant unless the owner deactives this + * configuration. + */ + private boolean nonanonymous; + /** + * Indicates if users must supply a password to join the room. + */ + private boolean passwordProtected; + /** + * Persistent rooms are saved to the database to make sure that rooms configurations can be + * restored in case the server goes down. + */ + private boolean persistent; + + RoomInfo(DiscoverInfo info) { + super(); + this.room = info.getFrom(); + // Get the information based on the discovered features + this.membersOnly = info.containsFeature("muc_membersonly"); + this.moderated = info.containsFeature("muc_moderated"); + this.nonanonymous = info.containsFeature("muc_nonanonymous"); + this.passwordProtected = info.containsFeature("muc_passwordprotected"); + this.persistent = info.containsFeature("muc_persistent"); + // Get the information based on the discovered extended information + Form form = Form.getFormFrom(info); + if (form != null) { + FormField descField = form.getField("muc#roominfo_description"); + this.description = ( descField == null || !(descField.getValues().hasNext()) )? "" : descField.getValues().next(); + + FormField subjField = form.getField("muc#roominfo_subject"); + this.subject = ( subjField == null || !(subjField.getValues().hasNext()) ) ? "" : subjField.getValues().next(); + + FormField occCountField = form.getField("muc#roominfo_occupants"); + this.occupantsCount = occCountField == null ? -1 : Integer.parseInt(occCountField.getValues() + .next()); + } + } + + /** + * Returns the JID of the room whose information was discovered. + * + * @return the JID of the room whose information was discovered. + */ + public String getRoom() { + return room; + } + + /** + * Returns the discovered description of the room. + * + * @return the discovered description of the room. + */ + public String getDescription() { + return description; + } + + /** + * Returns the discovered subject of the room. The subject may be empty if the room does not + * have a subject. + * + * @return the discovered subject of the room. + */ + public String getSubject() { + return subject; + } + + /** + * Returns the discovered number of occupants that are currently in the room. If this + * information was not discovered (i.e. the server didn't send it) then a value of -1 will be + * returned. + * + * @return the number of occupants that are currently in the room or -1 if that information was + * not provided by the server. + */ + public int getOccupantsCount() { + return occupantsCount; + } + + /** + * Returns true if the room has restricted the access so that only members may enter the room. + * + * @return true if the room has restricted the access so that only members may enter the room. + */ + public boolean isMembersOnly() { + return membersOnly; + } + + /** + * Returns true if the room enabled only participants to speak. Occupants with a role of + * visitor won't be able to speak in the room. + * + * @return true if the room enabled only participants to speak. + */ + public boolean isModerated() { + return moderated; + } + + /** + * Returns true if presence packets will include the JID of every occupant. + * + * @return true if presence packets will include the JID of every occupant. + */ + public boolean isNonanonymous() { + return nonanonymous; + } + + /** + * Returns true if users musy provide a valid password in order to join the room. + * + * @return true if users musy provide a valid password in order to join the room. + */ + public boolean isPasswordProtected() { + return passwordProtected; + } + + /** + * Returns true if the room will persist after the last occupant have left the room. + * + * @return true if the room will persist after the last occupant have left the room. + */ + public boolean isPersistent() { + return persistent; + } + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/RoomListenerMultiplexor.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/RoomListenerMultiplexor.java new file mode 100644 index 0000000..6f8bf05 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/RoomListenerMultiplexor.java @@ -0,0 +1,227 @@ +/** + * $RCSfile$ + * $Revision: 2779 $ + * $Date: 2005-09-05 17:00:45 -0300 (Mon, 05 Sep 2005) $ + * + * Copyright 2003-2006 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.smackx.muc; + +import org.jivesoftware.smack.ConnectionListener; +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.filter.PacketFilter; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.util.StringUtils; + +import java.lang.ref.WeakReference; +import java.util.Map; +import java.util.WeakHashMap; +import java.util.concurrent.ConcurrentHashMap; + +/** + * A <code>RoomListenerMultiplexor</code> multiplexes incoming packets on + * a <code>Connection</code> using a single listener/filter pair. + * A single <code>RoomListenerMultiplexor</code> is created for each + * {@link org.jivesoftware.smack.Connection} that has joined MUC rooms + * within its session. + * + * @author Larry Kirschner + */ +class RoomListenerMultiplexor implements ConnectionListener { + + // We use a WeakHashMap so that the GC can collect the monitor when the + // connection is no longer referenced by any object. + private static final Map<Connection, WeakReference<RoomListenerMultiplexor>> monitors = + new WeakHashMap<Connection, WeakReference<RoomListenerMultiplexor>>(); + + private Connection connection; + private RoomMultiplexFilter filter; + private RoomMultiplexListener listener; + + /** + * Returns a new or existing RoomListenerMultiplexor for a given connection. + * + * @param conn the connection to monitor for room invitations. + * @return a new or existing RoomListenerMultiplexor for a given connection. + */ + public static RoomListenerMultiplexor getRoomMultiplexor(Connection conn) { + synchronized (monitors) { + if (!monitors.containsKey(conn) || monitors.get(conn).get() == null) { + RoomListenerMultiplexor rm = new RoomListenerMultiplexor(conn, new RoomMultiplexFilter(), + new RoomMultiplexListener()); + + rm.init(); + + // We need to use a WeakReference because the monitor references the + // connection and this could prevent the GC from collecting the monitor + // when no other object references the monitor + monitors.put(conn, new WeakReference<RoomListenerMultiplexor>(rm)); + } + // Return the InvitationsMonitor that monitors the connection + return monitors.get(conn).get(); + } + } + + /** + * All access should be through + * the static method {@link #getRoomMultiplexor(Connection)}. + */ + private RoomListenerMultiplexor(Connection connection, RoomMultiplexFilter filter, + RoomMultiplexListener listener) { + if (connection == null) { + throw new IllegalArgumentException("Connection is null"); + } + if (filter == null) { + throw new IllegalArgumentException("Filter is null"); + } + if (listener == null) { + throw new IllegalArgumentException("Listener is null"); + } + this.connection = connection; + this.filter = filter; + this.listener = listener; + } + + public void addRoom(String address, PacketMultiplexListener roomListener) { + filter.addRoom(address); + listener.addRoom(address, roomListener); + } + + public void connectionClosed() { + cancel(); + } + + public void connectionClosedOnError(Exception e) { + cancel(); + } + + public void reconnectingIn(int seconds) { + // ignore + } + + public void reconnectionSuccessful() { + // ignore + } + + public void reconnectionFailed(Exception e) { + // ignore + } + + /** + * Initializes the listeners to detect received room invitations and to detect when the + * connection gets closed. As soon as a room invitation is received the invitations + * listeners will be fired. When the connection gets closed the monitor will remove + * his listeners on the connection. + */ + public void init() { + connection.addConnectionListener(this); + connection.addPacketListener(listener, filter); + } + + public void removeRoom(String address) { + filter.removeRoom(address); + listener.removeRoom(address); + } + + /** + * Cancels all the listeners that this InvitationsMonitor has added to the connection. + */ + private void cancel() { + connection.removeConnectionListener(this); + connection.removePacketListener(listener); + } + + /** + * The single <code>Connection</code>-level <code>PacketFilter</code> used by a {@link RoomListenerMultiplexor} + * for all muc chat rooms on an <code>Connection</code>. + * Each time a muc chat room is added to/removed from an + * <code>Connection</code> the address for that chat room + * is added to/removed from that <code>Connection</code>'s + * <code>RoomMultiplexFilter</code>. + */ + private static class RoomMultiplexFilter implements PacketFilter { + + private Map<String, String> roomAddressTable = new ConcurrentHashMap<String, String>(); + + public boolean accept(Packet p) { + String from = p.getFrom(); + if (from == null) { + return false; + } + return roomAddressTable.containsKey(StringUtils.parseBareAddress(from).toLowerCase()); + } + + public void addRoom(String address) { + if (address == null) { + return; + } + roomAddressTable.put(address.toLowerCase(), address); + } + + public void removeRoom(String address) { + if (address == null) { + return; + } + roomAddressTable.remove(address.toLowerCase()); + } + } + + /** + * The single <code>Connection</code>-level <code>PacketListener</code> + * used by a {@link RoomListenerMultiplexor} + * for all muc chat rooms on an <code>Connection</code>. + * Each time a muc chat room is added to/removed from an + * <code>Connection</code> the address and listener for that chat room + * are added to/removed from that <code>Connection</code>'s + * <code>RoomMultiplexListener</code>. + * + * @author Larry Kirschner + */ + private static class RoomMultiplexListener implements PacketListener { + + private Map<String, PacketMultiplexListener> roomListenersByAddress = + new ConcurrentHashMap<String, PacketMultiplexListener>(); + + public void processPacket(Packet p) { + String from = p.getFrom(); + if (from == null) { + return; + } + + PacketMultiplexListener listener = + roomListenersByAddress.get(StringUtils.parseBareAddress(from).toLowerCase()); + + if (listener != null) { + listener.processPacket(p); + } + } + + public void addRoom(String address, PacketMultiplexListener listener) { + if (address == null) { + return; + } + roomListenersByAddress.put(address.toLowerCase(), listener); + } + + public void removeRoom(String address) { + if (address == null) { + return; + } + roomListenersByAddress.remove(address.toLowerCase()); + } + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/SubjectUpdatedListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/SubjectUpdatedListener.java new file mode 100644 index 0000000..3a2deab --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/SubjectUpdatedListener.java @@ -0,0 +1,38 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.muc; + +/** + * A listener that is fired anytime a MUC room changes its subject. + * + * @author Gaston Dombiak + */ +public interface SubjectUpdatedListener { + + /** + * Called when a MUC room has changed its subject. + * + * @param subject the new room's subject. + * @param from the user that changed the room's subject (e.g. room@conference.jabber.org/nick). + */ + public abstract void subjectUpdated(String subject, String from); + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/UserStatusListener.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/UserStatusListener.java new file mode 100644 index 0000000..27f0f58 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/UserStatusListener.java @@ -0,0 +1,127 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.muc; + +/** + * A listener that is fired anytime your participant's status in a room is changed, such as the + * user being kicked, banned, or granted admin permissions. + * + * @author Gaston Dombiak + */ +public interface UserStatusListener { + + /** + * Called when a moderator kicked your user from the room. This means that you are no longer + * participanting in the room. + * + * @param actor the moderator that kicked your user from the room (e.g. user@host.org). + * @param reason the reason provided by the actor to kick you from the room. + */ + public abstract void kicked(String actor, String reason); + + /** + * Called when a moderator grants voice to your user. This means that you were a visitor in + * the moderated room before and now you can participate in the room by sending messages to + * all occupants. + * + */ + public abstract void voiceGranted(); + + /** + * Called when a moderator revokes voice from your user. This means that you were a + * participant in the room able to speak and now you are a visitor that can't send + * messages to the room occupants. + * + */ + public abstract void voiceRevoked(); + + /** + * Called when an administrator or owner banned your user from the room. This means that you + * will no longer be able to join the room unless the ban has been removed. + * + * @param actor the administrator that banned your user (e.g. user@host.org). + * @param reason the reason provided by the administrator to banned you. + */ + public abstract void banned(String actor, String reason); + + /** + * Called when an administrator grants your user membership to the room. This means that you + * will be able to join the members-only room. + * + */ + public abstract void membershipGranted(); + + /** + * Called when an administrator revokes your user membership to the room. This means that you + * will not be able to join the members-only room. + * + */ + public abstract void membershipRevoked(); + + /** + * Called when an administrator grants moderator privileges to your user. This means that you + * will be able to kick users, grant and revoke voice, invite other users, modify room's + * subject plus all the partcipants privileges. + * + */ + public abstract void moderatorGranted(); + + /** + * Called when an administrator revokes moderator privileges from your user. This means that + * you will no longer be able to kick users, grant and revoke voice, invite other users, + * modify room's subject plus all the partcipants privileges. + * + */ + public abstract void moderatorRevoked(); + + /** + * Called when an owner grants to your user ownership on the room. This means that you + * will be able to change defining room features as well as perform all administrative + * functions. + * + */ + public abstract void ownershipGranted(); + + /** + * Called when an owner revokes from your user ownership on the room. This means that you + * will no longer be able to change defining room features as well as perform all + * administrative functions. + * + */ + public abstract void ownershipRevoked(); + + /** + * Called when an owner grants administrator privileges to your user. This means that you + * will be able to perform administrative functions such as banning users and edit moderator + * list. + * + */ + public abstract void adminGranted(); + + /** + * Called when an owner revokes administrator privileges from your user. This means that you + * will no longer be able to perform administrative functions such as banning users and edit + * moderator list. + * + */ + public abstract void adminRevoked(); + +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/package.html b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/package.html new file mode 100644 index 0000000..dcfaeaa --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/muc/package.html @@ -0,0 +1 @@ +<body>Classes and Interfaces that implement Multi-User Chat (MUC).</body> \ No newline at end of file diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/package.html b/external/asmack/build/src/trunk/org/jivesoftware/smackx/package.html new file mode 100644 index 0000000..d574a2a --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/package.html @@ -0,0 +1 @@ +<body>Smack extensions API.</body> \ No newline at end of file diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/AdHocCommandData.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/AdHocCommandData.java new file mode 100755 index 0000000..d0b49af --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/AdHocCommandData.java @@ -0,0 +1,279 @@ +/** + * $RCSfile$ + * $Revision: $ + * $Date: $ + * + * Copyright 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.smackx.packet; + +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.PacketExtension; +import org.jivesoftware.smackx.commands.AdHocCommand; +import org.jivesoftware.smackx.commands.AdHocCommand.Action; +import org.jivesoftware.smackx.commands.AdHocCommand.SpecificErrorCondition; +import org.jivesoftware.smackx.commands.AdHocCommandNote; + +import java.util.ArrayList; +import java.util.List; + +/** + * Represents the state and the request of the execution of an adhoc command. + * + * @author Gabriel Guardincerri + */ +public class AdHocCommandData extends IQ { + + /* JID of the command host */ + private String id; + + /* Command name */ + private String name; + + /* Command identifier */ + private String node; + + /* Unique ID of the execution */ + private String sessionID; + + private List<AdHocCommandNote> notes = new ArrayList<AdHocCommandNote>(); + + private DataForm form; + + /* Action request to be executed */ + private AdHocCommand.Action action; + + /* Current execution status */ + private AdHocCommand.Status status; + + private ArrayList<AdHocCommand.Action> actions = new ArrayList<AdHocCommand.Action>(); + + private AdHocCommand.Action executeAction; + + private String lang; + + public AdHocCommandData() { + } + + @Override + public String getChildElementXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<command xmlns=\"http://jabber.org/protocol/commands\""); + buf.append(" node=\"").append(node).append("\""); + if (sessionID != null) { + if (!sessionID.equals("")) { + buf.append(" sessionid=\"").append(sessionID).append("\""); + } + } + if (status != null) { + buf.append(" status=\"").append(status).append("\""); + } + if (action != null) { + buf.append(" action=\"").append(action).append("\""); + } + + if (lang != null) { + if (!lang.equals("")) { + buf.append(" lang=\"").append(lang).append("\""); + } + } + buf.append(">"); + + if (getType() == Type.RESULT) { + buf.append("<actions"); + + if (executeAction != null) { + buf.append(" execute=\"").append(executeAction).append("\""); + } + if (actions.size() == 0) { + buf.append("/>"); + } else { + buf.append(">"); + + for (AdHocCommand.Action action : actions) { + buf.append("<").append(action).append("/>"); + } + buf.append("</actions>"); + } + } + + if (form != null) { + buf.append(form.toXML()); + } + + for (AdHocCommandNote note : notes) { + buf.append("<note type=\"").append(note.getType().toString()).append("\">"); + buf.append(note.getValue()); + buf.append("</note>"); + } + + // TODO ERRORS +// if (getError() != null) { +// buf.append(getError().toXML()); +// } + + buf.append("</command>"); + return buf.toString(); + } + + /** + * Returns the JID of the command host. + * + * @return the JID of the command host. + */ + public String getId() { + return id; + } + + public void setId(String id) { + this.id = id; + } + + /** + * Returns the human name of the command + * + * @return the name of the command. + */ + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + /** + * Returns the identifier of the command + * + * @return the node. + */ + public String getNode() { + return node; + } + + public void setNode(String node) { + this.node = node; + } + + /** + * Returns the list of notes that the command has. + * + * @return the notes. + */ + public List<AdHocCommandNote> getNotes() { + return notes; + } + + public void addNote(AdHocCommandNote note) { + this.notes.add(note); + } + + public void remveNote(AdHocCommandNote note) { + this.notes.remove(note); + } + + /** + * Returns the form of the command. + * + * @return the data form associated with the command. + */ + public DataForm getForm() { + return form; + } + + public void setForm(DataForm form) { + this.form = form; + } + + /** + * Returns the action to execute. The action is set only on a request. + * + * @return the action to execute. + */ + public AdHocCommand.Action getAction() { + return action; + } + + public void setAction(AdHocCommand.Action action) { + this.action = action; + } + + /** + * Returns the status of the execution. + * + * @return the status. + */ + public AdHocCommand.Status getStatus() { + return status; + } + + public void setStatus(AdHocCommand.Status status) { + this.status = status; + } + + public List<Action> getActions() { + return actions; + } + + public void addAction(Action action) { + actions.add(action); + } + + public void setExecuteAction(Action executeAction) { + this.executeAction = executeAction; + } + + public Action getExecuteAction() { + return executeAction; + } + + public void setSessionID(String sessionID) { + this.sessionID = sessionID; + } + + public String getSessionID() { + return sessionID; + } + + public static class SpecificError implements PacketExtension { + + public static final String namespace = "http://jabber.org/protocol/commands"; + + public SpecificErrorCondition condition; + + public SpecificError(SpecificErrorCondition condition) { + this.condition = condition; + } + + public String getElementName() { + return condition.toString(); + } + public String getNamespace() { + return namespace; + } + + public SpecificErrorCondition getCondition() { + return condition; + } + + public String toXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<").append(getElementName()); + buf.append(" xmlns=\"").append(getNamespace()).append("\"/>"); + return buf.toString(); + } + } +} \ No newline at end of file diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/AttentionExtension.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/AttentionExtension.java new file mode 100644 index 0000000..d86fa41 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/AttentionExtension.java @@ -0,0 +1,100 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2010 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.smackx.packet; + +import org.jivesoftware.smack.packet.PacketExtension; +import org.jivesoftware.smack.provider.PacketExtensionProvider; +import org.xmlpull.v1.XmlPullParser; + +/** + * A PacketExtension that implements XEP-0224: Attention + * + * This extension is expected to be added to message stanzas of type 'headline.' + * Please refer to the XEP for more implementation guidelines. + * + * @author Guus der Kinderen, guus.der.kinderen@gmail.com + * @see <a + * href="http://xmpp.org/extensions/xep-0224.html">XEP-0224: Attention</a> + */ +public class AttentionExtension implements PacketExtension { + + /** + * The XML element name of an 'attention' extension. + */ + public static final String ELEMENT_NAME = "attention"; + + /** + * The namespace that qualifies the XML element of an 'attention' extension. + */ + public static final String NAMESPACE = "urn:xmpp:attention:0"; + + /* + * (non-Javadoc) + * + * @see org.jivesoftware.smack.packet.PacketExtension#getElementName() + */ + public String getElementName() { + return ELEMENT_NAME; + } + + /* + * (non-Javadoc) + * + * @see org.jivesoftware.smack.packet.PacketExtension#getNamespace() + */ + public String getNamespace() { + return NAMESPACE; + } + + /* + * (non-Javadoc) + * + * @see org.jivesoftware.smack.packet.PacketExtension#toXML() + */ + public String toXML() { + final StringBuilder sb = new StringBuilder(); + sb.append("<").append(getElementName()).append(" xmlns=\"").append( + getNamespace()).append("\"/>"); + return sb.toString(); + } + + /** + * A {@link PacketExtensionProvider} for the {@link AttentionExtension}. As + * Attention elements have no state/information other than the element name + * and namespace, this implementation simply returns new instances of + * {@link AttentionExtension}. + * + * @author Guus der Kinderen, guus.der.kinderen@gmail.com +s */ + public static class Provider implements PacketExtensionProvider { + + /* + * (non-Javadoc) + * + * @see + * org.jivesoftware.smack.provider.PacketExtensionProvider#parseExtension + * (org.xmlpull.v1.XmlPullParser) + */ + public PacketExtension parseExtension(XmlPullParser arg0) + throws Exception { + return new AttentionExtension(); + } + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/CapsExtension.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/CapsExtension.java new file mode 100644 index 0000000..a7fc144 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/CapsExtension.java @@ -0,0 +1,83 @@ +/* + * Copyright 2009 Jonas Ådahl. + * + * 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.smackx.packet; + +import org.jivesoftware.smack.packet.PacketExtension; + +public class CapsExtension implements PacketExtension { + + private String node, version, hash; + public static final String XMLNS = "http://jabber.org/protocol/caps"; + public static final String NODE_NAME = "c"; + + public CapsExtension() { + } + + public CapsExtension(String node, String version, String hash) { + this.node = node; + this.version = version; + this.hash = hash; + } + + public String getElementName() { + return NODE_NAME; + } + + public String getNamespace() { + return XMLNS; + } + + public String getNode() { + return node; + } + + public void setNode(String node) { + this.node = node; + } + + public String getVersion() { + return version; + } + + public void setVersion(String version) { + this.version = version; + } + + public String getHash() { + return hash; + } + + public void setHash(String hash) { + this.hash = hash; + } + + /* + * <c xmlns='http://jabber.org/protocol/caps' + * hash='sha-1' + * node='http://code.google.com/p/exodus' + * ver='QgayPKawpkPSDYmwT/WM94uAlu0='/> + * + */ + public String toXML() { + String xml = "<c xmlns='" + XMLNS + "' " + + "hash='" + hash + "' " + + "node='" + node + "' " + + "ver='" + version + "'/>"; + + return xml; + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/ChatStateExtension.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/ChatStateExtension.java new file mode 100644 index 0000000..ecc6acc --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/ChatStateExtension.java @@ -0,0 +1,73 @@ +/** + * $RCSfile$ + * $Revision: 2407 $ + * $Date: 2004-11-02 15:37:00 -0800 (Tue, 02 Nov 2004) $ + * + * Copyright 2003-2007 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.smackx.packet; + +import org.jivesoftware.smackx.ChatState; +import org.jivesoftware.smack.packet.PacketExtension; +import org.jivesoftware.smack.provider.PacketExtensionProvider; +import org.xmlpull.v1.XmlPullParser; + +/** + * Represents a chat state which is an extension to message packets which is used to indicate + * the current status of a chat participant. + * + * @author Alexander Wenckus + * @see org.jivesoftware.smackx.ChatState + */ +public class ChatStateExtension implements PacketExtension { + + private ChatState state; + + /** + * Default constructor. The argument provided is the state that the extension will represent. + * + * @param state the state that the extension represents. + */ + public ChatStateExtension(ChatState state) { + this.state = state; + } + + public String getElementName() { + return state.name(); + } + + public String getNamespace() { + return "http://jabber.org/protocol/chatstates"; + } + + public String toXML() { + return "<" + getElementName() + " xmlns=\"" + getNamespace() + "\" />"; + } + + public static class Provider implements PacketExtensionProvider { + + public PacketExtension parseExtension(XmlPullParser parser) throws Exception { + ChatState state; + try { + state = ChatState.valueOf(parser.getName()); + } + catch (Exception ex) { + state = ChatState.active; + } + return new ChatStateExtension(state); + } + } +} diff --git a/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/DataForm.java b/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/DataForm.java new file mode 100644 index 0000000..c0c2630 --- /dev/null +++ b/external/asmack/build/src/trunk/org/jivesoftware/smackx/packet/DataForm.java @@ -0,0 +1,296 @@ +/** + * $RCSfile$ + * $Revision$ + * $Date$ + * + * Copyright 2003-2007 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.smackx.packet; + +import org.jivesoftware.smack.packet.PacketExtension; +import org.jivesoftware.smackx.FormField; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; + +/** + * Represents a form that could be use for gathering data as well as for reporting data + * returned from a search. + * + * @author Gaston Dombiak + */ +public class DataForm implements PacketExtension { + + private String type; + private String title; + private List<String> instructions = new ArrayList<String>(); + private ReportedData reportedData; + private final List<Item> items = new ArrayList<Item>(); + private final List<FormField> fields = new ArrayList<FormField>(); + + public DataForm(String type) { + this.type = type; + } + + /** + * Returns the meaning of the data within the context. The data could be part of a form + * to fill out, a form submission or data results. + * + * Possible form types are: + * <ul> + * <li>form -> This packet contains a form to fill out. Display it to the user (if your + * program can).</li> + * <li>submit -> The form is filled out, and this is the data that is being returned from + * the form.</li> + * <li>cancel -> The form was cancelled. Tell the asker that piece of information.</li> + * <li>result -> Data results being returned from a search, or some other query.</li> + * </ul> + * + * @return the form's type. + */ + public String getType() { + return type; + } + + /** + * Returns the description of the data. It is similar to the title on a web page or an X + * window. You can put a <title/> on either a form to fill out, or a set of data results. + * + * @return description of the data. + */ + public String getTitle() { + return title; + } + + /** + * Returns an Iterator for the list of instructions that explain how to fill out the form and + * what the form is about. The dataform could include multiple instructions since each + * instruction could not contain newlines characters. Join the instructions together in order + * to show them to the user. + * + * @return an Iterator for the list of instructions that explain how to fill out the form. + */ + public Iterator<String> getInstructions() { + synchronized (instructions) { + return Collections.unmodifiableList(new ArrayList<String>(instructions)).iterator(); + } + } + + /** + * Returns the fields that will be returned from a search. + * + * @return fields that will be returned from a search. + */ + public ReportedData getReportedData() { + return reportedData; + } + + /** + * Returns an Iterator for the items returned from a search. + * + * @return an Iterator for the items returned from a search. + */ + public Iterator<Item> getItems() { + synchronized (items) { + return Collections.unmodifiableList(new ArrayList<Item>(items)).iterator(); + } + } + + /** + * Returns an Iterator for the fields that are part of the form. + * + * @return an Iterator for the fields that are part of the form. + */ + public Iterator<FormField> getFields() { + synchronized (fields) { + return Collections.unmodifiableList(new ArrayList<FormField>(fields)).iterator(); + } + } + + public String getElementName() { + return "x"; + } + + public String getNamespace() { + return "jabber:x:data"; + } + + /** + * Sets the description of the data. It is similar to the title on a web page or an X window. + * You can put a <title/> on either a form to fill out, or a set of data results. + * + * @param title description of the data. + */ + public void setTitle(String title) { + this.title = title; + } + + /** + * Sets the list of instructions that explain how to fill out the form and what the form is + * about. The dataform could include multiple instructions since each instruction could not + * contain newlines characters. + * + * @param instructions list of instructions that explain how to fill out the form. + */ + public void setInstructions(List<String> instructions) { + this.instructions = instructions; + } + + /** + * Sets the fields that will be returned from a search. + * + * @param reportedData the fields that will be returned from a search. + */ + public void setReportedData(ReportedData reportedData) { + this.reportedData = reportedData; + } + + /** + * Adds a new field as part of the form. + * + * @param field the field to add to the form. + */ + public void addField(FormField field) { + synchronized (fields) { + fields.add(field); + } + } + + /** + * Adds a new instruction to the list of instructions that explain how to fill out the form + * and what the form is about. The dataform could include multiple instructions since each + * instruction could not contain newlines characters. + * + * @param instruction the new instruction that explain how to fill out the form. + */ + public void addInstruction(String instruction) { + synchronized (instructions) { + instructions.add(instruction); + } + } + + /** + * Adds a new item returned from a search. + * + * @param item the item returned from a search. + */ + public void addItem(Item item) { + synchronized (items) { + items.add(item); + } + } + + public String toXML() { + StringBuilder buf = new StringBuilder(); + buf.append("<").append(getElementName()).append(" xmlns=\"").append(getNamespace()).append( + "\" type=\"" + getType() +"\">"); + if (getTitle() != null) { + buf.append("<title>").append(getTitle()).append("

Instead of using the build.bash script which doesn't work with dash shell, apply the patch as a patch diff --git a/external/asmack/build/src/trunk/META-INF/services/com.kenai.jbosh.HTTPSender b/external/asmack/build/src/trunk/META-INF/services/com.kenai.jbosh.HTTPSender new file mode 100644 index 0000000..3608d8e --- /dev/null +++ b/external/asmack/build/src/trunk/META-INF/services/com.kenai.jbosh.HTTPSender @@ -0,0 +1 @@ +com.kenai.jbosh.ApacheHTTPSender diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AbstractAttr.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AbstractAttr.java new file mode 100644 index 0000000..0d6f84c --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AbstractAttr.java @@ -0,0 +1,116 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Abstract base class for creating BOSH attribute classes. Concrete + * implementations of this class will naturally inherit the underlying + * type's behavior for {@code equals()}, {@code hashCode()}, + * {@code toString()}, and {@code compareTo()}, allowing for the easy + * creation of objects which extend existing trivial types. This was done + * to comply with the prefactoring rule declaring, "when you are being + * abstract, be abstract all the way". + * + * @param type of the extension object + */ +abstract class AbstractAttr + implements Comparable { + + /** + * Captured value. + */ + private final T value; + + /** + * Creates a new encapsulated object instance. + * + * @param aValue encapsulated getValue + */ + protected AbstractAttr(final T aValue) { + value = aValue; + } + + /** + * Gets the encapsulated data value. + * + * @return data value + */ + public final T getValue() { + return value; + } + + /////////////////////////////////////////////////////////////////////////// + // Object method overrides: + + /** + * {@inheritDoc} + * + * @param otherObj object to compare to + * @return true if the objects are equal, false otherwise + */ + @Override + public boolean equals(final Object otherObj) { + if (otherObj == null) { + return false; + } else if (otherObj instanceof AbstractAttr) { + AbstractAttr other = + (AbstractAttr) otherObj; + return value.equals(other.value); + } else { + return false; + } + } + + /** + * {@inheritDoc} + * + * @return hashCode of the encapsulated object + */ + @Override + public int hashCode() { + return value.hashCode(); + } + + /** + * {@inheritDoc} + * + * @return string representation of the encapsulated object + */ + @Override + public String toString() { + return value.toString(); + } + + /////////////////////////////////////////////////////////////////////////// + // Comparable interface: + + /** + * {@inheritDoc} + * + * @param otherObj object to compare to + * @return -1, 0, or 1 + */ + @SuppressWarnings("unchecked") + public int compareTo(final Object otherObj) { + if (otherObj == null) { + return 1; + } else { + return value.compareTo(otherObj); + } + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AbstractBody.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AbstractBody.java new file mode 100644 index 0000000..4d66c8c --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AbstractBody.java @@ -0,0 +1,104 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.util.Collections; +import java.util.Map; +import java.util.Set; + +/** + * Class representing a single message to or from the BOSH connection + * manager (CM). + *

+ * These messages consist of a single {@code body} element + * (qualified within the BOSH namespace: + * {@code http://jabber.org/protocol/httpbind}) and contain zero or more + * child elements (of any namespace). These child elements constitute the + * message payload. + *

+ * In addition to the message payload, the attributes of the wrapper + * {@code body} element may also need to be used as part of the communication + * protocol being implemented on top of BOSH, or to define additional + * namespaces used by the child "payload" elements. These attributes are + * exposed via accessors. + */ +public abstract class AbstractBody { + + /////////////////////////////////////////////////////////////////////////// + // Constructor: + + /** + * Restrict subclasses to the local package. + */ + AbstractBody() { + // Empty + } + + /////////////////////////////////////////////////////////////////////////// + // Public methods: + + /** + * Get a set of all defined attribute names. + * + * @return set of qualified attribute names + */ + public final Set getAttributeNames() { + Map attrs = getAttributes(); + return Collections.unmodifiableSet(attrs.keySet()); + } + + /** + * Get the value of the specified attribute. + * + * @param attr name of the attribute to retriece + * @return attribute value, or {@code null} if not defined + */ + public final String getAttribute(final BodyQName attr) { + Map attrs = getAttributes(); + return attrs.get(attr); + } + + /////////////////////////////////////////////////////////////////////////// + // Abstract methods: + + /** + * Get a map of all defined attribute names with their corresponding values. + * + * @return map of qualified attributes + */ + public abstract Map getAttributes(); + + /** + * Get an XML String representation of this message. + * + * @return XML string representing the body message + */ + public abstract String toXML(); + + /////////////////////////////////////////////////////////////////////////// + // Package-private methods: + + /** + * Returns the qualified name of the root/wrapper element. + * + * @return qualified name + */ + static BodyQName getBodyQName() { + return BodyQName.createBOSH("body"); + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AbstractIntegerAttr.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AbstractIntegerAttr.java new file mode 100644 index 0000000..1b827f9 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AbstractIntegerAttr.java @@ -0,0 +1,97 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Abstract base class for attribute implementations based on {@code Integer} + * types. Additional support for parsing of integer values from their + * {@code String} representations as well as callback handling of value + * validity checks are also provided. + */ +abstract class AbstractIntegerAttr extends AbstractAttr { + + /** + * Creates a new attribute object. + * + * @param val attribute value + * @throws BOSHException on parse or validation failure + */ + protected AbstractIntegerAttr(final int val) throws BOSHException { + super(Integer.valueOf(val)); + } + + /** + * Creates a new attribute object. + * + * @param val attribute value in string form + * @throws BOSHException on parse or validation failure + */ + protected AbstractIntegerAttr(final String val) throws BOSHException { + super(parseInt(val)); + } + + /** + * Utility method intended to be called by concrete implementation + * classes from within the {@code check()} method when the concrete + * class needs to ensure that the integer value does not drop below + * the specified minimum value. + * + * @param minVal minimum value to allow + * @throws BOSHException if the integer value is below the specific + * minimum + */ + protected final void checkMinValue(int minVal) throws BOSHException { + int intVal = getValue(); + if (intVal < minVal) { + throw(new BOSHException( + "Illegal attribute value '" + intVal + "' provided. " + + "Must be >= " + minVal)); + } + } + + /** + * Utility method to parse a {@code String} into an {@code Integer}, + * converting any possible {@code NumberFormatException} thrown into + * a {@code BOSHException}. + * + * @param str string to parse + * @return integer value + * @throws BOSHException on {@code NumberFormatException} + */ + private static int parseInt(final String str) throws BOSHException { + try { + return Integer.parseInt(str); + } catch (NumberFormatException nfx) { + throw(new BOSHException( + "Could not parse an integer from the value provided: " + + str, + nfx)); + } + } + + /** + * Returns the native {@code int} value of the underlying {@code Integer}. + * Will throw {@code NullPointerException} if the underlying + * integer was {@code null}. + * + * @return native {@code int} value + */ + public int intValue() { + return getValue().intValue(); + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/ApacheHTTPResponse.java b/external/asmack/build/src/trunk/com/kenai/jbosh/ApacheHTTPResponse.java new file mode 100644 index 0000000..9f6731f --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/ApacheHTTPResponse.java @@ -0,0 +1,253 @@ +/* + * Copyright 2009 Guenther Niess + * + * 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 com.kenai.jbosh; + +import java.io.IOException; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +import org.apache.http.HttpEntity; +import org.apache.http.HttpResponse; +import org.apache.http.client.HttpClient; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.entity.ByteArrayEntity; + +import org.apache.http.protocol.BasicHttpContext; +import org.apache.http.protocol.HttpContext; +import org.apache.http.util.EntityUtils; + +final class ApacheHTTPResponse implements HTTPResponse { + + /////////////////////////////////////////////////////////////////////////// + // Constants: + + /** + * Name of the accept encoding header. + */ + private static final String ACCEPT_ENCODING = "Accept-Encoding"; + + /** + * Value to use for the ACCEPT_ENCODING header. + */ + private static final String ACCEPT_ENCODING_VAL = + ZLIBCodec.getID() + ", " + GZIPCodec.getID(); + + /** + * Name of the character set to encode the body to/from. + */ + private static final String CHARSET = "UTF-8"; + + /** + * Content type to use when transmitting the body data. + */ + private static final String CONTENT_TYPE = "text/xml; charset=utf-8"; + + /////////////////////////////////////////////////////////////////////////// + // Class variables: + + /** + * Lock used for internal synchronization. + */ + private final Lock lock = new ReentrantLock(); + + /** + * The execution state of an HTTP process. + */ + private final HttpContext context; + + /** + * HttpClient instance to use to communicate. + */ + private final HttpClient client; + + /** + * The HTTP POST request is sent to the server. + */ + private final HttpPost post; + + /** + * A flag which indicates if the transmission was already done. + */ + private boolean sent; + + /** + * Exception to throw when the response data is attempted to be accessed, + * or {@code null} if no exception should be thrown. + */ + private BOSHException toThrow; + + /** + * The response body which was received from the server or {@code null} + * if that has not yet happened. + */ + private AbstractBody body; + + /** + * The HTTP response status code. + */ + private int statusCode; + + /////////////////////////////////////////////////////////////////////////// + // Constructors: + + /** + * Create and send a new request to the upstream connection manager, + * providing deferred access to the results to be returned. + * + * @param client client instance to use when sending the request + * @param cfg client configuration + * @param params connection manager parameters from the session creation + * response, or {@code null} if the session has not yet been established + * @param request body of the client request + */ + ApacheHTTPResponse( + final HttpClient client, + final BOSHClientConfig cfg, + final CMSessionParams params, + final AbstractBody request) { + super(); + this.client = client; + this.context = new BasicHttpContext(); + this.post = new HttpPost(cfg.getURI().toString()); + this.sent = false; + + try { + String xml = request.toXML(); + byte[] data = xml.getBytes(CHARSET); + + String encoding = null; + if (cfg.isCompressionEnabled() && params != null) { + AttrAccept accept = params.getAccept(); + if (accept != null) { + if (accept.isAccepted(ZLIBCodec.getID())) { + encoding = ZLIBCodec.getID(); + data = ZLIBCodec.encode(data); + } else if (accept.isAccepted(GZIPCodec.getID())) { + encoding = GZIPCodec.getID(); + data = GZIPCodec.encode(data); + } + } + } + + ByteArrayEntity entity = new ByteArrayEntity(data); + entity.setContentType(CONTENT_TYPE); + if (encoding != null) { + entity.setContentEncoding(encoding); + } + post.setEntity(entity); + if (cfg.isCompressionEnabled()) { + post.setHeader(ACCEPT_ENCODING, ACCEPT_ENCODING_VAL); + } + } catch (Exception e) { + toThrow = new BOSHException("Could not generate request", e); + } + } + + /////////////////////////////////////////////////////////////////////////// + // HTTPResponse interface methods: + + /** + * Abort the client transmission and response processing. + */ + public void abort() { + if (post != null) { + post.abort(); + toThrow = new BOSHException("HTTP request aborted"); + } + } + + /** + * Wait for and then return the response body. + * + * @return body of the response + * @throws InterruptedException if interrupted while awaiting the response + * @throws BOSHException on communication failure + */ + public AbstractBody getBody() throws InterruptedException, BOSHException { + if (toThrow != null) { + throw(toThrow); + } + lock.lock(); + try { + if (!sent) { + awaitResponse(); + } + } finally { + lock.unlock(); + } + return body; + } + + /** + * Wait for and then return the response HTTP status code. + * + * @return HTTP status code of the response + * @throws InterruptedException if interrupted while awaiting the response + * @throws BOSHException on communication failure + */ + public int getHTTPStatus() throws InterruptedException, BOSHException { + if (toThrow != null) { + throw(toThrow); + } + lock.lock(); + try { + if (!sent) { + awaitResponse(); + } + } finally { + lock.unlock(); + } + return statusCode; + } + + /////////////////////////////////////////////////////////////////////////// + // Package-private methods: + + /** + * Await the response, storing the result in the instance variables of + * this class when they arrive. + * + * @throws InterruptedException if interrupted while awaiting the response + * @throws BOSHException on communication failure + */ + private synchronized void awaitResponse() throws BOSHException { + HttpEntity entity = null; + try { + HttpResponse httpResp = client.execute(post, context); + entity = httpResp.getEntity(); + byte[] data = EntityUtils.toByteArray(entity); + String encoding = entity.getContentEncoding() != null ? + entity.getContentEncoding().getValue() : + null; + if (ZLIBCodec.getID().equalsIgnoreCase(encoding)) { + data = ZLIBCodec.decode(data); + } else if (GZIPCodec.getID().equalsIgnoreCase(encoding)) { + data = GZIPCodec.decode(data); + } + body = StaticBody.fromString(new String(data, CHARSET)); + statusCode = httpResp.getStatusLine().getStatusCode(); + sent = true; + } catch (IOException iox) { + abort(); + toThrow = new BOSHException("Could not obtain response", iox); + throw(toThrow); + } catch (RuntimeException ex) { + abort(); + throw(ex); + } + } +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/ApacheHTTPSender.java b/external/asmack/build/src/trunk/com/kenai/jbosh/ApacheHTTPSender.java new file mode 100644 index 0000000..b3d3c93 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/ApacheHTTPSender.java @@ -0,0 +1,156 @@ +/* + * Copyright 2009 Guenther Niess + * + * 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 com.kenai.jbosh; + +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +import org.apache.http.HttpHost; +import org.apache.http.HttpVersion; +import org.apache.http.client.HttpClient; +import org.apache.http.conn.ClientConnectionManager; +import org.apache.http.conn.params.ConnManagerParams; +import org.apache.http.conn.params.ConnRoutePNames; +import org.apache.http.conn.scheme.PlainSocketFactory; +import org.apache.http.conn.scheme.Scheme; +import org.apache.http.conn.scheme.SchemeRegistry; +import org.apache.http.conn.ssl.SSLSocketFactory; +import org.apache.http.impl.client.DefaultHttpClient; +import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager; +import org.apache.http.params.BasicHttpParams; +import org.apache.http.params.HttpParams; +import org.apache.http.params.HttpProtocolParams; + +/** + * Implementation of the {@code HTTPSender} interface which uses the + * Apache HttpClient API to send messages to the connection manager. + */ +final class ApacheHTTPSender implements HTTPSender { + + /** + * Lock used for internal synchronization. + */ + private final Lock lock = new ReentrantLock(); + + /** + * Session configuration. + */ + private BOSHClientConfig cfg; + + /** + * HttpClient instance to use to communicate. + */ + private HttpClient httpClient; + + /////////////////////////////////////////////////////////////////////////// + // Constructors: + + /** + * Prevent construction apart from our package. + */ + ApacheHTTPSender() { + // Load Apache HTTP client class + HttpClient.class.getName(); + } + + /////////////////////////////////////////////////////////////////////////// + // HTTPSender interface methods: + + /** + * {@inheritDoc} + */ + public void init(final BOSHClientConfig session) { + lock.lock(); + try { + cfg = session; + httpClient = initHttpClient(session); + } finally { + lock.unlock(); + } + } + + /** + * {@inheritDoc} + */ + public void destroy() { + lock.lock(); + try { + if (httpClient != null) { + httpClient.getConnectionManager().shutdown(); + } + } finally { + cfg = null; + httpClient = null; + lock.unlock(); + } + } + + /** + * {@inheritDoc} + */ + public HTTPResponse send( + final CMSessionParams params, + final AbstractBody body) { + HttpClient mClient; + BOSHClientConfig mCfg; + lock.lock(); + try { + if (httpClient == null) { + httpClient = initHttpClient(cfg); + } + mClient = httpClient; + mCfg = cfg; + } finally { + lock.unlock(); + } + return new ApacheHTTPResponse(mClient, mCfg, params, body); + } + + /////////////////////////////////////////////////////////////////////////// + // Package-private methods: + + private synchronized HttpClient initHttpClient(final BOSHClientConfig config) { + // Create and initialize HTTP parameters + HttpParams params = new BasicHttpParams(); + ConnManagerParams.setMaxTotalConnections(params, 100); + HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1); + HttpProtocolParams.setUseExpectContinue(params, false); + if (config != null && + config.getProxyHost() != null && + config.getProxyPort() != 0) { + HttpHost proxy = new HttpHost( + config.getProxyHost(), + config.getProxyPort()); + params.setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy); + } + + // Create and initialize scheme registry + SchemeRegistry schemeRegistry = new SchemeRegistry(); + schemeRegistry.register( + new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); + SSLSocketFactory sslFactory = SSLSocketFactory.getSocketFactory(); + sslFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); + schemeRegistry.register( + new Scheme("https", sslFactory, 443)); + + // Create an HttpClient with the ThreadSafeClientConnManager. + // This connection manager must be used if more than one thread will + // be using the HttpClient. + ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry); + return new DefaultHttpClient(cm, params); + } +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AttrAccept.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrAccept.java new file mode 100644 index 0000000..4f767df --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrAccept.java @@ -0,0 +1,74 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Data type representing the getValue of the {@code accept} attribute of the + * {@code bosh} element. + */ +final class AttrAccept extends AbstractAttr { + + /** + * Array of the accepted encodings. + */ + private final String[] encodings; + + /** + * Creates a new attribute object. + * + * @param val attribute getValue + * @throws BOSHException on parse or validation failure + */ + private AttrAccept(final String val) { + super(val); + encodings = val.split("[\\s,]+"); + } + + /** + * Creates a new attribute instance from the provided String. + * + * @param str string representation of the attribute + * @return attribute instance or {@code null} if provided string is + * {@code null} + * @throws BOSHException on parse or validation failure + */ + static AttrAccept createFromString(final String str) + throws BOSHException { + if (str == null) { + return null; + } else { + return new AttrAccept(str); + } + } + + /** + * Determines whether or not the specified encoding is supported. + * + * @param name encoding name + * @result {@code true} if the encoding is accepted, {@code false} + * otherwise + */ + boolean isAccepted(final String name) { + for (String str : encodings) { + if (str.equalsIgnoreCase(name)) { + return true; + } + } + return false; + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AttrAck.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrAck.java new file mode 100644 index 0000000..6cfe22b --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrAck.java @@ -0,0 +1,52 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Data type representing the getValue of the {@code ack} attribute of the + * {@code bosh} element. + */ +final class AttrAck extends AbstractAttr { + + /** + * Creates a new attribute object. + * + * @param val attribute getValue + * @throws BOSHException on parse or validation failure + */ + private AttrAck(final String val) throws BOSHException { + super(val); + } + + /** + * Creates a new attribute instance from the provided String. + * + * @param str string representation of the attribute + * @return attribute instance or {@code null} if provided string is + * {@code null} + * @throws BOSHException on parse or validation failure + */ + static AttrAck createFromString(final String str) + throws BOSHException { + if (str == null) { + return null; + } else { + return new AttrAck(str); + } + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AttrCharsets.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrCharsets.java new file mode 100644 index 0000000..45ce78c --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrCharsets.java @@ -0,0 +1,71 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Data type representing the getValue of the {@code charsets} attribute of the + * {@code bosh} element. + */ +final class AttrCharsets extends AbstractAttr { + + /** + * Array of the accepted character sets. + */ + private final String[] charsets; + + /** + * Creates a new attribute object. + * + * @param val attribute getValue + */ + private AttrCharsets(final String val) { + super(val); + charsets = val.split("\\ +"); + } + + /** + * Creates a new attribute instance from the provided String. + * + * @param str string representation of the attribute + * @return attribute instance or {@code null} if provided string is + * {@code null} + */ + static AttrCharsets createFromString(final String str) { + if (str == null) { + return null; + } else { + return new AttrCharsets(str); + } + } + + /** + * Determines whether or not the specified charset is supported. + * + * @param name encoding name + * @result {@code true} if the encoding is accepted, {@code false} + * otherwise + */ + boolean isAccepted(final String name) { + for (String str : charsets) { + if (str.equalsIgnoreCase(name)) { + return true; + } + } + return false; + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AttrHold.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrHold.java new file mode 100644 index 0000000..56f21dd --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrHold.java @@ -0,0 +1,53 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Data type representing the getValue of the {@code hold} attribute of the + * {@code bosh} element. + */ +final class AttrHold extends AbstractIntegerAttr { + + /** + * Creates a new attribute object. + * + * @param val attribute getValue + * @throws BOSHException on parse or validation failure + */ + private AttrHold(final String val) throws BOSHException { + super(val); + checkMinValue(0); + } + + /** + * Creates a new attribute instance from the provided String. + * + * @param str string representation of the attribute + * @return attribute instance or {@code null} if provided string is + * {@code null} + * @throws BOSHException on parse or validation failure + */ + static AttrHold createFromString(final String str) + throws BOSHException { + if (str == null) { + return null; + } else { + return new AttrHold(str); + } + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AttrInactivity.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrInactivity.java new file mode 100644 index 0000000..14ab7d4 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrInactivity.java @@ -0,0 +1,53 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Data type representing the value of the {@code inactivity} attribute of the + * {@code bosh} element. + */ +final class AttrInactivity extends AbstractIntegerAttr { + + /** + * Creates a new attribute object. + * + * @param val attribute value + * @throws BOSHException on parse or validation failure + */ + private AttrInactivity(final String val) throws BOSHException { + super(val); + checkMinValue(0); + } + + /** + * Creates a new attribute instance from the provided String. + * + * @param str string representation of the attribute + * @return instance of the attribute for the specified string, or + * {@code null} if input string is {@code null} + * @throws BOSHException on parse or validation failure + */ + static AttrInactivity createFromString(final String str) + throws BOSHException { + if (str == null) { + return null; + } else { + return new AttrInactivity(str); + } + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AttrMaxPause.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrMaxPause.java new file mode 100644 index 0000000..8d1d98b --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrMaxPause.java @@ -0,0 +1,65 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.util.concurrent.TimeUnit; + +/** + * Data type representing the getValue of the {@code maxpause} attribute of the + * {@code bosh} element. + */ +final class AttrMaxPause extends AbstractIntegerAttr { + + /** + * Creates a new attribute object. + * + * @param val attribute getValue + * @throws BOSHException on parse or validation failure + */ + private AttrMaxPause(final String val) throws BOSHException { + super(val); + checkMinValue(1); + } + + /** + * Creates a new attribute instance from the provided String. + * + * @param str string representation of the attribute + * @return attribute instance or {@code null} if provided string is + * {@code null} + * @throws BOSHException on parse or validation failure + */ + static AttrMaxPause createFromString(final String str) + throws BOSHException { + if (str == null) { + return null; + } else { + return new AttrMaxPause(str); + } + } + + /** + * Get the max pause time in milliseconds. + * + * @return pause tme in milliseconds + */ + public int getInMilliseconds() { + return (int) TimeUnit.MILLISECONDS.convert( + intValue(), TimeUnit.SECONDS); + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AttrPause.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrPause.java new file mode 100644 index 0000000..5fb3282 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrPause.java @@ -0,0 +1,65 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.util.concurrent.TimeUnit; + +/** + * Data type representing the getValue of the {@code pause} attribute of the + * {@code bosh} element. + */ +final class AttrPause extends AbstractIntegerAttr { + + /** + * Creates a new attribute object. + * + * @param val attribute getValue + * @throws BOSHException on parse or validation failure + */ + private AttrPause(final String val) throws BOSHException { + super(val); + checkMinValue(1); + } + + /** + * Creates a new attribute instance from the provided String. + * + * @param str string representation of the attribute + * @return attribute instance or {@code null} if provided string is + * {@code null} + * @throws BOSHException on parse or validation failure + */ + static AttrPause createFromString(final String str) + throws BOSHException { + if (str == null) { + return null; + } else { + return new AttrPause(str); + } + } + + /** + * Get the pause time in milliseconds. + * + * @return pause tme in milliseconds + */ + public int getInMilliseconds() { + return (int) TimeUnit.MILLISECONDS.convert( + intValue(), TimeUnit.SECONDS); + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AttrPolling.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrPolling.java new file mode 100644 index 0000000..3f0b08d --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrPolling.java @@ -0,0 +1,65 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.util.concurrent.TimeUnit; + +/** + * Data type representing the getValue of the {@code polling} attribute of the + * {@code bosh} element. + */ +final class AttrPolling extends AbstractIntegerAttr { + + /** + * Creates a new attribute object. + * + * @param val attribute getValue + * @throws BOSHException on parse or validation failure + */ + private AttrPolling(final String str) throws BOSHException { + super(str); + checkMinValue(0); + } + + /** + * Creates a new attribute instance from the provided String. + * + * @param str string representation of the attribute + * @return instance of the attribute for the specified string, or + * {@code null} if input string is {@code null} + * @throws BOSHException on parse or validation failure + */ + static AttrPolling createFromString(final String str) + throws BOSHException { + if (str == null) { + return null; + } else { + return new AttrPolling(str); + } + } + + /** + * Get the polling interval in milliseconds. + * + * @return polling interval in milliseconds + */ + public int getInMilliseconds() { + return (int) TimeUnit.MILLISECONDS.convert( + intValue(), TimeUnit.SECONDS); + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AttrRequests.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrRequests.java new file mode 100644 index 0000000..bfdc529 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrRequests.java @@ -0,0 +1,53 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Data type representing the value of the {@code requests} attribute of the + * {@code bosh} element. + */ +final class AttrRequests extends AbstractIntegerAttr { + + /** + * Creates a new attribute object. + * + * @param val attribute value + * @throws BOSHException on parse or validation failure + */ + private AttrRequests(final String val) throws BOSHException { + super(val); + checkMinValue(1); + } + + /** + * Creates a new attribute instance from the provided String. + * + * @param str string representation of the attribute + * @return instance of the attribute for the specified string, or + * {@code null} if input string is {@code null} + * @throws BOSHException on parse or validation failure + */ + static AttrRequests createFromString(final String str) + throws BOSHException { + if (str == null) { + return null; + } else { + return new AttrRequests(str); + } + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AttrSessionID.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrSessionID.java new file mode 100644 index 0000000..1998968 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrSessionID.java @@ -0,0 +1,44 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Data type representing the getValue of the {@code sid} attribute of the + * {@code bosh} element. + */ +final class AttrSessionID extends AbstractAttr { + + /** + * Creates a new attribute object. + * + * @param val attribute getValue + */ + private AttrSessionID(final String val) { + super(val); + } + + /** + * Creates a new attribute instance from the provided String. + * + * @param str string representation of the attribute + * @return attribute instance + */ + static AttrSessionID createFromString(final String str) { + return new AttrSessionID(str); + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AttrVersion.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrVersion.java new file mode 100644 index 0000000..9396e3b --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrVersion.java @@ -0,0 +1,165 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Data type representing the getValue of the {@code ver} attribute of the + * {@code bosh} element. + */ +final class AttrVersion extends AbstractAttr implements Comparable { + + /** + * Default value if none is provided. + */ + private static final AttrVersion DEFAULT; + static { + try { + DEFAULT = createFromString("1.8"); + } catch (BOSHException boshx) { + throw(new IllegalStateException(boshx)); + } + } + + /** + * Major portion of the version. + */ + private final int major; + + /** + * Minor portion of the version. + */ + private final int minor; + + /** + * Creates a new attribute object. + * + * @param val attribute getValue + * @throws BOSHException on parse or validation failure + */ + private AttrVersion(final String val) throws BOSHException { + super(val); + + int idx = val.indexOf('.'); + if (idx <= 0) { + throw(new BOSHException( + "Illegal ver attribute value (not in major.minor form): " + + val)); + } + + String majorStr = val.substring(0, idx); + try { + major = Integer.parseInt(majorStr); + } catch (NumberFormatException nfx) { + throw(new BOSHException( + "Could not parse ver attribute value (major ver): " + + majorStr, + nfx)); + } + if (major < 0) { + throw(new BOSHException( + "Major version may not be < 0")); + } + + String minorStr = val.substring(idx + 1); + try { + minor = Integer.parseInt(minorStr); + } catch (NumberFormatException nfx) { + throw(new BOSHException( + "Could not parse ver attribute value (minor ver): " + + minorStr, + nfx)); + } + if (minor < 0) { + throw(new BOSHException( + "Minor version may not be < 0")); + } + } + + /** + * Get the version of specifcation that we support. + * + * @return max spec version the code supports + */ + static AttrVersion getSupportedVersion() { + return DEFAULT; + } + + /** + * Creates a new attribute instance from the provided String. + * + * @param str string representation of the attribute + * @return attribute instance or {@code null} if provided string is + * {@code null} + * @throws BOSHException on parse or validation failure + */ + static AttrVersion createFromString(final String str) + throws BOSHException { + if (str == null) { + return null; + } else { + return new AttrVersion(str); + } + } + + /** + * Returns the 'major' portion of the version number. + * + * @return major digits only + */ + int getMajor() { + return major; + } + + /** + * Returns the 'minor' portion of the version number. + * + * @return minor digits only + */ + int getMinor() { + return minor; + } + + /////////////////////////////////////////////////////////////////////////// + // Comparable interface: + + /** + * {@inheritDoc} + * + * @param otherObj object to compare to + * @return -1, 0, or 1 + */ + @Override + public int compareTo(final Object otherObj) { + if (otherObj instanceof AttrVersion) { + AttrVersion other = (AttrVersion) otherObj; + if (major < other.major) { + return -1; + } else if (major > other.major) { + return 1; + } else if (minor < other.minor) { + return -1; + } else if (minor > other.minor) { + return 1; + } else { + return 0; + } + } else { + return 0; + } + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/AttrWait.java b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrWait.java new file mode 100644 index 0000000..d2c95f7 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/AttrWait.java @@ -0,0 +1,53 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Data type representing the getValue of the {@code wait} attribute of the + * {@code bosh} element. + */ +final class AttrWait extends AbstractIntegerAttr { + + /** + * Creates a new attribute object. + * + * @param val attribute getValue + * @throws BOSHException on parse or validation failure + */ + private AttrWait(final String val) throws BOSHException { + super(val); + checkMinValue(1); + } + + /** + * Creates a new attribute instance from the provided String. + * + * @param str string representation of the attribute + * @return attribute instance or {@code null} if provided string is + * {@code null} + * @throws BOSHException on parse or validation failure + */ + static AttrWait createFromString(final String str) + throws BOSHException { + if (str == null) { + return null; + } else { + return new AttrWait(str); + } + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/Attributes.java b/external/asmack/build/src/trunk/com/kenai/jbosh/Attributes.java new file mode 100644 index 0000000..d01541e --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/Attributes.java @@ -0,0 +1,64 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import javax.xml.XMLConstants; + +/** + * Class containing constants for attribute definitions used by the + * XEP-0124 specification. We shouldn't need to expose these outside + * our package, since nobody else should be needing to worry about + * them. + */ +final class Attributes { + + /** + * Private constructor to prevent construction of library class. + */ + private Attributes() { + super(); + } + + static final BodyQName ACCEPT = BodyQName.createBOSH("accept"); + static final BodyQName AUTHID = BodyQName.createBOSH("authid"); + static final BodyQName ACK = BodyQName.createBOSH("ack"); + static final BodyQName CHARSETS = BodyQName.createBOSH("charsets"); + static final BodyQName CONDITION = BodyQName.createBOSH("condition"); + static final BodyQName CONTENT = BodyQName.createBOSH("content"); + static final BodyQName FROM = BodyQName.createBOSH("from"); + static final BodyQName HOLD = BodyQName.createBOSH("hold"); + static final BodyQName INACTIVITY = BodyQName.createBOSH("inactivity"); + static final BodyQName KEY = BodyQName.createBOSH("key"); + static final BodyQName MAXPAUSE = BodyQName.createBOSH("maxpause"); + static final BodyQName NEWKEY = BodyQName.createBOSH("newkey"); + static final BodyQName PAUSE = BodyQName.createBOSH("pause"); + static final BodyQName POLLING = BodyQName.createBOSH("polling"); + static final BodyQName REPORT = BodyQName.createBOSH("report"); + static final BodyQName REQUESTS = BodyQName.createBOSH("requests"); + static final BodyQName RID = BodyQName.createBOSH("rid"); + static final BodyQName ROUTE = BodyQName.createBOSH("route"); + static final BodyQName SECURE = BodyQName.createBOSH("secure"); + static final BodyQName SID = BodyQName.createBOSH("sid"); + static final BodyQName STREAM = BodyQName.createBOSH("stream"); + static final BodyQName TIME = BodyQName.createBOSH("time"); + static final BodyQName TO = BodyQName.createBOSH("to"); + static final BodyQName TYPE = BodyQName.createBOSH("type"); + static final BodyQName VER = BodyQName.createBOSH("ver"); + static final BodyQName WAIT = BodyQName.createBOSH("wait"); + static final BodyQName XML_LANG = + BodyQName.createWithPrefix(XMLConstants.XML_NS_URI, "lang", "xml"); +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClient.java b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClient.java new file mode 100644 index 0000000..b96d188 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClient.java @@ -0,0 +1,1536 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import com.kenai.jbosh.ComposableBody.Builder; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; +import java.util.Set; +import java.util.SortedSet; +import java.util.TreeSet; +import java.util.concurrent.CopyOnWriteArraySet; +import java.util.concurrent.Executors; +import java.util.concurrent.RejectedExecutionException; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ScheduledFuture; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.ReentrantLock; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * BOSH Client session instance. Each communication session with a remote + * connection manager is represented and handled by an instance of this + * class. This is the main entry point for client-side communications. + * To create a new session, a client configuration must first be created + * and then used to create a client instance: + *

+ * BOSHClientConfig cfg = BOSHClientConfig.Builder.create(
+ *         "http://server:1234/httpbind", "jabber.org")
+ *     .setFrom("user@jabber.org")
+ *     .build();
+ * BOSHClient client = BOSHClient.create(cfg);
+ *

+ * Additional client configuration options are available. See the + * {@code BOSHClientConfig.Builder} class for more information. + *

+ * Once a {@code BOSHClient} instance has been created, communication with + * the remote connection manager can begin. No attempt will be made to + * establish a connection to the connection manager until the first call + * is made to the {@code send(ComposableBody)} method. Note that it is + * possible to send an empty body to cause an immediate connection attempt + * to the connection manager. Sending an empty message would look like + * the following: + *

+ * client.send(ComposableBody.builder().build());
+ *

+ * For more information on creating body messages with content, see the + * {@code ComposableBody.Builder} class documentation. + *

+ * Once a session has been successfully started, the client instance can be + * used to send arbitrary payload data. All aspects of the BOSH + * protocol involving setting and processing attributes in the BOSH + * namespace will be handled by the client code transparently and behind the + * scenes. The user of the client instance can therefore concentrate + * entirely on the content of the message payload, leaving the semantics of + * the BOSH protocol to the client implementation. + *

+ * To be notified of incoming messages from the remote connection manager, + * a {@code BOSHClientResponseListener} should be added to the client instance. + * All incoming messages will be published to all response listeners as they + * arrive and are processed. As with the transmission of payload data via + * the {@code send(ComposableBody)} method, there is no need to worry about + * handling of the BOSH attributes, since this is handled behind the scenes. + *

+ * If the connection to the remote connection manager is terminated (either + * explicitly or due to a terminal condition of some sort), all connection + * listeners will be notified. After the connection has been closed, the + * client instance is considered dead and a new one must be created in order + * to resume communications with the remote server. + *

+ * Instances of this class are thread-safe. + * + * @see BOSHClientConfig.Builder + * @see BOSHClientResponseListener + * @see BOSHClientConnListener + * @see ComposableBody.Builder + */ +public final class BOSHClient { + + /** + * Logger. + */ + private static final Logger LOG = Logger.getLogger( + BOSHClient.class.getName()); + + /** + * Value of the 'type' attribute used for session termination. + */ + private static final String TERMINATE = "terminate"; + + /** + * Value of the 'type' attribute used for recoverable errors. + */ + private static final String ERROR = "error"; + + /** + * Message to use for interrupted exceptions. + */ + private static final String INTERRUPTED = "Interrupted"; + + /** + * Message used for unhandled exceptions. + */ + private static final String UNHANDLED = "Unhandled Exception"; + + /** + * Message used whena null listener is detected. + */ + private static final String NULL_LISTENER = "Listener may not b enull"; + + /** + * Default empty request delay. + */ + private static final int DEFAULT_EMPTY_REQUEST_DELAY = 100; + + /** + * Amount of time to wait before sending an empty request, in + * milliseconds. + */ + private static final int EMPTY_REQUEST_DELAY = Integer.getInteger( + BOSHClient.class.getName() + ".emptyRequestDelay", + DEFAULT_EMPTY_REQUEST_DELAY); + + /** + * Default value for the pause margin. + */ + private static final int DEFAULT_PAUSE_MARGIN = 500; + + /** + * The amount of time in milliseconds which will be reserved as a + * safety margin when scheduling empty requests against a maxpause + * value. This should give us enough time to build the message + * and transport it to the remote host. + */ + private static final int PAUSE_MARGIN = Integer.getInteger( + BOSHClient.class.getName() + ".pauseMargin", + DEFAULT_PAUSE_MARGIN); + + /** + * Flag indicating whether or not we want to perform assertions. + */ + private static final boolean ASSERTIONS; + + /** + * Connection listeners. + */ + private final Set connListeners = + new CopyOnWriteArraySet(); + + /** + * Request listeners. + */ + private final Set requestListeners = + new CopyOnWriteArraySet(); + + /** + * Response listeners. + */ + private final Set responseListeners = + new CopyOnWriteArraySet(); + + /** + * Lock instance. + */ + private final ReentrantLock lock = new ReentrantLock(); + + /** + * Condition indicating that there are messages to be exchanged. + */ + private final Condition notEmpty = lock.newCondition(); + + /** + * Condition indicating that there are available slots for sending + * messages. + */ + private final Condition notFull = lock.newCondition(); + + /** + * Condition indicating that there are no outstanding connections. + */ + private final Condition drained = lock.newCondition(); + + /** + * Session configuration. + */ + private final BOSHClientConfig cfg; + + /** + * Processor thread runnable instance. + */ + private final Runnable procRunnable = new Runnable() { + /** + * Process incoming messages. + */ + public void run() { + processMessages(); + } + }; + + /** + * Processor thread runnable instance. + */ + private final Runnable emptyRequestRunnable = new Runnable() { + /** + * Process incoming messages. + */ + public void run() { + sendEmptyRequest(); + } + }; + + /** + * HTTPSender instance. + */ + private final HTTPSender httpSender = + new ApacheHTTPSender(); + + /** + * Storage for test hook implementation. + */ + private final AtomicReference exchInterceptor = + new AtomicReference(); + + /** + * Request ID sequence to use for the session. + */ + private final RequestIDSequence requestIDSeq = new RequestIDSequence(); + + /** + * ScheduledExcecutor to use for deferred tasks. + */ + private final ScheduledExecutorService schedExec = + Executors.newSingleThreadScheduledExecutor(); + + /************************************************************ + * The following vars must be accessed via the lock instance. + */ + + /** + * Thread which is used to process responses from the connection + * manager. Becomes null when session is terminated. + */ + private Thread procThread; + + /** + * Future for sending a deferred empty request, if needed. + */ + private ScheduledFuture emptyRequestFuture; + + /** + * Connection Manager session parameters. Only available when in a + * connected state. + */ + private CMSessionParams cmParams; + + /** + * List of active/outstanding requests. + */ + private Queue exchanges = new LinkedList(); + + /** + * Set of RIDs which have been received, for the purpose of sending + * response acknowledgements. + */ + private SortedSet pendingResponseAcks = new TreeSet(); + + /** + * The highest RID that we've already received a response for. This value + * is used to implement response acks. + */ + private Long responseAck = Long.valueOf(-1L); + + /** + * List of requests which have been made but not yet acknowledged. This + * list remains unpopulated if the CM is not acking requests. + */ + private List pendingRequestAcks = + new ArrayList(); + + /////////////////////////////////////////////////////////////////////////// + // Classes: + + /** + * Class used in testing to dynamically manipulate received exchanges + * at test runtime. + */ + abstract static class ExchangeInterceptor { + /** + * Limit construction. + */ + ExchangeInterceptor() { + // Empty; + } + + /** + * Hook to manipulate an HTTPExchange as is is about to be processed. + * + * @param exch original exchange that would be processed + * @return replacement exchange instance, or {@code null} to skip + * processing of this exchange + */ + abstract HTTPExchange interceptExchange(final HTTPExchange exch); + } + + /////////////////////////////////////////////////////////////////////////// + // Constructors: + + /** + * Determine whether or not we should perform assertions. Assertions + * can be specified via system property explicitly, or defaulted to + * the JVM assertions status. + */ + static { + final String prop = + BOSHClient.class.getSimpleName() + ".assertionsEnabled"; + boolean enabled = false; + if (System.getProperty(prop) == null) { + assert enabled = true; + } else { + enabled = Boolean.getBoolean(prop); + } + ASSERTIONS = enabled; + } + + /** + * Prevent direct construction. + */ + private BOSHClient(final BOSHClientConfig sessCfg) { + cfg = sessCfg; + init(); + } + + /////////////////////////////////////////////////////////////////////////// + // Public methods: + + /** + * Create a new BOSH client session using the client configuration + * information provided. + * + * @param clientCfg session configuration + * @return BOSH session instance + */ + public static BOSHClient create(final BOSHClientConfig clientCfg) { + if (clientCfg == null) { + throw(new IllegalArgumentException( + "Client configuration may not be null")); + } + return new BOSHClient(clientCfg); + } + + /** + * Get the client configuration that was used to create this client + * instance. + * + * @return client configuration + */ + public BOSHClientConfig getBOSHClientConfig() { + return cfg; + } + + /** + * Adds a connection listener to the session. + * + * @param listener connection listener to add, if not already added + */ + public void addBOSHClientConnListener( + final BOSHClientConnListener listener) { + if (listener == null) { + throw(new IllegalArgumentException(NULL_LISTENER)); + } + connListeners.add(listener); + } + + /** + * Removes a connection listener from the session. + * + * @param listener connection listener to remove, if previously added + */ + public void removeBOSHClientConnListener( + final BOSHClientConnListener listener) { + if (listener == null) { + throw(new IllegalArgumentException(NULL_LISTENER)); + } + connListeners.remove(listener); + } + + /** + * Adds a request message listener to the session. + * + * @param listener request listener to add, if not already added + */ + public void addBOSHClientRequestListener( + final BOSHClientRequestListener listener) { + if (listener == null) { + throw(new IllegalArgumentException(NULL_LISTENER)); + } + requestListeners.add(listener); + } + + /** + * Removes a request message listener from the session, if previously + * added. + * + * @param listener instance to remove + */ + public void removeBOSHClientRequestListener( + final BOSHClientRequestListener listener) { + if (listener == null) { + throw(new IllegalArgumentException(NULL_LISTENER)); + } + requestListeners.remove(listener); + } + + /** + * Adds a response message listener to the session. + * + * @param listener response listener to add, if not already added + */ + public void addBOSHClientResponseListener( + final BOSHClientResponseListener listener) { + if (listener == null) { + throw(new IllegalArgumentException(NULL_LISTENER)); + } + responseListeners.add(listener); + } + + /** + * Removes a response message listener from the session, if previously + * added. + * + * @param listener instance to remove + */ + public void removeBOSHClientResponseListener( + final BOSHClientResponseListener listener) { + if (listener == null) { + throw(new IllegalArgumentException(NULL_LISTENER)); + } + responseListeners.remove(listener); + } + + /** + * Send the provided message data to the remote connection manager. The + * provided message body does not need to have any BOSH-specific attribute + * information set. It only needs to contain the actual message payload + * that should be delivered to the remote server. + *

+ * The first call to this method will result in a connection attempt + * to the remote connection manager. Subsequent calls to this method + * will block until the underlying session state allows for the message + * to be transmitted. In certain scenarios - such as when the maximum + * number of outbound connections has been reached - calls to this method + * will block for short periods of time. + * + * @param body message data to send to remote server + * @throws BOSHException on message transmission failure + */ + public void send(final ComposableBody body) throws BOSHException { + assertUnlocked(); + if (body == null) { + throw(new IllegalArgumentException( + "Message body may not be null")); + } + + HTTPExchange exch; + CMSessionParams params; + lock.lock(); + try { + blockUntilSendable(body); + if (!isWorking() && !isTermination(body)) { + throw(new BOSHException( + "Cannot send message when session is closed")); + } + + long rid = requestIDSeq.getNextRID(); + ComposableBody request = body; + params = cmParams; + if (params == null && exchanges.isEmpty()) { + // This is the first message being sent + request = applySessionCreationRequest(rid, body); + } else { + request = applySessionData(rid, body); + if (cmParams.isAckingRequests()) { + pendingRequestAcks.add(request); + } + } + exch = new HTTPExchange(request); + exchanges.add(exch); + notEmpty.signalAll(); + clearEmptyRequest(); + } finally { + lock.unlock(); + } + AbstractBody finalReq = exch.getRequest(); + HTTPResponse resp = httpSender.send(params, finalReq); + exch.setHTTPResponse(resp); + fireRequestSent(finalReq); + } + + /** + * Attempt to pause the current session. When supported by the remote + * connection manager, pausing the session will result in the connection + * manager closing out all outstanding requests (including the pause + * request) and increases the inactivity timeout of the session. The + * exact value of the temporary timeout is dependent upon the connection + * manager. This method should be used if a client encounters an + * exceptional temporary situation during which it will be unable to send + * requests to the connection manager for a period of time greater than + * the maximum inactivity period. + * + * The session will revert back to it's normal, unpaused state when the + * client sends it's next message. + * + * @return {@code true} if the connection manager supports session pausing, + * {@code false} if the connection manager does not support session + * pausing or if the session has not yet been established + */ + public boolean pause() { + assertUnlocked(); + lock.lock(); + AttrMaxPause maxPause = null; + try { + if (cmParams == null) { + return false; + } + + maxPause = cmParams.getMaxPause(); + if (maxPause == null) { + return false; + } + } finally { + lock.unlock(); + } + try { + send(ComposableBody.builder() + .setAttribute(Attributes.PAUSE, maxPause.toString()) + .build()); + } catch (BOSHException boshx) { + LOG.log(Level.FINEST, "Could not send pause", boshx); + } + return true; + } + + /** + * End the BOSH session by disconnecting from the remote BOSH connection + * manager. + * + * @throws BOSHException when termination message cannot be sent + */ + public void disconnect() throws BOSHException { + disconnect(ComposableBody.builder().build()); + } + + /** + * End the BOSH session by disconnecting from the remote BOSH connection + * manager, sending the provided content in the final connection + * termination message. + * + * @param msg final message to send + * @throws BOSHException when termination message cannot be sent + */ + public void disconnect(final ComposableBody msg) throws BOSHException { + if (msg == null) { + throw(new IllegalArgumentException( + "Message body may not be null")); + } + + Builder builder = msg.rebuild(); + builder.setAttribute(Attributes.TYPE, TERMINATE); + send(builder.build()); + } + + /** + * Forcibly close this client session instance. The preferred mechanism + * to close the connection is to send a disconnect message and wait for + * organic termination. Calling this method simply shuts down the local + * session without sending a termination message, releasing all resources + * associated with the session. + */ + public void close() { + dispose(new BOSHException("Session explicitly closed by caller")); + } + + /////////////////////////////////////////////////////////////////////////// + // Package-private methods: + + /** + * Get the current CM session params. + * + * @return current session params, or {@code null} + */ + CMSessionParams getCMSessionParams() { + lock.lock(); + try { + return cmParams; + } finally { + lock.unlock(); + } + } + + /** + * Wait until no more messages are waiting to be processed. + */ + void drain() { + lock.lock(); + try { + LOG.finest("Waiting while draining..."); + while (isWorking() + && (emptyRequestFuture == null + || emptyRequestFuture.isDone())) { + try { + drained.await(); + } catch (InterruptedException intx) { + LOG.log(Level.FINEST, INTERRUPTED, intx); + } + } + LOG.finest("Drained"); + } finally { + lock.unlock(); + } + } + + /** + * Test method used to forcibly discard next exchange. + * + * @param interceptor exchange interceptor + */ + void setExchangeInterceptor(final ExchangeInterceptor interceptor) { + exchInterceptor.set(interceptor); + } + + + /////////////////////////////////////////////////////////////////////////// + // Private methods: + + /** + * Initialize the session. This initializes the underlying HTTP + * transport implementation and starts the receive thread. + */ + private void init() { + assertUnlocked(); + + lock.lock(); + try { + httpSender.init(cfg); + procThread = new Thread(procRunnable); + procThread.setDaemon(true); + procThread.setName(BOSHClient.class.getSimpleName() + + "[" + System.identityHashCode(this) + + "]: Receive thread"); + procThread.start(); + } finally { + lock.unlock(); + } + } + + /** + * Destroy this session. + * + * @param cause the reason for the session termination, or {@code null} + * for normal termination + */ + private void dispose(final Throwable cause) { + assertUnlocked(); + + lock.lock(); + try { + if (procThread == null) { + // Already disposed + return; + } + procThread = null; + } finally { + lock.unlock(); + } + + if (cause == null) { + fireConnectionClosed(); + } else { + fireConnectionClosedOnError(cause); + } + + lock.lock(); + try { + clearEmptyRequest(); + exchanges = null; + cmParams = null; + pendingResponseAcks = null; + pendingRequestAcks = null; + notEmpty.signalAll(); + notFull.signalAll(); + drained.signalAll(); + } finally { + lock.unlock(); + } + + httpSender.destroy(); + schedExec.shutdownNow(); + } + + /** + * Determines if the message body specified indicates a request to + * pause the session. + * + * @param msg message to evaluate + * @return {@code true} if the message is a pause request, {@code false} + * otherwise + */ + private static boolean isPause(final AbstractBody msg) { + return msg.getAttribute(Attributes.PAUSE) != null; + } + + /** + * Determines if the message body specified indicates a termination of + * the session. + * + * @param msg message to evaluate + * @return {@code true} if the message is a session termination, + * {@code false} otherwise + */ + private static boolean isTermination(final AbstractBody msg) { + return TERMINATE.equals(msg.getAttribute(Attributes.TYPE)); + } + + /** + * Evaluates the HTTP response code and response message and returns the + * terminal binding condition that it describes, if any. + * + * @param respCode HTTP response code + * @param respBody response body + * @return terminal binding condition, or {@code null} if not a terminal + * binding condition message + */ + private TerminalBindingCondition getTerminalBindingCondition( + final int respCode, + final AbstractBody respBody) { + assertLocked(); + + if (isTermination(respBody)) { + String str = respBody.getAttribute(Attributes.CONDITION); + return TerminalBindingCondition.forString(str); + } + // Check for deprecated HTTP Error Conditions + if (cmParams != null && cmParams.getVersion() == null) { + return TerminalBindingCondition.forHTTPResponseCode(respCode); + } + return null; + } + + /** + * Determines if the message specified is immediately sendable or if it + * needs to block until the session state changes. + * + * @param msg message to evaluate + * @return {@code true} if the message can be immediately sent, + * {@code false} otherwise + */ + private boolean isImmediatelySendable(final AbstractBody msg) { + assertLocked(); + + if (cmParams == null) { + // block if we're waiting for a response to our first request + return exchanges.isEmpty(); + } + + AttrRequests requests = cmParams.getRequests(); + if (requests == null) { + return true; + } + int maxRequests = requests.intValue(); + if (exchanges.size() < maxRequests) { + return true; + } + if (exchanges.size() == maxRequests + && (isTermination(msg) || isPause(msg))) { + // One additional terminate or pause message is allowed + return true; + } + return false; + } + + /** + * Determines whether or not the session is still active. + * + * @return {@code true} if it is, {@code false} otherwise + */ + private boolean isWorking() { + assertLocked(); + + return procThread != null; + } + + /** + * Blocks until either the message provided becomes immediately + * sendable or until the session is terminated. + * + * @param msg message to evaluate + */ + private void blockUntilSendable(final AbstractBody msg) { + assertLocked(); + + while (isWorking() && !isImmediatelySendable(msg)) { + try { + notFull.await(); + } catch (InterruptedException intx) { + LOG.log(Level.FINEST, INTERRUPTED, intx); + } + } + } + + /** + * Modifies the specified body message such that it becomes a new + * BOSH session creation request. + * + * @param rid request ID to use + * @param orig original body to modify + * @return modified message which acts as a session creation request + */ + private ComposableBody applySessionCreationRequest( + final long rid, final ComposableBody orig) throws BOSHException { + assertLocked(); + + Builder builder = orig.rebuild(); + builder.setAttribute(Attributes.TO, cfg.getTo()); + builder.setAttribute(Attributes.XML_LANG, cfg.getLang()); + builder.setAttribute(Attributes.VER, + AttrVersion.getSupportedVersion().toString()); + builder.setAttribute(Attributes.WAIT, "60"); + builder.setAttribute(Attributes.HOLD, "1"); + builder.setAttribute(Attributes.RID, Long.toString(rid)); + applyRoute(builder); + applyFrom(builder); + builder.setAttribute(Attributes.ACK, "1"); + + // Make sure the following are NOT present (i.e., during retries) + builder.setAttribute(Attributes.SID, null); + return builder.build(); + } + + /** + * Applies routing information to the request message who's builder has + * been provided. + * + * @param builder builder instance to add routing information to + */ + private void applyRoute(final Builder builder) { + assertLocked(); + + String route = cfg.getRoute(); + if (route != null) { + builder.setAttribute(Attributes.ROUTE, route); + } + } + + /** + * Applies the local station ID information to the request message who's + * builder has been provided. + * + * @param builder builder instance to add station ID information to + */ + private void applyFrom(final Builder builder) { + assertLocked(); + + String from = cfg.getFrom(); + if (from != null) { + builder.setAttribute(Attributes.FROM, from); + } + } + + /** + * Applies existing session data to the outbound request, returning the + * modified request. + * + * This method assumes the lock is currently held. + * + * @param rid request ID to use + * @param orig original/raw request + * @return modified request with session information applied + */ + private ComposableBody applySessionData( + final long rid, + final ComposableBody orig) throws BOSHException { + assertLocked(); + + Builder builder = orig.rebuild(); + builder.setAttribute(Attributes.SID, + cmParams.getSessionID().toString()); + builder.setAttribute(Attributes.RID, Long.toString(rid)); + applyResponseAcknowledgement(builder, rid); + return builder.build(); + } + + /** + * Sets the 'ack' attribute of the request to the value of the highest + * 'rid' of a request for which it has already received a response in the + * case where it has also received all responses associated with lower + * 'rid' values. The only exception is that, after its session creation + * request, the client SHOULD NOT include an 'ack' attribute in any request + * if it has received responses to all its previous requests. + * + * @param builder message builder + * @param rid current request RID + */ + private void applyResponseAcknowledgement( + final Builder builder, + final long rid) { + assertLocked(); + + if (responseAck.equals(Long.valueOf(-1L))) { + // We have not received any responses yet + return; + } + + Long prevRID = Long.valueOf(rid - 1L); + if (responseAck.equals(prevRID)) { + // Implicit ack + return; + } + + builder.setAttribute(Attributes.ACK, responseAck.toString()); + } + + /** + * While we are "connected", process received responses. + * + * This method is run in the processing thread. + */ + private void processMessages() { + LOG.log(Level.FINEST, "Processing thread starting"); + try { + HTTPExchange exch; + do { + exch = nextExchange(); + if (exch == null) { + break; + } + + // Test hook to manipulate what the client sees: + ExchangeInterceptor interceptor = exchInterceptor.get(); + if (interceptor != null) { + HTTPExchange newExch = interceptor.interceptExchange(exch); + if (newExch == null) { + LOG.log(Level.FINE, "Discarding exchange on request " + + "of test hook: RID=" + + exch.getRequest().getAttribute( + Attributes.RID)); + lock.lock(); + try { + exchanges.remove(exch); + } finally { + lock.unlock(); + } + continue; + } + exch = newExch; + } + + processExchange(exch); + } while (true); + } finally { + LOG.log(Level.FINEST, "Processing thread exiting"); + } + + } + + /** + * Get the next message exchange to process, blocking until one becomes + * available if nothing is already waiting for processing. + * + * @return next available exchange to process, or {@code null} if no + * exchanges are immediately available + */ + private HTTPExchange nextExchange() { + assertUnlocked(); + + final Thread thread = Thread.currentThread(); + HTTPExchange exch = null; + lock.lock(); + try { + do { + if (!thread.equals(procThread)) { + break; + } + exch = exchanges.peek(); + if (exch == null) { + try { + notEmpty.await(); + } catch (InterruptedException intx) { + LOG.log(Level.FINEST, INTERRUPTED, intx); + } + } + } while (exch == null); + } finally { + lock.unlock(); + } + return exch; + } + + /** + * Process the next, provided exchange. This is the main processing + * method of the receive thread. + * + * @param exch message exchange to process + */ + private void processExchange(final HTTPExchange exch) { + assertUnlocked(); + + HTTPResponse resp; + AbstractBody body; + int respCode; + try { + resp = exch.getHTTPResponse(); + body = resp.getBody(); + respCode = resp.getHTTPStatus(); + } catch (BOSHException boshx) { + LOG.log(Level.FINEST, "Could not obtain response", boshx); + dispose(boshx); + return; + } catch (InterruptedException intx) { + LOG.log(Level.FINEST, INTERRUPTED, intx); + dispose(intx); + return; + } + fireResponseReceived(body); + + // Process the message with the current session state + AbstractBody req = exch.getRequest(); + CMSessionParams params; + List toResend = null; + lock.lock(); + try { + // Check for session creation response info, if needed + if (cmParams == null) { + cmParams = CMSessionParams.fromSessionInit(req, body); + + // The following call handles the lock. It's not an escape. + fireConnectionEstablished(); + } + params = cmParams; + + checkForTerminalBindingConditions(body, respCode); + if (isTermination(body)) { + // Explicit termination + lock.unlock(); + dispose(null); + return; + } + + if (isRecoverableBindingCondition(body)) { + // Retransmit outstanding requests + if (toResend == null) { + toResend = new ArrayList(exchanges.size()); + } + for (HTTPExchange exchange : exchanges) { + HTTPExchange resendExch = + new HTTPExchange(exchange.getRequest()); + toResend.add(resendExch); + } + for (HTTPExchange exchange : toResend) { + exchanges.add(exchange); + } + } else { + // Process message as normal + processRequestAcknowledgements(req, body); + processResponseAcknowledgementData(req); + HTTPExchange resendExch = + processResponseAcknowledgementReport(body); + if (resendExch != null && toResend == null) { + toResend = new ArrayList(1); + toResend.add(resendExch); + exchanges.add(resendExch); + } + } + } catch (BOSHException boshx) { + LOG.log(Level.FINEST, "Could not process response", boshx); + lock.unlock(); + dispose(boshx); + return; + } finally { + if (lock.isHeldByCurrentThread()) { + try { + exchanges.remove(exch); + if (exchanges.isEmpty()) { + scheduleEmptyRequest(processPauseRequest(req)); + } + notFull.signalAll(); + } finally { + lock.unlock(); + } + } + } + + if (toResend != null) { + for (HTTPExchange resend : toResend) { + HTTPResponse response = + httpSender.send(params, resend.getRequest()); + resend.setHTTPResponse(response); + fireRequestSent(resend.getRequest()); + } + } + } + + /** + * Clears any scheduled empty requests. + */ + private void clearEmptyRequest() { + assertLocked(); + + if (emptyRequestFuture != null) { + emptyRequestFuture.cancel(false); + emptyRequestFuture = null; + } + } + + /** + * Calculates the default empty request delay/interval to use for the + * active session. + * + * @return delay in milliseconds + */ + private long getDefaultEmptyRequestDelay() { + assertLocked(); + + // Figure out how long we should wait before sending an empty request + AttrPolling polling = cmParams.getPollingInterval(); + long delay; + if (polling == null) { + delay = EMPTY_REQUEST_DELAY; + } else { + delay = polling.getInMilliseconds(); + } + return delay; + } + + /** + * Schedule an empty request to be sent if no other requests are + * sent in a reasonable amount of time. + */ + private void scheduleEmptyRequest(long delay) { + assertLocked(); + if (delay < 0L) { + throw(new IllegalArgumentException( + "Empty request delay must be >= 0 (was: " + delay + ")")); + } + + clearEmptyRequest(); + if (!isWorking()) { + return; + } + + // Schedule the transmission + if (LOG.isLoggable(Level.FINER)) { + LOG.finer("Scheduling empty request in " + delay + "ms"); + } + try { + emptyRequestFuture = schedExec.schedule(emptyRequestRunnable, + delay, TimeUnit.MILLISECONDS); + } catch (RejectedExecutionException rex) { + LOG.log(Level.FINEST, "Could not schedule empty request", rex); + } + drained.signalAll(); + } + + /** + * Sends an empty request to maintain session requirements. If a request + * is sent within a reasonable time window, the empty request transmission + * will be cancelled. + */ + private void sendEmptyRequest() { + assertUnlocked(); + // Send an empty request + LOG.finest("Sending empty request"); + try { + send(ComposableBody.builder().build()); + } catch (BOSHException boshx) { + dispose(boshx); + } + } + + /** + * Assert that the internal lock is held. + */ + private void assertLocked() { + if (ASSERTIONS) { + if (!lock.isHeldByCurrentThread()) { + throw(new AssertionError("Lock is not held by current thread")); + } + return; + } + } + + /** + * Assert that the internal lock is *not* held. + */ + private void assertUnlocked() { + if (ASSERTIONS) { + if (lock.isHeldByCurrentThread()) { + throw(new AssertionError("Lock is held by current thread")); + } + return; + } + } + + /** + * Checks to see if the response indicates a terminal binding condition + * (as per XEP-0124 section 17). If it does, an exception is thrown. + * + * @param body response body to evaluate + * @param code HTTP response code + * @throws BOSHException if a terminal binding condition is detected + */ + private void checkForTerminalBindingConditions( + final AbstractBody body, + final int code) + throws BOSHException { + TerminalBindingCondition cond = + getTerminalBindingCondition(code, body); + if (cond != null) { + throw(new BOSHException( + "Terminal binding condition encountered: " + + cond.getCondition() + " (" + + cond.getMessage() + ")")); + } + } + + /** + * Determines whether or not the response indicates a recoverable + * binding condition (as per XEP-0124 section 17). + * + * @param resp response body + * @return {@code true} if it does, {@code false} otherwise + */ + private static boolean isRecoverableBindingCondition( + final AbstractBody resp) { + return ERROR.equals(resp.getAttribute(Attributes.TYPE)); + } + + /** + * Process the request to determine if the empty request delay + * can be determined by looking to see if the request is a pause + * request. If it can, the request's delay is returned, otherwise + * the default delay is returned. + * + * @return delay in milliseconds that should elapse prior to an + * empty message being sent + */ + private long processPauseRequest( + final AbstractBody req) { + assertLocked(); + + if (cmParams != null && cmParams.getMaxPause() != null) { + try { + AttrPause pause = AttrPause.createFromString( + req.getAttribute(Attributes.PAUSE)); + if (pause != null) { + long delay = pause.getInMilliseconds() - PAUSE_MARGIN; + if (delay < 0) { + delay = EMPTY_REQUEST_DELAY; + } + return delay; + } + } catch (BOSHException boshx) { + LOG.log(Level.FINEST, "Could not extract", boshx); + } + } + + return getDefaultEmptyRequestDelay(); + } + + /** + * Check the response for request acknowledgements and take appropriate + * action. + * + * This method assumes the lock is currently held. + * + * @param req request + * @param resp response + */ + private void processRequestAcknowledgements( + final AbstractBody req, final AbstractBody resp) { + assertLocked(); + + if (!cmParams.isAckingRequests()) { + return; + } + + // If a report or time attribute is set, we aren't acking anything + if (resp.getAttribute(Attributes.REPORT) != null) { + return; + } + + // Figure out what the highest acked RID is + String acked = resp.getAttribute(Attributes.ACK); + Long ackUpTo; + if (acked == null) { + // Implicit ack of all prior requests up until RID + ackUpTo = Long.parseLong(req.getAttribute(Attributes.RID)); + } else { + ackUpTo = Long.parseLong(acked); + } + + // Remove the acked requests from the list + if (LOG.isLoggable(Level.FINEST)) { + LOG.finest("Removing pending acks up to: " + ackUpTo); + } + Iterator iter = pendingRequestAcks.iterator(); + while (iter.hasNext()) { + AbstractBody pending = iter.next(); + Long pendingRID = Long.parseLong( + pending.getAttribute(Attributes.RID)); + if (pendingRID.compareTo(ackUpTo) <= 0) { + iter.remove(); + } + } + } + + /** + * Process the response in order to update the response acknowlegement + * data. + * + * This method assumes the lock is currently held. + * + * @param req request + */ + private void processResponseAcknowledgementData( + final AbstractBody req) { + assertLocked(); + + Long rid = Long.parseLong(req.getAttribute(Attributes.RID)); + if (responseAck.equals(Long.valueOf(-1L))) { + // This is the first request + responseAck = rid; + } else { + pendingResponseAcks.add(rid); + // Remove up until the first missing response (or end of queue) + Long whileVal = responseAck; + while (whileVal.equals(pendingResponseAcks.first())) { + responseAck = whileVal; + pendingResponseAcks.remove(whileVal); + whileVal = Long.valueOf(whileVal.longValue() + 1); + } + } + } + + /** + * Process the response in order to check for and respond to any potential + * ack reports. + * + * This method assumes the lock is currently held. + * + * @param resp response + * @return exchange to transmit if a resend is to be performed, or + * {@code null} if no resend is necessary + * @throws BOSHException when a a retry is needed but cannot be performed + */ + private HTTPExchange processResponseAcknowledgementReport( + final AbstractBody resp) + throws BOSHException { + assertLocked(); + + String reportStr = resp.getAttribute(Attributes.REPORT); + if (reportStr == null) { + // No report on this message + return null; + } + + Long report = Long.parseLong(reportStr); + Long time = Long.parseLong(resp.getAttribute(Attributes.TIME)); + if (LOG.isLoggable(Level.FINE)) { + LOG.fine("Received report of missing request (RID=" + + report + ", time=" + time + "ms)"); + } + + // Find the missing request + Iterator iter = pendingRequestAcks.iterator(); + AbstractBody req = null; + while (iter.hasNext() && req == null) { + AbstractBody pending = iter.next(); + Long pendingRID = Long.parseLong( + pending.getAttribute(Attributes.RID)); + if (report.equals(pendingRID)) { + req = pending; + } + } + + if (req == null) { + throw(new BOSHException("Report of missing message with RID '" + + reportStr + + "' but local copy of that request was not found")); + } + + // Resend the missing request + HTTPExchange exch = new HTTPExchange(req); + exchanges.add(exch); + notEmpty.signalAll(); + return exch; + } + + /** + * Notifies all request listeners that the specified request is being + * sent. + * + * @param request request being sent + */ + private void fireRequestSent(final AbstractBody request) { + assertUnlocked(); + + BOSHMessageEvent event = null; + for (BOSHClientRequestListener listener : requestListeners) { + if (event == null) { + event = BOSHMessageEvent.createRequestSentEvent(this, request); + } + try { + listener.requestSent(event); + } catch (Exception ex) { + LOG.log(Level.WARNING, UNHANDLED, ex); + } + } + } + + /** + * Notifies all response listeners that the specified response has been + * received. + * + * @param response response received + */ + private void fireResponseReceived(final AbstractBody response) { + assertUnlocked(); + + BOSHMessageEvent event = null; + for (BOSHClientResponseListener listener : responseListeners) { + if (event == null) { + event = BOSHMessageEvent.createResponseReceivedEvent( + this, response); + } + try { + listener.responseReceived(event); + } catch (Exception ex) { + LOG.log(Level.WARNING, UNHANDLED, ex); + } + } + } + + /** + * Notifies all connection listeners that the session has been successfully + * established. + */ + private void fireConnectionEstablished() { + final boolean hadLock = lock.isHeldByCurrentThread(); + if (hadLock) { + lock.unlock(); + } + try { + BOSHClientConnEvent event = null; + for (BOSHClientConnListener listener : connListeners) { + if (event == null) { + event = BOSHClientConnEvent + .createConnectionEstablishedEvent(this); + } + try { + listener.connectionEvent(event); + } catch (Exception ex) { + LOG.log(Level.WARNING, UNHANDLED, ex); + } + } + } finally { + if (hadLock) { + lock.lock(); + } + } + } + + /** + * Notifies all connection listeners that the session has been + * terminated normally. + */ + private void fireConnectionClosed() { + assertUnlocked(); + + BOSHClientConnEvent event = null; + for (BOSHClientConnListener listener : connListeners) { + if (event == null) { + event = BOSHClientConnEvent.createConnectionClosedEvent(this); + } + try { + listener.connectionEvent(event); + } catch (Exception ex) { + LOG.log(Level.WARNING, UNHANDLED, ex); + } + } + } + + /** + * Notifies all connection listeners that the session has been + * terminated due to the exceptional condition provided. + * + * @param cause cause of the termination + */ + private void fireConnectionClosedOnError( + final Throwable cause) { + assertUnlocked(); + + BOSHClientConnEvent event = null; + for (BOSHClientConnListener listener : connListeners) { + if (event == null) { + event = BOSHClientConnEvent + .createConnectionClosedOnErrorEvent( + this, pendingRequestAcks, cause); + } + try { + listener.connectionEvent(event); + } catch (Exception ex) { + LOG.log(Level.WARNING, UNHANDLED, ex); + } + } + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientConfig.java b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientConfig.java new file mode 100644 index 0000000..23915b6 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientConfig.java @@ -0,0 +1,446 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.net.URI; +import javax.net.ssl.SSLContext; + +/** + * BOSH client configuration information. Instances of this class contain + * all information necessary to establish connectivity with a remote + * connection manager. + *

+ * Instances of this class are immutable, thread-safe, + * and can be re-used to configure multiple client session instances. + */ +public final class BOSHClientConfig { + + /** + * Connection manager URI. + */ + private final URI uri; + + /** + * Target domain. + */ + private final String to; + + /** + * Client ID of this station. + */ + private final String from; + + /** + * Default XML language. + */ + private final String lang; + + /** + * Routing information for messages sent to CM. + */ + private final String route; + + /** + * Proxy host. + */ + private final String proxyHost; + + /** + * Proxy port. + */ + private final int proxyPort; + + /** + * SSL context. + */ + private final SSLContext sslContext; + + /** + * Flag indicating that compression should be attempted, if possible. + */ + private final boolean compressionEnabled; + + /////////////////////////////////////////////////////////////////////////// + // Classes: + + /** + * Class instance builder, after the builder pattern. This allows each + * {@code BOSHClientConfig} instance to be immutable while providing + * flexibility when building new {@code BOSHClientConfig} instances. + *

+ * Instances of this class are not thread-safe. If template-style + * use is desired, see the {@code create(BOSHClientConfig)} method. + */ + public static final class Builder { + // Required args + private final URI bURI; + private final String bDomain; + + // Optional args + private String bFrom; + private String bLang; + private String bRoute; + private String bProxyHost; + private int bProxyPort; + private SSLContext bSSLContext; + private Boolean bCompression; + + /** + * Creates a new builder instance, used to create instances of the + * {@code BOSHClientConfig} class. + * + * @param cmURI URI to use to contact the connection manager + * @param domain target domain to communicate with + */ + private Builder(final URI cmURI, final String domain) { + bURI = cmURI; + bDomain = domain; + } + + /** + * Creates a new builder instance, used to create instances of the + * {@code BOSHClientConfig} class. + * + * @param cmURI URI to use to contact the connection manager + * @param domain target domain to communicate with + * @return builder instance + */ + public static Builder create(final URI cmURI, final String domain) { + if (cmURI == null) { + throw(new IllegalArgumentException( + "Connection manager URI must not be null")); + } + if (domain == null) { + throw(new IllegalArgumentException( + "Target domain must not be null")); + } + String scheme = cmURI.getScheme(); + if (!("http".equals(scheme) || "https".equals(scheme))) { + throw(new IllegalArgumentException( + "Only 'http' and 'https' URI are allowed")); + } + return new Builder(cmURI, domain); + } + + /** + * Creates a new builder instance using the existing configuration + * provided as a starting point. + * + * @param cfg configuration to copy + * @return builder instance + */ + public static Builder create(final BOSHClientConfig cfg) { + Builder result = new Builder(cfg.getURI(), cfg.getTo()); + result.bFrom = cfg.getFrom(); + result.bLang = cfg.getLang(); + result.bRoute = cfg.getRoute(); + result.bProxyHost = cfg.getProxyHost(); + result.bProxyPort = cfg.getProxyPort(); + result.bSSLContext = cfg.getSSLContext(); + result.bCompression = cfg.isCompressionEnabled(); + return result; + } + + /** + * Set the ID of the client station, to be forwarded to the connection + * manager when new sessions are created. + * + * @param id client ID + * @return builder instance + */ + public Builder setFrom(final String id) { + if (id == null) { + throw(new IllegalArgumentException( + "Client ID must not be null")); + } + bFrom = id; + return this; + } + + /** + * Set the default language of any human-readable content within the + * XML. + * + * @param lang XML language ID + * @return builder instance + */ + public Builder setXMLLang(final String lang) { + if (lang == null) { + throw(new IllegalArgumentException( + "Default language ID must not be null")); + } + bLang = lang; + return this; + } + + /** + * Sets the destination server/domain that the client should connect to. + * Connection managers may be configured to enable sessions with more + * that one server in different domains. When requesting a session with + * such a "proxy" connection manager, a client should use this method to + * specify the server with which it wants to communicate. + * + * @param protocol connection protocol (e.g, "xmpp") + * @param host host or domain to be served by the remote server. Note + * that this is not necessarily the host name or domain name of the + * remote server. + * @param port port number of the remote server + * @return builder instance + */ + public Builder setRoute( + final String protocol, + final String host, + final int port) { + if (protocol == null) { + throw(new IllegalArgumentException("Protocol cannot be null")); + } + if (protocol.contains(":")) { + throw(new IllegalArgumentException( + "Protocol cannot contain the ':' character")); + } + if (host == null) { + throw(new IllegalArgumentException("Host cannot be null")); + } + if (host.contains(":")) { + throw(new IllegalArgumentException( + "Host cannot contain the ':' character")); + } + if (port <= 0) { + throw(new IllegalArgumentException("Port number must be > 0")); + } + bRoute = protocol + ":" + host + ":" + port; + return this; + } + + /** + * Specify the hostname and port of an HTTP proxy to connect through. + * + * @param hostName proxy hostname + * @param port proxy port number + * @return builder instance + */ + public Builder setProxy(final String hostName, final int port) { + if (hostName == null || hostName.length() == 0) { + throw(new IllegalArgumentException( + "Proxy host name cannot be null or empty")); + } + if (port <= 0) { + throw(new IllegalArgumentException( + "Proxy port must be > 0")); + } + bProxyHost = hostName; + bProxyPort = port; + return this; + } + + /** + * Set the SSL context to use for this session. This can be used + * to configure certificate-based authentication, etc.. + * + * @param ctx SSL context + * @return builder instance + */ + public Builder setSSLContext(final SSLContext ctx) { + if (ctx == null) { + throw(new IllegalArgumentException( + "SSL context cannot be null")); + } + bSSLContext = ctx; + return this; + } + + /** + * Set whether or not compression of the underlying data stream + * should be attempted. By default, compression is disabled. + * + * @param enabled set to {@code true} if compression should be + * attempted when possible, {@code false} to disable compression + * @return builder instance + */ + public Builder setCompressionEnabled(final boolean enabled) { + bCompression = Boolean.valueOf(enabled); + return this; + } + + /** + * Build the immutable object instance with the current configuration. + * + * @return BOSHClientConfig instance + */ + public BOSHClientConfig build() { + // Default XML language + String lang; + if (bLang == null) { + lang = "en"; + } else { + lang = bLang; + } + + // Default proxy port + int port; + if (bProxyHost == null) { + port = 0; + } else { + port = bProxyPort; + } + + // Default compression + boolean compression; + if (bCompression == null) { + compression = false; + } else { + compression = bCompression.booleanValue(); + } + + return new BOSHClientConfig( + bURI, + bDomain, + bFrom, + lang, + bRoute, + bProxyHost, + port, + bSSLContext, + compression); + } + + } + + /////////////////////////////////////////////////////////////////////////// + // Constructor: + + /** + * Prevent direct construction. + * + * @param cURI URI of the connection manager to connect to + * @param cDomain the target domain of the first stream + * @param cFrom client ID + * @param cLang default XML language + * @param cRoute target route + * @param cProxyHost proxy host + * @param cProxyPort proxy port + * @param cSSLContext SSL context + * @param cCompression compression enabled flag + */ + private BOSHClientConfig( + final URI cURI, + final String cDomain, + final String cFrom, + final String cLang, + final String cRoute, + final String cProxyHost, + final int cProxyPort, + final SSLContext cSSLContext, + final boolean cCompression) { + uri = cURI; + to = cDomain; + from = cFrom; + lang = cLang; + route = cRoute; + proxyHost = cProxyHost; + proxyPort = cProxyPort; + sslContext = cSSLContext; + compressionEnabled = cCompression; + } + + /** + * Get the URI to use to contact the connection manager. + * + * @return connection manager URI. + */ + public URI getURI() { + return uri; + } + + /** + * Get the ID of the target domain. + * + * @return domain id + */ + public String getTo() { + return to; + } + + /** + * Get the ID of the local client. + * + * @return client id, or {@code null} + */ + public String getFrom() { + return from; + } + + /** + * Get the default language of any human-readable content within the + * XML. Defaults to "en". + * + * @return XML language ID + */ + public String getLang() { + return lang; + } + + /** + * Get the routing information for messages sent to the CM. + * + * @return route attribute string, or {@code null} if no routing + * info was provided. + */ + public String getRoute() { + return route; + } + + /** + * Get the HTTP proxy host to use. + * + * @return proxy host, or {@code null} if no proxy information was specified + */ + public String getProxyHost() { + return proxyHost; + } + + /** + * Get the HTTP proxy port to use. + * + * @return proxy port, or 0 if no proxy information was specified + */ + public int getProxyPort() { + return proxyPort; + } + + /** + * Get the SSL context to use for this session. + * + * @return SSL context instance to use, or {@code null} if no + * context instance was provided. + */ + public SSLContext getSSLContext() { + return sslContext; + } + + /** + * Determines whether or not compression of the underlying data stream + * should be attempted/allowed. Defaults to {@code false}. + * + * @return {@code true} if compression should be attempted, {@code false} + * if compression is disabled or was not specified + */ + boolean isCompressionEnabled() { + return compressionEnabled; + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientConnEvent.java b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientConnEvent.java new file mode 100644 index 0000000..0ac7943 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientConnEvent.java @@ -0,0 +1,189 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.EventObject; +import java.util.List; + +/** + * Client connection event, notifying of changes in connection state. + *

+ * This class is immutable and thread-safe. + */ +public final class BOSHClientConnEvent extends EventObject { + + /** + * Serialized version. + */ + private static final long serialVersionUID = 1L; + + /** + * Boolean flag indicating whether or not a session has been established + * and is currently active. + */ + private final boolean connected; + + /** + * List of outstanding requests which may not have been sent and/or + * acknowledged by the remote CM. + */ + private final List requests; + + /** + * Cause of the session termination, or {@code null}. + */ + private final Throwable cause; + + /** + * Creates a new connection event instance. + * + * @param source event source + * @param cConnected flag indicating whether or not the session is + * currently active + * @param cRequests outstanding requests when an error condition is + * detected, or {@code null} when not an error condition + * @param cCause cause of the error condition, or {@code null} when no + * error condition is present + */ + private BOSHClientConnEvent( + final BOSHClient source, + final boolean cConnected, + final List cRequests, + final Throwable cCause) { + super(source); + connected = cConnected; + cause = cCause; + + if (connected) { + if (cCause != null) { + throw(new IllegalStateException( + "Cannot be connected and have a cause")); + } + if (cRequests != null && cRequests.size() > 0) { + throw(new IllegalStateException( + "Cannot be connected and have outstanding requests")); + } + } + + if (cRequests == null) { + requests = Collections.emptyList(); + } else { + // Defensive copy: + requests = Collections.unmodifiableList( + new ArrayList(cRequests)); + } + } + + /** + * Creates a new connection establishment event. + * + * @param source client which has become connected + * @return event instance + */ + static BOSHClientConnEvent createConnectionEstablishedEvent( + final BOSHClient source) { + return new BOSHClientConnEvent(source, true, null, null); + } + + /** + * Creates a new successful connection closed event. This represents + * a clean termination of the client session. + * + * @param source client which has been disconnected + * @return event instance + */ + static BOSHClientConnEvent createConnectionClosedEvent( + final BOSHClient source) { + return new BOSHClientConnEvent(source, false, null, null); + } + + /** + * Creates a connection closed on error event. This represents + * an unexpected termination of the client session. + * + * @param source client which has been disconnected + * @param outstanding list of requests which may not have been received + * by the remote connection manager + * @param cause cause of termination + * @return event instance + */ + static BOSHClientConnEvent createConnectionClosedOnErrorEvent( + final BOSHClient source, + final List outstanding, + final Throwable cause) { + return new BOSHClientConnEvent(source, false, outstanding, cause); + } + + /** + * Gets the client from which this event originated. + * + * @return client instance + */ + public BOSHClient getBOSHClient() { + return (BOSHClient) getSource(); + } + + /** + * Returns whether or not the session has been successfully established + * and is currently active. + * + * @return {@code true} if a session is active, {@code false} otherwise + */ + public boolean isConnected() { + return connected; + } + + /** + * Returns whether or not this event indicates an error condition. This + * will never return {@code true} when {@code isConnected()} returns + * {@code true}. + * + * @return {@code true} if the event indicates a terminal error has + * occurred, {@code false} otherwise. + */ + public boolean isError() { + return cause != null; + } + + /** + * Returns the underlying cause of the error condition. This method is + * guaranteed to return {@code null} when @{code isError()} returns + * {@code false}. Similarly, this method is guaranteed to return + * non-@{code null} if {@code isError()} returns {@code true}. + * + * @return underlying cause of the error condition, or {@code null} if + * this event does not represent an error condition + */ + public Throwable getCause() { + return cause; + } + + /** + * Get the list of requests which may not have been sent or were not + * acknowledged by the remote connection manager prior to session + * termination. + * + * @return list of messages which may not have been received by the remote + * connection manager, or an empty list if the session is still connected + */ + public List getOutstandingRequests() { + return requests; + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientConnListener.java b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientConnListener.java new file mode 100644 index 0000000..6d646cb --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientConnListener.java @@ -0,0 +1,34 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Interface used by parties interested in monitoring the connection state + * of a client session. + */ +public interface BOSHClientConnListener { + + /** + * Called when the connection state of the client which the listener + * is registered against has changed. The event object supplied can + * be used to determine the current session state. + * + * @param connEvent connection event describing the state + */ + void connectionEvent(BOSHClientConnEvent connEvent); + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientRequestListener.java b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientRequestListener.java new file mode 100644 index 0000000..2cc92f3 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientRequestListener.java @@ -0,0 +1,45 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Interface used by parties interested in monitoring outbound requests made + * by the client to the connection manager (CM). No opportunity is provided + * to manipulate the outbound request. + *

+ * The messages being sent are typically modified copies of the message + * body provided to the {@code BOSHClient} instance, built from the + * originally provided message body plus additional BOSH protocol + * state and information. Messages may also be sent automatically when the + * protocol requires it, such as maintaining a minimum number of open + * connections to the connection manager. + *

+ * Listeners are executed by the sending thread immediately prior to + * message transmission and should not block for any significant amount + * of time. + */ +public interface BOSHClientRequestListener { + + /** + * Called when the listener is being notified that a client request is + * about to be sent to the connection manager. + * + * @param event event instance containing the message being sent + */ + void requestSent(BOSHMessageEvent event); + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientResponseListener.java b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientResponseListener.java new file mode 100644 index 0000000..1d86e4f --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHClientResponseListener.java @@ -0,0 +1,37 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Interface used by parties interested in monitoring inbound responses + * to the client from the connection manager (CM). No opportunity is provided + * to manipulate the response. + *

+ * Listeners are executed by the message processing thread and should not + * block for any significant amount of time. + */ +public interface BOSHClientResponseListener { + + /** + * Called when the listener is being notified that a response has been + * received from the connection manager. + * + * @param event event instance containing the message being sent + */ + void responseReceived(BOSHMessageEvent event); + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHException.java b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHException.java new file mode 100644 index 0000000..e0bc05b --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHException.java @@ -0,0 +1,50 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Exception class used by the BOSH API to minimize the number of checked + * exceptions which must be handled by the user of the API. + */ +public class BOSHException extends Exception { + + /** + * Servial version UID. + */ + private static final long serialVersionUID = 1L; + + /** + * Creates a new exception isntance with the specified descriptive message. + * + * @param msg description of the exceptional condition + */ + public BOSHException(final String msg) { + super(msg); + } + + /** + * Creates a new exception isntance with the specified descriptive + * message and the underlying root cause of the exceptional condition. + * + * @param msg description of the exceptional condition + * @param cause root cause or instigator of the condition + */ + public BOSHException(final String msg, final Throwable cause) { + super(msg, cause); + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHMessageEvent.java b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHMessageEvent.java new file mode 100644 index 0000000..550903e --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/BOSHMessageEvent.java @@ -0,0 +1,92 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.util.EventObject; + +/** + * Event representing a message sent to or from a BOSH connection manager. + *

+ * This class is immutable and thread-safe. + */ +public final class BOSHMessageEvent extends EventObject { + + /** + * Serialized version. + */ + private static final long serialVersionUID = 1L; + + /** + * Message which was sent or received. + */ + private final AbstractBody body; + + /** + * Creates a new message event instance. + * + * @param source event source + * @param cBody message body + */ + private BOSHMessageEvent( + final Object source, + final AbstractBody cBody) { + super(source); + if (cBody == null) { + throw(new IllegalArgumentException( + "message body may not be null")); + } + body = cBody; + } + + /** + * Creates a new message event for clients sending events to the + * connection manager. + * + * @param source sender of the message + * @param body message body + * @return event instance + */ + static BOSHMessageEvent createRequestSentEvent( + final BOSHClient source, + final AbstractBody body) { + return new BOSHMessageEvent(source, body); + } + + /** + * Creates a new message event for clients receiving new messages + * from the connection manager. + * + * @param source receiver of the message + * @param body message body + * @return event instance + */ + static BOSHMessageEvent createResponseReceivedEvent( + final BOSHClient source, + final AbstractBody body) { + return new BOSHMessageEvent(source, body); + } + + /** + * Gets the message body which was sent or received. + * + * @return message body + */ + public AbstractBody getBody() { + return body; + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/BodyParser.java b/external/asmack/build/src/trunk/com/kenai/jbosh/BodyParser.java new file mode 100644 index 0000000..5ef5276 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/BodyParser.java @@ -0,0 +1,36 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Interface for parser implementations to implement in order to abstract the + * business of XML parsing out of the Body class. This allows us to leverage + * a variety of parser implementations to gain performance advantages. + */ +interface BodyParser { + + /** + * Parses the XML message, extracting the useful data from the initial + * body element and returning it in a results object. + * + * @param xml XML to parse + * @return useful data parsed out of the XML + * @throws BOSHException on parse error + */ + BodyParserResults parse(String xml) throws BOSHException; + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/BodyParserResults.java b/external/asmack/build/src/trunk/com/kenai/jbosh/BodyParserResults.java new file mode 100644 index 0000000..955e4bf --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/BodyParserResults.java @@ -0,0 +1,64 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.util.HashMap; +import java.util.Map; + +/** + * Data extracted from a raw XML message by a BodyParser implementation. + * Currently, this is limited to the attributes of the wrapper element. + */ +final class BodyParserResults { + + /** + * Map of qualified names to their values. This map is defined to + * match the requirement of the {@code Body} class to prevent + * excessive copying. + */ + private final Map attrs = + new HashMap(); + + /** + * Constructor. + */ + BodyParserResults() { + // Empty + } + + /** + * Add an attribute definition to the results. + * + * @param name attribute's qualified name + * @param value attribute value + */ + void addBodyAttributeValue( + final BodyQName name, + final String value) { + attrs.put(name, value); + } + + /** + * Returns the map of attributes added by the parser. + * + * @return map of atributes. Note: This is the live instance, not a copy. + */ + Map getAttributes() { + return attrs; + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/BodyParserSAX.java b/external/asmack/build/src/trunk/com/kenai/jbosh/BodyParserSAX.java new file mode 100644 index 0000000..54c6c01 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/BodyParserSAX.java @@ -0,0 +1,206 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.lang.ref.SoftReference; +import java.util.logging.Level; +import java.util.logging.Logger; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.parsers.SAXParser; +import javax.xml.parsers.SAXParserFactory; +import org.xml.sax.Attributes; +import org.xml.sax.SAXException; +import org.xml.sax.helpers.DefaultHandler; + +/** + * Implementation of the BodyParser interface which uses the SAX API + * that is part of the JDK. Due to the fact that we can cache and reuse + * SAXPArser instances, this has proven to be significantly faster than the + * use of the javax.xml.stream API introduced in Java 6 while simultaneously + * providing an implementation accessible to Java 5 users. + */ +final class BodyParserSAX implements BodyParser { + + /** + * Logger. + */ + private static final Logger LOG = + Logger.getLogger(BodyParserSAX.class.getName()); + + /** + * SAX parser factory. + */ + private static final SAXParserFactory SAX_FACTORY; + static { + SAX_FACTORY = SAXParserFactory.newInstance(); + SAX_FACTORY.setNamespaceAware(true); + SAX_FACTORY.setValidating(false); + } + + /** + * Thread local to contain a SAX parser instance for each thread that + * attempts to use one. This allows us to gain an order of magnitude of + * performance as a result of not constructing parsers for each + * invocation while retaining thread safety. + */ + private static final ThreadLocal> PARSER = + new ThreadLocal>() { + @Override protected SoftReference initialValue() { + return new SoftReference(null); + } + }; + + /** + * SAX event handler class. + */ + private static final class Handler extends DefaultHandler { + private final BodyParserResults result; + private final SAXParser parser; + private String defaultNS = null; + + private Handler(SAXParser theParser, BodyParserResults results) { + parser = theParser; + result = results; + } + + /** + * {@inheritDoc} + */ + @Override + public void startElement( + final String uri, + final String localName, + final String qName, + final Attributes attributes) { + if (LOG.isLoggable(Level.FINEST)) { + LOG.finest("Start element: " + qName); + LOG.finest(" URI: " + uri); + LOG.finest(" local: " + localName); + } + + BodyQName bodyName = AbstractBody.getBodyQName(); + // Make sure the first element is correct + if (!(bodyName.getNamespaceURI().equals(uri) + && bodyName.getLocalPart().equals(localName))) { + throw(new IllegalStateException( + "Root element was not '" + bodyName.getLocalPart() + + "' in the '" + bodyName.getNamespaceURI() + + "' namespace. (Was '" + localName + "' in '" + uri + + "')")); + } + + // Read in the attributes, making sure to expand the namespaces + // as needed. + for (int idx=0; idx < attributes.getLength(); idx++) { + String attrURI = attributes.getURI(idx); + if (attrURI.length() == 0) { + attrURI = defaultNS; + } + String attrLN = attributes.getLocalName(idx); + String attrVal = attributes.getValue(idx); + if (LOG.isLoggable(Level.FINEST)) { + LOG.finest(" Attribute: {" + attrURI + "}" + + attrLN + " = '" + attrVal + "'"); + } + + BodyQName aqn = BodyQName.create(attrURI, attrLN); + result.addBodyAttributeValue(aqn, attrVal); + } + + parser.reset(); + } + + /** + * {@inheritDoc} + * + * This implementation uses this event hook to keep track of the + * default namespace on the body element. + */ + @Override + public void startPrefixMapping( + final String prefix, + final String uri) { + if (prefix.length() == 0) { + if (LOG.isLoggable(Level.FINEST)) { + LOG.finest("Prefix mapping: => " + uri); + } + defaultNS = uri; + } else { + if (LOG.isLoggable(Level.FINEST)) { + LOG.info("Prefix mapping: " + prefix + " => " + uri); + } + } + } + } + + /////////////////////////////////////////////////////////////////////////// + // BodyParser interface methods: + + /** + * {@inheritDoc} + */ + public BodyParserResults parse(String xml) throws BOSHException { + BodyParserResults result = new BodyParserResults(); + Exception thrown; + try { + InputStream inStream = new ByteArrayInputStream(xml.getBytes()); + SAXParser parser = getSAXParser(); + parser.parse(inStream, new Handler(parser, result)); + return result; + } catch (SAXException saxx) { + thrown = saxx; + } catch (IOException iox) { + thrown = iox; + } + throw(new BOSHException("Could not parse body:\n" + xml, thrown)); + } + + /////////////////////////////////////////////////////////////////////////// + // Private methods: + + /** + * Gets a SAXParser for use in parsing incoming messages. + * + * @return parser instance + */ + private static SAXParser getSAXParser() { + SoftReference ref = PARSER.get(); + SAXParser result = ref.get(); + if (result == null) { + Exception thrown; + try { + result = SAX_FACTORY.newSAXParser(); + ref = new SoftReference(result); + PARSER.set(ref); + return result; + } catch (ParserConfigurationException ex) { + thrown = ex; + } catch (SAXException ex) { + thrown = ex; + } + throw(new IllegalStateException( + "Could not create SAX parser", thrown)); + } else { + result.reset(); + return result; + } + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/BodyParserXmlPull.java b/external/asmack/build/src/trunk/com/kenai/jbosh/BodyParserXmlPull.java new file mode 100644 index 0000000..5f23b06 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/BodyParserXmlPull.java @@ -0,0 +1,165 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.io.IOException; +import java.io.StringReader; +import java.lang.ref.SoftReference; +import java.util.logging.Level; +import java.util.logging.Logger; +import javax.xml.XMLConstants; +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; +import org.xmlpull.v1.XmlPullParserFactory; + +/** + * Implementation of the BodyParser interface which uses the XmlPullParser + * API. When available, this API provides an order of magnitude performance + * improvement over the default SAX parser implementation. + */ +final class BodyParserXmlPull implements BodyParser { + + /** + * Logger. + */ + private static final Logger LOG = + Logger.getLogger(BodyParserXmlPull.class.getName()); + + /** + * Thread local to contain a XmlPullParser instance for each thread that + * attempts to use one. This allows us to gain an order of magnitude of + * performance as a result of not constructing parsers for each + * invocation while retaining thread safety. + */ + private static final ThreadLocal> XPP_PARSER = + new ThreadLocal>() { + @Override protected SoftReference initialValue() { + return new SoftReference(null); + } + }; + + /////////////////////////////////////////////////////////////////////////// + // BodyParser interface methods: + + /** + * {@inheritDoc} + */ + public BodyParserResults parse(final String xml) throws BOSHException { + BodyParserResults result = new BodyParserResults(); + Exception thrown; + try { + XmlPullParser xpp = getXmlPullParser(); + + xpp.setInput(new StringReader(xml)); + int eventType = xpp.getEventType(); + while (eventType != XmlPullParser.END_DOCUMENT) { + if (eventType == XmlPullParser.START_TAG) { + if (LOG.isLoggable(Level.FINEST)) { + LOG.finest("Start tag: " + xpp.getName()); + } + } else { + eventType = xpp.next(); + continue; + } + + String prefix = xpp.getPrefix(); + if (prefix == null) { + prefix = XMLConstants.DEFAULT_NS_PREFIX; + } + String uri = xpp.getNamespace(); + String localName = xpp.getName(); + QName name = new QName(uri, localName, prefix); + if (LOG.isLoggable(Level.FINEST)) { + LOG.finest("Start element: "); + LOG.finest(" prefix: " + prefix); + LOG.finest(" URI: " + uri); + LOG.finest(" local: " + localName); + } + + BodyQName bodyName = AbstractBody.getBodyQName(); + if (!bodyName.equalsQName(name)) { + throw(new IllegalStateException( + "Root element was not '" + bodyName.getLocalPart() + + "' in the '" + bodyName.getNamespaceURI() + + "' namespace. (Was '" + localName + + "' in '" + uri + "')")); + } + + for (int idx=0; idx < xpp.getAttributeCount(); idx++) { + String attrURI = xpp.getAttributeNamespace(idx); + if (attrURI.length() == 0) { + attrURI = xpp.getNamespace(null); + } + String attrPrefix = xpp.getAttributePrefix(idx); + if (attrPrefix == null) { + attrPrefix = XMLConstants.DEFAULT_NS_PREFIX; + } + String attrLN = xpp.getAttributeName(idx); + String attrVal = xpp.getAttributeValue(idx); + BodyQName aqn = BodyQName.createWithPrefix( + attrURI, attrLN, attrPrefix); + if (LOG.isLoggable(Level.FINEST)) { + LOG.finest(" Attribute: {" + attrURI + "}" + + attrLN + " = '" + attrVal + "'"); + } + result.addBodyAttributeValue(aqn, attrVal); + } + break; + } + return result; + } catch (RuntimeException rtx) { + thrown = rtx; + } catch (XmlPullParserException xmlppx) { + thrown = xmlppx; + } catch (IOException iox) { + thrown = iox; + } + throw(new BOSHException("Could not parse body:\n" + xml, thrown)); + } + + /////////////////////////////////////////////////////////////////////////// + // Private methods: + + /** + * Gets a XmlPullParser for use in parsing incoming messages. + * + * @return parser instance + */ + private static XmlPullParser getXmlPullParser() { + SoftReference ref = XPP_PARSER.get(); + XmlPullParser result = ref.get(); + if (result == null) { + Exception thrown; + try { + XmlPullParserFactory factory = XmlPullParserFactory.newInstance(); + factory.setNamespaceAware(true); + factory.setValidating(false); + result = factory.newPullParser(); + ref = new SoftReference(result); + XPP_PARSER.set(ref); + return result; + } catch (Exception ex) { + thrown = ex; + } + throw(new IllegalStateException( + "Could not create XmlPull parser", thrown)); + } else { + return result; + } + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/BodyQName.java b/external/asmack/build/src/trunk/com/kenai/jbosh/BodyQName.java new file mode 100644 index 0000000..83acdf1 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/BodyQName.java @@ -0,0 +1,165 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Qualified name of an attribute of the wrapper element. This class is + * analagous to the {@code javax.xml.namespace.QName} class. + * Each qualified name consists of a namespace URI and a local name. + *

+ * Instances of this class are immutable and thread-safe. + */ +public final class BodyQName { + + /** + * BOSH namespace URI. + */ + static final String BOSH_NS_URI = + "http://jabber.org/protocol/httpbind"; + + /** + * Namespace URI. + */ + private final QName qname; + + /** + * Private constructor to prevent direct construction. + * + * @param wrapped QName instance to wrap + */ + private BodyQName( + final QName wrapped) { + qname = wrapped; + } + + /** + * Creates a new qualified name using a namespace URI and local name. + * + * @param uri namespace URI + * @param local local name + * @return BodyQName instance + */ + public static BodyQName create( + final String uri, + final String local) { + return createWithPrefix(uri, local, null); + } + + /** + * Creates a new qualified name using a namespace URI and local name + * along with an optional prefix. + * + * @param uri namespace URI + * @param local local name + * @param prefix optional prefix or @{code null} for no prefix + * @return BodyQName instance + */ + public static BodyQName createWithPrefix( + final String uri, + final String local, + final String prefix) { + if (uri == null || uri.length() == 0) { + throw(new IllegalArgumentException( + "URI is required and may not be null/empty")); + } + if (local == null || local.length() == 0) { + throw(new IllegalArgumentException( + "Local arg is required and may not be null/empty")); + } + if (prefix == null || prefix.length() == 0) { + return new BodyQName(new QName(uri, local)); + } else { + return new BodyQName(new QName(uri, local, prefix)); + } + } + + /** + * Get the namespace URI of this qualified name. + * + * @return namespace uri + */ + public String getNamespaceURI() { + return qname.getNamespaceURI(); + } + + /** + * Get the local part of this qualified name. + * + * @return local name + */ + public String getLocalPart() { + return qname.getLocalPart(); + } + + /** + * Get the optional prefix used with this qualified name, or {@code null} + * if no prefix has been assiciated. + * + * @return prefix, or {@code null} if no prefix was supplied + */ + public String getPrefix() { + return qname.getPrefix(); + } + + /** + * {@inheritDoc} + */ + @Override + public boolean equals(final Object obj) { + if (obj instanceof BodyQName) { + BodyQName other = (BodyQName) obj; + return qname.equals(other.qname); + } else { + return false; + } + } + + /** + * {@inheritDoc} + */ + @Override + public int hashCode() { + return qname.hashCode(); + } + + /////////////////////////////////////////////////////////////////////////// + // Package-private methods: + + /** + * Creates a new qualified name using the BOSH namespace URI and local name. + * + * @param local local name + * @return BodyQName instance + */ + static BodyQName createBOSH( + final String local) { + return createWithPrefix(BOSH_NS_URI, local, null); + } + + /** + * Convenience method to compare this qualified name with a + * {@code javax.xml.namespace.QName}. + * + * @param otherName QName to compare to + * @return @{code true} if the qualified name is the same, {@code false} + * otherwise + */ + boolean equalsQName(final QName otherName) { + return qname.equals(otherName); + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/CMSessionParams.java b/external/asmack/build/src/trunk/com/kenai/jbosh/CMSessionParams.java new file mode 100644 index 0000000..bbed628 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/CMSessionParams.java @@ -0,0 +1,177 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * A BOSH connection manager session instance. This consolidates the + * configuration knowledge related to the CM session and provides a + * mechanism by which + */ +final class CMSessionParams { + + private final AttrSessionID sid; + + private final AttrWait wait; + + private final AttrVersion ver; + + private final AttrPolling polling; + + private final AttrInactivity inactivity; + + private final AttrRequests requests; + + private final AttrHold hold; + + private final AttrAccept accept; + + private final AttrMaxPause maxPause; + + private final AttrAck ack; + + private final AttrCharsets charsets; + + private final boolean ackingRequests; + + /** + * Prevent direct construction. + */ + private CMSessionParams( + final AttrSessionID aSid, + final AttrWait aWait, + final AttrVersion aVer, + final AttrPolling aPolling, + final AttrInactivity aInactivity, + final AttrRequests aRequests, + final AttrHold aHold, + final AttrAccept aAccept, + final AttrMaxPause aMaxPause, + final AttrAck aAck, + final AttrCharsets aCharsets, + final boolean amAckingRequests) { + sid = aSid; + wait = aWait; + ver = aVer; + polling = aPolling; + inactivity = aInactivity; + requests = aRequests; + hold = aHold; + accept = aAccept; + maxPause = aMaxPause; + ack = aAck; + charsets = aCharsets; + ackingRequests = amAckingRequests; + } + + static CMSessionParams fromSessionInit( + final AbstractBody req, + final AbstractBody resp) + throws BOSHException { + AttrAck aAck = AttrAck.createFromString( + resp.getAttribute(Attributes.ACK)); + String rid = req.getAttribute(Attributes.RID); + boolean acking = (aAck != null && aAck.getValue().equals(rid)); + + return new CMSessionParams( + AttrSessionID.createFromString( + getRequiredAttribute(resp, Attributes.SID)), + AttrWait.createFromString( + getRequiredAttribute(resp, Attributes.WAIT)), + AttrVersion.createFromString( + resp.getAttribute(Attributes.VER)), + AttrPolling.createFromString( + resp.getAttribute(Attributes.POLLING)), + AttrInactivity.createFromString( + resp.getAttribute(Attributes.INACTIVITY)), + AttrRequests.createFromString( + resp.getAttribute(Attributes.REQUESTS)), + AttrHold.createFromString( + resp.getAttribute(Attributes.HOLD)), + AttrAccept.createFromString( + resp.getAttribute(Attributes.ACCEPT)), + AttrMaxPause.createFromString( + resp.getAttribute(Attributes.MAXPAUSE)), + aAck, + AttrCharsets.createFromString( + resp.getAttribute(Attributes.CHARSETS)), + acking + ); + } + + private static String getRequiredAttribute( + final AbstractBody body, + final BodyQName name) + throws BOSHException { + String attrStr = body.getAttribute(name); + if (attrStr == null) { + throw(new BOSHException( + "Connection Manager session creation response did not " + + "include required '" + name.getLocalPart() + + "' attribute")); + } + return attrStr; + } + + AttrSessionID getSessionID() { + return sid; + } + + AttrWait getWait() { + return wait; + } + + AttrVersion getVersion() { + return ver; + } + + AttrPolling getPollingInterval() { + return polling; + } + + AttrInactivity getInactivityPeriod() { + return inactivity; + } + + AttrRequests getRequests() { + return requests; + } + + AttrHold getHold() { + return hold; + } + + AttrAccept getAccept() { + return accept; + } + + AttrMaxPause getMaxPause() { + return maxPause; + } + + AttrAck getAck() { + return ack; + } + + AttrCharsets getCharsets() { + return charsets; + } + + boolean isAckingRequests() { + return ackingRequests; + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/ComposableBody.java b/external/asmack/build/src/trunk/com/kenai/jbosh/ComposableBody.java new file mode 100644 index 0000000..7f3b159 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/ComposableBody.java @@ -0,0 +1,345 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.atomic.AtomicReference; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import javax.xml.XMLConstants; + +/** + * Implementation of the {@code AbstractBody} class which allows for the + * definition of messages from individual elements of a body. + *

+ * A message is constructed by creating a builder, manipulating the + * configuration of the builder, and then building it into a class instance, + * as in the following example: + *

+ * ComposableBody body = ComposableBody.builder()
+ *     .setNamespaceDefinition("foo", "http://foo.com/bar")
+ *     .setPayloadXML("Data to send to remote server")
+ *     .build();
+ *

+ * Class instances can also be "rebuilt", allowing them to be used as templates + * when building many similar messages: + *

+ * ComposableBody body2 = body.rebuild()
+ *     .setPayloadXML("More data to send")
+ *     .build();
+ *

+ * This class does only minimal syntactic and semantic checking with respect + * to what the generated XML will look like. It is up to the developer to + * protect against the definition of malformed XML messages when building + * instances of this class. + *

+ * Instances of this class are immutable and thread-safe. + */ +public final class ComposableBody extends AbstractBody { + + /** + * Pattern used to identify the beginning {@code body} element of a + * BOSH message. + */ + private static final Pattern BOSH_START = + Pattern.compile("<" + + "body" + "(?:[\t\n\r ][^>]*?)?" + "(/>|>)", Pattern.UNICODE_CASE); + + /** + * Map of all attributes to their values. + */ + private final Map attrs; + + /** + * Payload XML. + */ + private final String payload; + + /** + * Computed raw XML. + */ + private final AtomicReference computed = + new AtomicReference(); + + /** + * Class instance builder, after the builder pattern. This allows each + * message instance to be immutable while providing flexibility when + * building new messages. + *

+ * Instances of this class are not thread-safe. + */ + public static final class Builder { + private Map map; + private boolean doMapCopy; + private String payloadXML; + + /** + * Prevent direct construction. + */ + private Builder() { + // Empty + } + + /** + * Creates a builder which is initialized to the values of the + * provided {@code ComposableBody} instance. This allows an + * existing {@code ComposableBody} to be used as a + * template/starting point. + * + * @param source body template + * @return builder instance + */ + private static Builder fromBody(final ComposableBody source) { + Builder result = new Builder(); + result.map = source.getAttributes(); + result.doMapCopy = true; + result.payloadXML = source.payload; + return result; + } + + /** + * Set the body message's wrapped payload content. Any previous + * content will be replaced. + * + * @param xml payload XML content + * @return builder instance + */ + public Builder setPayloadXML(final String xml) { + if (xml == null) { + throw(new IllegalArgumentException( + "payload XML argument cannot be null")); + } + payloadXML = xml; + return this; + } + + /** + * Set an attribute on the message body / wrapper element. + * + * @param name qualified name of the attribute + * @param value value of the attribute + * @return builder instance + */ + public Builder setAttribute( + final BodyQName name, final String value) { + if (map == null) { + map = new HashMap(); + } else if (doMapCopy) { + map = new HashMap(map); + doMapCopy = false; + } + if (value == null) { + map.remove(name); + } else { + map.put(name, value); + } + return this; + } + + /** + * Convenience method to set a namespace definition. This would result + * in a namespace prefix definition similar to: + * {@code } + * + * @param prefix prefix to define + * @param uri namespace URI to associate with the prefix + * @return builder instance + */ + public Builder setNamespaceDefinition( + final String prefix, final String uri) { + BodyQName qname = BodyQName.createWithPrefix( + XMLConstants.XML_NS_URI, prefix, + XMLConstants.XMLNS_ATTRIBUTE); + return setAttribute(qname, uri); + } + + /** + * Build the immutable object instance with the current configuration. + * + * @return composable body instance + */ + public ComposableBody build() { + if (map == null) { + map = new HashMap(); + } + if (payloadXML == null) { + payloadXML = ""; + } + return new ComposableBody(map, payloadXML); + } + } + + /////////////////////////////////////////////////////////////////////////// + // Constructors: + + /** + * Prevent direct construction. This constructor is for body messages + * which are dynamically assembled. + */ + private ComposableBody( + final Map attrMap, + final String payloadXML) { + super(); + attrs = attrMap; + payload = payloadXML; + } + + /** + * Parse a static body instance into a composable instance. This is an + * expensive operation and should not be used lightly. + *

+ * The current implementation does not obtain the payload XML by means of + * a proper XML parser. It uses some string pattern searching to find the + * first @{code body} element and the last element's closing tag. It is + * assumed that the static body's XML is well formed, etc.. This + * implementation may change in the future. + * + * @param body static body instance to convert + * @return composable bosy instance + * @throws BOSHException + */ + static ComposableBody fromStaticBody(final StaticBody body) + throws BOSHException { + String raw = body.toXML(); + Matcher matcher = BOSH_START.matcher(raw); + if (!matcher.find()) { + throw(new BOSHException( + "Could not locate 'body' element in XML. The raw XML did" + + " not match the pattern: " + BOSH_START)); + } + String payload; + if (">".equals(matcher.group(1))) { + int first = matcher.end(); + int last = raw.lastIndexOf(" getAttributes() { + return Collections.unmodifiableMap(attrs); + } + + /** + * {@inheritDoc} + */ + public String toXML() { + String comp = computed.get(); + if (comp == null) { + comp = computeXML(); + computed.set(comp); + } + return comp; + } + + /** + * Get the paylaod XML in String form. + * + * @return payload XML + */ + public String getPayloadXML() { + return payload; + } + + /////////////////////////////////////////////////////////////////////////// + // Private methods: + + /** + * Escape the value of an attribute to ensure we maintain valid + * XML syntax. + * + * @param value value to escape + * @return escaped value + */ + private String escape(final String value) { + return value.replace("'", "'"); + } + + /** + * Generate a String representation of the message body. + * + * @return XML string representation of the body + */ + private String computeXML() { + BodyQName bodyName = getBodyQName(); + StringBuilder builder = new StringBuilder(); + builder.append("<"); + builder.append(bodyName.getLocalPart()); + for (Map.Entry entry : attrs.entrySet()) { + builder.append(" "); + BodyQName name = entry.getKey(); + String prefix = name.getPrefix(); + if (prefix != null && prefix.length() > 0) { + builder.append(prefix); + builder.append(":"); + } + builder.append(name.getLocalPart()); + builder.append("='"); + builder.append(escape(entry.getValue())); + builder.append("'"); + } + builder.append(" "); + builder.append(XMLConstants.XMLNS_ATTRIBUTE); + builder.append("='"); + builder.append(bodyName.getNamespaceURI()); + builder.append("'>"); + if (payload != null) { + builder.append(payload); + } + builder.append(""); + return builder.toString(); + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/GZIPCodec.java b/external/asmack/build/src/trunk/com/kenai/jbosh/GZIPCodec.java new file mode 100644 index 0000000..988f27f --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/GZIPCodec.java @@ -0,0 +1,104 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.util.zip.GZIPInputStream; +import java.util.zip.GZIPOutputStream; + +/** + * Codec methods for compressing and uncompressing using GZIP. + */ +final class GZIPCodec { + + /** + * Size of the internal buffer when decoding. + */ + private static final int BUFFER_SIZE = 512; + + /////////////////////////////////////////////////////////////////////////// + // Constructors: + + /** + * Prevent construction. + */ + private GZIPCodec() { + // Empty + } + + /** + * Returns the name of the codec. + * + * @return string name of the codec (i.e., "gzip") + */ + public static String getID() { + return "gzip"; + } + + /** + * Compress/encode the data provided using the GZIP format. + * + * @param data data to compress + * @return compressed data + * @throws IOException on compression failure + */ + public static byte[] encode(final byte[] data) throws IOException { + ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); + GZIPOutputStream gzOut = null; + try { + gzOut = new GZIPOutputStream(byteOut); + gzOut.write(data); + gzOut.close(); + byteOut.close(); + return byteOut.toByteArray(); + } finally { + gzOut.close(); + byteOut.close(); + } + } + + /** + * Uncompress/decode the data provided using the GZIP format. + * + * @param data data to uncompress + * @return uncompressed data + * @throws IOException on decompression failure + */ + public static byte[] decode(final byte[] compressed) throws IOException { + ByteArrayInputStream byteIn = new ByteArrayInputStream(compressed); + ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); + GZIPInputStream gzIn = null; + try { + gzIn = new GZIPInputStream(byteIn); + int read; + byte[] buffer = new byte[BUFFER_SIZE]; + do { + read = gzIn.read(buffer); + if (read > 0) { + byteOut.write(buffer, 0, read); + } + } while (read >= 0); + return byteOut.toByteArray(); + } finally { + gzIn.close(); + byteOut.close(); + } + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/HTTPExchange.java b/external/asmack/build/src/trunk/com/kenai/jbosh/HTTPExchange.java new file mode 100644 index 0000000..c77caf0 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/HTTPExchange.java @@ -0,0 +1,126 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * A request and response pair representing a single exchange with a remote + * content manager. This is primarily a container class intended to maintain + * the relationship between the request and response but allows the response + * to be added after the fact. + */ +final class HTTPExchange { + + /** + * Logger. + */ + private static final Logger LOG = + Logger.getLogger(HTTPExchange.class.getName()); + + /** + * Request body. + */ + private final AbstractBody request; + + /** + * Lock instance used to protect and provide conditions. + */ + private final Lock lock = new ReentrantLock(); + + /** + * Condition used to signal when the response has been set. + */ + private final Condition ready = lock.newCondition(); + + /** + * HTTPResponse instance. + */ + private HTTPResponse response; + + /////////////////////////////////////////////////////////////////////////// + // Constructor: + + /** + * Create a new request/response pair object. + * + * @param req request message body + */ + HTTPExchange(final AbstractBody req) { + if (req == null) { + throw(new IllegalArgumentException("Request body cannot be null")); + } + request = req; + } + + /////////////////////////////////////////////////////////////////////////// + // Package-private methods: + + /** + * Get the original request message. + * + * @return request message body. + */ + AbstractBody getRequest() { + return request; + } + + /** + * Set the HTTPResponse instance. + * + * @return HTTPResponse instance associated with the request. + */ + void setHTTPResponse(HTTPResponse resp) { + lock.lock(); + try { + if (response != null) { + throw(new IllegalStateException( + "HTTPResponse was already set")); + } + response = resp; + ready.signalAll(); + } finally { + lock.unlock(); + } + } + + /** + * Get the HTTPResponse instance. + * + * @return HTTPResponse instance associated with the request. + */ + HTTPResponse getHTTPResponse() { + lock.lock(); + try { + while (response == null) { + try { + ready.await(); + } catch (InterruptedException intx) { + LOG.log(Level.FINEST, "Interrupted", intx); + } + } + return response; + } finally { + lock.unlock(); + } + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/HTTPResponse.java b/external/asmack/build/src/trunk/com/kenai/jbosh/HTTPResponse.java new file mode 100644 index 0000000..f1f301c --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/HTTPResponse.java @@ -0,0 +1,54 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * This class represents a complete HTTP response to a request made via + * a {@code HTTPSender} send request. Instances of this interface are + * intended to represent a deferred, future response, not necessarily a + * response which is immediately available. + */ +interface HTTPResponse { + + /** + * Close out any resources still held by the original request. The + * conversation may need to be aborted if the session it was a part of + * gets abruptly terminated. + */ + void abort(); + + /** + * Get the HTTP status code of the response (e.g., 200, 404, etc.). If + * the response has not yet been received from the remote server, this + * method should block until the response has arrived. + * + * @return HTTP status code + * @throws InterruptedException if interrupted while awaiting response + */ + int getHTTPStatus() throws InterruptedException, BOSHException; + + /** + * Get the HTTP response message body. If the response has not yet been + * received from the remote server, this method should block until the + * response has arrived. + * + * @return response message body + * @throws InterruptedException if interrupted while awaiting response + */ + AbstractBody getBody() throws InterruptedException, BOSHException; + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/HTTPSender.java b/external/asmack/build/src/trunk/com/kenai/jbosh/HTTPSender.java new file mode 100644 index 0000000..486d274 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/HTTPSender.java @@ -0,0 +1,54 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +/** + * Interface used to represent code which can send a BOSH XML body over + * HTTP to a connection manager. + */ +interface HTTPSender { + + /** + * Initialize the HTTP sender instance for use with the session provided. + * This method will be called once before use of the service instance. + * + * @param sessionCfg session configuration + */ + void init(BOSHClientConfig sessionCfg); + + /** + * Dispose of all resources used to provide the required services. This + * method will be called once when the service instance is no longer + * required. + */ + void destroy(); + + /** + * Create a {@code Callable} instance which can be used to send the + * request specified to the connection manager. This method should + * return immediately, prior to doing any real work. The invocation + * of the returned {@code Callable} should send the request (if it has + * not already been sent by the time of the call), block while waiting + * for the response, and then return the response body. + * + * @param params CM session creation resopnse params + * @param body request body to send + * @return callable used to access the response + */ + HTTPResponse send(CMSessionParams params, AbstractBody body); + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/QName.java b/external/asmack/build/src/trunk/com/kenai/jbosh/QName.java new file mode 100644 index 0000000..d395a06 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/QName.java @@ -0,0 +1,269 @@ +/* + * The Apache Software License, Version 1.1 + * + * + * Copyright (c) 2001-2003 The Apache Software Foundation. All rights + * reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. The end-user documentation included with the redistribution, + * if any, must include the following acknowledgment: + * "This product includes software developed by the + * Apache Software Foundation (http://www.apache.org/)." + * Alternately, this acknowledgment may appear in the software itself, + * if and wherever such third-party acknowledgments normally appear. + * + * 4. The names "Axis" and "Apache Software Foundation" must + * not be used to endorse or promote products derived from this + * software without prior written permission. For written + * permission, please contact apache@apache.org. + * + * 5. Products derived from this software may not be called "Apache", + * nor may "Apache" appear in their name, without prior written + * permission of the Apache Software Foundation. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * ==================================================================== + * + * This software consists of voluntary contributions made by many + * individuals on behalf of the Apache Software Foundation. For more + * information on the Apache Software Foundation, please see + * . + */ +package com.kenai.jbosh; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.Serializable; + +/** + * QName class represents the value of a qualified name + * as specified in XML + * Schema Part2: Datatypes specification. + *

+ * The value of a QName contains a namespaceURI, a localPart and a prefix. + * The localPart provides the local part of the qualified name. The + * namespaceURI is a URI reference identifying the namespace. + * + * @version 1.1 + */ +public class QName implements Serializable { + + /** comment/shared empty string */ + private static final String emptyString = "".intern(); + + /** Field namespaceURI */ + private String namespaceURI; + + /** Field localPart */ + private String localPart; + + /** Field prefix */ + private String prefix; + + /** + * Constructor for the QName. + * + * @param localPart Local part of the QName + */ + public QName(String localPart) { + this(emptyString, localPart, emptyString); + } + + /** + * Constructor for the QName. + * + * @param namespaceURI Namespace URI for the QName + * @param localPart Local part of the QName. + */ + public QName(String namespaceURI, String localPart) { + this(namespaceURI, localPart, emptyString); + } + + /** + * Constructor for the QName. + * + * @param namespaceURI Namespace URI for the QName + * @param localPart Local part of the QName. + * @param prefix Prefix of the QName. + */ + public QName(String namespaceURI, String localPart, String prefix) { + this.namespaceURI = (namespaceURI == null) + ? emptyString + : namespaceURI.intern(); + if (localPart == null) { + throw new IllegalArgumentException("invalid QName local part"); + } else { + this.localPart = localPart.intern(); + } + + if (prefix == null) { + throw new IllegalArgumentException("invalid QName prefix"); + } else { + this.prefix = prefix.intern(); + } + } + + /** + * Gets the Namespace URI for this QName + * + * @return Namespace URI + */ + public String getNamespaceURI() { + return namespaceURI; + } + + /** + * Gets the Local part for this QName + * + * @return Local part + */ + public String getLocalPart() { + return localPart; + } + + /** + * Gets the Prefix for this QName + * + * @return Prefix + */ + public String getPrefix() { + return prefix; + } + + /** + * Returns a string representation of this QName + * + * @return a string representation of the QName + */ + public String toString() { + + return ((namespaceURI == emptyString) + ? localPart + : '{' + namespaceURI + '}' + localPart); + } + + /** + * Tests this QName for equality with another object. + *

+ * If the given object is not a QName or is null then this method + * returns false. + *

+ * For two QNames to be considered equal requires that both + * localPart and namespaceURI must be equal. This method uses + * String.equals to check equality of localPart + * and namespaceURI. Any class that extends QName is required + * to satisfy this equality contract. + *

+ * This method satisfies the general contract of the Object.equals method. + * + * @param obj the reference object with which to compare + * + * @return true if the given object is identical to this + * QName: false otherwise. + */ + public final boolean equals(Object obj) { + + if (obj == this) { + return true; + } + + if (!(obj instanceof QName)) { + return false; + } + + if ((namespaceURI == ((QName) obj).namespaceURI) + && (localPart == ((QName) obj).localPart)) { + return true; + } + + return false; + } + + /** + * Returns a QName holding the value of the specified String. + *

+ * The string must be in the form returned by the QName.toString() + * method, i.e. "{namespaceURI}localPart", with the "{namespaceURI}" + * part being optional. + *

+ * This method doesn't do a full validation of the resulting QName. + * In particular, it doesn't check that the resulting namespace URI + * is a legal URI (per RFC 2396 and RFC 2732), nor that the resulting + * local part is a legal NCName per the XML Namespaces specification. + * + * @param s the string to be parsed + * @throws java.lang.IllegalArgumentException If the specified String cannot be parsed as a QName + * @return QName corresponding to the given String + */ + public static QName valueOf(String s) { + + if ((s == null) || s.equals("")) { + throw new IllegalArgumentException("invalid QName literal"); + } + + if (s.charAt(0) == '{') { + int i = s.indexOf('}'); + + if (i == -1) { + throw new IllegalArgumentException("invalid QName literal"); + } + + if (i == s.length() - 1) { + throw new IllegalArgumentException("invalid QName literal"); + } else { + return new QName(s.substring(1, i), s.substring(i + 1)); + } + } else { + return new QName(s); + } + } + + /** + * Returns a hash code value for this QName object. The hash code + * is based on both the localPart and namespaceURI parts of the + * QName. This method satisfies the general contract of the + * Object.hashCode method. + * + * @return a hash code value for this Qname object + */ + public final int hashCode() { + return namespaceURI.hashCode() ^ localPart.hashCode(); + } + + /** + * Ensure that deserialization properly interns the results. + * @param in the ObjectInputStream to be read + */ + private void readObject(ObjectInputStream in) throws + IOException, ClassNotFoundException { + in.defaultReadObject(); + + namespaceURI = namespaceURI.intern(); + localPart = localPart.intern(); + prefix = prefix.intern(); + } +} + diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/RequestIDSequence.java b/external/asmack/build/src/trunk/com/kenai/jbosh/RequestIDSequence.java new file mode 100644 index 0000000..14b1475 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/RequestIDSequence.java @@ -0,0 +1,120 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.security.SecureRandom; +import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +/** + * Request ID sequence generator. This generator generates a random first + * RID and then manages the sequence from there on out. + */ +final class RequestIDSequence { + + /** + * Maximum number of bits available for representing request IDs, according + * to the XEP-0124 spec.s + */ + private static final int MAX_BITS = 53; + + /** + * Bits devoted to incremented values. + */ + private static final int INCREMENT_BITS = 32; + + /** + * Minimum number of times the initial RID can be incremented before + * exceeding the maximum. + */ + private static final long MIN_INCREMENTS = 1L << INCREMENT_BITS; + + /** + * Max initial value. + */ + private static final long MAX_INITIAL = (1L << MAX_BITS) - MIN_INCREMENTS; + + /** + * Max bits mask. + */ + private static final long MASK = ~(Long.MAX_VALUE << MAX_BITS); + + /** + * Random number generator. + */ + private static final SecureRandom RAND = new SecureRandom(); + + /** + * Internal lock. + */ + private static final Lock LOCK = new ReentrantLock(); + + /** + * The last reqest ID used, or <= 0 if a new request ID needs to be + * generated. + */ + private AtomicLong nextRequestID = new AtomicLong(); + + /////////////////////////////////////////////////////////////////////////// + // Constructors: + + /** + * Prevent direct construction. + */ + RequestIDSequence() { + nextRequestID = new AtomicLong(generateInitialValue()); + } + + /////////////////////////////////////////////////////////////////////////// + // Public methods: + + /** + * Calculates the next request ID value to use. This number must be + * initialized such that it is unlikely to ever exceed 2 ^ 53, according + * to XEP-0124. + * + * @return next request ID value + */ + public long getNextRID() { + return nextRequestID.getAndIncrement(); + } + + /////////////////////////////////////////////////////////////////////////// + // Private methods: + + /** + * Generates an initial RID value by generating numbers until a number is + * found which is smaller than the maximum allowed value and greater + * than zero. + * + * @return random initial value + */ + private long generateInitialValue() { + long result; + LOCK.lock(); + try { + do { + result = RAND.nextLong() & MASK; + } while (result > MAX_INITIAL); + } finally { + LOCK.unlock(); + } + return result; + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/ServiceLib.java b/external/asmack/build/src/trunk/com/kenai/jbosh/ServiceLib.java new file mode 100644 index 0000000..07d0556 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/ServiceLib.java @@ -0,0 +1,195 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.io.BufferedReader; +import java.io.Closeable; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.net.URL; +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * Utility library for use in loading services using the Jar Service + * Provider Interface (Jar SPI). This can be replaced once the minimum + * java rev moves beyond Java 5. + */ +final class ServiceLib { + + /** + * Logger. + */ + private static final Logger LOG = + Logger.getLogger(ServiceLib.class.getName()); + + /////////////////////////////////////////////////////////////////////////// + // Package-private methods: + + /** + * Prevent construction. + */ + private ServiceLib() { + // Empty + } + + /////////////////////////////////////////////////////////////////////////// + // Package-private methods: + + /** + * Probe for and select an implementation of the specified service + * type by using the a modified Jar SPI mechanism. Modified in that + * the system properties will be checked to see if there is a value + * set for the naem of the class to be loaded. If so, that value is + * treated as the class name of the first implementation class to be + * attempted to be loaded. This provides a (unsupported) mechanism + * to insert other implementations. Note that the supported mechanism + * is by properly ordering the classpath. + * + * @return service instance + * @throws IllegalStateException is no service implementations could be + * instantiated + */ + static T loadService(Class ofType) { + List implClasses = loadServicesImplementations(ofType); + for (String implClass : implClasses) { + T result = attemptLoad(ofType, implClass); + if (result != null) { + if (LOG.isLoggable(Level.FINEST)) { + LOG.finest("Selected " + ofType.getSimpleName() + + " implementation: " + + result.getClass().getName()); + } + return result; + } + } + throw(new IllegalStateException( + "Could not load " + ofType.getName() + " implementation")); + } + + /////////////////////////////////////////////////////////////////////////// + // Private methods: + + /** + * Generates a list of implementation class names by using + * the Jar SPI technique. The order in which the class names occur + * in the service manifest is significant. + * + * @return list of all declared implementation class names + */ + private static List loadServicesImplementations( + final Class ofClass) { + List result = new ArrayList(); + + // Allow a sysprop to specify the first candidate + String override = System.getProperty(ofClass.getName()); + if (override != null) { + result.add(override); + } + + ClassLoader loader = ServiceLib.class.getClassLoader(); + URL url = loader.getResource("META-INF/services/" + ofClass.getName()); + InputStream inStream = null; + InputStreamReader reader = null; + BufferedReader bReader = null; + try { + inStream = url.openStream(); + reader = new InputStreamReader(inStream); + bReader = new BufferedReader(reader); + String line; + while ((line = bReader.readLine()) != null) { + if (!line.matches("\\s*(#.*)?")) { + // not a comment or blank line + result.add(line.trim()); + } + } + } catch (IOException iox) { + LOG.log(Level.WARNING, + "Could not load services descriptor: " + url.toString(), + iox); + } finally { + finalClose(bReader); + finalClose(reader); + finalClose(inStream); + } + return result; + } + + /** + * Attempts to load the specified implementation class. + * Attempts will fail if - for example - the implementation depends + * on a class not found on the classpath. + * + * @param className implementation class to attempt to load + * @return service instance, or {@code null} if the instance could not be + * loaded + */ + private static T attemptLoad( + final Class ofClass, + final String className) { + if (LOG.isLoggable(Level.FINEST)) { + LOG.finest("Attempting service load: " + className); + } + Level level; + Exception thrown; + try { + Class clazz = Class.forName(className); + if (!ofClass.isAssignableFrom(clazz)) { + if (LOG.isLoggable(Level.WARNING)) { + LOG.warning(clazz.getName() + " is not assignable to " + + ofClass.getName()); + } + return null; + } + return ofClass.cast(clazz.newInstance()); + } catch (ClassNotFoundException ex) { + level = Level.FINEST; + thrown = ex; + } catch (InstantiationException ex) { + level = Level.WARNING; + thrown = ex; + } catch (IllegalAccessException ex) { + level = Level.WARNING; + thrown = ex; + } + LOG.log(level, + "Could not load " + ofClass.getSimpleName() + + " instance: " + className, + thrown); + return null; + } + + /** + * Check and close a closeable object, trapping and ignoring any + * exception that might result. + * + * @param closeMe the thing to close + */ + private static void finalClose(final Closeable closeMe) { + if (closeMe != null) { + try { + closeMe.close(); + } catch (IOException iox) { + LOG.log(Level.FINEST, "Could not close: " + closeMe, iox); + } + } + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/StaticBody.java b/external/asmack/build/src/trunk/com/kenai/jbosh/StaticBody.java new file mode 100644 index 0000000..fe225fb --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/StaticBody.java @@ -0,0 +1,133 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.util.Collections; +import java.util.Map; + +/** + * Implementation of the {@code AbstractBody} class which allows for the + * definition of messages from pre-existing message content. Instances of + * this class are based on the underlying data and therefore cannot be + * modified. In order to obtain the wrapper element namespace and + * attribute information, the body content is partially parsed. + *

+ * Instances of this class are immutable and thread-safe. + */ +final class StaticBody extends AbstractBody { + + /** + * Selected parser to be used to process raw XML messages. + */ + private static final BodyParser PARSER = + new BodyParserXmlPull(); + + /** + * Size of the internal buffer when copying from a stream. + */ + private static final int BUFFER_SIZE = 1024; + + /** + * Map of all attributes to their values. + */ + private final Map attrs; + + /** + * This body message in raw XML form. + */ + private final String raw; + + /////////////////////////////////////////////////////////////////////////// + // Constructors: + + /** + * Prevent direct construction. + */ + private StaticBody( + final Map attrMap, + final String rawXML) { + attrs = attrMap; + raw = rawXML; + } + + /** + * Creates an instance which is initialized by reading a body + * message from the provided stream. + * + * @param inStream stream to read message XML from + * @return body instance + * @throws BOSHException on parse error + */ + public static StaticBody fromStream( + final InputStream inStream) + throws BOSHException { + ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); + try { + byte[] buffer = new byte[BUFFER_SIZE]; + int read; + do { + read = inStream.read(buffer); + if (read > 0) { + byteOut.write(buffer, 0, read); + } + } while (read >= 0); + } catch (IOException iox) { + throw(new BOSHException( + "Could not read body data", iox)); + } + return fromString(byteOut.toString()); + } + + /** + * Creates an instance which is initialized by reading a body + * message from the provided raw XML string. + * + * @param rawXML raw message XML in string form + * @return body instance + * @throws BOSHException on parse error + */ + public static StaticBody fromString( + final String rawXML) + throws BOSHException { + BodyParserResults results = PARSER.parse(rawXML); + return new StaticBody(results.getAttributes(), rawXML); + } + + + /** + * {@inheritDoc} + */ + public Map getAttributes() { + return Collections.unmodifiableMap(attrs); + } + + /** + * {@inheritDoc} + */ + public String toXML() { + return raw; + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/TerminalBindingCondition.java b/external/asmack/build/src/trunk/com/kenai/jbosh/TerminalBindingCondition.java new file mode 100644 index 0000000..0aecfd8 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/TerminalBindingCondition.java @@ -0,0 +1,208 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.util.HashMap; +import java.util.Map; + +/** + * Terminal binding conditions and their associated messages. + */ +final class TerminalBindingCondition { + + /** + * Map of condition names to condition instances. + */ + private static final Map + COND_TO_INSTANCE = new HashMap(); + + /** + * Map of HTTP response codes to condition instances. + */ + private static final Map + CODE_TO_INSTANCE = new HashMap(); + + static final TerminalBindingCondition BAD_REQUEST = + createWithCode("bad-request", "The format of an HTTP header or " + + "binding element received from the client is unacceptable " + + "(e.g., syntax error).", Integer.valueOf(400)); + + static final TerminalBindingCondition HOST_GONE = + create("host-gone", "The target domain specified in the 'to' " + + "attribute or the target host or port specified in the 'route' " + + "attribute is no longer serviced by the connection manager."); + + static final TerminalBindingCondition HOST_UNKNOWN = + create("host-unknown", "The target domain specified in the 'to' " + + "attribute or the target host or port specified in the 'route' " + + "attribute is unknown to the connection manager."); + + static final TerminalBindingCondition IMPROPER_ADDRESSING = + create("improper-addressing", "The initialization element lacks a " + + "'to' or 'route' attribute (or the attribute has no value) but " + + "the connection manager requires one."); + + static final TerminalBindingCondition INTERNAL_SERVER_ERROR = + create("internal-server-error", "The connection manager has " + + "experienced an internal error that prevents it from servicing " + + "the request."); + + static final TerminalBindingCondition ITEM_NOT_FOUND = + createWithCode("item-not-found", "(1) 'sid' is not valid, (2) " + + "'stream' is not valid, (3) 'rid' is larger than the upper limit " + + "of the expected window, (4) connection manager is unable to " + + "resend response, (5) 'key' sequence is invalid.", + Integer.valueOf(404)); + + static final TerminalBindingCondition OTHER_REQUEST = + create("other-request", "Another request being processed at the " + + "same time as this request caused the session to terminate."); + + static final TerminalBindingCondition POLICY_VIOLATION = + createWithCode("policy-violation", "The client has broken the " + + "session rules (polling too frequently, requesting too " + + "frequently, sending too many simultaneous requests).", + Integer.valueOf(403)); + + static final TerminalBindingCondition REMOTE_CONNECTION_FAILED = + create("remote-connection-failed", "The connection manager was " + + "unable to connect to, or unable to connect securely to, or has " + + "lost its connection to, the server."); + + static final TerminalBindingCondition REMOTE_STREAM_ERROR = + create("remote-stream-error", "Encapsulated transport protocol " + + "error."); + + static final TerminalBindingCondition SEE_OTHER_URI = + create("see-other-uri", "The connection manager does not operate " + + "at this URI (e.g., the connection manager accepts only SSL or " + + "TLS connections at some https: URI rather than the http: URI " + + "requested by the client)."); + + static final TerminalBindingCondition SYSTEM_SHUTDOWN = + create("system-shutdown", "The connection manager is being shut " + + "down. All active HTTP sessions are being terminated. No new " + + "sessions can be created."); + + static final TerminalBindingCondition UNDEFINED_CONDITION = + create("undefined-condition", "Unknown or undefined error " + + "condition."); + + /** + * Condition name. + */ + private final String cond; + + /** + * Descriptive message. + */ + private final String msg; + + /** + * Private constructor to pre + */ + private TerminalBindingCondition( + final String condition, + final String message) { + cond = condition; + msg = message; + } + + /** + * Helper method to call the helper method to add entries. + */ + private static TerminalBindingCondition create( + final String condition, + final String message) { + return createWithCode(condition, message, null); + } + + /** + * Helper method to add entries. + */ + private static TerminalBindingCondition createWithCode( + final String condition, + final String message, + final Integer code) { + if (condition == null) { + throw(new IllegalArgumentException( + "condition may not be null")); + } + if (message == null) { + throw(new IllegalArgumentException( + "message may not be null")); + } + if (COND_TO_INSTANCE.get(condition) != null) { + throw(new IllegalStateException( + "Multiple definitions of condition: " + condition)); + } + TerminalBindingCondition result = + new TerminalBindingCondition(condition, message); + COND_TO_INSTANCE.put(condition, result); + if (code != null) { + if (CODE_TO_INSTANCE.get(code) != null) { + throw(new IllegalStateException( + "Multiple definitions of code: " + code)); + } + CODE_TO_INSTANCE.put(code, result); + } + return result; + } + + /** + * Lookup the terminal binding condition instance with the condition + * name specified. + * + * @param condStr condition name + * @return terminal binding condition instance, or {@code null} if no + * instance is known by the name specified + */ + static TerminalBindingCondition forString(final String condStr) { + return COND_TO_INSTANCE.get(condStr); + } + + /** + * Lookup the terminal binding condition instance associated with the + * HTTP response code specified. + * + * @param httpRespCode HTTP response code + * @return terminal binding condition instance, or {@code null} if no + * instance is known by the response code specified + */ + static TerminalBindingCondition forHTTPResponseCode(final int httpRespCode) { + return CODE_TO_INSTANCE.get(Integer.valueOf(httpRespCode)); + } + + /** + * Get the name of the condition. + * + * @return condition name + */ + String getCondition() { + return cond; + } + + /** + * Get the human readable error message associated with this condition. + * + * @return error message + */ + String getMessage() { + return msg; + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/ZLIBCodec.java b/external/asmack/build/src/trunk/com/kenai/jbosh/ZLIBCodec.java new file mode 100644 index 0000000..20844ad --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/ZLIBCodec.java @@ -0,0 +1,104 @@ +/* + * Copyright 2009 Mike Cumings + * + * 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 com.kenai.jbosh; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.util.zip.DeflaterOutputStream; +import java.util.zip.InflaterInputStream; + +/** + * Codec methods for compressing and uncompressing using ZLIB. + */ +final class ZLIBCodec { + + /** + * Size of the internal buffer when decoding. + */ + private static final int BUFFER_SIZE = 512; + + /////////////////////////////////////////////////////////////////////////// + // Constructors: + + /** + * Prevent construction. + */ + private ZLIBCodec() { + // Empty + } + + /** + * Returns the name of the codec. + * + * @return string name of the codec (i.e., "deflate") + */ + public static String getID() { + return "deflate"; + } + + /** + * Compress/encode the data provided using the ZLIB format. + * + * @param data data to compress + * @return compressed data + * @throws IOException on compression failure + */ + public static byte[] encode(final byte[] data) throws IOException { + ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); + DeflaterOutputStream deflateOut = null; + try { + deflateOut = new DeflaterOutputStream(byteOut); + deflateOut.write(data); + deflateOut.close(); + byteOut.close(); + return byteOut.toByteArray(); + } finally { + deflateOut.close(); + byteOut.close(); + } + } + + /** + * Uncompress/decode the data provided using the ZLIB format. + * + * @param data data to uncompress + * @return uncompressed data + * @throws IOException on decompression failure + */ + public static byte[] decode(final byte[] compressed) throws IOException { + ByteArrayInputStream byteIn = new ByteArrayInputStream(compressed); + ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); + InflaterInputStream inflaterIn = null; + try { + inflaterIn = new InflaterInputStream(byteIn); + int read; + byte[] buffer = new byte[BUFFER_SIZE]; + do { + read = inflaterIn.read(buffer); + if (read > 0) { + byteOut.write(buffer, 0, read); + } + } while (read >= 0); + return byteOut.toByteArray(); + } finally { + inflaterIn.close(); + byteOut.close(); + } + } + +} diff --git a/external/asmack/build/src/trunk/com/kenai/jbosh/package.html b/external/asmack/build/src/trunk/com/kenai/jbosh/package.html new file mode 100644 index 0000000..77a1924 --- /dev/null +++ b/external/asmack/build/src/trunk/com/kenai/jbosh/package.html @@ -0,0 +1,8 @@ + + + Core classes of the JBOSH API. +

+ Users of the client portion of the API should start by reading + up on the BOSHClient documentation. + + \ No newline at end of file diff --git a/external/asmack/build/src/trunk/com/novell/sasl/client/DigestChallenge.java b/external/asmack/build/src/trunk/com/novell/sasl/client/DigestChallenge.java new file mode 100644 index 0000000..90e6247 --- /dev/null +++ b/external/asmack/build/src/trunk/com/novell/sasl/client/DigestChallenge.java @@ -0,0 +1,393 @@ +/* ************************************************************************** + * $OpenLDAP: /com/novell/sasl/client/DigestChallenge.java,v 1.3 2005/01/17 15:00:54 sunilk Exp $ + * + * Copyright (C) 2003 Novell, Inc. All Rights Reserved. + * + * THIS WORK IS SUBJECT TO U.S. AND INTERNATIONAL COPYRIGHT LAWS AND + * TREATIES. USE, MODIFICATION, AND REDISTRIBUTION OF THIS WORK IS SUBJECT + * TO VERSION 2.0.1 OF THE OPENLDAP PUBLIC LICENSE, A COPY OF WHICH IS + * AVAILABLE AT HTTP://WWW.OPENLDAP.ORG/LICENSE.HTML OR IN THE FILE "LICENSE" + * IN THE TOP-LEVEL DIRECTORY OF THE DISTRIBUTION. ANY USE OR EXPLOITATION + * OF THIS WORK OTHER THAN AS AUTHORIZED IN VERSION 2.0.1 OF THE OPENLDAP + * PUBLIC LICENSE, OR OTHER PRIOR WRITTEN CONSENT FROM NOVELL, COULD SUBJECT + * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY. + ******************************************************************************/ +package com.novell.sasl.client; + +import java.util.*; +import org.apache.harmony.javax.security.sasl.*; + +/** + * Implements the DigestChallenge class which will be used by the + * DigestMD5SaslClient class + */ +class DigestChallenge extends Object +{ + public static final int QOP_AUTH = 0x01; + public static final int QOP_AUTH_INT = 0x02; + public static final int QOP_AUTH_CONF = 0x04; + public static final int QOP_UNRECOGNIZED = 0x08; + + private static final int CIPHER_3DES = 0x01; + private static final int CIPHER_DES = 0x02; + private static final int CIPHER_RC4_40 = 0x04; + private static final int CIPHER_RC4 = 0x08; + private static final int CIPHER_RC4_56 = 0x10; + private static final int CIPHER_UNRECOGNIZED = 0x20; + private static final int CIPHER_RECOGNIZED_MASK = + CIPHER_3DES | CIPHER_DES | CIPHER_RC4_40 | CIPHER_RC4 | CIPHER_RC4_56; + + private ArrayList m_realms; + private String m_nonce; + private int m_qop; + private boolean m_staleFlag; + private int m_maxBuf; + private String m_characterSet; + private String m_algorithm; + private int m_cipherOptions; + + DigestChallenge( + byte[] challenge) + throws SaslException + { + m_realms = new ArrayList(5); + m_nonce = null; + m_qop = 0; + m_staleFlag = false; + m_maxBuf = -1; + m_characterSet = null; + m_algorithm = null; + m_cipherOptions = 0; + + DirectiveList dirList = new DirectiveList(challenge); + try + { + dirList.parseDirectives(); + checkSemantics(dirList); + } + catch (SaslException e) + { + } + } + + /** + * Checks the semantics of the directives in the directive list as parsed + * from the digest challenge byte array. + * + * @param dirList the list of directives parsed from the digest challenge + * + * @exception SaslException If a semantic error occurs + */ + void checkSemantics( + DirectiveList dirList) throws SaslException + { + Iterator directives = dirList.getIterator(); + ParsedDirective directive; + String name; + + while (directives.hasNext()) + { + directive = (ParsedDirective)directives.next(); + name = directive.getName(); + if (name.equals("realm")) + handleRealm(directive); + else if (name.equals("nonce")) + handleNonce(directive); + else if (name.equals("qop")) + handleQop(directive); + else if (name.equals("maxbuf")) + handleMaxbuf(directive); + else if (name.equals("charset")) + handleCharset(directive); + else if (name.equals("algorithm")) + handleAlgorithm(directive); + else if (name.equals("cipher")) + handleCipher(directive); + else if (name.equals("stale")) + handleStale(directive); + } + + /* post semantic check */ + if (-1 == m_maxBuf) + m_maxBuf = 65536; + + if (m_qop == 0) + m_qop = QOP_AUTH; + else if ( (m_qop & QOP_AUTH) != QOP_AUTH ) + throw new SaslException("Only qop-auth is supported by client"); + else if ( ((m_qop & QOP_AUTH_CONF) == QOP_AUTH_CONF) && + (0 == (m_cipherOptions & CIPHER_RECOGNIZED_MASK)) ) + throw new SaslException("Invalid cipher options"); + else if (null == m_nonce) + throw new SaslException("Missing nonce directive"); + else if (m_staleFlag) + throw new SaslException("Unexpected stale flag"); + else if ( null == m_algorithm ) + throw new SaslException("Missing algorithm directive"); + } + + /** + * This function implements the semenatics of the nonce directive. + * + * @param pd ParsedDirective + * + * @exception SaslException If an error occurs due to too many nonce + * values + */ + void handleNonce( + ParsedDirective pd) throws SaslException + { + if (null != m_nonce) + throw new SaslException("Too many nonce values."); + + m_nonce = pd.getValue(); + } + + /** + * This function implements the semenatics of the realm directive. + * + * @param pd ParsedDirective + */ + void handleRealm( + ParsedDirective pd) + { + m_realms.add(pd.getValue()); + } + + /** + * This function implements the semenatics of the qop (quality of protection) + * directive. The value of the qop directive is as defined below: + * qop-options = "qop" "=" <"> qop-list <"> + * qop-list = 1#qop-value + * qop-value = "auth" | "auth-int" | "auth-conf" | token + * + * @param pd ParsedDirective + * + * @exception SaslException If an error occurs due to too many qop + * directives + */ + void handleQop( + ParsedDirective pd) throws SaslException + { + String token; + TokenParser parser; + + if (m_qop != 0) + throw new SaslException("Too many qop directives."); + + parser = new TokenParser(pd.getValue()); + for (token = parser.parseToken(); + token != null; + token = parser.parseToken()) + { + if (token.equals("auth")) + m_qop |= QOP_AUTH; + else if (token.equals("auth-int")) + m_qop |= QOP_AUTH_INT; + else if (token.equals("auth-conf")) + m_qop |= QOP_AUTH_CONF; + else + m_qop |= QOP_UNRECOGNIZED; + } + } + + /** + * This function implements the semenatics of the Maxbuf directive. + * the value is defined as: 1*DIGIT + * + * @param pd ParsedDirective + * + * @exception SaslException If an error occur + */ + void handleMaxbuf( + ParsedDirective pd) throws SaslException + { + if (-1 != m_maxBuf) /*it's initialized to -1 */ + throw new SaslException("Too many maxBuf directives."); + + m_maxBuf = Integer.parseInt(pd.getValue()); + + if (0 == m_maxBuf) + throw new SaslException("Max buf value must be greater than zero."); + } + + /** + * This function implements the semenatics of the charset directive. + * the value is defined as: 1*DIGIT + * + * @param pd ParsedDirective + * + * @exception SaslException If an error occurs dur to too many charset + * directives or Invalid character encoding + * directive + */ + void handleCharset( + ParsedDirective pd) throws SaslException + { + if (null != m_characterSet) + throw new SaslException("Too many charset directives."); + + m_characterSet = pd.getValue(); + + if (!m_characterSet.equals("utf-8")) + throw new SaslException("Invalid character encoding directive"); + } + + /** + * This function implements the semenatics of the charset directive. + * the value is defined as: 1*DIGIT + * + * @param pd ParsedDirective + * + * @exception SaslException If an error occurs due to too many algorith + * directive or Invalid algorithm directive + * value + */ + void handleAlgorithm( + ParsedDirective pd) throws SaslException + { + if (null != m_algorithm) + throw new SaslException("Too many algorithm directives."); + + m_algorithm = pd.getValue(); + + if (!"md5-sess".equals(m_algorithm)) + throw new SaslException("Invalid algorithm directive value: " + + m_algorithm); + } + + /** + * This function implements the semenatics of the cipher-opts directive + * directive. The value of the qop directive is as defined below: + * qop-options = "qop" "=" <"> qop-list <"> + * qop-list = 1#qop-value + * qop-value = "auth" | "auth-int" | "auth-conf" | token + * + * @param pd ParsedDirective + * + * @exception SaslException If an error occurs due to Too many cipher + * directives + */ + void handleCipher( + ParsedDirective pd) throws SaslException + { + String token; + TokenParser parser; + + if (0 != m_cipherOptions) + throw new SaslException("Too many cipher directives."); + + parser = new TokenParser(pd.getValue()); + token = parser.parseToken(); + for (token = parser.parseToken(); + token != null; + token = parser.parseToken()) + { + if ("3des".equals(token)) + m_cipherOptions |= CIPHER_3DES; + else if ("des".equals(token)) + m_cipherOptions |= CIPHER_DES; + else if ("rc4-40".equals(token)) + m_cipherOptions |= CIPHER_RC4_40; + else if ("rc4".equals(token)) + m_cipherOptions |= CIPHER_RC4; + else if ("rc4-56".equals(token)) + m_cipherOptions |= CIPHER_RC4_56; + else + m_cipherOptions |= CIPHER_UNRECOGNIZED; + } + + if (m_cipherOptions == 0) + m_cipherOptions = CIPHER_UNRECOGNIZED; + } + + /** + * This function implements the semenatics of the stale directive. + * + * @param pd ParsedDirective + * + * @exception SaslException If an error occurs due to Too many stale + * directives or Invalid stale directive value + */ + void handleStale( + ParsedDirective pd) throws SaslException + { + if (false != m_staleFlag) + throw new SaslException("Too many stale directives."); + + if ("true".equals(pd.getValue())) + m_staleFlag = true; + else + throw new SaslException("Invalid stale directive value: " + + pd.getValue()); + } + + /** + * Return the list of the All the Realms + * + * @return List of all the realms + */ + public ArrayList getRealms() + { + return m_realms; + } + + /** + * @return Returns the Nonce + */ + public String getNonce() + { + return m_nonce; + } + + /** + * Return the quality-of-protection + * + * @return The quality-of-protection + */ + public int getQop() + { + return m_qop; + } + + /** + * @return The state of the Staleflag + */ + public boolean getStaleFlag() + { + return m_staleFlag; + } + + /** + * @return The Maximum Buffer value + */ + public int getMaxBuf() + { + return m_maxBuf; + } + + /** + * @return character set values as string + */ + public String getCharacterSet() + { + return m_characterSet; + } + + /** + * @return The String value of the algorithm + */ + public String getAlgorithm() + { + return m_algorithm; + } + + /** + * @return The cipher options + */ + public int getCipherOptions() + { + return m_cipherOptions; + } +} + diff --git a/external/asmack/build/src/trunk/com/novell/sasl/client/DigestMD5SaslClient.java b/external/asmack/build/src/trunk/com/novell/sasl/client/DigestMD5SaslClient.java new file mode 100644 index 0000000..141c96b --- /dev/null +++ b/external/asmack/build/src/trunk/com/novell/sasl/client/DigestMD5SaslClient.java @@ -0,0 +1,820 @@ +/* ************************************************************************** + * $OpenLDAP: /com/novell/sasl/client/DigestMD5SaslClient.java,v 1.4 2005/01/17 15:00:54 sunilk Exp $ + * + * Copyright (C) 2003 Novell, Inc. All Rights Reserved. + * + * THIS WORK IS SUBJECT TO U.S. AND INTERNATIONAL COPYRIGHT LAWS AND + * TREATIES. USE, MODIFICATION, AND REDISTRIBUTION OF THIS WORK IS SUBJECT + * TO VERSION 2.0.1 OF THE OPENLDAP PUBLIC LICENSE, A COPY OF WHICH IS + * AVAILABLE AT HTTP://WWW.OPENLDAP.ORG/LICENSE.HTML OR IN THE FILE "LICENSE" + * IN THE TOP-LEVEL DIRECTORY OF THE DISTRIBUTION. ANY USE OR EXPLOITATION + * OF THIS WORK OTHER THAN AS AUTHORIZED IN VERSION 2.0.1 OF THE OPENLDAP + * PUBLIC LICENSE, OR OTHER PRIOR WRITTEN CONSENT FROM NOVELL, COULD SUBJECT + * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY. + ******************************************************************************/ +package com.novell.sasl.client; + +import org.apache.harmony.javax.security.sasl.*; +import org.apache.harmony.javax.security.auth.callback.*; +import java.security.SecureRandom; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.io.UnsupportedEncodingException; +import java.io.IOException; +import java.util.*; + +/** + * Implements the Client portion of DigestMD5 Sasl mechanism. + */ +public class DigestMD5SaslClient implements SaslClient +{ + private String m_authorizationId = ""; + private String m_protocol = ""; + private String m_serverName = ""; + private Map m_props; + private CallbackHandler m_cbh; + private int m_state; + private String m_qopValue = ""; + private char[] m_HA1 = null; + private String m_digestURI; + private DigestChallenge m_dc; + private String m_clientNonce = ""; + private String m_realm = ""; + private String m_name = ""; + + private static final int STATE_INITIAL = 0; + private static final int STATE_DIGEST_RESPONSE_SENT = 1; + private static final int STATE_VALID_SERVER_RESPONSE = 2; + private static final int STATE_INVALID_SERVER_RESPONSE = 3; + private static final int STATE_DISPOSED = 4; + + private static final int NONCE_BYTE_COUNT = 32; + private static final int NONCE_HEX_COUNT = 2*NONCE_BYTE_COUNT; + + private static final String DIGEST_METHOD = "AUTHENTICATE"; + + /** + * Creates an DigestMD5SaslClient object using the parameters supplied. + * Assumes that the QOP, STRENGTH, and SERVER_AUTH properties are + * contained in props + * + * @param authorizationId The possibly null protocol-dependent + * identification to be used for authorization. If + * null or empty, the server derives an authorization + * ID from the client's authentication credentials. + * When the SASL authentication completes + * successfully, the specified entity is granted + * access. + * + * @param protocol The non-null string name of the protocol for which + * the authentication is being performed (e.g. "ldap") + * + * @param serverName The non-null fully qualified host name of the server + * to authenticate to + * + * @param props The possibly null set of properties used to select + * the SASL mechanism and to configure the + * authentication exchange of the selected mechanism. + * See the Sasl class for a list of standard properties. + * Other, possibly mechanism-specific, properties can + * be included. Properties not relevant to the selected + * mechanism are ignored. + * + * @param cbh The possibly null callback handler to used by the + * SASL mechanisms to get further information from the + * application/library to complete the authentication. + * For example, a SASL mechanism might require the + * authentication ID, password and realm from the + * caller. The authentication ID is requested by using + * a NameCallback. The password is requested by using + * a PasswordCallback. The realm is requested by using + * a RealmChoiceCallback if there is a list of realms + * to choose from, and by using a RealmCallback if the + * realm must be entered. + * + * @return A possibly null SaslClient created using the + * parameters supplied. If null, this factory cannot + * produce a SaslClient using the parameters supplied. + * + * @exception SaslException If a SaslClient instance cannot be created + * because of an error + */ + public static SaslClient getClient( + String authorizationId, + String protocol, + String serverName, + Map props, + CallbackHandler cbh) + { + String desiredQOP = (String)props.get(Sasl.QOP); + String desiredStrength = (String)props.get(Sasl.STRENGTH); + String serverAuth = (String)props.get(Sasl.SERVER_AUTH); + + //only support qop equal to auth + if ((desiredQOP != null) && !"auth".equals(desiredQOP)) + return null; + + //doesn't support server authentication + if ((serverAuth != null) && !"false".equals(serverAuth)) + return null; + + //need a callback handler to get the password + if (cbh == null) + return null; + + return new DigestMD5SaslClient(authorizationId, protocol, + serverName, props, cbh); + } + + /** + * Creates an DigestMD5SaslClient object using the parameters supplied. + * Assumes that the QOP, STRENGTH, and SERVER_AUTH properties are + * contained in props + * + * @param authorizationId The possibly null protocol-dependent + * identification to be used for authorization. If + * null or empty, the server derives an authorization + * ID from the client's authentication credentials. + * When the SASL authentication completes + * successfully, the specified entity is granted + * access. + * + * @param protocol The non-null string name of the protocol for which + * the authentication is being performed (e.g. "ldap") + * + * @param serverName The non-null fully qualified host name of the server + * to authenticate to + * + * @param props The possibly null set of properties used to select + * the SASL mechanism and to configure the + * authentication exchange of the selected mechanism. + * See the Sasl class for a list of standard properties. + * Other, possibly mechanism-specific, properties can + * be included. Properties not relevant to the selected + * mechanism are ignored. + * + * @param cbh The possibly null callback handler to used by the + * SASL mechanisms to get further information from the + * application/library to complete the authentication. + * For example, a SASL mechanism might require the + * authentication ID, password and realm from the + * caller. The authentication ID is requested by using + * a NameCallback. The password is requested by using + * a PasswordCallback. The realm is requested by using + * a RealmChoiceCallback if there is a list of realms + * to choose from, and by using a RealmCallback if the + * realm must be entered. + * + */ + private DigestMD5SaslClient( + String authorizationId, + String protocol, + String serverName, + Map props, + CallbackHandler cbh) + { + m_authorizationId = authorizationId; + m_protocol = protocol; + m_serverName = serverName; + m_props = props; + m_cbh = cbh; + + m_state = STATE_INITIAL; + } + + /** + * Determines if this mechanism has an optional initial response. If true, + * caller should call evaluateChallenge() with an empty array to get the + * initial response. + * + * @return true if this mechanism has an initial response + */ + public boolean hasInitialResponse() + { + return false; + } + + /** + * Determines if the authentication exchange has completed. This method + * may be called at any time, but typically, it will not be called until + * the caller has received indication from the server (in a protocol- + * specific manner) that the exchange has completed. + * + * @return true if the authentication exchange has completed; + * false otherwise. + */ + public boolean isComplete() + { + if ((m_state == STATE_VALID_SERVER_RESPONSE) || + (m_state == STATE_INVALID_SERVER_RESPONSE) || + (m_state == STATE_DISPOSED)) + return true; + else + return false; + } + + /** + * Unwraps a byte array received from the server. This method can be called + * only after the authentication exchange has completed (i.e., when + * isComplete() returns true) and only if the authentication exchange has + * negotiated integrity and/or privacy as the quality of protection; + * otherwise, an IllegalStateException is thrown. + * + * incoming is the contents of the SASL buffer as defined in RFC 2222 + * without the leading four octet field that represents the length. + * offset and len specify the portion of incoming to use. + * + * @param incoming A non-null byte array containing the encoded bytes + * from the server + * @param offset The starting position at incoming of the bytes to use + * + * @param len The number of bytes from incoming to use + * + * @return A non-null byte array containing the decoded bytes + * + */ + public byte[] unwrap( + byte[] incoming, + int offset, + int len) + throws SaslException + { + throw new IllegalStateException( + "unwrap: QOP has neither integrity nor privacy>"); + } + + /** + * Wraps a byte array to be sent to the server. This method can be called + * only after the authentication exchange has completed (i.e., when + * isComplete() returns true) and only if the authentication exchange has + * negotiated integrity and/or privacy as the quality of protection; + * otherwise, an IllegalStateException is thrown. + * + * The result of this method will make up the contents of the SASL buffer as + * defined in RFC 2222 without the leading four octet field that represents + * the length. offset and len specify the portion of outgoing to use. + * + * @param outgoing A non-null byte array containing the bytes to encode + * @param offset The starting position at outgoing of the bytes to use + * @param len The number of bytes from outgoing to use + * + * @return A non-null byte array containing the encoded bytes + * + * @exception SaslException if incoming cannot be successfully unwrapped. + * + * @exception IllegalStateException if the authentication exchange has + * not completed, or if the negotiated quality of + * protection has neither integrity nor privacy. + */ + public byte[] wrap( + byte[] outgoing, + int offset, + int len) + throws SaslException + { + throw new IllegalStateException( + "wrap: QOP has neither integrity nor privacy>"); + } + + /** + * Retrieves the negotiated property. This method can be called only after + * the authentication exchange has completed (i.e., when isComplete() + * returns true); otherwise, an IllegalStateException is thrown. + * + * @param propName The non-null property name + * + * @return The value of the negotiated property. If null, the property was + * not negotiated or is not applicable to this mechanism. + * + * @exception IllegalStateException if this authentication exchange has + * not completed + */ + public Object getNegotiatedProperty( + String propName) + { + if (m_state != STATE_VALID_SERVER_RESPONSE) + throw new IllegalStateException( + "getNegotiatedProperty: authentication exchange not complete."); + + if (Sasl.QOP.equals(propName)) + return "auth"; + else + return null; + } + + /** + * Disposes of any system resources or security-sensitive information the + * SaslClient might be using. Invoking this method invalidates the + * SaslClient instance. This method is idempotent. + * + * @exception SaslException if a problem was encountered while disposing + * of the resources + */ + public void dispose() + throws SaslException + { + if (m_state != STATE_DISPOSED) + { + m_state = STATE_DISPOSED; + } + } + + /** + * Evaluates the challenge data and generates a response. If a challenge + * is received from the server during the authentication process, this + * method is called to prepare an appropriate next response to submit to + * the server. + * + * @param challenge The non-null challenge sent from the server. The + * challenge array may have zero length. + * + * @return The possibly null reponse to send to the server. It is null + * if the challenge accompanied a "SUCCESS" status and the + * challenge only contains data for the client to update its + * state and no response needs to be sent to the server. + * The response is a zero-length byte array if the client is to + * send a response with no data. + * + * @exception SaslException If an error occurred while processing the + * challenge or generating a response. + */ + public byte[] evaluateChallenge( + byte[] challenge) + throws SaslException + { + byte[] response = null; + + //printState(); + switch (m_state) + { + case STATE_INITIAL: + if (challenge.length == 0) + throw new SaslException("response = byte[0]"); + else + try + { + response = createDigestResponse(challenge). + getBytes("UTF-8"); + m_state = STATE_DIGEST_RESPONSE_SENT; + } + catch (java.io.UnsupportedEncodingException e) + { + throw new SaslException( + "UTF-8 encoding not suppported by platform", e); + } + break; + case STATE_DIGEST_RESPONSE_SENT: + if (checkServerResponseAuth(challenge)) + m_state = STATE_VALID_SERVER_RESPONSE; + else + { + m_state = STATE_INVALID_SERVER_RESPONSE; + throw new SaslException("Could not validate response-auth " + + "value from server"); + } + break; + case STATE_VALID_SERVER_RESPONSE: + case STATE_INVALID_SERVER_RESPONSE: + throw new SaslException("Authentication sequence is complete"); + case STATE_DISPOSED: + throw new SaslException("Client has been disposed"); + default: + throw new SaslException("Unknown client state."); + } + + return response; + } + + /** + * This function takes a 16 byte binary md5-hash value and creates a 32 + * character (plus a terminating null character) hex-digit + * representation of binary data. + * + * @param hash 16 byte binary md5-hash value in bytes + * + * @return 32 character (plus a terminating null character) hex-digit + * representation of binary data. + */ + char[] convertToHex( + byte[] hash) + { + int i; + byte j; + byte fifteen = 15; + char[] hex = new char[32]; + + for (i = 0; i < 16; i++) + { + //convert value of top 4 bits to hex char + hex[i*2] = getHexChar((byte)((hash[i] & 0xf0) >> 4)); + //convert value of bottom 4 bits to hex char + hex[(i*2)+1] = getHexChar((byte)(hash[i] & 0x0f)); + } + + return hex; + } + + /** + * Calculates the HA1 portion of the response + * + * @param algorithm Algorith to use. + * @param userName User being authenticated + * @param realm realm information + * @param password password of teh user + * @param nonce nonce value + * @param clientNonce Clients Nonce value + * + * @return HA1 portion of the response in a character array + * + * @exception SaslException If an error occurs + */ + char[] DigestCalcHA1( + String algorithm, + String userName, + String realm, + String password, + String nonce, + String clientNonce) throws SaslException + { + byte[] hash; + + try + { + MessageDigest md = MessageDigest.getInstance("MD5"); + + md.update(userName.getBytes("UTF-8")); + md.update(":".getBytes("UTF-8")); + md.update(realm.getBytes("UTF-8")); + md.update(":".getBytes("UTF-8")); + md.update(password.getBytes("UTF-8")); + hash = md.digest(); + + if ("md5-sess".equals(algorithm)) + { + md.update(hash); + md.update(":".getBytes("UTF-8")); + md.update(nonce.getBytes("UTF-8")); + md.update(":".getBytes("UTF-8")); + md.update(clientNonce.getBytes("UTF-8")); + hash = md.digest(); + } + } + catch(NoSuchAlgorithmException e) + { + throw new SaslException("No provider found for MD5 hash", e); + } + catch(UnsupportedEncodingException e) + { + throw new SaslException( + "UTF-8 encoding not supported by platform.", e); + } + + return convertToHex(hash); + } + + + /** + * This function calculates the response-value of the response directive of + * the digest-response as documented in RFC 2831 + * + * @param HA1 H(A1) + * @param serverNonce nonce from server + * @param nonceCount 8 hex digits + * @param clientNonce client nonce + * @param qop qop-value: "", "auth", "auth-int" + * @param method method from the request + * @param digestUri requested URL + * @param clientResponseFlag request-digest or response-digest + * + * @return Response-value of the response directive of the digest-response + * + * @exception SaslException If an error occurs + */ + char[] DigestCalcResponse( + char[] HA1, /* H(A1) */ + String serverNonce, /* nonce from server */ + String nonceCount, /* 8 hex digits */ + String clientNonce, /* client nonce */ + String qop, /* qop-value: "", "auth", "auth-int" */ + String method, /* method from the request */ + String digestUri, /* requested URL */ + boolean clientResponseFlag) /* request-digest or response-digest */ + throws SaslException + { + byte[] HA2; + byte[] respHash; + char[] HA2Hex; + + // calculate H(A2) + try + { + MessageDigest md = MessageDigest.getInstance("MD5"); + if (clientResponseFlag) + md.update(method.getBytes("UTF-8")); + md.update(":".getBytes("UTF-8")); + md.update(digestUri.getBytes("UTF-8")); + if ("auth-int".equals(qop)) + { + md.update(":".getBytes("UTF-8")); + md.update("00000000000000000000000000000000".getBytes("UTF-8")); + } + HA2 = md.digest(); + HA2Hex = convertToHex(HA2); + + // calculate response + md.update(new String(HA1).getBytes("UTF-8")); + md.update(":".getBytes("UTF-8")); + md.update(serverNonce.getBytes("UTF-8")); + md.update(":".getBytes("UTF-8")); + if (qop.length() > 0) + { + md.update(nonceCount.getBytes("UTF-8")); + md.update(":".getBytes("UTF-8")); + md.update(clientNonce.getBytes("UTF-8")); + md.update(":".getBytes("UTF-8")); + md.update(qop.getBytes("UTF-8")); + md.update(":".getBytes("UTF-8")); + } + md.update(new String(HA2Hex).getBytes("UTF-8")); + respHash = md.digest(); + } + catch(NoSuchAlgorithmException e) + { + throw new SaslException("No provider found for MD5 hash", e); + } + catch(UnsupportedEncodingException e) + { + throw new SaslException( + "UTF-8 encoding not supported by platform.", e); + } + + return convertToHex(respHash); + } + + + /** + * Creates the intial response to be sent to the server. + * + * @param challenge Challenge in bytes recived form the Server + * + * @return Initial response to be sent to the server + */ + private String createDigestResponse( + byte[] challenge) + throws SaslException + { + char[] response; + StringBuffer digestResponse = new StringBuffer(512); + int realmSize; + + m_dc = new DigestChallenge(challenge); + + m_digestURI = m_protocol + "/" + m_serverName; + + if ((m_dc.getQop() & DigestChallenge.QOP_AUTH) + == DigestChallenge.QOP_AUTH ) + m_qopValue = "auth"; + else + throw new SaslException("Client only supports qop of 'auth'"); + + //get call back information + Callback[] callbacks = new Callback[3]; + ArrayList realms = m_dc.getRealms(); + realmSize = realms.size(); + if (realmSize == 0) + { + callbacks[0] = new RealmCallback("Realm"); + } + else if (realmSize == 1) + { + callbacks[0] = new RealmCallback("Realm", (String)realms.get(0)); + } + else + { + callbacks[0] = + new RealmChoiceCallback( + "Realm", + (String[])realms.toArray(new String[realmSize]), + 0, //the default choice index + false); //no multiple selections + } + + callbacks[1] = new PasswordCallback("Password", false); + //false = no echo + + if (m_authorizationId == null || m_authorizationId.length() == 0) + callbacks[2] = new NameCallback("Name"); + else + callbacks[2] = new NameCallback("Name", m_authorizationId); + + try + { + m_cbh.handle(callbacks); + } + catch(UnsupportedCallbackException e) + { + throw new SaslException("Handler does not support" + + " necessary callbacks",e); + } + catch(IOException e) + { + throw new SaslException("IO exception in CallbackHandler.", e); + } + + if (realmSize > 1) + { + int[] selections = + ((RealmChoiceCallback)callbacks[0]).getSelectedIndexes(); + + if (selections.length > 0) + m_realm = + ((RealmChoiceCallback)callbacks[0]).getChoices()[selections[0]]; + else + m_realm = ((RealmChoiceCallback)callbacks[0]).getChoices()[0]; + } + else + m_realm = ((RealmCallback)callbacks[0]).getText(); + + m_clientNonce = getClientNonce(); + + m_name = ((NameCallback)callbacks[2]).getName(); + if (m_name == null) + m_name = ((NameCallback)callbacks[2]).getDefaultName(); + if (m_name == null) + throw new SaslException("No user name was specified."); + + m_HA1 = DigestCalcHA1( + m_dc.getAlgorithm(), + m_name, + m_realm, + new String(((PasswordCallback)callbacks[1]).getPassword()), + m_dc.getNonce(), + m_clientNonce); + + response = DigestCalcResponse(m_HA1, + m_dc.getNonce(), + "00000001", + m_clientNonce, + m_qopValue, + "AUTHENTICATE", + m_digestURI, + true); + + digestResponse.append("username=\""); + digestResponse.append(m_authorizationId); + if (0 != m_realm.length()) + { + digestResponse.append("\",realm=\""); + digestResponse.append(m_realm); + } + digestResponse.append("\",cnonce=\""); + digestResponse.append(m_clientNonce); + digestResponse.append("\",nc="); + digestResponse.append("00000001"); //nounce count + digestResponse.append(",qop="); + digestResponse.append(m_qopValue); + digestResponse.append(",digest-uri=\""); + digestResponse.append(m_digestURI); + digestResponse.append("\",response="); + digestResponse.append(response); + digestResponse.append(",charset=utf-8,nonce=\""); + digestResponse.append(m_dc.getNonce()); + digestResponse.append("\""); + + return digestResponse.toString(); + } + + + /** + * This function validates the server response. This step performs a + * modicum of mutual authentication by verifying that the server knows + * the user's password + * + * @param serverResponse Response recived form Server + * + * @return true if the mutual authentication succeeds; + * else return false + * + * @exception SaslException If an error occurs + */ + boolean checkServerResponseAuth( + byte[] serverResponse) throws SaslException + { + char[] response; + ResponseAuth responseAuth = null; + String responseStr; + + responseAuth = new ResponseAuth(serverResponse); + + response = DigestCalcResponse(m_HA1, + m_dc.getNonce(), + "00000001", + m_clientNonce, + m_qopValue, + DIGEST_METHOD, + m_digestURI, + false); + + responseStr = new String(response); + + return responseStr.equals(responseAuth.getResponseValue()); + } + + + /** + * This function returns hex character representing the value of the input + * + * @param value Input value in byte + * + * @return Hex value of the Input byte value + */ + private static char getHexChar( + byte value) + { + switch (value) + { + case 0: + return '0'; + case 1: + return '1'; + case 2: + return '2'; + case 3: + return '3'; + case 4: + return '4'; + case 5: + return '5'; + case 6: + return '6'; + case 7: + return '7'; + case 8: + return '8'; + case 9: + return '9'; + case 10: + return 'a'; + case 11: + return 'b'; + case 12: + return 'c'; + case 13: + return 'd'; + case 14: + return 'e'; + case 15: + return 'f'; + default: + return 'Z'; + } + } + + /** + * Calculates the Nonce value of the Client + * + * @return Nonce value of the client + * + * @exception SaslException If an error Occurs + */ + String getClientNonce() throws SaslException + { + byte[] nonceBytes = new byte[NONCE_BYTE_COUNT]; + SecureRandom prng; + byte nonceByte; + char[] hexNonce = new char[NONCE_HEX_COUNT]; + + try + { + prng = SecureRandom.getInstance("SHA1PRNG"); + prng.nextBytes(nonceBytes); + for(int i=0; i> 4)); + } + return new String(hexNonce); + } + catch(NoSuchAlgorithmException e) + { + throw new SaslException("No random number generator available", e); + } + } + + /** + * Returns the IANA-registered mechanism name of this SASL client. + * (e.g. "CRAM-MD5", "GSSAPI") + * + * @return "DIGEST-MD5"the IANA-registered mechanism name of this SASL + * client. + */ + public String getMechanismName() + { + return "DIGEST-MD5"; + } + +} //end class DigestMD5SaslClient + diff --git a/external/asmack/build/src/trunk/com/novell/sasl/client/DirectiveList.java b/external/asmack/build/src/trunk/com/novell/sasl/client/DirectiveList.java new file mode 100644 index 0000000..fc26a6b --- /dev/null +++ b/external/asmack/build/src/trunk/com/novell/sasl/client/DirectiveList.java @@ -0,0 +1,363 @@ +/* ************************************************************************** + * $OpenLDAP: /com/novell/sasl/client/DirectiveList.java,v 1.4 2005/01/17 15:00:54 sunilk Exp $ + * + * Copyright (C) 2002 Novell, Inc. All Rights Reserved. + * + * THIS WORK IS SUBJECT TO U.S. AND INTERNATIONAL COPYRIGHT LAWS AND + * TREATIES. USE, MODIFICATION, AND REDISTRIBUTION OF THIS WORK IS SUBJECT + * TO VERSION 2.0.1 OF THE OPENLDAP PUBLIC LICENSE, A COPY OF WHICH IS + * AVAILABLE AT HTTP://WWW.OPENLDAP.ORG/LICENSE.HTML OR IN THE FILE "LICENSE" + * IN THE TOP-LEVEL DIRECTORY OF THE DISTRIBUTION. ANY USE OR EXPLOITATION + * OF THIS WORK OTHER THAN AS AUTHORIZED IN VERSION 2.0.1 OF THE OPENLDAP + * PUBLIC LICENSE, OR OTHER PRIOR WRITTEN CONSENT FROM NOVELL, COULD SUBJECT + * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY. + ******************************************************************************/ +package com.novell.sasl.client; + +import java.util.*; +import org.apache.harmony.javax.security.sasl.*; +import java.io.UnsupportedEncodingException; + +/** + * Implements the DirectiveList class whihc will be used by the + * DigestMD5SaslClient class + */ +class DirectiveList extends Object +{ + private static final int STATE_LOOKING_FOR_FIRST_DIRECTIVE = 1; + private static final int STATE_LOOKING_FOR_DIRECTIVE = 2; + private static final int STATE_SCANNING_NAME = 3; + private static final int STATE_LOOKING_FOR_EQUALS = 4; + private static final int STATE_LOOKING_FOR_VALUE = 5; + private static final int STATE_LOOKING_FOR_COMMA = 6; + private static final int STATE_SCANNING_QUOTED_STRING_VALUE = 7; + private static final int STATE_SCANNING_TOKEN_VALUE = 8; + private static final int STATE_NO_UTF8_SUPPORT = 9; + + private int m_curPos; + private int m_errorPos; + private String m_directives; + private int m_state; + private ArrayList m_directiveList; + private String m_curName; + private int m_scanStart; + + /** + * Constructs a new DirectiveList. + */ + DirectiveList( + byte[] directives) + { + m_curPos = 0; + m_state = STATE_LOOKING_FOR_FIRST_DIRECTIVE; + m_directiveList = new ArrayList(10); + m_scanStart = 0; + m_errorPos = -1; + try + { + m_directives = new String(directives, "UTF-8"); + } + catch(UnsupportedEncodingException e) + { + m_state = STATE_NO_UTF8_SUPPORT; + } + } + + /** + * This function takes a US-ASCII character string containing a list of comma + * separated directives, and parses the string into the individual directives + * and their values. A directive consists of a token specifying the directive + * name followed by an equal sign (=) and the directive value. The value is + * either a token or a quoted string + * + * @exception SaslException If an error Occurs + */ + void parseDirectives() throws SaslException + { + char prevChar; + char currChar; + int rc = 0; + boolean haveQuotedPair = false; + String currentName = ""; + + if (m_state == STATE_NO_UTF8_SUPPORT) + throw new SaslException("No UTF-8 support on platform"); + + prevChar = 0; + + while (m_curPos < m_directives.length()) + { + currChar = m_directives.charAt(m_curPos); + switch (m_state) + { + case STATE_LOOKING_FOR_FIRST_DIRECTIVE: + case STATE_LOOKING_FOR_DIRECTIVE: + if (isWhiteSpace(currChar)) + { + break; + } + else if (isValidTokenChar(currChar)) + { + m_scanStart = m_curPos; + m_state = STATE_SCANNING_NAME; + } + else + { + m_errorPos = m_curPos; + throw new SaslException("Parse error: Invalid name character"); + } + break; + + case STATE_SCANNING_NAME: + if (isValidTokenChar(currChar)) + { + break; + } + else if (isWhiteSpace(currChar)) + { + currentName = m_directives.substring(m_scanStart, m_curPos); + m_state = STATE_LOOKING_FOR_EQUALS; + } + else if ('=' == currChar) + { + currentName = m_directives.substring(m_scanStart, m_curPos); + m_state = STATE_LOOKING_FOR_VALUE; + } + else + { + m_errorPos = m_curPos; + throw new SaslException("Parse error: Invalid name character"); + } + break; + + case STATE_LOOKING_FOR_EQUALS: + if (isWhiteSpace(currChar)) + { + break; + } + else if ('=' == currChar) + { + m_state = STATE_LOOKING_FOR_VALUE; + } + else + { + m_errorPos = m_curPos; + throw new SaslException("Parse error: Expected equals sign '='."); + } + break; + + case STATE_LOOKING_FOR_VALUE: + if (isWhiteSpace(currChar)) + { + break; + } + else if ('"' == currChar) + { + m_scanStart = m_curPos+1; /* don't include the quote */ + m_state = STATE_SCANNING_QUOTED_STRING_VALUE; + } + else if (isValidTokenChar(currChar)) + { + m_scanStart = m_curPos; + m_state = STATE_SCANNING_TOKEN_VALUE; + } + else + { + m_errorPos = m_curPos; + throw new SaslException("Parse error: Unexpected character"); + } + break; + + case STATE_SCANNING_TOKEN_VALUE: + if (isValidTokenChar(currChar)) + { + break; + } + else if (isWhiteSpace(currChar)) + { + addDirective(currentName, false); + m_state = STATE_LOOKING_FOR_COMMA; + } + else if (',' == currChar) + { + addDirective(currentName, false); + m_state = STATE_LOOKING_FOR_DIRECTIVE; + } + else + { + m_errorPos = m_curPos; + throw new SaslException("Parse error: Invalid value character"); + } + break; + + case STATE_SCANNING_QUOTED_STRING_VALUE: + if ('\\' == currChar) + haveQuotedPair = true; + if ( ('"' == currChar) && + ('\\' != prevChar) ) + { + addDirective(currentName, haveQuotedPair); + haveQuotedPair = false; + m_state = STATE_LOOKING_FOR_COMMA; + } + break; + + case STATE_LOOKING_FOR_COMMA: + if (isWhiteSpace(currChar)) + break; + else if (currChar == ',') + m_state = STATE_LOOKING_FOR_DIRECTIVE; + else + { + m_errorPos = m_curPos; + throw new SaslException("Parse error: Expected a comma."); + } + break; + } + if (0 != rc) + break; + prevChar = currChar; + m_curPos++; + } /* end while loop */ + + + if (rc == 0) + { + /* check the ending state */ + switch (m_state) + { + case STATE_SCANNING_TOKEN_VALUE: + addDirective(currentName, false); + break; + + case STATE_LOOKING_FOR_FIRST_DIRECTIVE: + case STATE_LOOKING_FOR_COMMA: + break; + + case STATE_LOOKING_FOR_DIRECTIVE: + throw new SaslException("Parse error: Trailing comma."); + + case STATE_SCANNING_NAME: + case STATE_LOOKING_FOR_EQUALS: + case STATE_LOOKING_FOR_VALUE: + throw new SaslException("Parse error: Missing value."); + + case STATE_SCANNING_QUOTED_STRING_VALUE: + throw new SaslException("Parse error: Missing closing quote."); + } + } + + } + + /** + * This function returns TRUE if the character is a valid token character. + * + * token = 1* + * + * separators = "(" | ")" | "<" | ">" | "@" + * | "," | ";" | ":" | "\" | <"> + * | "/" | "[" | "]" | "?" | "=" + * | "{" | "}" | SP | HT + * + * CTL = + * + * CHAR = + * + * @param c character to be tested + * + * @return Returns TRUE if the character is a valid token character. + */ + boolean isValidTokenChar( + char c) + { + if ( ( (c >= '\u0000') && (c <='\u0020') ) || + ( (c >= '\u003a') && (c <= '\u0040') ) || + ( (c >= '\u005b') && (c <= '\u005d') ) || + ('\u002c' == c) || + ('\u0025' == c) || + ('\u0028' == c) || + ('\u0029' == c) || + ('\u007b' == c) || + ('\u007d' == c) || + ('\u007f' == c) ) + return false; + + return true; + } + + /** + * This function returns TRUE if the character is linear white space (LWS). + * LWS = [CRLF] 1*( SP | HT ) + * @param c Input charcter to be tested + * + * @return Returns TRUE if the character is linear white space (LWS) + */ + boolean isWhiteSpace( + char c) + { + if ( ('\t' == c) || // HORIZONTAL TABULATION. + ('\n' == c) || // LINE FEED. + ('\r' == c) || // CARRIAGE RETURN. + ('\u0020' == c) ) + return true; + + return false; + } + + /** + * This function creates a directive record and adds it to the list, the + * value will be added later after it is parsed. + * + * @param name Name + * @param haveQuotedPair true if quoted pair is there else false + */ + void addDirective( + String name, + boolean haveQuotedPair) + { + String value; + int inputIndex; + int valueIndex; + char valueChar; + int type; + + if (!haveQuotedPair) + { + value = m_directives.substring(m_scanStart, m_curPos); + } + else + { //copy one character at a time skipping backslash excapes. + StringBuffer valueBuf = new StringBuffer(m_curPos - m_scanStart); + valueIndex = 0; + inputIndex = m_scanStart; + while (inputIndex < m_curPos) + { + if ('\\' == (valueChar = m_directives.charAt(inputIndex))) + inputIndex++; + valueBuf.setCharAt(valueIndex, m_directives.charAt(inputIndex)); + valueIndex++; + inputIndex++; + } + value = new String(valueBuf); + } + + if (m_state == STATE_SCANNING_QUOTED_STRING_VALUE) + type = ParsedDirective.QUOTED_STRING_VALUE; + else + type = ParsedDirective.TOKEN_VALUE; + m_directiveList.add(new ParsedDirective(name, value, type)); + } + + + /** + * Returns the List iterator. + * + * @return Returns the Iterator Object for the List. + */ + Iterator getIterator() + { + return m_directiveList.iterator(); + } +} + diff --git a/external/asmack/build/src/trunk/com/novell/sasl/client/ParsedDirective.java b/external/asmack/build/src/trunk/com/novell/sasl/client/ParsedDirective.java new file mode 100644 index 0000000..17bf70e --- /dev/null +++ b/external/asmack/build/src/trunk/com/novell/sasl/client/ParsedDirective.java @@ -0,0 +1,56 @@ +/* ************************************************************************** + * $OpenLDAP: /com/novell/sasl/client/ParsedDirective.java,v 1.1 2003/08/21 10:06:26 kkanil Exp $ + * + * Copyright (C) 2002 Novell, Inc. All Rights Reserved. + * + * THIS WORK IS SUBJECT TO U.S. AND INTERNATIONAL COPYRIGHT LAWS AND + * TREATIES. USE, MODIFICATION, AND REDISTRIBUTION OF THIS WORK IS SUBJECT + * TO VERSION 2.0.1 OF THE OPENLDAP PUBLIC LICENSE, A COPY OF WHICH IS + * AVAILABLE AT HTTP://WWW.OPENLDAP.ORG/LICENSE.HTML OR IN THE FILE "LICENSE" + * IN THE TOP-LEVEL DIRECTORY OF THE DISTRIBUTION. ANY USE OR EXPLOITATION + * OF THIS WORK OTHER THAN AS AUTHORIZED IN VERSION 2.0.1 OF THE OPENLDAP + * PUBLIC LICENSE, OR OTHER PRIOR WRITTEN CONSENT FROM NOVELL, COULD SUBJECT + * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY. + ******************************************************************************/ +package com.novell.sasl.client; + +/** + * Implements the ParsedDirective class which will be used in the + * DigestMD5SaslClient mechanism. + */ +class ParsedDirective +{ + public static final int QUOTED_STRING_VALUE = 1; + public static final int TOKEN_VALUE = 2; + + private int m_valueType; + private String m_name; + private String m_value; + + ParsedDirective( + String name, + String value, + int type) + { + m_name = name; + m_value = value; + m_valueType = type; + } + + String getValue() + { + return m_value; + } + + String getName() + { + return m_name; + } + + int getValueType() + { + return m_valueType; + } + +} + diff --git a/external/asmack/build/src/trunk/com/novell/sasl/client/ResponseAuth.java b/external/asmack/build/src/trunk/com/novell/sasl/client/ResponseAuth.java new file mode 100644 index 0000000..0aef955 --- /dev/null +++ b/external/asmack/build/src/trunk/com/novell/sasl/client/ResponseAuth.java @@ -0,0 +1,83 @@ +/* ************************************************************************** + * $OpenLDAP: /com/novell/sasl/client/ResponseAuth.java,v 1.3 2005/01/17 15:00:54 sunilk Exp $ + * + * Copyright (C) 2002 Novell, Inc. All Rights Reserved. + * + * THIS WORK IS SUBJECT TO U.S. AND INTERNATIONAL COPYRIGHT LAWS AND + * TREATIES. USE, MODIFICATION, AND REDISTRIBUTION OF THIS WORK IS SUBJECT + * TO VERSION 2.0.1 OF THE OPENLDAP PUBLIC LICENSE, A COPY OF WHICH IS + * AVAILABLE AT HTTP://WWW.OPENLDAP.ORG/LICENSE.HTML OR IN THE FILE "LICENSE" + * IN THE TOP-LEVEL DIRECTORY OF THE DISTRIBUTION. ANY USE OR EXPLOITATION + * OF THIS WORK OTHER THAN AS AUTHORIZED IN VERSION 2.0.1 OF THE OPENLDAP + * PUBLIC LICENSE, OR OTHER PRIOR WRITTEN CONSENT FROM NOVELL, COULD SUBJECT + * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY. + ******************************************************************************/ +package com.novell.sasl.client; + +import java.util.*; +import org.apache.harmony.javax.security.sasl.*; + +/** + * Implements the ResponseAuth class used by the DigestMD5SaslClient mechanism + */ +class ResponseAuth +{ + + private String m_responseValue; + + ResponseAuth( + byte[] responseAuth) + throws SaslException + { + m_responseValue = null; + + DirectiveList dirList = new DirectiveList(responseAuth); + try + { + dirList.parseDirectives(); + checkSemantics(dirList); + } + catch (SaslException e) + { + } + } + + /** + * Checks the semantics of the directives in the directive list as parsed + * from the digest challenge byte array. + * + * @param dirList the list of directives parsed from the digest challenge + * + * @exception SaslException If a semantic error occurs + */ + void checkSemantics( + DirectiveList dirList) throws SaslException + { + Iterator directives = dirList.getIterator(); + ParsedDirective directive; + String name; + + while (directives.hasNext()) + { + directive = (ParsedDirective)directives.next(); + name = directive.getName(); + if (name.equals("rspauth")) + m_responseValue = directive.getValue(); + } + + /* post semantic check */ + if (m_responseValue == null) + throw new SaslException("Missing response-auth directive."); + } + + /** + * returns the ResponseValue + * + * @return the ResponseValue as a String. + */ + public String getResponseValue() + { + return m_responseValue; + } +} + diff --git a/external/asmack/build/src/trunk/com/novell/sasl/client/TokenParser.java b/external/asmack/build/src/trunk/com/novell/sasl/client/TokenParser.java new file mode 100644 index 0000000..3d3491d --- /dev/null +++ b/external/asmack/build/src/trunk/com/novell/sasl/client/TokenParser.java @@ -0,0 +1,208 @@ +/* ************************************************************************** + * $OpenLDAP: /com/novell/sasl/client/TokenParser.java,v 1.3 2005/01/17 15:00:54 sunilk Exp $ + * + * Copyright (C) 2002 Novell, Inc. All Rights Reserved. + * + * THIS WORK IS SUBJECT TO U.S. AND INTERNATIONAL COPYRIGHT LAWS AND + * TREATIES. USE, MODIFICATION, AND REDISTRIBUTION OF THIS WORK IS SUBJECT + * TO VERSION 2.0.1 OF THE OPENLDAP PUBLIC LICENSE, A COPY OF WHICH IS + * AVAILABLE AT HTTP://WWW.OPENLDAP.ORG/LICENSE.HTML OR IN THE FILE "LICENSE" + * IN THE TOP-LEVEL DIRECTORY OF THE DISTRIBUTION. ANY USE OR EXPLOITATION + * OF THIS WORK OTHER THAN AS AUTHORIZED IN VERSION 2.0.1 OF THE OPENLDAP + * PUBLIC LICENSE, OR OTHER PRIOR WRITTEN CONSENT FROM NOVELL, COULD SUBJECT + * THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY. + ******************************************************************************/ +package com.novell.sasl.client; + +import org.apache.harmony.javax.security.sasl.*; +/** + * The TokenParser class will parse individual tokens from a list of tokens that + * are a directive value for a DigestMD5 authentication.The tokens are separated + * commas. + */ +class TokenParser extends Object +{ + private static final int STATE_LOOKING_FOR_FIRST_TOKEN = 1; + private static final int STATE_LOOKING_FOR_TOKEN = 2; + private static final int STATE_SCANNING_TOKEN = 3; + private static final int STATE_LOOKING_FOR_COMMA = 4; + private static final int STATE_PARSING_ERROR = 5; + private static final int STATE_DONE = 6; + + private int m_curPos; + private int m_scanStart; + private int m_state; + private String m_tokens; + + + TokenParser( + String tokens) + { + m_tokens = tokens; + m_curPos = 0; + m_scanStart = 0; + m_state = STATE_LOOKING_FOR_FIRST_TOKEN; + } + + /** + * This function parses the next token from the tokens string and returns + * it as a string. If there are no more tokens a null reference is returned. + * + * @return the parsed token or a null reference if there are no more + * tokens + * + * @exception SASLException if an error occurs while parsing + */ + String parseToken() throws SaslException + { + char currChar; + String token = null; + + + if (m_state == STATE_DONE) + return null; + + while (m_curPos < m_tokens.length() && (token == null)) + { + currChar = m_tokens.charAt(m_curPos); + switch (m_state) + { + case STATE_LOOKING_FOR_FIRST_TOKEN: + case STATE_LOOKING_FOR_TOKEN: + if (isWhiteSpace(currChar)) + { + break; + } + else if (isValidTokenChar(currChar)) + { + m_scanStart = m_curPos; + m_state = STATE_SCANNING_TOKEN; + } + else + { + m_state = STATE_PARSING_ERROR; + throw new SaslException("Invalid token character at position " + m_curPos); + } + break; + + case STATE_SCANNING_TOKEN: + if (isValidTokenChar(currChar)) + { + break; + } + else if (isWhiteSpace(currChar)) + { + token = m_tokens.substring(m_scanStart, m_curPos); + m_state = STATE_LOOKING_FOR_COMMA; + } + else if (',' == currChar) + { + token = m_tokens.substring(m_scanStart, m_curPos); + m_state = STATE_LOOKING_FOR_TOKEN; + } + else + { + m_state = STATE_PARSING_ERROR; + throw new SaslException("Invalid token character at position " + m_curPos); + } + break; + + + case STATE_LOOKING_FOR_COMMA: + if (isWhiteSpace(currChar)) + break; + else if (currChar == ',') + m_state = STATE_LOOKING_FOR_TOKEN; + else + { + m_state = STATE_PARSING_ERROR; + throw new SaslException("Expected a comma, found '" + + currChar + "' at postion " + + m_curPos); + } + break; + } + m_curPos++; + } /* end while loop */ + + if (token == null) + { /* check the ending state */ + switch (m_state) + { + case STATE_SCANNING_TOKEN: + token = m_tokens.substring(m_scanStart); + m_state = STATE_DONE; + break; + + case STATE_LOOKING_FOR_FIRST_TOKEN: + case STATE_LOOKING_FOR_COMMA: + break; + + case STATE_LOOKING_FOR_TOKEN: + throw new SaslException("Trialing comma"); + } + } + + return token; + } + + /** + * This function returns TRUE if the character is a valid token character. + * + * token = 1* + * + * separators = "(" | ")" | "<" | ">" | "@" + * | "," | ";" | ":" | "\" | <"> + * | "/" | "[" | "]" | "?" | "=" + * | "{" | "}" | SP | HT + * + * CTL = + * + * CHAR = + * + * @param c character to be validated + * + * @return True if character is valid Token character else it returns + * false + */ + boolean isValidTokenChar( + char c) + { + if ( ( (c >= '\u0000') && (c <='\u0020') ) || + ( (c >= '\u003a') && (c <= '\u0040') ) || + ( (c >= '\u005b') && (c <= '\u005d') ) || + ('\u002c' == c) || + ('\u0025' == c) || + ('\u0028' == c) || + ('\u0029' == c) || + ('\u007b' == c) || + ('\u007d' == c) || + ('\u007f' == c) ) + return false; + + return true; + } + + /** + * This function returns TRUE if the character is linear white space (LWS). + * LWS = [CRLF] 1*( SP | HT ) + * + * @param c character to be validated + * + * @return True if character is liner whitespace else it returns false + */ + boolean isWhiteSpace( + char c) + { + if ( ('\t' == c) || // HORIZONTAL TABULATION. + ('\n' == c) || // LINE FEED. + ('\r' == c) || // CARRIAGE RETURN. + ('\u0020' == c) ) + return true; + + return false; + } + +} + diff --git a/external/asmack/build/src/trunk/de/measite/smack/AndroidDebugger.java b/external/asmack/build/src/trunk/de/measite/smack/AndroidDebugger.java new file mode 100644 index 0000000..4dfc622 --- /dev/null +++ b/external/asmack/build/src/trunk/de/measite/smack/AndroidDebugger.java @@ -0,0 +1,185 @@ +package de.measite.smack; + +import org.jivesoftware.smack.debugger.SmackDebugger; +import org.jivesoftware.smack.ConnectionListener; +import org.jivesoftware.smack.PacketListener; +import org.jivesoftware.smack.Connection; +import org.jivesoftware.smack.packet.Packet; +import org.jivesoftware.smack.util.*; + +import android.util.Log; + +import java.io.Reader; +import java.io.Writer; +import java.text.SimpleDateFormat; +import java.util.Date; + +/** + * Very simple debugger that prints to the android log the sent and received stanzas. Use + * this debugger with caution since printing to the console is an expensive operation that may + * even block the thread since only one thread may print at a time.

+ *

+ * It is possible to not only print the raw sent and received stanzas but also the interpreted + * packets by Smack. By default interpreted packets won't be printed. To enable this feature + * just change the printInterpreted static variable to true. + * + * @author Gaston Dombiak + */ +public class AndroidDebugger implements SmackDebugger { + + public static boolean printInterpreted = false; + private SimpleDateFormat dateFormatter = new SimpleDateFormat("hh:mm:ss aaa"); + + private Connection connection = null; + + private PacketListener listener = null; + private ConnectionListener connListener = null; + + private Writer writer; + private Reader reader; + private ReaderListener readerListener; + private WriterListener writerListener; + + public AndroidDebugger(Connection connection, Writer writer, Reader reader) { + this.connection = connection; + this.writer = writer; + this.reader = reader; + createDebug(); + } + + /** + * Creates the listeners that will print in the console when new activity is detected. + */ + private void createDebug() { + // Create a special Reader that wraps the main Reader and logs data to the GUI. + ObservableReader debugReader = new ObservableReader(reader); + readerListener = new ReaderListener() { + public void read(String str) { + Log.d("SMACK", + dateFormatter.format(new Date()) + " RCV (" + connection.hashCode() + + "): " + + str); + } + }; + debugReader.addReaderListener(readerListener); + + // Create a special Writer that wraps the main Writer and logs data to the GUI. + ObservableWriter debugWriter = new ObservableWriter(writer); + writerListener = new WriterListener() { + public void write(String str) { + Log.d("SMACK", + dateFormatter.format(new Date()) + " SENT (" + connection.hashCode() + + "): " + + str); + } + }; + debugWriter.addWriterListener(writerListener); + + // Assign the reader/writer objects to use the debug versions. The packet reader + // and writer will use the debug versions when they are created. + reader = debugReader; + writer = debugWriter; + + // Create a thread that will listen for all incoming packets and write them to + // the GUI. This is what we call "interpreted" packet data, since it's the packet + // data as Smack sees it and not as it's coming in as raw XML. + listener = new PacketListener() { + public void processPacket(Packet packet) { + if (printInterpreted) { + Log.d("SMACK", + dateFormatter.format(new Date()) + " RCV PKT (" + + connection.hashCode() + + "): " + + packet.toXML()); + } + } + }; + + connListener = new ConnectionListener() { + public void connectionClosed() { + Log.d("SMACK", + dateFormatter.format(new Date()) + " Connection closed (" + + connection.hashCode() + + ")"); + } + + public void connectionClosedOnError(Exception e) { + Log.d("SMACK", + dateFormatter.format(new Date()) + + " Connection closed due to an exception (" + + connection.hashCode() + + ")"); + e.printStackTrace(); + } + public void reconnectionFailed(Exception e) { + Log.d("SMACK", + dateFormatter.format(new Date()) + + " Reconnection failed due to an exception (" + + connection.hashCode() + + ")"); + e.printStackTrace(); + } + public void reconnectionSuccessful() { + Log.d("SMACK", + dateFormatter.format(new Date()) + " Connection reconnected (" + + connection.hashCode() + + ")"); + } + public void reconnectingIn(int seconds) { + Log.d("SMACK", + dateFormatter.format(new Date()) + " Connection (" + + connection.hashCode() + + ") will reconnect in " + seconds); + } + }; + } + + public Reader newConnectionReader(Reader newReader) { + ((ObservableReader)reader).removeReaderListener(readerListener); + ObservableReader debugReader = new ObservableReader(newReader); + debugReader.addReaderListener(readerListener); + reader = debugReader; + return reader; + } + + public Writer newConnectionWriter(Writer newWriter) { + ((ObservableWriter)writer).removeWriterListener(writerListener); + ObservableWriter debugWriter = new ObservableWriter(newWriter); + debugWriter.addWriterListener(writerListener); + writer = debugWriter; + return writer; + } + + public void userHasLogged(String user) { + boolean isAnonymous = "".equals(StringUtils.parseName(user)); + String title = + "User logged (" + connection.hashCode() + "): " + + (isAnonymous ? "" : StringUtils.parseBareAddress(user)) + + "@" + + connection.getServiceName() + + ":" + + connection.getPort(); + title += "/" + StringUtils.parseResource(user); + Log.d("SMACK", title); + // Add the connection listener to the connection so that the debugger can be notified + // whenever the connection is closed. + connection.addConnectionListener(connListener); + } + + public Reader getReader() { + return reader; + } + + public Writer getWriter() { + return writer; + } + + public PacketListener getReaderListener() { + return listener; + } + + public PacketListener getWriterListener() { + return null; + } +} + diff --git a/external/asmack/build/src/trunk/de/measite/smack/Sasl.java b/external/asmack/build/src/trunk/de/measite/smack/Sasl.java new file mode 100644 index 0000000..a59135d --- /dev/null +++ b/external/asmack/build/src/trunk/de/measite/smack/Sasl.java @@ -0,0 +1,108 @@ +/* + * Copyright 2009 Rene Treffer + * + * 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 de.measite.smack; + +import java.util.Enumeration; +import java.util.Hashtable; +import java.util.Map; + +import org.apache.harmony.javax.security.auth.callback.CallbackHandler; +import org.apache.harmony.javax.security.sasl.SaslClient; +import org.apache.harmony.javax.security.sasl.SaslException; +import org.apache.harmony.javax.security.sasl.SaslServer; +import org.apache.harmony.javax.security.sasl.SaslServerFactory; + +public class Sasl { + + // SaslClientFactory service name + private static final String CLIENTFACTORYSRV = "SaslClientFactory"; //$NON-NLS-1$ + + // SaslServerFactory service name + private static final String SERVERFACTORYSRV = "SaslServerFactory"; //$NON-NLS-1$ + + public static final String POLICY_NOPLAINTEXT = "javax.security.sasl.policy.noplaintext"; //$NON-NLS-1$ + + public static final String POLICY_NOACTIVE = "javax.security.sasl.policy.noactive"; //$NON-NLS-1$ + + public static final String POLICY_NODICTIONARY = "javax.security.sasl.policy.nodictionary"; //$NON-NLS-1$ + + public static final String POLICY_NOANONYMOUS = "javax.security.sasl.policy.noanonymous"; //$NON-NLS-1$ + + public static final String POLICY_FORWARD_SECRECY = "javax.security.sasl.policy.forward"; //$NON-NLS-1$ + + public static final String POLICY_PASS_CREDENTIALS = "javax.security.sasl.policy.credentials"; //$NON-NLS-1$ + + public static final String MAX_BUFFER = "javax.security.sasl.maxbuffer"; //$NON-NLS-1$ + + public static final String RAW_SEND_SIZE = "javax.security.sasl.rawsendsize"; //$NON-NLS-1$ + + public static final String REUSE = "javax.security.sasl.reuse"; //$NON-NLS-1$ + + public static final String QOP = "javax.security.sasl.qop"; //$NON-NLS-1$ + + public static final String STRENGTH = "javax.security.sasl.strength"; //$NON-NLS-1$ + + public static final String SERVER_AUTH = "javax.security.sasl.server.authentication"; //$NON-NLS-1$ + + public static Enumeration getSaslClientFactories() { + Hashtable factories = new Hashtable(); + factories.put(new SaslClientFactory(), new Object()); + return factories.keys(); + } + + public static Enumeration getSaslServerFactories() { + return org.apache.harmony.javax.security.sasl.Sasl.getSaslServerFactories(); + } + + public static SaslServer createSaslServer(String mechanism, String protocol, + String serverName, Map prop, CallbackHandler cbh) throws SaslException { + return org.apache.harmony.javax.security.sasl.Sasl.createSaslServer(mechanism, protocol, serverName, prop, cbh); + } + + public static SaslClient createSaslClient(String[] mechanisms, String authanticationID, + String protocol, String serverName, Map prop, CallbackHandler cbh) + throws SaslException { + if (mechanisms == null) { + throw new NullPointerException("auth.33"); //$NON-NLS-1$ + } + SaslClientFactory fact = getSaslClientFactories().nextElement(); + String[] mech = fact.getMechanismNames(null); + boolean is = false; + if (mech != null) { + for (int j = 0; j < mech.length; j++) { + for (int n = 0; n < mechanisms.length; n++) { + if (mech[j].equals(mechanisms[n])) { + is = true; + break; + } + } + } + } + if (is) { + return fact.createSaslClient( + mechanisms, + authanticationID, + protocol, + serverName, + prop, + cbh + ); + } + return null; + } + +} diff --git a/external/asmack/build/src/trunk/de/measite/smack/SaslClientFactory.java b/external/asmack/build/src/trunk/de/measite/smack/SaslClientFactory.java new file mode 100644 index 0000000..2fa1ebd --- /dev/null +++ b/external/asmack/build/src/trunk/de/measite/smack/SaslClientFactory.java @@ -0,0 +1,60 @@ +/* + * Copyright 2009 Rene Treffer + * + * 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 de.measite.smack; + +import java.util.Map; + +import com.novell.sasl.client.DigestMD5SaslClient; + +import org.apache.harmony.javax.security.auth.callback.CallbackHandler; +import org.apache.harmony.javax.security.sasl.SaslClient; +import org.apache.harmony.javax.security.sasl.SaslException; +import org.apache.qpid.management.common.sasl.PlainSaslClient; + +public class SaslClientFactory implements + org.apache.harmony.javax.security.sasl.SaslClientFactory { + + @Override + public SaslClient createSaslClient(String[] mechanisms, + String authorizationId, String protocol, String serverName, + Map props, CallbackHandler cbh) throws SaslException { + for (String mech: mechanisms) { + if ("PLAIN".equals(mech)) { + return new PlainSaslClient(authorizationId, cbh); + } else + if ("DIGEST-MD5".equals(mech)) { + return DigestMD5SaslClient.getClient( + authorizationId, + protocol, + serverName, + props, + cbh + ); + } + } + return null; + } + + @Override + public String[] getMechanismNames(Map props) { + return new String[]{ + "PLAIN", + "DIGEST-MD5" + }; + } + +} diff --git a/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/AuthPermission.java b/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/AuthPermission.java new file mode 100644 index 0000000..bb12554 --- /dev/null +++ b/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/AuthPermission.java @@ -0,0 +1,97 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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.apache.harmony.javax.security.auth; + +import java.security.BasicPermission; + + + +/** + * Governs the use of methods in this package and also its subpackages. A + * target name of the permission specifies which methods are allowed + * without specifying the concrete action lists. Possible target names and + * associated authentication permissions are: + * + *

+ *    doAs                      invoke Subject.doAs methods.
+ *    doAsPrivileged            invoke the Subject.doAsPrivileged methods.
+ *    getSubject                invoke Subject.getSubject().
+ *    getSubjectFromDomainCombiner    invoke SubjectDomainCombiner.getSubject().
+ *    setReadOnly               invoke Subject.setReadonly().
+ *    modifyPrincipals          modify the set of principals
+ *                              associated with a Subject.
+ *    modifyPublicCredentials   modify the set of public credentials
+ *                              associated with a Subject.
+ *    modifyPrivateCredentials  modify the set of private credentials
+ *                              associated with a Subject.
+ *    refreshCredential         invoke the refresh method on a credential of a
+ *                              refreshable credential class.
+ *    destroyCredential         invoke the destroy method on a credential of a
+ *                              destroyable credential class.
+ *    createLoginContext.name   instantiate a LoginContext with the
+ *                              specified name. The wildcard name ('*')
+ *                              allows to a LoginContext of any name.
+ *    getLoginConfiguration     invoke the getConfiguration method of
+ *                              javax.security.auth.login.Configuration.
+ *    refreshLoginConfiguration Invoke the refresh method of
+ *                              javax.security.auth.login.Configuration.
+ *

+ */ +public final class AuthPermission extends BasicPermission { + + private static final long serialVersionUID = 5806031445061587174L; + + private static final String CREATE_LOGIN_CONTEXT = "createLoginContext"; //$NON-NLS-1$ + + private static final String CREATE_LOGIN_CONTEXT_ANY = "createLoginContext.*"; //$NON-NLS-1$ + + // inits permission name. + private static String init(String name) { + + if (name == null) { + throw new NullPointerException("auth.13"); //$NON-NLS-1$ + } + + if (CREATE_LOGIN_CONTEXT.equals(name)) { + return CREATE_LOGIN_CONTEXT_ANY; + } + return name; + } + + /** + * Creates an authentication permission with the specified target name. + * + * @param name + * the target name of this authentication permission. + */ + public AuthPermission(String name) { + super(init(name)); + } + + /** + * Creates an authentication permission with the specified target name. + * + * @param name + * the target name of this authentication permission. + * @param actions + * this parameter is ignored and should be {@code null}. + */ + public AuthPermission(String name, String actions) { + super(init(name), actions); + } +} \ No newline at end of file diff --git a/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/DestroyFailedException.java b/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/DestroyFailedException.java new file mode 100644 index 0000000..7c7ea79 --- /dev/null +++ b/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/DestroyFailedException.java @@ -0,0 +1,44 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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.apache.harmony.javax.security.auth; + +/** + * Signals that the {@link Destroyable#destroy()} method failed. + */ +public class DestroyFailedException extends Exception { + + private static final long serialVersionUID = -7790152857282749162L; + + /** + * Creates an exception of type {@code DestroyFailedException}. + */ + public DestroyFailedException() { + super(); + } + + /** + * Creates an exception of type {@code DestroyFailedException}. + * + * @param message + * A detail message that describes the reason for this exception. + */ + public DestroyFailedException(String message) { + super(message); + } + +} diff --git a/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/Destroyable.java b/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/Destroyable.java new file mode 100644 index 0000000..12a107b --- /dev/null +++ b/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/Destroyable.java @@ -0,0 +1,43 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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.apache.harmony.javax.security.auth; + +/** + * Allows for special treatment of sensitive information, when it comes to + * destroying or clearing of the data. + */ +public interface Destroyable { + + /** + * Erases the sensitive information. Once an object is destroyed any calls + * to its methods will throw an {@code IllegalStateException}. If it does + * not succeed a DestroyFailedException is thrown. + * + * @throws DestroyFailedException + * if the information cannot be erased. + */ + void destroy() throws DestroyFailedException; + + /** + * Returns {@code true} once an object has been safely destroyed. + * + * @return whether the object has been safely destroyed. + */ + boolean isDestroyed(); + +} diff --git a/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/PrivateCredentialPermission.java b/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/PrivateCredentialPermission.java new file mode 100644 index 0000000..d62bb24 --- /dev/null +++ b/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/PrivateCredentialPermission.java @@ -0,0 +1,395 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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.apache.harmony.javax.security.auth; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.Serializable; +import java.security.Permission; +import java.security.PermissionCollection; +import java.security.Principal; +import java.util.Set; + + + +/** + * Protects private credential objects belonging to a {@code Subject}. It has + * only one action which is "read". The target name of this permission has a + * special syntax: + * + *

+ * targetName = CredentialClass {PrincipalClass "PrincipalName"}*
+ *

+ * + * First it states a credential class and is followed then by a list of one or + * more principals identifying the subject. + *

+ * The principals on their part are specified as the name of the {@code + * Principal} class followed by the principal name in quotes. For example, the + * following file may define permission to read the private credentials of a + * principal named "Bob": "com.sun.PrivateCredential com.sun.Principal \"Bob\"" + *

+ * The syntax also allows the use of the wildcard "*" in place of {@code + * CredentialClass} or {@code PrincipalClass} and/or {@code PrincipalName}. + * + * @see Principal + */ +public final class PrivateCredentialPermission extends Permission { + + private static final long serialVersionUID = 5284372143517237068L; + + // allowed action + private static final String READ = "read"; //$NON-NLS-1$ + + private String credentialClass; + + // current offset + private transient int offset; + + // owners set + private transient CredOwner[] set; + + /** + * Creates a new permission for private credentials specified by the target + * name {@code name} and an {@code action}. The action is always + * {@code "read"}. + * + * @param name + * the target name of the permission. + * @param action + * the action {@code "read"}. + */ + public PrivateCredentialPermission(String name, String action) { + super(name); + if (READ.equalsIgnoreCase(action)) { + initTargetName(name); + } else { + throw new IllegalArgumentException("auth.11"); //$NON-NLS-1$ + } + } + + /** + * Creates a {@code PrivateCredentialPermission} from the {@code Credential} + * class and set of principals. + * + * @param credentialClass + * the credential class name. + * @param principals + * the set of principals. + */ + PrivateCredentialPermission(String credentialClass, Set principals) { + super(credentialClass); + this.credentialClass = credentialClass; + + set = new CredOwner[principals.size()]; + for (Principal p : principals) { + CredOwner element = new CredOwner(p.getClass().getName(), p.getName()); + // check for duplicate elements + boolean found = false; + for (int ii = 0; ii < offset; ii++) { + if (set[ii].equals(element)) { + found = true; + break; + } + } + if (!found) { + set[offset++] = element; + } + } + } + + /** + * Initialize a PrivateCredentialPermission object and checks that a target + * name has a correct format: CredentialClass 1*(PrincipalClass + * "PrincipalName") + */ + private void initTargetName(String name) { + + if (name == null) { + throw new NullPointerException("auth.0E"); //$NON-NLS-1$ + } + + // check empty string + name = name.trim(); + if (name.length() == 0) { + throw new IllegalArgumentException("auth.0F"); //$NON-NLS-1$ + } + + // get CredentialClass + int beg = name.indexOf(' '); + if (beg == -1) { + throw new IllegalArgumentException("auth.10"); //$NON-NLS-1$ + } + credentialClass = name.substring(0, beg); + + // get a number of pairs: PrincipalClass "PrincipalName" + beg++; + int count = 0; + int nameLength = name.length(); + for (int i, j = 0; beg < nameLength; beg = j + 2, count++) { + i = name.indexOf(' ', beg); + j = name.indexOf('"', i + 2); + + if (i == -1 || j == -1 || name.charAt(i + 1) != '"') { + throw new IllegalArgumentException("auth.10"); //$NON-NLS-1$ + } + } + + // name MUST have one pair at least + if (count < 1) { + throw new IllegalArgumentException("auth.10"); //$NON-NLS-1$ + } + + beg = name.indexOf(' '); + beg++; + + // populate principal set with instances of CredOwner class + String principalClass; + String principalName; + + set = new CredOwner[count]; + for (int index = 0, i, j; index < count; beg = j + 2, index++) { + i = name.indexOf(' ', beg); + j = name.indexOf('"', i + 2); + + principalClass = name.substring(beg, i); + principalName = name.substring(i + 2, j); + + CredOwner element = new CredOwner(principalClass, principalName); + // check for duplicate elements + boolean found = false; + for (int ii = 0; ii < offset; ii++) { + if (set[ii].equals(element)) { + found = true; + break; + } + } + if (!found) { + set[offset++] = element; + } + } + } + + private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { + ois.defaultReadObject(); + initTargetName(getName()); + } + + /** + * Returns the principal's classes and names associated with this {@code + * PrivateCredentialPermission} as a two dimensional array. The first + * dimension of the array corresponds to the number of principals. The + * second dimension defines either the name of the {@code PrincipalClass} + * [x][0] or the value of {@code PrincipalName} [x][1]. + *

+ * This corresponds to the the target name's syntax: + * + *

+     * targetName = CredentialClass {PrincipalClass "PrincipalName"}*
+     *

+ * + * @return the principal classes and names associated with this {@code + * PrivateCredentialPermission}. + */ + public String[][] getPrincipals() { + + String[][] s = new String[offset][2]; + + for (int i = 0; i < s.length; i++) { + s[i][0] = set[i].principalClass; + s[i][1] = set[i].principalName; + } + return s; + } + + @Override + public String getActions() { + return READ; + } + + /** + * Returns the class name of the credential associated with this permission. + * + * @return the class name of the credential associated with this permission. + */ + public String getCredentialClass() { + return credentialClass; + } + + @Override + public int hashCode() { + int hash = 0; + for (int i = 0; i < offset; i++) { + hash = hash + set[i].hashCode(); + } + return getCredentialClass().hashCode() + hash; + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + + if (obj == null || this.getClass() != obj.getClass()) { + return false; + } + + PrivateCredentialPermission that = (PrivateCredentialPermission) obj; + + return credentialClass.equals(that.credentialClass) && (offset == that.offset) + && sameMembers(set, that.set, offset); + } + + @Override + public boolean implies(Permission permission) { + + if (permission == null || this.getClass() != permission.getClass()) { + return false; + } + + PrivateCredentialPermission that = (PrivateCredentialPermission) permission; + + if (!("*".equals(credentialClass) || credentialClass //$NON-NLS-1$ + .equals(that.getCredentialClass()))) { + return false; + } + + if (that.offset == 0) { + return true; + } + + CredOwner[] thisCo = set; + CredOwner[] thatCo = that.set; + int thisPrincipalsSize = offset; + int thatPrincipalsSize = that.offset; + for (int i = 0, j; i < thisPrincipalsSize; i++) { + for (j = 0; j < thatPrincipalsSize; j++) { + if (thisCo[i].implies(thatCo[j])) { + break; + } + } + if (j == thatCo.length) { + return false; + } + } + return true; + } + + @Override + public PermissionCollection newPermissionCollection() { + return null; + } + + /** + * Returns true if the two arrays have the same length, and every member of + * one array is contained in another array + */ + private boolean sameMembers(Object[] ar1, Object[] ar2, int length) { + if (ar1 == null && ar2 == null) { + return true; + } + if (ar1 == null || ar2 == null) { + return false; + } + boolean found; + for (int i = 0; i < length; i++) { + found = false; + for (int j = 0; j < length; j++) { + if (ar1[i].equals(ar2[j])) { + found = true; + break; + } + } + if (!found) { + return false; + } + } + return true; + } + + private static final class CredOwner implements Serializable { + + private static final long serialVersionUID = -5607449830436408266L; + + String principalClass; + + String principalName; + + // whether class name contains wildcards + private transient boolean isClassWildcard; + + // whether pname contains wildcards + private transient boolean isPNameWildcard; + + // Creates a new CredOwner with the specified Principal Class and Principal Name + CredOwner(String principalClass, String principalName) { + super(); + if ("*".equals(principalClass)) { //$NON-NLS-1$ + isClassWildcard = true; + } + + if ("*".equals(principalName)) { //$NON-NLS-1$ + isPNameWildcard = true; + } + + if (isClassWildcard && !isPNameWildcard) { + throw new IllegalArgumentException("auth.12"); //$NON-NLS-1$ + } + + this.principalClass = principalClass; + this.principalName = principalName; + } + + // Checks if this CredOwner implies the specified Object. + boolean implies(Object obj) { + if (obj == this) { + return true; + } + + CredOwner co = (CredOwner) obj; + + if (isClassWildcard || principalClass.equals(co.principalClass)) { + if (isPNameWildcard || principalName.equals(co.principalName)) { + return true; + } + } + return false; + } + + // Checks two CredOwner objects for equality. + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof CredOwner) { + CredOwner that = (CredOwner) obj; + return principalClass.equals(that.principalClass) + && principalName.equals(that.principalName); + } + return false; + } + + // Returns the hash code value for this object. + @Override + public int hashCode() { + return principalClass.hashCode() + principalName.hashCode(); + } + } +} diff --git a/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/RefreshFailedException.java b/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/RefreshFailedException.java new file mode 100644 index 0000000..71bcc6b --- /dev/null +++ b/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/RefreshFailedException.java @@ -0,0 +1,31 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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.apache.harmony.javax.security.auth; + +public class RefreshFailedException extends Exception { + + private static final long serialVersionUID = 5058444488565265840L; + + public RefreshFailedException() { + super(); + } + + public RefreshFailedException(String message) { + super(message); + } +} diff --git a/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/Refreshable.java b/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/Refreshable.java new file mode 100644 index 0000000..90b00cb --- /dev/null +++ b/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/Refreshable.java @@ -0,0 +1,26 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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.apache.harmony.javax.security.auth; + +public interface Refreshable { + + void refresh() throws RefreshFailedException; + + boolean isCurrent(); + +} diff --git a/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/Subject.java b/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/Subject.java new file mode 100644 index 0000000..142686e --- /dev/null +++ b/external/asmack/build/src/trunk/org/apache/harmony/javax/security/auth/Subject.java @@ -0,0 +1,782 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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.apache.harmony.javax.security.auth; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.Serializable; +import java.security.AccessControlContext; +import java.security.AccessController; +import java.security.DomainCombiner; +import java.security.Permission; +import java.security.Principal; +import java.security.PrivilegedAction; +import java.security.PrivilegedActionException; +import java.security.PrivilegedExceptionAction; +import java.security.ProtectionDomain; +import java.util.AbstractSet; +import java.util.Collection; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.Set; + + + +/** + * The central class of the {@code javax.security.auth} package representing an + * authenticated user or entity (both referred to as "subject"). IT defines also + * the static methods that allow code to be run, and do modifications according + * to the subject's permissions. + *

+ * A subject has the following features: + *

A set of {@code Principal} objects specifying the identities bound to a + * {@code Subject} that distinguish it.
Credentials (public and private) such as certificates, keys, or + * authentication proofs such as tickets

+ */ +public final class Subject implements Serializable { + + private static final long serialVersionUID = -8308522755600156056L; + + private static final AuthPermission _AS = new AuthPermission("doAs"); //$NON-NLS-1$ + + private static final AuthPermission _AS_PRIVILEGED = new AuthPermission( + "doAsPrivileged"); //$NON-NLS-1$ + + private static final AuthPermission _SUBJECT = new AuthPermission( + "getSubject"); //$NON-NLS-1$ + + private static final AuthPermission _PRINCIPALS = new AuthPermission( + "modifyPrincipals"); //$NON-NLS-1$ + + private static final AuthPermission _PRIVATE_CREDENTIALS = new AuthPermission( + "modifyPrivateCredentials"); //$NON-NLS-1$ + + private static final AuthPermission _PUBLIC_CREDENTIALS = new AuthPermission( + "modifyPublicCredentials"); //$NON-NLS-1$ + + private static final AuthPermission _READ_ONLY = new AuthPermission( + "setReadOnly"); //$NON-NLS-1$ + + private final Set principals; + + private boolean readOnly; + + // set of private credentials + private transient SecureSet

	Message type
Field	Normal	Chat	Group Chat	Headline	XMPPError
subject	SHOULD	SHOULD NOT	SHOULD NOT	SHOULD NOT	SHOULD NOT
thread	OPTIONAL	SHOULD	OPTIONAL	OPTIONAL	SHOULD NOT
body	SHOULD	SHOULD	SHOULD	SHOULD	SHOULD NOT
error	MUST NOT	MUST NOT	MUST NOT	MUST NOT	MUST

Code	Description
bad-format	the entity has sent XML that cannot be processed
unsupported-encoding	the entity has sent a namespace prefix that is + * unsupported
bad-namespace-prefix	Remote Server Timeout
conflict	the server is closing the active stream for this entity + * because a new stream has been initiated that conflicts with the existing + * stream.
connection-timeout	the entity has not generated any traffic over + * the stream for some period of time.
host-gone	the value of the 'to' attribute provided by the initiating + * entity in the stream header corresponds to a hostname that is no longer hosted by + * the server.
host-unknown	the value of the 'to' attribute provided by the + * initiating entity in the stream header does not correspond to a hostname that is + * hosted by the server.
improper-addressing	a stanza sent between two servers lacks a 'to' + * or 'from' attribute
internal-server-error	the server has experienced a + * misconfiguration.
invalid-from	the JID or hostname provided in a 'from' address does + * not match an authorized JID.
invalid-id	the stream ID or dialback ID is invalid or does not match + * an ID previously provided.
invalid-namespace	the streams namespace name is invalid.
invalid-xml	the entity has sent invalid XML over the stream.
not-authorized	the entity has attempted to send data before the + * stream has been authenticated
policy-violation	the entity has violated some local service + * policy.
remote-connection-failed	Rthe server is unable to properly connect + * to a remote entity.
resource-constraint	Rthe server lacks the system resources necessary + * to service the stream.
restricted-xml	the entity has attempted to send restricted XML + * features.
see-other-host	the server will not provide service to the initiating + * entity but is redirecting traffic to another host.
system-shutdown	the server is being shut down and all active streams + * are being closed.
undefined-condition	the error condition is not one of those defined + * by the other conditions in this list.
unsupported-encoding	the initiating entity has encoded the stream in + * an encoding that is not supported.
unsupported-stanza-type	the initiating entity has sent a first-level + * child of the stream that is not supported.
unsupported-version	the value of the 'version' attribute provided by + * the initiating entity in the stream header specifies a version of XMPP that is not + * supported.
xml-not-well-formed	the initiating entity has sent XML that is + * not well-formed.

Unescaped Character	Encoded Sequence
<space>	\20
"	\22
&	\26
'	\27
/	\2f
:	\3a
<	\3c
>	\3e
@	\40
\	\5c

Unescaped Character	Encoded Sequence
<space>	\20
"	\22
&	\26
'	\27
/	\2f
:	\3a
<	\3c
>	\3e
@	\40
\	\5c

Related Documentation

Related Documentation

Code	XMPP Error	Type
500	interna-server-error	WAIT
403	forbidden	AUTH
400bad-request	MODIFY
404	item-not-found	CANCEL
409	conflict	CANCEL
501	feature-not-implemented	CANCEL
302	gone	MODIFY
400	jid-malformed	MODIFY
406	no-acceptable	MODIFY
405	not-allowed	CANCEL
401	not-authorized	AUTH
402	payment-required	AUTH
404	recipient-unavailable	WAIT
302	redirect	MODIFY
407	registration-required	AUTH
404	remote-server-not-found	CANCEL
504	remote-server-timeout	WAIT
502	remote-server-error	CANCEL
500	resource-constraint	WAIT
503	service-unavailable	CANCEL
407	subscription-required	AUTH
500	undefined-condition	WAIT
400	unexpected-condition	WAIT
408	request-timeout	CANCEL