AbstractHttpOverXmppProvider.java

  1. /**
  2.  *
  3.  * Copyright 2014 Andriy Tsykholyas
  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.smackx.hoxt.provider;

  19. import org.jivesoftware.smack.packet.NamedElement;
  20. import org.jivesoftware.smack.provider.IQProvider;
  21. import org.jivesoftware.smack.util.StringUtils;
  22. import org.jivesoftware.smackx.hoxt.packet.AbstractHttpOverXmpp;
  23. import org.jivesoftware.smackx.shim.packet.HeadersExtension;
  24. import org.jivesoftware.smackx.shim.provider.HeadersProvider;
  25. import org.xmlpull.v1.XmlPullParser;
  26. import org.xmlpull.v1.XmlPullParserException;

  28. import java.io.IOException;

  30. /**
  31.  * Abstract parent for Req and Resp packet providers.
  32.  *
  33.  * @author Andriy Tsykholyas
  34.  * @see <a href="http://xmpp.org/extensions/xep-0332.html">XEP-0332: HTTP over XMPP transport</a>
  35.  */
  36. public abstract class AbstractHttpOverXmppProvider<H extends AbstractHttpOverXmpp> extends IQProvider<H> {

  38.     private static final String ELEMENT_DATA = "data";
  39.     private static final String ELEMENT_TEXT = "text";
  40.     private static final String ELEMENT_BASE_64 = "base64";
  41.     private static final String ELEMENT_CHUNKED_BASE_64 = "chunkedBase64";
  42.     private static final String ELEMENT_XML = "xml";
  43.     static final String ELEMENT_IBB = "ibb";
  44.     static final String ELEMENT_SIPUB = "sipub";
  45.     static final String ELEMENT_JINGLE = "jingle";

  47.     private static final String ATTRIBUTE_STREAM_ID = "streamId";
  48.     private static final String ATTRIBUTE_SID = "sid";
  49.     static final String ATTRIBUTE_VERSION = "version";

  51.     /**
  52.      * Parses Headers and Data elements.
  53.      *
  54.      * @param parser      parser
  55.      * @param elementName name of concrete implementation of this element
  56.      * @param body        parent Body element
  57.      * @throws Exception 
  58.      */
  59.     protected void parseHeadersAndData(XmlPullParser parser, String elementName, AbstractHttpOverXmpp body) throws Exception {
  60.         boolean done = false;

  62.         while (!done) {
  63.             int eventType = parser.next();

  65.             if (eventType == XmlPullParser.START_TAG) {
  66.                 if (parser.getName().equals(HeadersExtension.ELEMENT)) {
  67.                     HeadersExtension headersExtension = HeadersProvider.INSTANCE.parse(parser);
  68.                     body.setHeaders(headersExtension);
  69.                 } else if (parser.getName().endsWith(ELEMENT_DATA)) {
  70.                     AbstractHttpOverXmpp.Data data = parseData(parser);
  71.                     body.setData(data);
  72.                 } else {
  73.                     throw new IllegalArgumentException("unexpected tag:" + parser.getName() + "'");
  74.                 }
  75.             } else if (eventType == XmlPullParser.END_TAG) {
  76.                 if (parser.getName().equals(elementName)) {
  77.                     done = true;
  78.                 }
  79.             }
  80.         }
  81.     }

  83.     private AbstractHttpOverXmpp.Data parseData(XmlPullParser parser) throws XmlPullParserException, IOException {
  84.         NamedElement child = null;
  85.         boolean done = false;

  87.         while (!done) {
  88.             int eventType = parser.next();

  90.             if (eventType == XmlPullParser.START_TAG) {
  91.                 if (parser.getName().equals(ELEMENT_TEXT)) {
  92.                     child = parseText(parser);
  93.                 } else if (parser.getName().equals(ELEMENT_BASE_64)) {
  94.                     child = parseBase64(parser);
  95.                 } else if (parser.getName().equals(ELEMENT_CHUNKED_BASE_64)) {
  96.                     child = parseChunkedBase64(parser);
  97.                 } else if (parser.getName().equals(ELEMENT_XML)) {
  98.                     child = parseXml(parser);
  99.                 } else if (parser.getName().equals(ELEMENT_IBB)) {
  100.                     child = parseIbb(parser);
  101.                 } else if (parser.getName().equals(ELEMENT_SIPUB)) {
  102.                     // TODO: sipub is allowed by xep-0332, but is not implemented yet
  103.                     throw new UnsupportedOperationException("sipub is not supported yet");
  104.                 } else if (parser.getName().equals(ELEMENT_JINGLE)) {
  105.                     // TODO: jingle is allowed by xep-0332, but is not implemented yet
  106.                     throw new UnsupportedOperationException("jingle is not supported yet");
  107.                 } else {
  108.                     // other elements are not allowed
  109.                     throw new IllegalArgumentException("unsupported child tag: " + parser.getName());
  110.                 }
  111.             } else if (eventType == XmlPullParser.END_TAG) {
  112.                 if (parser.getName().equals(ELEMENT_DATA)) {
  113.                     done = true;
  114.                 }
  115.             }
  116.         }

  118.         AbstractHttpOverXmpp.Data data = new AbstractHttpOverXmpp.Data(child);
  119.         return data;
  120.     }

  122.     private AbstractHttpOverXmpp.Text parseText(XmlPullParser parser) throws XmlPullParserException, IOException {
  123.         String text = null;
  124.         boolean done = false;

  126.         while (!done) {
  127.             int eventType = parser.next();

  129.             if (eventType == XmlPullParser.END_TAG) {
  130.                 if (parser.getName().equals(ELEMENT_TEXT)) {
  131.                     done = true;
  132.                 } else {
  133.                     throw new IllegalArgumentException("unexpected end tag of: " + parser.getName());
  134.                 }
  135.             } else if (eventType == XmlPullParser.TEXT) {
  136.                 text = parser.getText();
  137.             } else {
  138.                 throw new IllegalArgumentException("unexpected eventType: " + eventType);
  139.             }
  140.         }

  142.         return new AbstractHttpOverXmpp.Text(text);
  143.     }

  145.     private AbstractHttpOverXmpp.Xml parseXml(XmlPullParser parser) throws XmlPullParserException, IOException {
  146.         StringBuilder builder = new StringBuilder();
  147.         boolean done = false;
  148.         boolean startClosed = true;

  150.         while (!done) {
  151.             int eventType = parser.next();

  153.             if ((eventType == XmlPullParser.END_TAG) && parser.getName().equals(ELEMENT_XML)) {
  154.                 done = true;
  155.             } else { // just write everything else as text

  157.                 if (eventType == XmlPullParser.START_TAG) {

  159.                     if (!startClosed) {
  160.                         builder.append('>');
  161.                     }

  163.                     builder.append('<');
  164.                     builder.append(parser.getName());
  165.                     appendXmlAttributes(parser, builder);
  166.                     startClosed = false;
  167.                 } else if (eventType == XmlPullParser.END_TAG) {

  169.                     if (startClosed) {
  170.                         builder.append("</");
  171.                         builder.append(parser.getName());
  172.                         builder.append('>');
  173.                     } else {
  174.                         builder.append("/>");
  175.                         startClosed = true;
  176.                     }
  177.                 } else if (eventType == XmlPullParser.TEXT) {

  179.                     if (!startClosed) {
  180.                         builder.append('>');
  181.                         startClosed = true;
  182.                     }
  183.                     builder.append(StringUtils.escapeForXML(parser.getText()));
  184.                 } else {
  185.                     throw new IllegalArgumentException("unexpected eventType: " + eventType);
  186.                 }
  187.             }
  188.         }

  190.         return new AbstractHttpOverXmpp.Xml(builder.toString());
  191.     }

  193.     private void appendXmlAttributes(XmlPullParser parser, StringBuilder builder) {
  194.         // NOTE: for now we ignore namespaces
  195.         int count = parser.getAttributeCount();

  197.         if (count > 0) {

  199.             for (int i = 0; i < count; i++) {
  200.                 builder.append(' ');
  201.                 builder.append(parser.getAttributeName(i));
  202.                 builder.append("=\"");
  203.                 builder.append(StringUtils.escapeForXML(parser.getAttributeValue(i)));
  204.                 builder.append('"');
  205.             }
  206.         }
  207.     }

  209.     private AbstractHttpOverXmpp.Base64 parseBase64(XmlPullParser parser) throws XmlPullParserException, IOException {
  210.         String text = null;
  211.         boolean done = false;

  213.         while (!done) {
  214.             int eventType = parser.next();

  216.             if (eventType == XmlPullParser.END_TAG) {

  218.                 if (parser.getName().equals(ELEMENT_BASE_64)) {
  219.                     done = true;
  220.                 } else {
  221.                     throw new IllegalArgumentException("unexpected end tag of: " + parser.getName());
  222.                 }
  223.             } else if (eventType == XmlPullParser.TEXT) {
  224.                 text = parser.getText();
  225.             } else {
  226.                 throw new IllegalArgumentException("unexpected eventType: " + eventType);
  227.             }
  228.         }

  230.         return new AbstractHttpOverXmpp.Base64(text);
  231.     }

  233.     private AbstractHttpOverXmpp.ChunkedBase64 parseChunkedBase64(XmlPullParser parser) throws XmlPullParserException, IOException {
  234.         String streamId = parser.getAttributeValue("", ATTRIBUTE_STREAM_ID);
  235.         AbstractHttpOverXmpp.ChunkedBase64 child = new AbstractHttpOverXmpp.ChunkedBase64(streamId);
  236.         boolean done = false;

  238.         while (!done) {
  239.             int eventType = parser.next();

  241.             if (eventType == XmlPullParser.END_TAG) {
  242.                 if (parser.getName().equals(ELEMENT_CHUNKED_BASE_64)) {
  243.                     done = true;
  244.                 } else {
  245.                     throw new IllegalArgumentException("unexpected end tag: " + parser.getName());
  246.                 }
  247.             } else {
  248.                 throw new IllegalArgumentException("unexpected event type: " + eventType);
  249.             }
  250.         }
  251.         return child;
  252.     }

  254.     private AbstractHttpOverXmpp.Ibb parseIbb(XmlPullParser parser) throws XmlPullParserException, IOException {
  255.         String sid = parser.getAttributeValue("", ATTRIBUTE_SID);
  256.         AbstractHttpOverXmpp.Ibb child = new AbstractHttpOverXmpp.Ibb(sid);
  257.         boolean done = false;

  259.         while (!done) {
  260.             int eventType = parser.next();

  262.             if (eventType == XmlPullParser.END_TAG) {
  263.                 if (parser.getName().equals(ELEMENT_IBB)) {
  264.                     done = true;
  265.                 } else {
  266.                     throw new IllegalArgumentException("unexpected end tag: " + parser.getName());
  267.                 }
  268.             } else {
  269.                 throw new IllegalArgumentException("unexpected event type: " + eventType);
  270.             }
  271.         }
  272.         return child;
  273.     }
  274. }
Created with JaCoCo 0.7.4.201502262128