4 files changed, 547 insertions, 0 deletions
diff --git a/src/main/java/eu/siacs/conversations/xml/Element.java b/src/main/java/eu/siacs/conversations/xml/Element.java
new file mode 100644
index 00000000..9152c679
--- /dev/null
+++ b/src/main/java/eu/siacs/conversations/xml/Element.java
@@ -0,0 +1,188 @@
+package eu.siacs.conversations.xml;
+
+import java.util.ArrayList;
+import java.util.Hashtable;
+import java.util.List;
+
+import de.thedevstack.android.logcat.Logging;
+import eu.siacs.conversations.Config;
+import eu.siacs.conversations.utils.XmlHelper;
+import eu.siacs.conversations.xmpp.jid.InvalidJidException;
+import eu.siacs.conversations.xmpp.jid.Jid;
+
+public class Element {
+	private final String name;
+	private Hashtable<String, String> attributes = new Hashtable<>();
+	private String content;
+	protected List<Element> children = new ArrayList<>();
+
+	public Element(String name) {
+		this.name = name;
+	}
+
+	public Element(String name, String xmlns) {
+		this.name = name;
+		this.setAttribute("xmlns", xmlns);
+	}
+
+	public Element addChild(Element child) {
+		this.content = null;
+		children.add(child);
+		return child;
+	}
+
+	public Element addChild(String name) {
+		this.content = null;
+		Element child = new Element(name);
+		children.add(child);
+		return child;
+	}
+
+	public Element addChild(String name, String xmlns) {
+		this.content = null;
+		Element child = new Element(name);
+		child.setAttribute("xmlns", xmlns);
+		children.add(child);
+		return child;
+	}
+
+	public Element setContent(String content) {
+		this.content = content;
+		this.children.clear();
+		return this;
+	}
+
+	public Element findChild(String name) {
+		for (Element child : this.children) {
+			if (child.getName().equals(name)) {
+				return child;
+			}
+		}
+		return null;
+	}
+
+	public String findChildContent(String name) {
+		Element element = findChild(name);
+		return element == null ? null : element.getContent();
+	}
+
+	public Element findChild(String name, String xmlns) {
+		for (Element child : this.children) {
+			if (name.equals(child.getName()) && xmlns.equals(child.getAttribute("xmlns"))) {
+				return child;
+			}
+		}
+		return null;
+	}
+
+	public String findChildContent(String name, String xmlns) {
+		Element element = findChild(name,xmlns);
+		return element == null ? null : element.getContent();
+	}
+
+	public boolean hasChild(final String name) {
+		return findChild(name) != null;
+	}
+
+	public boolean hasChild(final String name, final String xmlns) {
+		return findChild(name, xmlns) != null;
+	}
+
+	public List<Element> getChildren() {
+		return this.children;
+	}
+
+	public Element setChildren(List<Element> children) {
+		this.children = children;
+		return this;
+	}
+
+	public final String getContent() {
+		return content;
+	}
+
+	public Element setAttribute(String name, String value) {
+		if (name != null && value != null) {
+			this.attributes.put(name, value);
+		}
+		return this;
+	}
+
+	public Element setAttributes(Hashtable<String, String> attributes) {
+		this.attributes = attributes;
+		return this;
+	}
+
+	public String getAttribute(String name) {
+		if (this.attributes.containsKey(name)) {
+			return this.attributes.get(name);
+		} else {
+			return null;
+		}
+	}
+
+	public Jid getAttributeAsJid(String name) {
+		final String jid = this.getAttribute(name);
+		if (jid != null && !jid.isEmpty()) {
+			try {
+				return Jid.fromString(jid);
+			} catch (final InvalidJidException e) {
+				Logging.e(Config.LOGTAG, "could not parse jid " + jid);
+				return null;
+			}
+		}
+		return null;
+	}
+
+	public Hashtable<String, String> getAttributes() {
+		return this.attributes;
+	}
+
+	public String toString() {
+		StringBuilder elementOutput = new StringBuilder();
+		if ((content == null) && (children.size() == 0)) {
+			Tag emptyTag = Tag.empty(name);
+			emptyTag.setAtttributes(this.attributes);
+			elementOutput.append(emptyTag.toString());
+		} else {
+			Tag startTag = Tag.start(name);
+			startTag.setAtttributes(this.attributes);
+			elementOutput.append(startTag);
+			if (content != null) {
+				elementOutput.append(XmlHelper.encodeEntities(content));
+			} else {
+				for (Element child : children) {
+					elementOutput.append(child.toString());
+				}
+			}
+			Tag endTag = Tag.end(name);
+			elementOutput.append(endTag);
+		}
+		return elementOutput.toString();
+	}
+
+	public final String getName() {
+		return name;
+	}
+
+	public void clearChildren() {
+		this.children.clear();
+	}
+
+	public void setAttribute(String name, long value) {
+		this.setAttribute(name, Long.toString(value));
+	}
+
+	public void setAttribute(String name, int value) {
+		this.setAttribute(name, Integer.toString(value));
+	}
+
+	public boolean getAttributeAsBoolean(String name) {
+		String attr = getAttribute(name);
+		return (attr != null && (attr.equalsIgnoreCase("true") || attr.equalsIgnoreCase("1")));
+	}
+
+	public String getNamespace() {
+		return getAttribute("xmlns");
+	}
+}
diff --git a/src/main/java/eu/siacs/conversations/xml/Tag.java b/src/main/java/eu/siacs/conversations/xml/Tag.java
new file mode 100644
index 00000000..b9ef979f
--- /dev/null
+++ b/src/main/java/eu/siacs/conversations/xml/Tag.java
@@ -0,0 +1,104 @@
+package eu.siacs.conversations.xml;
+
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import eu.siacs.conversations.utils.XmlHelper;
+
+public class Tag {
+	public static final int NO = -1;
+	public static final int START = 0;
+	public static final int END = 1;
+	public static final int EMPTY = 2;
+
+	protected int type;
+	protected String name;
+	protected Hashtable<String, String> attributes = new Hashtable<String, String>();
+
+	protected Tag(int type, String name) {
+		this.type = type;
+		this.name = name;
+	}
+
+	public static Tag no(String text) {
+		return new Tag(NO, text);
+	}
+
+	public static Tag start(String name) {
+		return new Tag(START, name);
+	}
+
+	public static Tag end(String name) {
+		return new Tag(END, name);
+	}
+
+	public static Tag empty(String name) {
+		return new Tag(EMPTY, name);
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public String getAttribute(String attrName) {
+		return this.attributes.get(attrName);
+	}
+
+	public Tag setAttribute(String attrName, String attrValue) {
+		this.attributes.put(attrName, attrValue);
+		return this;
+	}
+
+	public Tag setAtttributes(Hashtable<String, String> attributes) {
+		this.attributes = attributes;
+		return this;
+	}
+
+	public boolean isStart(String needle) {
+		if (needle == null)
+			return false;
+		return (this.type == START) && (needle.equals(this.name));
+	}
+
+	public boolean isEnd(String needle) {
+		if (needle == null)
+			return false;
+		return (this.type == END) && (needle.equals(this.name));
+	}
+
+	public boolean isNo() {
+		return (this.type == NO);
+	}
+
+	public String toString() {
+		StringBuilder tagOutput = new StringBuilder();
+		tagOutput.append('<');
+		if (type == END) {
+			tagOutput.append('/');
+		}
+		tagOutput.append(name);
+		if (type != END) {
+			Set<Entry<String, String>> attributeSet = attributes.entrySet();
+			Iterator<Entry<String, String>> it = attributeSet.iterator();
+			while (it.hasNext()) {
+				Entry<String, String> entry = it.next();
+				tagOutput.append(' ');
+				tagOutput.append(entry.getKey());
+				tagOutput.append("=\"");
+				tagOutput.append(XmlHelper.encodeEntities(entry.getValue()));
+				tagOutput.append('"');
+			}
+		}
+		if (type == EMPTY) {
+			tagOutput.append('/');
+		}
+		tagOutput.append('>');
+		return tagOutput.toString();
+	}
+
+	public Hashtable<String, String> getAttributes() {
+		return this.attributes;
+	}
+}
diff --git a/src/main/java/eu/siacs/conversations/xml/TagWriter.java b/src/main/java/eu/siacs/conversations/xml/TagWriter.java
new file mode 100644
index 00000000..f11c1846
--- /dev/null
+++ b/src/main/java/eu/siacs/conversations/xml/TagWriter.java
@@ -0,0 +1,114 @@
+package eu.siacs.conversations.xml;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import eu.siacs.conversations.xmpp.stanzas.AbstractStanza;
+
+public class TagWriter {
+
+	private OutputStream plainOutputStream;
+	private OutputStreamWriter outputStream;
+	private boolean finshed = false;
+	private LinkedBlockingQueue<AbstractStanza> writeQueue = new LinkedBlockingQueue<AbstractStanza>();
+	private Thread asyncStanzaWriter = new Thread() {
+		private boolean shouldStop = false;
+
+		@Override
+		public void run() {
+			while (!shouldStop) {
+				if ((finshed) && (writeQueue.size() == 0)) {
+					return;
+				}
+				try {
+					AbstractStanza output = writeQueue.take();
+					if (outputStream == null) {
+						shouldStop = true;
+					} else {
+						outputStream.write(output.toString());
+						outputStream.flush();
+					}
+				} catch (IOException e) {
+					shouldStop = true;
+				} catch (InterruptedException e) {
+					shouldStop = true;
+				}
+			}
+		}
+	};
+
+	public TagWriter() {
+	}
+
+	public void setOutputStream(OutputStream out) throws IOException {
+		if (out == null) {
+			throw new IOException();
+		}
+		this.plainOutputStream = out;
+		this.outputStream = new OutputStreamWriter(out);
+	}
+
+	public OutputStream getOutputStream() throws IOException {
+		if (this.plainOutputStream == null) {
+			throw new IOException();
+		}
+		return this.plainOutputStream;
+	}
+
+	public TagWriter beginDocument() throws IOException {
+		if (outputStream == null) {
+			throw new IOException("output stream was null");
+		}
+		outputStream.write("<?xml version='1.0'?>");
+		outputStream.flush();
+		return this;
+	}
+
+	public TagWriter writeTag(Tag tag) throws IOException {
+		if (outputStream == null) {
+			throw new IOException("output stream was null");
+		}
+		outputStream.write(tag.toString());
+		outputStream.flush();
+		return this;
+	}
+
+	public TagWriter writeElement(Element element) throws IOException {
+		if (outputStream == null) {
+			throw new IOException("output stream was null");
+		}
+		outputStream.write(element.toString());
+		outputStream.flush();
+		return this;
+	}
+
+	public TagWriter writeStanzaAsync(AbstractStanza stanza) {
+		if (finshed) {
+			return this;
+		} else {
+			if (!asyncStanzaWriter.isAlive()) {
+				try {
+					asyncStanzaWriter.start();
+				} catch (IllegalThreadStateException e) {
+					// already started
+				}
+			}
+			writeQueue.add(stanza);
+			return this;
+		}
+	}
+
+	public void finish() {
+		this.finshed = true;
+	}
+
+	public boolean finished() {
+		return (this.writeQueue.size() == 0);
+	}
+
+	public boolean isActive() {
+		return outputStream != null;
+	}
+}
diff --git a/src/main/java/eu/siacs/conversations/xml/XmlReader.java b/src/main/java/eu/siacs/conversations/xml/XmlReader.java
new file mode 100644
index 00000000..74e65fcd
--- /dev/null
+++ b/src/main/java/eu/siacs/conversations/xml/XmlReader.java
@@ -0,0 +1,141 @@
+package eu.siacs.conversations.xml;
+
+import android.os.PowerManager;
+import android.os.PowerManager.WakeLock;
+import android.util.Xml;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+import de.thedevstack.android.logcat.Logging;
+import eu.siacs.conversations.Config;
+
+public class XmlReader {
+	private XmlPullParser parser;
+	private PowerManager.WakeLock wakeLock;
+	private InputStream is;
+
+	public XmlReader(WakeLock wakeLock) {
+		this.parser = Xml.newPullParser();
+		try {
+			this.parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES,
+					true);
+		} catch (XmlPullParserException e) {
+			Logging.d(Config.LOGTAG, "error setting namespace feature on parser");
+		}
+		this.wakeLock = wakeLock;
+	}
+
+	public void setInputStream(InputStream inputStream) throws IOException {
+		if (inputStream == null) {
+			throw new IOException();
+		}
+		this.is = inputStream;
+		try {
+			parser.setInput(new InputStreamReader(this.is));
+		} catch (XmlPullParserException e) {
+			throw new IOException("error resetting parser");
+		}
+	}
+
+	public InputStream getInputStream() throws IOException {
+		if (this.is == null) {
+			throw new IOException();
+		}
+		return is;
+	}
+
+	public void reset() throws IOException {
+		if (this.is == null) {
+			throw new IOException();
+		}
+		try {
+			parser.setInput(new InputStreamReader(this.is));
+		} catch (XmlPullParserException e) {
+			throw new IOException("error resetting parser");
+		}
+	}
+
+	public Tag readTag() throws XmlPullParserException, IOException {
+		if (wakeLock.isHeld()) {
+			try {
+				wakeLock.release();
+			} catch (RuntimeException re) {
+			}
+		}
+		try {
+			while (this.is != null
+					&& parser.next() != XmlPullParser.END_DOCUMENT) {
+				wakeLock.acquire();
+				if (parser.getEventType() == XmlPullParser.START_TAG) {
+					Tag tag = Tag.start(parser.getName());
+					for (int i = 0; i < parser.getAttributeCount(); ++i) {
+						tag.setAttribute(parser.getAttributeName(i),
+								parser.getAttributeValue(i));
+					}
+					String xmlns = parser.getNamespace();
+					if (xmlns != null) {
+						tag.setAttribute("xmlns", xmlns);
+					}
+					return tag;
+				} else if (parser.getEventType() == XmlPullParser.END_TAG) {
+					Tag tag = Tag.end(parser.getName());
+					return tag;
+				} else if (parser.getEventType() == XmlPullParser.TEXT) {
+					Tag tag = Tag.no(parser.getText());
+					return tag;
+				}
+			}
+			if (wakeLock.isHeld()) {
+				try {
+					wakeLock.release();
+				} catch (RuntimeException re) {
+				}
+			}
+		} catch (ArrayIndexOutOfBoundsException e) {
+			throw new IOException(
+					"xml parser mishandled ArrayIndexOufOfBounds", e);
+		} catch (StringIndexOutOfBoundsException e) {
+			throw new IOException(
+					"xml parser mishandled StringIndexOufOfBounds", e);
+		} catch (NullPointerException e) {
+			throw new IOException("xml parser mishandled NullPointerException",
+					e);
+		} catch (IndexOutOfBoundsException e) {
+			throw new IOException("xml parser mishandled IndexOutOfBound", e);
+		}
+		return null;
+	}
+
+	public Element readElement(Tag currentTag) throws XmlPullParserException,
+			IOException {
+		Element element = new Element(currentTag.getName());
+		element.setAttributes(currentTag.getAttributes());
+		Tag nextTag = this.readTag();
+		if (nextTag == null) {
+			throw new IOException("unterupted mid tag");
+		}
+		if (nextTag.isNo()) {
+			element.setContent(nextTag.getName());
+			nextTag = this.readTag();
+			if (nextTag == null) {
+				throw new IOException("unterupted mid tag");
+			}
+		}
+		while (!nextTag.isEnd(element.getName())) {
+			if (!nextTag.isNo()) {
+				Element child = this.readElement(nextTag);
+				element.addChild(child);
+			}
+			nextTag = this.readTag();
+			if (nextTag == null) {
+				throw new IOException("unterupted mid tag");
+			}
+		}
+		return element;
+	}
+}