PacketParserUtils.java

  1. /**
  2.  *
  3.  * Copyright 2003-2007 Jive Software.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.jivesoftware.smack.util;

  19. import java.io.IOException;
  20. import java.io.Reader;
  21. import java.io.StringReader;
  22. import java.util.ArrayList;
  23. import java.util.Collection;
  24. import java.util.HashMap;
  25. import java.util.LinkedList;
  26. import java.util.List;
  27. import java.util.Map;
  28. import java.util.logging.Level;
  29. import java.util.logging.Logger;

  31. import org.jivesoftware.smack.SmackException;
  32. import org.jivesoftware.smack.compress.packet.Compress;
  33. import org.jivesoftware.smack.packet.DefaultExtensionElement;
  34. import org.jivesoftware.smack.packet.EmptyResultIQ;
  35. import org.jivesoftware.smack.packet.ErrorIQ;
  36. import org.jivesoftware.smack.packet.IQ;
  37. import org.jivesoftware.smack.packet.Message;
  38. import org.jivesoftware.smack.packet.Stanza;
  39. import org.jivesoftware.smack.packet.ExtensionElement;
  40. import org.jivesoftware.smack.packet.Presence;
  41. import org.jivesoftware.smack.packet.Session;
  42. import org.jivesoftware.smack.packet.StartTls;
  43. import org.jivesoftware.smack.packet.StreamError;
  44. import org.jivesoftware.smack.packet.UnparsedIQ;
  45. import org.jivesoftware.smack.packet.XMPPError;
  46. import org.jivesoftware.smack.provider.IQProvider;
  47. import org.jivesoftware.smack.provider.ExtensionElementProvider;
  48. import org.jivesoftware.smack.provider.ProviderManager;
  49. import org.jivesoftware.smack.sasl.packet.SaslStreamElements.SASLFailure;
  50. import org.jxmpp.jid.Jid;
  51. import org.xmlpull.v1.XmlPullParser;
  52. import org.xmlpull.v1.XmlPullParserException;
  53. import org.xmlpull.v1.XmlPullParserFactory;

  55. /**
  56.  * Utility class that helps to parse packets. Any parsing packets method that must be shared
  57.  * between many clients must be placed in this utility class.
  58.  *
  59.  * @author Gaston Dombiak
  60.  */
  61. public class PacketParserUtils {
  62.     private static final Logger LOGGER = Logger.getLogger(PacketParserUtils.class.getName());

  64.     public static final String FEATURE_XML_ROUNDTRIP = "http://xmlpull.org/v1/doc/features.html#xml-roundtrip";

  66.     private static final XmlPullParserFactory XML_PULL_PARSER_FACTORY;

  68.     /**
  69.      * True if the XmlPullParser supports the XML_ROUNDTRIP feature.
  70.      */
  71.     public static final boolean XML_PULL_PARSER_SUPPORTS_ROUNDTRIP;

  73.     static {
  74.         XmlPullParser xmlPullParser;
  75.         boolean roundtrip = false;
  76.         try {
  77.             XML_PULL_PARSER_FACTORY = XmlPullParserFactory.newInstance();
  78.             xmlPullParser = XML_PULL_PARSER_FACTORY.newPullParser();
  79.             try {
  80.                 xmlPullParser.setFeature(FEATURE_XML_ROUNDTRIP, true);
  81.                 // We could successfully set the feature
  82.                 roundtrip = true;
  83.             } catch (XmlPullParserException e) {
  84.                 // Doesn't matter if FEATURE_XML_ROUNDTRIP isn't available
  85.                 LOGGER.log(Level.FINEST, "XmlPullParser does not support XML_ROUNDTRIP", e);
  86.             }
  87.         }
  88.         catch (XmlPullParserException e) {
  89.             // Something really bad happened
  90.             throw new AssertionError(e);
  91.         }
  92.         XML_PULL_PARSER_SUPPORTS_ROUNDTRIP = roundtrip;
  93.     }

  95.     public static XmlPullParser getParserFor(String stanza) throws XmlPullParserException, IOException {
  96.         return getParserFor(new StringReader(stanza));
  97.     }

  99.     public static XmlPullParser getParserFor(Reader reader) throws XmlPullParserException, IOException {
  100.         XmlPullParser parser = newXmppParser(reader);
  101.         // Wind the parser forward to the first start tag
  102.         int event = parser.getEventType();
  103.         while (event != XmlPullParser.START_TAG) {
  104.             if (event == XmlPullParser.END_DOCUMENT) {
  105.                 throw new IllegalArgumentException("Document contains no start tag");
  106.             }
  107.             event = parser.next();
  108.         }
  109.         return parser;
  110.     }

  112.     public static XmlPullParser getParserFor(String stanza, String startTag)
  113.                     throws XmlPullParserException, IOException {
  114.         XmlPullParser parser = getParserFor(stanza);

  116.         while (true) {
  117.             int event = parser.getEventType();
  118.             String name = parser.getName();
  119.             if (event == XmlPullParser.START_TAG && name.equals(startTag)) {
  120.                 break;
  121.             }
  122.             else if (event == XmlPullParser.END_DOCUMENT) {
  123.                 throw new IllegalArgumentException("Could not find start tag '" + startTag
  124.                                 + "' in stanza: " + stanza);
  125.             }
  126.             parser.next();
  127.         }

  129.         return parser;
  130.     }

  132.     public static Stanza parseStanza(String stanza) throws Exception {
  133.         return parseStanza(getParserFor(stanza));
  134.     }

  136.     /**
  137.      * Tries to parse and return either a Message, IQ or Presence stanza.
  138.      * 
  139.      * connection is optional and is used to return feature-not-implemented errors for unknown IQ stanzas.
  140.      *
  141.      * @param parser
  142.      * @return a packet which is either a Message, IQ or Presence.
  143.      * @throws Exception 
  144.      */
  145.     public static Stanza parseStanza(XmlPullParser parser) throws Exception {
  146.         ParserUtils.assertAtStartTag(parser);
  147.         final String name = parser.getName();
  148.         switch (name) {
  149.         case Message.ELEMENT:
  150.             return parseMessage(parser);
  151.         case IQ.IQ_ELEMENT:
  152.             return parseIQ(parser);
  153.         case Presence.ELEMENT:
  154.             return parsePresence(parser);
  155.         default:
  156.             throw new IllegalArgumentException("Can only parse message, iq or presence, not " + name);
  157.         }
  158.     }

  160.     /**
  161.      * Creates a new XmlPullParser suitable for parsing XMPP. This means in particular that
  162.      * FEATURE_PROCESS_NAMESPACES is enabled.
  163.      * <p>
  164.      * Note that not all XmlPullParser implementations will return a String on
  165.      * <code>getText()</code> if the parser is on START_TAG or END_TAG. So you must not rely on this
  166.      * behavior when using the parser.
  167.      * </p>
  168.      * 
  169.      * @return A suitable XmlPullParser for XMPP parsing
  170.      * @throws XmlPullParserException
  171.      */
  172.     public static XmlPullParser newXmppParser() throws XmlPullParserException {
  173.         XmlPullParser parser = XmlPullParserFactory.newInstance().newPullParser();
  174.         parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true);
  175.         if (XML_PULL_PARSER_SUPPORTS_ROUNDTRIP) {
  176.             try {
  177.                 parser.setFeature(FEATURE_XML_ROUNDTRIP, true);
  178.             }
  179.             catch (XmlPullParserException e) {
  180.                 LOGGER.log(Level.SEVERE,
  181.                                 "XmlPullParser does not support XML_ROUNDTRIP, although it was first determined to be supported",
  182.                                 e);
  183.             }
  184.         }
  185.         return parser;
  186.     }

  188.     /**
  189.      * Creates a new XmlPullParser suitable for parsing XMPP. This means in particular that
  190.      * FEATURE_PROCESS_NAMESPACES is enabled.
  191.      * <p>
  192.      * Note that not all XmlPullParser implementations will return a String on
  193.      * <code>getText()</code> if the parser is on START_TAG or END_TAG. So you must not rely on this
  194.      * behavior when using the parser.
  195.      * </p>
  196.      * 
  197.      * @param reader
  198.      * @return A suitable XmlPullParser for XMPP parsing
  199.      * @throws XmlPullParserException
  200.      */
  201.     public static XmlPullParser newXmppParser(Reader reader) throws XmlPullParserException {
  202.         XmlPullParser parser = newXmppParser();
  203.         parser.setInput(reader);
  204.         return parser;
  205.     }

  207.     /**
  208.      * Parses a message packet.
  209.      *
  210.      * @param parser the XML parser, positioned at the start of a message packet.
  211.      * @return a Message packet.
  212.      * @throws Exception 
  213.      */
  214.     public static Message parseMessage(XmlPullParser parser)
  215.                     throws Exception {
  216.         ParserUtils.assertAtStartTag(parser);
  217.         assert(parser.getName().equals(Message.ELEMENT));

  219.         final int initialDepth = parser.getDepth();
  220.         Message message = new Message();
  221.         message.setStanzaId(parser.getAttributeValue("", "id"));
  222.         message.setTo(ParserUtils.getJidAttribute(parser, "to"));
  223.         message.setFrom(ParserUtils.getJidAttribute(parser, "from"));
  224.         String typeString = parser.getAttributeValue("", "type");
  225.         if (typeString != null) {
  226.             message.setType(Message.Type.fromString(typeString));
  227.         }
  228.         String language = getLanguageAttribute(parser);
  229.         
  230.         // determine message's default language
  231.         String defaultLanguage = null;
  232.         if (language != null && !"".equals(language.trim())) {
  233.             message.setLanguage(language);
  234.             defaultLanguage = language;
  235.         } 
  236.         else {
  237.             defaultLanguage = Stanza.getDefaultLanguage();
  238.         }

  240.         // Parse sub-elements. We include extra logic to make sure the values
  241.         // are only read once. This is because it's possible for the names to appear
  242.         // in arbitrary sub-elements.
  243.         String thread = null;
  244.         outerloop: while (true) {
  245.             int eventType = parser.next();
  246.             switch (eventType) {
  247.             case XmlPullParser.START_TAG:
  248.                 String elementName = parser.getName();
  249.                 String namespace = parser.getNamespace();
  250.                 switch(elementName) {
  251.                 case "subject":
  252.                     String xmlLangSubject = getLanguageAttribute(parser);
  253.                     if (xmlLangSubject == null) {
  254.                         xmlLangSubject = defaultLanguage;
  255.                     }

  257.                     String subject = parseElementText(parser);

  259.                     if (message.getSubject(xmlLangSubject) == null) {
  260.                         message.addSubject(xmlLangSubject, subject);
  261.                     }
  262.                     break;
  263.                 case Message.BODY:
  264.                     String xmlLang = getLanguageAttribute(parser);
  265.                     if (xmlLang == null) {
  266.                         xmlLang = defaultLanguage;
  267.                     }

  269.                     String body = parseElementText(parser);

  271.                     if (message.getBody(xmlLang) == null) {
  272.                         message.addBody(xmlLang, body);
  273.                     }
  274.                     break;
  275.                 case "thread":
  276.                     if (thread == null) {
  277.                         thread = parser.nextText();
  278.                     }
  279.                     break;
  280.                 case "error":
  281.                     message.setError(parseError(parser));
  282.                     break;
  283.                  default:
  284.                     PacketParserUtils.addExtensionElement(message, parser, elementName, namespace);
  285.                     break;
  286.                 }
  287.                 break;
  288.             case XmlPullParser.END_TAG:
  289.                 if (parser.getDepth() == initialDepth) {
  290.                     break outerloop;
  291.                 }
  292.                 break;
  293.             }
  294.         }

  296.         message.setThread(thread);
  297.         return message;
  298.     }

  300.     /**
  301.      * Returns the textual content of an element as String.
  302.      * <p>
  303.      * The parser must be positioned on a START_TAG of an element which MUST NOT contain Mixed
  304.      * Content (as defined in XML 3.2.2), or else an XmlPullParserException will be thrown.
  305.      * </p>
  306.      * This method is used for the parts where the XMPP specification requires elements that contain
  307.      * only text or are the empty element.
  308.      * 
  309.      * @param parser
  310.      * @return the textual content of the element as String
  311.      * @throws XmlPullParserException
  312.      * @throws IOException
  313.      */
  314.     public static String parseElementText(XmlPullParser parser) throws XmlPullParserException, IOException {
  315.         assert (parser.getEventType() == XmlPullParser.START_TAG);
  316.         String res;
  317.         if (parser.isEmptyElementTag()) {
  318.             res = "";
  319.         }
  320.         else {
  321.             // Advance to the text of the Element
  322.             int event = parser.next();
  323.             if (event != XmlPullParser.TEXT) {
  324.                 if (event == XmlPullParser.END_TAG) {
  325.                     // Assume this is the end tag of the start tag at the
  326.                     // beginning of this method. Typical examples where this
  327.                     // happens are body elements containing the empty string,
  328.                     // ie. <body></body>, which appears to be valid XMPP, or a
  329.                     // least it's not explicitly forbidden by RFC 6121 5.2.3
  330.                     return "";
  331.                 } else {
  332.                     throw new XmlPullParserException(
  333.                                     "Non-empty element tag not followed by text, while Mixed Content (XML 3.2.2) is disallowed");
  334.                 }
  335.             }
  336.             res = parser.getText();
  337.             event = parser.next();
  338.             if (event != XmlPullParser.END_TAG) {
  339.                 throw new XmlPullParserException(
  340.                                 "Non-empty element tag contains child-elements, while Mixed Content (XML 3.2.2) is disallowed");
  341.             }
  342.         }
  343.         return res;
  344.     }

  346.     /**
  347.      * Returns the current element as string.
  348.      * <p>
  349.      * The parser must be positioned on START_TAG.
  350.      * </p>
  351.      * Note that only the outermost namespace attributes ("xmlns") will be returned, not nested ones.
  352.      *
  353.      * @param parser the XML pull parser
  354.      * @return the element as string
  355.      * @throws XmlPullParserException
  356.      * @throws IOException
  357.      */
  358.     public static CharSequence parseElement(XmlPullParser parser) throws XmlPullParserException, IOException {
  359.         return parseElement(parser, false);
  360.     }

  362.     public static CharSequence parseElement(XmlPullParser parser,
  363.                     boolean fullNamespaces) throws XmlPullParserException,
  364.                     IOException {
  365.         assert (parser.getEventType() == XmlPullParser.START_TAG);
  366.         return parseContentDepth(parser, parser.getDepth(), fullNamespaces);
  367.     }

  369.     /**
  370.      * Returns the content of a element.
  371.      * <p>
  372.      * The parser must be positioned on the START_TAG of the element which content is going to get
  373.      * returned. If the current element is the empty element, then the empty string is returned. If
  374.      * it is a element which contains just text, then just the text is returned. If it contains
  375.      * nested elements (and text), then everything from the current opening tag to the corresponding
  376.      * closing tag of the same depth is returned as String.
  377.      * </p>
  378.      * Note that only the outermost namespace attributes ("xmlns") will be returned, not nested ones.
  379.      * 
  380.      * @param parser the XML pull parser
  381.      * @return the content of a tag
  382.      * @throws XmlPullParserException if parser encounters invalid XML
  383.      * @throws IOException if an IO error occurs
  384.      */
  385.     public static CharSequence parseContent(XmlPullParser parser)
  386.                     throws XmlPullParserException, IOException {
  387.         assert(parser.getEventType() == XmlPullParser.START_TAG);
  388.         if (parser.isEmptyElementTag()) {
  389.             return "";
  390.         }
  391.         // Advance the parser, since we want to parse the content of the current element
  392.         parser.next();
  393.         return parseContentDepth(parser, parser.getDepth(), false);
  394.     }

  396.     public static CharSequence parseContentDepth(XmlPullParser parser, int depth)
  397.                     throws XmlPullParserException, IOException {
  398.         return parseContentDepth(parser, depth, false);
  399.     }

  401.     /**
  402.      * Returns the content from the current position of the parser up to the closing tag of the
  403.      * given depth. Note that only the outermost namespace attributes ("xmlns") will be returned,
  404.      * not nested ones, if <code>fullNamespaces</code> is false. If it is true, then namespaces of
  405.      * parent elements will be added to child elements that don't define a different namespace.
  406.      * <p>
  407.      * This method is able to parse the content with MX- and KXmlParser. KXmlParser does not support
  408.      * xml-roundtrip. i.e. return a String on getText() on START_TAG and END_TAG. We check for the
  409.      * XML_ROUNDTRIP feature. If it's not found we are required to work around this limitation, which
  410.      * results in only partial support for XML namespaces ("xmlns"): Only the outermost namespace of
  411.      * elements will be included in the resulting String, if <code>fullNamespaces</code> is set to false.
  412.      * </p>
  413.      * <p>
  414.      * In particular Android's XmlPullParser does not support XML_ROUNDTRIP.
  415.      * </p>
  416.      * 
  417.      * @param parser
  418.      * @param depth
  419.      * @param fullNamespaces
  420.      * @return the content of the current depth
  421.      * @throws XmlPullParserException
  422.      * @throws IOException
  423.      */
  424.     public static CharSequence parseContentDepth(XmlPullParser parser, int depth, boolean fullNamespaces) throws XmlPullParserException, IOException {
  425.         if (parser.getFeature(FEATURE_XML_ROUNDTRIP)) {
  426.             return parseContentDepthWithRoundtrip(parser, depth, fullNamespaces);
  427.         } else {
  428.             return parseContentDepthWithoutRoundtrip(parser, depth, fullNamespaces);
  429.         }
  430.     }

  432.     private static CharSequence parseContentDepthWithoutRoundtrip(XmlPullParser parser, int depth,
  433.                     boolean fullNamespaces) throws XmlPullParserException, IOException {
  434.         XmlStringBuilder xml = new XmlStringBuilder();
  435.         int event = parser.getEventType();
  436.         boolean isEmptyElement = false;
  437.         // XmlPullParser reports namespaces in nested elements even if *only* the outer ones defines
  438.         // it. This 'flag' ensures that when a namespace is set for an element, it won't be set again
  439.         // in a nested element. It's an ugly workaround that has the potential to break things.
  440.         String namespaceElement = null;
  441.         outerloop: while (true) {
  442.             switch (event) {
  443.             case XmlPullParser.START_TAG:
  444.                 xml.halfOpenElement(parser.getName());
  445.                 if (namespaceElement == null || fullNamespaces) {
  446.                     String namespace = parser.getNamespace();
  447.                     if (StringUtils.isNotEmpty(namespace)) {
  448.                         xml.attribute("xmlns", namespace);
  449.                         namespaceElement = parser.getName();
  450.                     }
  451.                 }
  452.                 for (int i = 0; i < parser.getAttributeCount(); i++) {
  453.                     xml.attribute(parser.getAttributeName(i), parser.getAttributeValue(i));
  454.                 }
  455.                 if (parser.isEmptyElementTag()) {
  456.                     xml.closeEmptyElement();
  457.                     isEmptyElement = true;
  458.                 }
  459.                 else {
  460.                     xml.rightAngleBracket();
  461.                 }
  462.                 break;
  463.             case XmlPullParser.END_TAG:
  464.                 if (isEmptyElement) {
  465.                     // Do nothing as the element was already closed, just reset the flag
  466.                     isEmptyElement = false;
  467.                 }
  468.                 else {
  469.                     xml.closeElement(parser.getName());
  470.                 }
  471.                 if (namespaceElement != null && namespaceElement.equals(parser.getName())) {
  472.                     // We are on the closing tag, which defined the namespace as starting tag, reset the 'flag'
  473.                     namespaceElement = null;
  474.                 }
  475.                 if (parser.getDepth() <= depth) {
  476.                     // Abort parsing, we are done
  477.                     break outerloop;
  478.                 }
  479.                 break;
  480.             case XmlPullParser.TEXT:
  481.                 xml.append(parser.getText());
  482.                 break;
  483.             }
  484.             event = parser.next();
  485.         }
  486.         return xml;
  487.     }

  489.     private static CharSequence parseContentDepthWithRoundtrip(XmlPullParser parser, int depth, boolean fullNamespaces)
  490.                     throws XmlPullParserException, IOException {
  491.         StringBuilder sb = new StringBuilder();
  492.         int event = parser.getEventType();
  493.         outerloop: while (true) {
  494.             // Only append the text if the parser is not on on an empty element' start tag. Empty elements are reported
  495.             // twice, so in order to prevent duplication we only add their text when we are on their end tag.
  496.             if (!(event == XmlPullParser.START_TAG && parser.isEmptyElementTag())) {
  497.                 sb.append(parser.getText());
  498.             }
  499.             if (event == XmlPullParser.END_TAG && parser.getDepth() <= depth) {
  500.                 break outerloop;
  501.             }
  502.             event = parser.next();
  503.         }
  504.         return sb;
  505.     }

  507.     /**
  508.      * Parses a presence packet.
  509.      *
  510.      * @param parser the XML parser, positioned at the start of a presence packet.
  511.      * @return a Presence packet.
  512.      * @throws Exception 
  513.      */
  514.     public static Presence parsePresence(XmlPullParser parser)
  515.                     throws Exception {
  516.         ParserUtils.assertAtStartTag(parser);
  517.         final int initialDepth = parser.getDepth();

  519.         Presence.Type type = Presence.Type.available;
  520.         String typeString = parser.getAttributeValue("", "type");
  521.         if (typeString != null && !typeString.equals("")) {
  522.             type = Presence.Type.fromString(typeString);
  523.         }
  524.         Presence presence = new Presence(type);
  525.         presence.setTo(ParserUtils.getJidAttribute(parser, "to"));
  526.         presence.setFrom(ParserUtils.getJidAttribute(parser, "from"));
  527.         presence.setStanzaId(parser.getAttributeValue("", "id"));

  529.         String language = getLanguageAttribute(parser);
  530.         if (language != null && !"".equals(language.trim())) {
  531.             presence.setLanguage(language);
  532.         }

  534.         // Parse sub-elements
  535.         outerloop: while (true) {
  536.             int eventType = parser.next();
  537.             switch (eventType) {
  538.             case XmlPullParser.START_TAG:
  539.                 String elementName = parser.getName();
  540.                 String namespace = parser.getNamespace();
  541.                 switch(elementName) {
  542.                 case "status":
  543.                     presence.setStatus(parser.nextText());
  544.                     break;
  545.                 case "priority":
  546.                     int priority = Integer.parseInt(parser.nextText());
  547.                     presence.setPriority(priority);
  548.                     break;
  549.                 case "show":
  550.                     String modeText = parser.nextText();
  551.                     if (StringUtils.isNotEmpty(modeText)) {
  552.                         presence.setMode(Presence.Mode.fromString(modeText));
  553.                     } else {
  554.                         // Some implementations send presence stanzas with a
  555.                         // '<show />' element, which is a invalid XMPP presence
  556.                         // stanza according to RFC 6121 4.7.2.1
  557.                         LOGGER.warning("Empty or null mode text in presence show element form "
  558.                                         + presence.getFrom()
  559.                                         + " with id '"
  560.                                         + presence.getStanzaId()
  561.                                         + "' which is invalid according to RFC6121 4.7.2.1");
  562.                     }
  563.                     break;
  564.                 case "error":
  565.                     presence.setError(parseError(parser));
  566.                     break;
  567.                 default:
  568.                 // Otherwise, it must be a packet extension.
  569.                     // Be extra robust: Skip PacketExtensions that cause Exceptions, instead of
  570.                     // failing completely here. See SMACK-390 for more information.
  571.                     try {
  572.                         PacketParserUtils.addExtensionElement(presence, parser, elementName, namespace);
  573.                     } catch (Exception e) {
  574.                         LOGGER.log(Level.WARNING, "Failed to parse extension packet in Presence packet.", e);
  575.                     }
  576.                     break;
  577.                 }
  578.             case XmlPullParser.END_TAG:
  579.                 if (parser.getDepth() == initialDepth) {
  580.                     break outerloop;
  581.                 }
  582.                 break;
  583.             }
  584.         }
  585.         return presence;
  586.     }

  588.     /**
  589.      * Parses an IQ packet.
  590.      *
  591.      * @param parser the XML parser, positioned at the start of an IQ packet.
  592.      * @return an IQ object.
  593.      * @throws XmlPullParserException 
  594.      * @throws IOException 
  595.      * @throws SmackException 
  596.      */
  597.     public static IQ parseIQ(XmlPullParser parser) throws Exception {
  598.         ParserUtils.assertAtStartTag(parser);
  599.         final int initialDepth = parser.getDepth();
  600.         IQ iqPacket = null;
  601.         XMPPError error = null;

  603.         final String id = parser.getAttributeValue("", "id");
  604.         final Jid to = ParserUtils.getJidAttribute(parser, "to");
  605.         final Jid from = ParserUtils.getJidAttribute(parser, "from");
  606.         final IQ.Type type = IQ.Type.fromString(parser.getAttributeValue("", "type"));

  608.         outerloop: while (true) {
  609.             int eventType = parser.next();

  611.             switch (eventType) {
  612.             case XmlPullParser.START_TAG:
  613.                 String elementName = parser.getName();
  614.                 String namespace = parser.getNamespace();
  615.                 switch(elementName) {
  616.                 case "error":
  617.                     error = PacketParserUtils.parseError(parser);
  618.                     break;
  619.                 // Otherwise, see if there is a registered provider for
  620.                 // this element name and namespace.
  621.                 default:
  622.                     IQProvider<IQ> provider = ProviderManager.getIQProvider(elementName, namespace);
  623.                     if (provider != null) {
  624.                             iqPacket = provider.parse(parser);
  625.                     }
  626.                     // Note that if we reach this code, it is guranteed that the result IQ contained a child element
  627.                     // (RFC 6120 § 8.2.3 6) because otherwhise we would have reached the END_TAG first.
  628.                     else {
  629.                         // No Provider found for the IQ stanza, parse it to an UnparsedIQ instance
  630.                         // so that the content of the IQ can be examined later on
  631.                         iqPacket = new UnparsedIQ(elementName, namespace, parseElement(parser));
  632.                     }
  633.                     break;
  634.                 }
  635.                 break;
  636.             case XmlPullParser.END_TAG:
  637.                 if (parser.getDepth() == initialDepth) {
  638.                     break outerloop;
  639.                 }
  640.                 break;
  641.             }
  642.         }
  643.         // Decide what to do when an IQ packet was not understood
  644.         if (iqPacket == null) {
  645.             switch (type) {
  646.             case error:
  647.                 // If an IQ packet wasn't created above, create an empty error IQ packet.
  648.                 iqPacket = new ErrorIQ(error);
  649.                 break;
  650.             case result:
  651.                 iqPacket = new EmptyResultIQ();
  652.                 break;
  653.             default:
  654.                 break;
  655.             }
  656.         }

  658.         // Set basic values on the iq packet.
  659.         iqPacket.setStanzaId(id);
  660.         iqPacket.setTo(to);
  661.         iqPacket.setFrom(from);
  662.         iqPacket.setType(type);
  663.         iqPacket.setError(error);

  665.         return iqPacket;
  666.     }

  668.     /**
  669.      * Parse the available SASL mechanisms reported from the server.
  670.      *
  671.      * @param parser the XML parser, positioned at the start of the mechanisms stanza.
  672.      * @return a collection of Stings with the mechanisms included in the mechanisms stanza.
  673.      * @throws IOException 
  674.      * @throws XmlPullParserException 
  675.      */
  676.     public static Collection<String> parseMechanisms(XmlPullParser parser)
  677.                     throws XmlPullParserException, IOException {
  678.         List<String> mechanisms = new ArrayList<String>();
  679.         boolean done = false;
  680.         while (!done) {
  681.             int eventType = parser.next();

  683.             if (eventType == XmlPullParser.START_TAG) {
  684.                 String elementName = parser.getName();
  685.                 if (elementName.equals("mechanism")) {
  686.                     mechanisms.add(parser.nextText());
  687.                 }
  688.             }
  689.             else if (eventType == XmlPullParser.END_TAG) {
  690.                 if (parser.getName().equals("mechanisms")) {
  691.                     done = true;
  692.                 }
  693.             }
  694.         }
  695.         return mechanisms;
  696.     }

  698.     /**
  699.      * Parse the Compression Feature reported from the server.
  700.      *
  701.      * @param parser the XML parser, positioned at the start of the compression stanza.
  702.      * @return The CompressionFeature stream element
  703.      * @throws XmlPullParserException if an exception occurs while parsing the stanza.
  704.      */
  705.     public static Compress.Feature parseCompressionFeature(XmlPullParser parser)
  706.                     throws IOException, XmlPullParserException {
  707.         assert (parser.getEventType() == XmlPullParser.START_TAG);
  708.         String name;
  709.         final int initialDepth = parser.getDepth();
  710.         List<String> methods = new LinkedList<String>();
  711.         outerloop: while (true) {
  712.             int eventType = parser.next();
  713.             switch (eventType) {
  714.             case XmlPullParser.START_TAG:
  715.                 name = parser.getName();
  716.                 switch (name) {
  717.                 case "method":
  718.                     methods.add(parser.nextText());
  719.                     break;
  720.                 }
  721.                 break;
  722.             case XmlPullParser.END_TAG:
  723.                 name = parser.getName();
  724.                 switch (name) {
  725.                 case Compress.Feature.ELEMENT:
  726.                     if (parser.getDepth() == initialDepth) {
  727.                         break outerloop;
  728.                     }
  729.                 }
  730.             }
  731.         }
  732.         assert (parser.getEventType() == XmlPullParser.END_TAG);
  733.         assert (parser.getDepth() == initialDepth);
  734.         return new Compress.Feature(methods);
  735.     }

  737.     public static Map<String, String> parseDescriptiveTexts(XmlPullParser parser, Map<String, String> descriptiveTexts)
  738.                     throws XmlPullParserException, IOException {
  739.         if (descriptiveTexts == null) {
  740.             descriptiveTexts = new HashMap<String, String>();
  741.         }
  742.         String xmllang = getLanguageAttribute(parser);
  743.         String text = parser.nextText();
  744.         String previousValue = descriptiveTexts.put(xmllang, text);
  745.         assert (previousValue == null);
  746.         return descriptiveTexts;
  747.     }

  749.     /**
  750.      * Parses SASL authentication error packets.
  751.      * 
  752.      * @param parser the XML parser.
  753.      * @return a SASL Failure packet.
  754.      * @throws IOException 
  755.      * @throws XmlPullParserException 
  756.      */
  757.     public static SASLFailure parseSASLFailure(XmlPullParser parser) throws XmlPullParserException, IOException {
  758.         final int initialDepth = parser.getDepth();
  759.         String condition = null;
  760.         Map<String, String> descriptiveTexts = null;
  761.         outerloop: while (true) {
  762.             int eventType = parser.next();
  763.             switch (eventType) {
  764.             case XmlPullParser.START_TAG:
  765.                 String name = parser.getName();
  766.                 if (name.equals("text")) {
  767.                     descriptiveTexts = parseDescriptiveTexts(parser, descriptiveTexts);
  768.                 }
  769.                 else {
  770.                     assert(condition == null);
  771.                     condition = parser.getName();
  772.                 }
  773.                 break;
  774.             case XmlPullParser.END_TAG:
  775.                 if (parser.getDepth() == initialDepth) {
  776.                     break outerloop;
  777.                 }
  778.                 break;
  779.             }
  780.         }
  781.         return new SASLFailure(condition, descriptiveTexts);
  782.     }

  784.     /**
  785.      * Parses stream error packets.
  786.      *
  787.      * @param parser the XML parser.
  788.      * @return an stream error packet.
  789.      * @throws Exception if an exception occurs while parsing the packet.
  790.      */
  791.     public static StreamError parseStreamError(XmlPullParser parser) throws Exception {
  792.         final int initialDepth = parser.getDepth();
  793.         List<ExtensionElement> extensions = new ArrayList<ExtensionElement>();
  794.         Map<String, String> descriptiveTexts = null;
  795.         StreamError.Condition condition = null;
  796.         String conditionText = null;
  797.         outerloop: while (true) {
  798.             int eventType = parser.next();
  799.             switch (eventType) {
  800.             case XmlPullParser.START_TAG:
  801.                 String name = parser.getName();
  802.                 String namespace = parser.getNamespace();
  803.                 switch (namespace) {
  804.                 case StreamError.NAMESPACE:
  805.                     switch (name) {
  806.                     case "text":
  807.                         descriptiveTexts = parseDescriptiveTexts(parser, descriptiveTexts);
  808.                         break;
  809.                     default:
  810.                         // If it's not a text element, that is qualified by the StreamError.NAMESPACE,
  811.                         // then it has to be the stream error code
  812.                         condition = StreamError.Condition.fromString(name);
  813.                         if (!parser.isEmptyElementTag()) {
  814.                             conditionText = parser.nextText();
  815.                         }
  816.                         break;
  817.                     }
  818.                     break;
  819.                 default:
  820.                     PacketParserUtils.addExtensionElement(extensions, parser, name, namespace);
  821.                     break;
  822.                 }
  823.                 break;
  824.             case XmlPullParser.END_TAG:
  825.                 if (parser.getDepth() == initialDepth) {
  826.                     break outerloop;
  827.                 }
  828.                 break;
  829.             }
  830.         }
  831.         return new StreamError(condition, conditionText, descriptiveTexts, extensions);
  832.     }

  834.     /**
  835.      * Parses error sub-packets.
  836.      *
  837.      * @param parser the XML parser.
  838.      * @return an error sub-packet.
  839.      * @throws Exception 
  840.      */
  841.     public static XMPPError parseError(XmlPullParser parser)
  842.                     throws Exception {
  843.         final int initialDepth = parser.getDepth();
  844.         Map<String, String> descriptiveTexts = null;
  845.         XMPPError.Condition condition = null;
  846.         String conditionText = null;
  847.         List<ExtensionElement> extensions = new ArrayList<ExtensionElement>();

  849.         // Parse the error header
  850.         XMPPError.Type errorType = XMPPError.Type.fromString(parser.getAttributeValue("", "type"));
  851.         String errorGenerator = parser.getAttributeValue("", "by");

  853.         outerloop: while (true) {
  854.             int eventType = parser.next();
  855.             switch (eventType) {
  856.             case XmlPullParser.START_TAG:
  857.                 String name = parser.getName();
  858.                 String namespace = parser.getNamespace();
  859.                 switch (namespace) {
  860.                 case XMPPError.NAMESPACE:
  861.                     switch (name) {
  862.                     case Stanza.TEXT:
  863.                         descriptiveTexts = parseDescriptiveTexts(parser, descriptiveTexts);
  864.                         break;
  865.                     default:
  866.                         condition = XMPPError.Condition.fromString(name);
  867.                         if (!parser.isEmptyElementTag()) {
  868.                             conditionText = parser.nextText();
  869.                         }
  870.                         break;
  871.                     }
  872.                     break;
  873.                 default:
  874.                     PacketParserUtils.addExtensionElement(extensions, parser, name, namespace);
  875.                 }
  876.                 break;
  877.             case XmlPullParser.END_TAG:
  878.                 if (parser.getDepth() == initialDepth) {
  879.                     break outerloop;
  880.                 }
  881.             }
  882.         }
  883.         return new XMPPError(condition, conditionText, errorGenerator, errorType, descriptiveTexts, extensions);
  884.     }

  886.     /**
  887.      * @deprecated use {@link #parseExtensionElement(String, String, XmlPullParser)} instead.
  888.      */
  889.     @Deprecated
  890.     public static ExtensionElement parsePacketExtension(String elementName, String namespace,
  891.                     XmlPullParser parser) throws Exception {
  892.         return parseExtensionElement(elementName, namespace, parser);
  893.     }
  894.  
  895.     /**
  896.      * Parses an extension element.
  897.      *
  898.      * @param elementName the XML element name of the extension element.
  899.      * @param namespace the XML namespace of the packet extension.
  900.      * @param parser the XML parser, positioned at the starting element of the extension.
  901.      * @return an extension element.
  902.      */
  903.     public static ExtensionElement parseExtensionElement(String elementName, String namespace,
  904.                     XmlPullParser parser) throws Exception {
  905.         ParserUtils.assertAtStartTag(parser);
  906.         // See if a provider is registered to handle the extension.
  907.         ExtensionElementProvider<ExtensionElement> provider = ProviderManager.getExtensionProvider(elementName, namespace);
  908.         if (provider != null) {
  909.                 return provider.parse(parser);
  910.         }

  912.         final int initialDepth = parser.getDepth();
  913.         // No providers registered, so use a default extension.
  914.         DefaultExtensionElement extension = new DefaultExtensionElement(elementName, namespace);
  915.         outerloop: while (true) {
  916.             int eventType = parser.next();
  917.             switch (eventType) {
  918.             case XmlPullParser.START_TAG:
  919.                 String name = parser.getName();
  920.                 // If an empty element, set the value with the empty string.
  921.                 if (parser.isEmptyElementTag()) {
  922.                     extension.setValue(name,"");
  923.                 }
  924.                 // Otherwise, get the the element text.
  925.                 else {
  926.                     eventType = parser.next();
  927.                     if (eventType == XmlPullParser.TEXT) {
  928.                         String value = parser.getText();
  929.                         extension.setValue(name, value);
  930.                     }
  931.                 }
  932.                 break;
  933.             case XmlPullParser.END_TAG:
  934.                 if (parser.getDepth() == initialDepth) {
  935.                     break outerloop;
  936.                 }
  937.             }
  938.         }
  939.         return extension;
  940.     }

  942.     public static StartTls parseStartTlsFeature(XmlPullParser parser)
  943.                     throws XmlPullParserException, IOException {
  944.         assert (parser.getEventType() == XmlPullParser.START_TAG);
  945.         assert (parser.getNamespace().equals(StartTls.NAMESPACE));
  946.         int initalDepth = parser.getDepth();
  947.         boolean required = false;
  948.         outerloop: while (true) {
  949.             int event = parser.next();
  950.             switch (event) {
  951.             case XmlPullParser.START_TAG:
  952.                 String name = parser.getName();
  953.                 switch (name) {
  954.                 case "required":
  955.                     required = true;
  956.                     break;
  957.                 }
  958.                 break;
  959.             case XmlPullParser.END_TAG:
  960.                 if (parser.getDepth() == initalDepth) {
  961.                     break outerloop;
  962.                 }
  963.             }
  964.         }
  965.         assert(parser.getEventType() == XmlPullParser.END_TAG);
  966.         return new StartTls(required);
  967.     }

  969.     public static Session.Feature parseSessionFeature(XmlPullParser parser) throws XmlPullParserException, IOException {
  970.         ParserUtils.assertAtStartTag(parser);
  971.         final int initialDepth = parser.getDepth();
  972.         boolean optional = false;
  973.         if (!parser.isEmptyElementTag()) {
  974.         outerloop: while(true) {
  975.             int event = parser.next();
  976.             switch (event) {
  977.             case XmlPullParser.START_TAG:
  978.                 String name = parser.getName();
  979.                 switch (name) {
  980.                     case Session.Feature.OPTIONAL_ELEMENT:
  981.                         optional = true;
  982.                         break;
  983.                 }
  984.                 break;
  985.             case XmlPullParser.END_TAG:
  986.                 if (parser.getDepth() == initialDepth) {
  987.                     break outerloop;
  988.                 }
  989.             }
  990.         }
  991.         }
  992.         return new Session.Feature(optional);

  994.     }
  995.     private static String getLanguageAttribute(XmlPullParser parser) {
  996.         for (int i = 0; i < parser.getAttributeCount(); i++) {
  997.             String attributeName = parser.getAttributeName(i);
  998.             if ( "xml:lang".equals(attributeName) ||
  999.                     ("lang".equals(attributeName) &&
  1000.                             "xml".equals(parser.getAttributePrefix(i)))) {
  1001.                 return parser.getAttributeValue(i);
  1002.             }
  1003.         }
  1004.         return null;
  1005.     }

  1007.     @Deprecated
  1008.     public static void addPacketExtension(Stanza packet, XmlPullParser parser) throws Exception {
  1009.         addExtensionElement(packet, parser);
  1010.     }

  1012.     @Deprecated
  1013.     public static void addPacketExtension(Stanza packet, XmlPullParser parser, String elementName, String namespace)
  1014.                     throws Exception {
  1015.         addExtensionElement(packet, parser, elementName, namespace);
  1016.     }

  1018.     @Deprecated
  1019.     public static void addPacketExtension(Collection<ExtensionElement> collection, XmlPullParser parser)
  1020.                     throws Exception {
  1021.         addExtensionElement(collection, parser, parser.getName(), parser.getNamespace());
  1022.     }

  1024.     @Deprecated
  1025.     public static void addPacketExtension(Collection<ExtensionElement> collection, XmlPullParser parser,
  1026.                     String elementName, String namespace) throws Exception {
  1027.         addExtensionElement(collection, parser, elementName, namespace);
  1028.     }


  1031.     public static void addExtensionElement(Stanza packet, XmlPullParser parser)
  1032.                     throws Exception {
  1033.         ParserUtils.assertAtStartTag(parser);
  1034.         addExtensionElement(packet, parser, parser.getName(), parser.getNamespace());
  1035.     }

  1037.     public static void addExtensionElement(Stanza packet, XmlPullParser parser, String elementName,
  1038.                     String namespace) throws Exception{
  1039.         ExtensionElement packetExtension = parseExtensionElement(elementName, namespace, parser);
  1040.         packet.addExtension(packetExtension);
  1041.     }

  1043.     public static void addExtensionElement(Collection<ExtensionElement> collection,
  1044.                     XmlPullParser parser) throws Exception {
  1045.         addExtensionElement(collection, parser, parser.getName(), parser.getNamespace());
  1046.     }

  1048.     public static void addExtensionElement(Collection<ExtensionElement> collection,
  1049.                     XmlPullParser parser, String elementName, String namespace)
  1050.                     throws Exception {
  1051.         ExtensionElement packetExtension = parseExtensionElement(elementName, namespace, parser);
  1052.         collection.add(packetExtension);
  1053.     }
  1054. }
Created with JaCoCo 0.7.4.201502262128