+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ iJab
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/com/anzsoft/server/JabberHTTPBind/DNSUtil.java b/src/com/anzsoft/server/JabberHTTPBind/DNSUtil.java
new file mode 100644
index 0000000..297c44d
--- /dev/null
+++ b/src/com/anzsoft/server/JabberHTTPBind/DNSUtil.java
@@ -0,0 +1,147 @@
+/**
+ * $RCSfile: DNSUtil.java,v $
+ * $Revision: 60 $
+ * $Date: 2007-08-27 16:52:28 +0200 (lun, 27 ago 2007) $
+ *
+ * Copyright (C) 2004-2005 Jive Software. All rights reserved.
+ *
+ * This software is published under the terms of the Apache License
+ */
+
+package com.anzsoft.server.JabberHTTPBind;
+
+import javax.naming.directory.Attributes;
+import javax.naming.directory.InitialDirContext;
+import javax.naming.directory.DirContext;
+import java.util.Hashtable;
+
+/**
+ * Utilty class to perform DNS lookups for XMPP services.
+ *
+ * @author Matt Tucker
+ */
+public class DNSUtil
+{
+ private static DirContext context;
+
+ static
+ {
+ try
+ {
+ Hashtable env = new Hashtable();
+ env.put("java.naming.factory.initial", "com.sun.jndi.dns.DnsContextFactory");
+ context = new InitialDirContext(env);
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * Returns the host name and port that the specified XMPP server can be
+ * reached at for communication. A DNS lookup for a SRV
+ * record in the form "_xmpp-server._tcp.example.com" is attempted, according
+ * to section 14.4 of RFC 3920. If that lookup fails, a lookup in the older form
+ * of "_jabber._tcp.example.com" is attempted since servers that implement an
+ * older version of the protocol may be listed using that notation. If that
+ * lookup fails as well, it's assumed that the XMPP server lives at the
+ * host resolved by a DNS lookup at the specified domain on the specified
+ * default port.
+ *
+ * As an example, a lookup for "example.com" may return "im.example.com:5269".
+ *
+ * @param domain the domain.
+ * @return a HostAddress, which encompasses the hostname and port that the XMPP
+ * server can be reached at for the specified domain.
+ */
+ public static HostAddress resolveXMPPServerDomain(String domain, int defaultport)
+ {
+ if (context == null)
+ {
+ return new HostAddress(domain, defaultport);
+ }
+ String host = domain;
+ int port = defaultport;
+
+ try
+ {
+ Attributes dnsLookup = context.getAttributes("_xmpp-client._tcp." + domain);
+ String srvRecord = (String)dnsLookup.get("SRV").get();
+ String [] srvRecordEntries = srvRecord.split(" ");
+ port = Integer.parseInt(srvRecordEntries[srvRecordEntries.length-2]);
+ host = srvRecordEntries[srvRecordEntries.length-1];
+ }
+ catch (Exception e)
+ {
+ // Attempt lookup with older "jabber" name.
+ try
+ {
+ Attributes dnsLookup = context.getAttributes("_jabber-client._tcp." + domain);
+ String srvRecord = (String)dnsLookup.get("SRV").get();
+ String [] srvRecordEntries = srvRecord.split(" ");
+ port = Integer.parseInt(srvRecordEntries[srvRecordEntries.length-2]);
+ host = srvRecordEntries[srvRecordEntries.length-1];
+ }
+ catch (Exception e2)
+ { }
+ }
+ // Host entries in DNS should end with a ".".
+ if (host.endsWith("."))
+ {
+ host = host.substring(0, host.length()-1);
+ }
+ return new HostAddress(host, port);
+ }
+
+ /**
+ * Encapsulates a hostname and port.
+ */
+ public static class HostAddress
+ {
+
+ private String host;
+ private int port;
+
+ private HostAddress(String host, int port)
+ {
+ this.host = host;
+ this.port = port;
+ }
+
+ /**
+ * Returns the hostname.
+ *
+ * @return the hostname.
+ */
+ public String getHost()
+ {
+ return host;
+ }
+
+ /**
+ * Returns the port.
+ *
+ * @return the port.
+ */
+ public int getPort()
+ {
+ return port;
+ }
+
+ public String toString()
+ {
+ return host + ":" + port;
+ }
+ }
+}
+
+
+
+
+
+
+
+
+
+
diff --git a/src/com/anzsoft/server/JabberHTTPBind/JHBServlet.java b/src/com/anzsoft/server/JabberHTTPBind/JHBServlet.java
new file mode 100644
index 0000000..96b208c
--- /dev/null
+++ b/src/com/anzsoft/server/JabberHTTPBind/JHBServlet.java
@@ -0,0 +1,645 @@
+/* JabberHTTPBind - An implementation of JEP-0124 (HTTP Binding)
+ * Please see http://www.jabber.org/jeps/jep-0124.html for details.
+ *
+ * Copyright (c) 2005-2006 Stefan Strigler
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+package com.anzsoft.server.JabberHTTPBind;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
+
+/**
+ * An implementation of JEP-0124 (HTTP Binding). See
+ * http://www.jabber.org/jeps/jep-0124.html for details.
+ *
+ * @author Stefan Strigler
+ */
+
+public final class JHBServlet extends HttpServlet {
+
+ private static final long serialVersionUID = 1L;
+
+ public static final String APP_VERSION = "1.1";
+
+ public static final String APP_NAME = "Jabber HTTP Binding Servlet";
+
+ public static final boolean DEBUG = false;
+
+ public static final int DEBUG_LEVEL = 2;
+
+ private DocumentBuilder db;
+
+ private Janitor janitor;
+
+ public void init() throws ServletException {
+ DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+
+ try {
+ db = dbf.newDocumentBuilder();
+ } catch (ParserConfigurationException e) {
+ log("failed to create DocumentBuilderFactory", e);
+ }
+
+ janitor = new Janitor(); // cleans up sessions
+ new Thread(janitor).start();
+ }
+
+ public void destroy() {
+ Session.stopSessions();
+ janitor.stop();
+ }
+
+ public static String hex(byte[] array) {
+ StringBuffer sb = new StringBuffer();
+ for (int i = 0; i < array.length; ++i) {
+ sb.append(Integer.toHexString((array[i] & 0xFF) | 0x100)
+ .toLowerCase().substring(1, 3));
+ }
+ return sb.toString();
+ }
+
+ public static String sha1(String message) {
+ try {
+ MessageDigest sha = MessageDigest.getInstance("SHA-1");
+ return hex(sha.digest(message.getBytes()));
+ } catch (NoSuchAlgorithmException e) {
+ }
+ return null;
+ }
+
+ public static void dbg(String msg) {
+ dbg(msg, 0);
+ }
+
+ public static void dbg(String msg, int lvl) {
+ if (!DEBUG)
+ return;
+ if (lvl > DEBUG_LEVEL)
+ return;
+ System.err.println("[" + lvl + "] " + msg);
+ }
+
+ /**
+ * We only need to respond to POST requests ...
+ *
+ * @param request
+ * The servlet request we are processing
+ * @param response
+ * The servlet response we are producing
+ *
+ * @exception IOException
+ * if an input/output error occurs
+ * @exception ServletException
+ * if a servlet error occurs
+ */
+ public void doPost(HttpServletRequest request, HttpServletResponse response)
+ throws IOException, ServletException {
+ long rid = 0;
+ try {
+ /*
+ * parse request
+ */
+ Document doc;
+ synchronized (db) {
+ doc = db.parse(request.getInputStream());
+ }
+
+ Node rootNode = doc.getDocumentElement();
+ if (rootNode == null || !rootNode.getNodeName().equals("body"))
+ // not a -tag - don't know what to do with it
+ response.sendError(HttpServletResponse.SC_BAD_REQUEST);
+ else {
+
+ /*
+ * we got a request - let's look if there something
+ * useful we could do with it
+ */
+
+ NamedNodeMap attribs = rootNode.getAttributes();
+
+ if (attribs.getNamedItem("sid") != null) {
+
+ /***********************************************************
+ * lookup existing session ***
+ */
+
+ Session sess = Session.getSession(attribs.getNamedItem(
+ "sid").getNodeValue());
+
+ if (sess != null) {
+ dbg("incoming request for " + sess.getSID(), 3);
+
+ /*******************************************************
+ * check if request is valid
+ */
+ // check if rid valid
+ if (attribs.getNamedItem("rid") == null) {
+ // rid missing
+ dbg("rid missing", 1);
+ response
+ .sendError(HttpServletResponse.SC_NOT_FOUND);
+ sess.terminate();
+ } else {
+ try {
+ rid = Integer.parseInt(attribs.getNamedItem(
+ "rid").getNodeValue());
+ } catch (NumberFormatException e) {
+ dbg("rid not a number", 1);
+ response
+ .sendError(HttpServletResponse.SC_BAD_REQUEST);
+ return;
+ }
+ Response r = sess.getResponse(rid);
+ if (r != null) { // resend
+ dbg("resend rid " + rid, 2);
+ r.setAborted(true);
+ r.send(response);
+ return;
+ }
+ if (!sess.checkValidRID(rid)) {
+ dbg("invalid rid " + rid, 1);
+ response
+ .sendError(HttpServletResponse.SC_NOT_FOUND);
+ sess.terminate();
+ return;
+ }
+ }
+
+ dbg("found valid rid " + rid, 3);
+
+ /* too many simultaneous requests? */
+ if (sess.numPendingRequests() >= Session.MAX_REQUESTS) {
+ dbg("too many simultaneous requests: "
+ + sess.numPendingRequests(), 1);
+ response
+ .sendError(HttpServletResponse.SC_FORBIDDEN);
+ // no pardon - kick it
+ sess.terminate();
+ return;
+ }
+
+ /*******************************************************
+ * we got a valid request start processing it
+ */
+
+ Response jresp = new Response(db
+ .newDocument());
+ jresp.setRID(rid);
+ jresp.setContentType(sess.getContent());
+ sess.addResponse(jresp);
+
+ try {
+ synchronized (sess.sock) {
+ /* wait till it's our turn */
+
+ /*
+ * NOTE: This only works when having
+ * MAX_REQUESTS set to 1 or 2 Otherwise we would
+ * fail on the condition that incoming data from
+ * the client has to be forwarded as soon as
+ * possible (the request might be pending
+ * waiting for others to timeout first)
+ */
+
+ /*
+ * wait 'till we are the lowest rid that's
+ * pending
+ */
+
+ long lastrid = sess.getLastDoneRID();
+ while (rid != lastrid + 1) {
+ if (sess.isStatus(Session.SESS_TERM)) {
+ dbg("session terminated for " + rid, 1);
+ response
+ .sendError(HttpServletResponse.SC_NOT_FOUND);
+ sess.sock.notifyAll();
+ return;
+ }
+ try {
+ dbg(rid + " waiting for "
+ + (lastrid + 1), 2);
+ sess.sock.wait();
+ dbg("bell for " + rid, 2);
+ lastrid = sess.getLastDoneRID();
+ } catch (InterruptedException e) {
+ }
+ }
+
+ dbg("handling response " + rid, 3);
+ /*
+ * check key
+ */
+ String key = sess.getKey();
+ if (key != null) {
+ dbg("checking keys for " + rid, 3);
+ if (attribs.getNamedItem("key") == null
+ || !sha1(
+ attribs.getNamedItem("key")
+ .getNodeValue())
+ .equals(key)) {
+ dbg("Key sequence error", 1);
+ response
+ .sendError(HttpServletResponse.SC_NOT_FOUND);
+ sess.terminate();
+ return;
+ }
+ if (attribs.getNamedItem("newkey") != null)
+ sess.setKey(attribs.getNamedItem(
+ "newkey").getNodeValue());
+ else
+ sess.setKey(attribs.getNamedItem("key")
+ .getNodeValue());
+ dbg("key valid for " + rid, 3);
+ }
+
+ if (attribs.getNamedItem("xmpp:restart") != null) {
+ dbg("XMPP RESTART", 2);
+ sess.setReinit(true);
+ }
+
+ /*
+ * check if we got sth to forward to remote
+ * jabber server
+ */
+ if (rootNode.hasChildNodes())
+ sess.sendNodes(rootNode.getChildNodes());
+ else {
+ /*
+ * check if polling too frequently only
+ * empty polls are considered harmfull
+ */
+ long now = System.currentTimeMillis();
+ if (sess.getHold() == 0 &&
+ now - sess.getLastPoll() < Session.MIN_POLLING * 1000) {
+ // indeed (s)he's violating our rules
+ dbg("polling too frequently! [now:"
+ + now + ", last:"
+ + sess.getLastPoll() + "("
+ + (now - sess.getLastPoll())
+ + ")]", 1);
+
+ response
+ .sendError(HttpServletResponse.SC_FORBIDDEN);
+ // no pardon - kick it
+ sess.terminate();
+ return;
+ }
+ // mark last empty poll
+ sess.setLastPoll();
+ }
+
+ /*
+ * send response
+ */
+
+ /* request to terminate session? */
+ if (attribs.getNamedItem("type") != null) {
+ String rType = attribs.getNamedItem("type")
+ .getNodeValue();
+ if (rType.equals("terminate")) {
+ sess.terminate();
+ jresp.send(response);
+ return;
+ }
+ }
+
+ /* check incoming queue */
+ NodeList nl = sess.checkInQ(rid);
+ // add items to response
+ if (nl != null)
+ for (int i = 0; i < nl.getLength(); i++)
+ jresp.addNode(nl.item(i),
+ "jabber:client");
+
+ if (sess.streamFeatures) {
+ jresp.setAttribute("xmlns:stream",
+ "http://etherx.jabber.org/streams");
+ sess.streamFeatures = false; // reset
+ }
+
+ /* check for streamid (digest auth!) */
+ if (!sess.authidSent
+ && sess.getAuthid() != null) {
+ sess.authidSent = true;
+ jresp.setAttribute("authid", sess
+ .getAuthid());
+ }
+
+ if (sess.isStatus(Session.SESS_TERM)) {
+ // closed due to stream error
+ jresp.setAttribute("type", "terminate");
+ jresp.setAttribute("condition",
+ "remote-stream-error");
+ }
+
+ /* finally send back response */
+ jresp.send(response);
+ sess.setLastDoneRID(jresp.getRID());
+ sess.sock.notifyAll();
+ }
+ } catch (IOException ioe) {
+ sess.terminate();
+ jresp.setAttribute("type", "terminate");
+ jresp.setAttribute("condition",
+ "remote-connection-failed");
+ jresp.send(response);
+ }
+ } else {
+ /* session not found! */
+ response.sendError(HttpServletResponse.SC_NOT_FOUND);
+ }
+ } else {
+
+ /***********************************************************
+ * request to create a new session ***
+ */
+
+ if (attribs.getNamedItem("rid") == null) {
+ response.sendError(HttpServletResponse.SC_BAD_REQUEST);
+ return;
+ } else {
+ try {
+ rid = Integer.parseInt(attribs.getNamedItem("rid")
+ .getNodeValue());
+ } catch (NumberFormatException e) {
+ response
+ .sendError(HttpServletResponse.SC_BAD_REQUEST);
+ return;
+ }
+ }
+
+ Response jresp = new Response(db.newDocument(),request);
+ jresp.setRID(rid);
+
+ // check 'route' attribute
+ String route = null;
+ if (attribs.getNamedItem("route") != null
+ && isValidRoute(attribs.getNamedItem("route")
+ .getNodeValue())) {
+ route = attribs.getNamedItem("route").getNodeValue()
+ .substring("xmpp:".length());
+ }
+
+ // check 'to' attribute
+ String to = null;
+ if ((attribs.getNamedItem("to") != null)
+ && (attribs.getNamedItem("to").getNodeValue() != "")) {
+ to = attribs.getNamedItem("to").getNodeValue();
+ }
+
+ if (to == null || to.equals("")) {
+ /*
+ * ERROR: 'to' attribute missing or emtpy
+ */
+
+ if (attribs.getNamedItem("content") != null) {
+ jresp.setContentType(attribs
+ .getNamedItem("content").getNodeValue());
+ } else {
+ jresp.setContentType(Session.DEFAULT_CONTENT);
+ }
+
+ jresp.setAttribute("type", "terminate");
+ jresp.setAttribute("condition", "improper-addressing");
+
+ jresp.send(response);
+ return;
+ }
+
+ /*
+ * really create new session
+ */
+ try {
+ Session sess = new Session(to, route);
+
+ if (attribs.getNamedItem("content") != null)
+ sess.setContent(attribs.getNamedItem("content")
+ .getNodeValue());
+
+ if (attribs.getNamedItem("wait") != null)
+ sess.setWait(Integer.parseInt(attribs.getNamedItem(
+ "wait").getNodeValue()));
+
+ if (attribs.getNamedItem("hold") != null)
+ sess.setHold(Integer.parseInt(attribs.getNamedItem(
+ "hold").getNodeValue()));
+
+ if (attribs.getNamedItem("xml:lang") != null)
+ sess.setXMLLang(attribs.getNamedItem("xml:lang")
+ .getNodeValue());
+
+ if (attribs.getNamedItem("newkey") != null)
+ sess.setKey(attribs.getNamedItem("newkey")
+ .getNodeValue());
+
+ if (attribs.getNamedItem("secure") != null
+ && (attribs.getNamedItem("secure")
+ .getNodeValue().equals("true") || attribs
+ .getNamedItem("secure").getNodeValue()
+ .equals("1")))
+ sess.setSecure(true); // forces IOException
+
+ sess.addResponse(jresp);
+
+ /*
+ * send back response
+ */
+ jresp.setContentType(sess.getContent());
+
+ /* check incoming queue */
+ NodeList nl = sess.checkInQ(jresp.getRID());
+
+ // add items to response
+ if (nl != null)
+ for (int i = 0; i < nl.getLength(); i++) {
+ if (!nl.item(i).getNodeName()
+ .equals("starttls"))
+ jresp.addNode(nl.item(i), "");
+ }
+
+ if (sess.streamFeatures) {
+ jresp.setAttribute("xmlns:stream",
+ "http://etherx.jabber.org/streams");
+ sess.streamFeatures = false; // reset
+ }
+
+ jresp.setAttribute("sid", sess.getSID());
+ jresp.setAttribute("wait", String.valueOf(sess
+ .getWait()));
+ jresp.setAttribute("inactivity", String
+ .valueOf(Session.MAX_INACTIVITY));
+ jresp.setAttribute("polling", String
+ .valueOf(Session.MIN_POLLING));
+
+ jresp.setAttribute("requests", String
+ .valueOf(Session.MAX_REQUESTS));
+
+ if (sess.getAuthid() != null) {
+ sess.authidSent = true;
+ jresp.setAttribute("authid", sess.getAuthid());
+ }
+
+ if (sess.isStatus(Session.SESS_TERM))
+ jresp.setAttribute("type", "terminate");
+
+ jresp.send(response);
+ sess.setLastDoneRID(jresp.getRID());
+ } catch (UnknownHostException uhe) {
+ /*
+ * ERROR: remote host unknown
+ */
+
+ if (attribs.getNamedItem("content") != null)
+ jresp.setContentType(attribs
+ .getNamedItem("content").getNodeValue());
+ else
+ jresp.setContentType(Session.DEFAULT_CONTENT);
+
+ jresp.setAttribute("type", "terminate");
+ jresp.setAttribute("condition", "host-unknown");
+
+ jresp.send(response);
+ } catch (IOException ioe) {
+ /*
+ * ERROR: could not connect to remote host
+ */
+
+ if (attribs.getNamedItem("content") != null)
+ jresp.setContentType(attribs
+ .getNamedItem("content").getNodeValue());
+ else
+ jresp.setContentType(Session.DEFAULT_CONTENT);
+
+ jresp.setAttribute("type", "terminate");
+ jresp.setAttribute("condition",
+ "remote-connection-failed");
+
+ jresp.send(response);
+ } catch (NumberFormatException nfe) {
+ response.sendError(HttpServletResponse.SC_BAD_REQUEST);
+ return;
+ }
+ }
+ }
+ } catch (SAXException se) {
+ /*
+ * ERROR: Parser error
+ */
+ dbg(se.toString(), 1);
+ response.sendError(HttpServletResponse.SC_BAD_REQUEST);
+ } catch (Exception e) {
+
+ System.err.println(e.toString());
+ e.printStackTrace();
+ try {
+ Response jresp = new Response(db.newDocument());
+ jresp.setAttribute("type", "terminate");
+ jresp.setAttribute("condition", "internal-server-error");
+ jresp.send(response);
+ } catch (Exception e2) {
+ e2.printStackTrace();
+ response.sendError(HttpServletResponse.SC_BAD_REQUEST);
+ }
+ }
+ }
+
+ public void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws IOException, ServletException {
+
+ /*
+ * This one's just for convenience to inform of improper use of
+ * component
+ */
+
+ response.setContentType("text/html");
+ PrintWriter writer = response.getWriter();
+ String title = APP_NAME + " v" + APP_VERSION;
+ writer
+ .println("");
+ writer.println("\n\n" + title
+ + "\n\n\n");
+ writer.println("" + title + "
");
+ writer
+ .println("This is an implementation of JEP-0124 (HTTP-Binding). Please see http://www.jabber.org/jeps/jep-0124.html for details.
");
+ writer.println("Active sessions: "+Session.getNumSessions());
+ writer.println("\n\n");
+ }
+
+ /**
+ * Checks if supplied parameter is a valid host value. Valid host values
+ * should be in the form: "xmpp:" ihost [ ":" port ]
+ *
+ * NOTE: RFC 3987 defines the form of ihost like this: ihost = IP-literal /
+ * IPv4address / ireg-name This function cuts corners and uses
+ * InetAddress.getByName() to check ihost validity.
+ *
+ *
+ * @see java.net.InetAddress
+ * @param route
+ * hostname that should be checked
+ * @return 'true' if host is in the form "xmpp:" ihost [ ":" port ]
+ * otherwise 'false'.
+ */
+ private static boolean isValidRoute(String route) {
+ if (!route.startsWith("xmpp:")) {
+ return false;
+ }
+
+ route = route.substring("xmpp:".length());
+
+ // check for port validity, if a port is given.
+ int port;
+ if ((port = route.lastIndexOf(":")) != -1) {
+ try {
+ int p = Integer.parseInt(route.substring(port + 1));
+ if (p < 0 || p > 65535) {
+ return false;
+ }
+ } catch (NumberFormatException nfe) {
+ return false;
+ }
+ route = route.substring(0, port);
+ }
+
+ try {
+ InetAddress.getByName(route);
+ } catch (Exception e) {
+ return false;
+ }
+
+ return true;
+ }
+
+}
diff --git a/src/com/anzsoft/server/JabberHTTPBind/Janitor.java b/src/com/anzsoft/server/JabberHTTPBind/Janitor.java
new file mode 100644
index 0000000..e35d5f9
--- /dev/null
+++ b/src/com/anzsoft/server/JabberHTTPBind/Janitor.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2005 Stefan Strigler
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+package com.anzsoft.server.JabberHTTPBind;
+
+import java.util.Enumeration;
+
+/**
+ * @author Stefan Strigler
+ */
+public class Janitor implements Runnable {
+ public static final int SLEEPMILLIS = 1000;
+
+ private boolean keep_running = true;
+
+ /*
+ * @see java.lang.Runnable#run()
+ */
+ public void run() {
+ while (this.keep_running) {
+ for (Enumeration e = Session.getSessions(); e.hasMoreElements();) {
+ Session sess = (Session) e.nextElement();
+
+ // stop inactive sessions
+ if (System.currentTimeMillis() - sess.getLastActive() > Session.MAX_INACTIVITY * 1000) {
+ if (JHBServlet.DEBUG)
+ System.err.println("Session timed out: " + sess.getSID());
+ sess.terminate();
+ }
+ }
+ try {
+ Thread.sleep(SLEEPMILLIS);
+ } catch (InterruptedException ie) {
+ ie.printStackTrace();
+ }
+ }
+ }
+
+ public void stop() {
+ this.keep_running = false;
+ }
+
+}
\ No newline at end of file
diff --git a/src/com/anzsoft/server/JabberHTTPBind/Response.java b/src/com/anzsoft/server/JabberHTTPBind/Response.java
new file mode 100644
index 0000000..1c4e650
--- /dev/null
+++ b/src/com/anzsoft/server/JabberHTTPBind/Response.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2005 Stefan Strigler
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+package com.anzsoft.server.JabberHTTPBind;
+
+import java.io.StringWriter;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+
+/**
+ * @author Stefan Strigler
+ */
+public class Response {
+ private static TransformerFactory tff = TransformerFactory.newInstance();
+ public static final String STATUS_LEAVING = "leaving";
+ public static final String STATUS_PENDING = "pending";
+ public static final String STATUS_DONE = "done";
+
+ private long cDate;
+ private Document doc;
+ private Element body;
+ private long rid;
+
+ private String contentType = Session.DEFAULT_CONTENT;
+
+ private String status;
+
+ private HttpServletRequest req;
+
+ private boolean aborted;
+
+ /**
+ * creates new high level response object specific to http binding
+ * responses
+ *
+ * @param response low level response object
+ * @param doc empty document to start with
+ */
+ public Response(Document doc) {
+ this.doc = doc;
+
+ this.body = this.doc.createElement("body");
+ this.doc.appendChild(this.body);
+
+ this.body.setAttribute("xmlns","http://jabber.org/protocol/httpbind");
+
+ this.cDate = System.currentTimeMillis();
+
+ setStatus(STATUS_PENDING);
+ }
+
+ public Response(Document doc, HttpServletRequest req) {
+ this(doc);
+ this.req = req;
+ }
+
+ /**
+ * adds an attribute to request's body element
+ *
+ * @param key attribute key
+ * @param val attribute value
+ * @return the response
+ */
+ public Response setAttribute(String key, String val) {
+ this.body.setAttribute(key,val);
+ return this;
+ }
+
+ /**
+ * sets content type header value of low-level response object
+ *
+ * @param type the content-type definition e.g. 'text/xml'
+ * @return the response
+ */
+ public Response setContentType(String type) {
+ this.contentType = type;
+ return this;
+ }
+
+ /**
+ * adds node as child of replies body element
+ *
+ * @param n The node to add
+ * @return Returns the response again
+ */
+ public Response addNode(Node n, String ns) {
+ /* make sure we set proper namespace for all nodes
+ * which must be 'jabber:client'
+ */
+ try {
+ if (!((Element) n).getAttribute("xmlns").equals(ns))
+ ((Element) n).setAttribute("xmlns",ns);
+ } catch (ClassCastException e) { /* ? skip! */ }
+ this.body.appendChild(this.doc.importNode(n,true));
+ return this;
+ }
+
+ /**
+ * sends this response
+ */
+ public synchronized void send(HttpServletResponse response) {
+ StringWriter strWtr = new StringWriter();
+ StreamResult strResult = new StreamResult(strWtr);
+ try {
+ Transformer tf = tff.newTransformer();
+ tf.setOutputProperty("omit-xml-declaration", "yes");
+ tf.transform(new DOMSource(this.doc.getDocumentElement()), strResult);
+ response.setContentType(this.contentType);
+ JHBServlet.dbg("sending response ["+this.getRID()+"]: "+strResult.getWriter().toString(),2);
+ response.getWriter().println(strResult.getWriter().toString());
+ JHBServlet.dbg("sent response for "+this.getRID(),3);
+ } catch (Exception e) {
+ JHBServlet.dbg("XML.toString(Document): " + e,1);
+ }
+ setStatus(STATUS_DONE);
+ }
+ /**
+ * @return Returns the status.
+ */
+ public synchronized String getStatus() {
+ return status;
+ }
+ /**
+ * @param status The status to set.
+ */
+ public synchronized void setStatus(String status) {
+ JHBServlet.dbg("response status "+status+" for "+this.getRID(),3);
+ this.status = status;
+ }
+
+ public long getRID() { return this.rid; }
+
+ public Response setRID(long rid) {
+ this.rid = rid;
+ return this;
+ }
+ /**
+ * @return Returns the cDate.
+ */
+ public synchronized long getCDate() {
+ return cDate;
+ }
+
+ /**
+ * @return the req
+ */
+ public synchronized HttpServletRequest getReq() {
+ return req;
+ }
+
+ /**
+ * @param req the req to set
+ */
+ public synchronized void setReq(HttpServletRequest req) {
+ this.req = req;
+ }
+
+ /**
+ * @return the aborted
+ */
+ public synchronized boolean isAborted() {
+ return aborted;
+ }
+
+ /**
+ * @param aborted the aborted to set
+ */
+ public synchronized void setAborted(boolean aborted) {
+ this.aborted = aborted;
+ }
+}
diff --git a/src/com/anzsoft/server/JabberHTTPBind/SSLSocketReader.java b/src/com/anzsoft/server/JabberHTTPBind/SSLSocketReader.java
new file mode 100644
index 0000000..b0075ff
--- /dev/null
+++ b/src/com/anzsoft/server/JabberHTTPBind/SSLSocketReader.java
@@ -0,0 +1,70 @@
+/*
+ * Created on Apr 11, 2004
+ */
+package com.anzsoft.server.JabberHTTPBind;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.SocketException;
+import java.net.SocketTimeoutException;
+
+import javax.net.ssl.SSLSocket;
+
+/**
+ * @author pau'ie
+ *
+ * This class extends BufferedReader to add expected functionality to the ready() method,
+ * when this class is used on an SSLSocket. An SSLSocket's inputStream will return 0 upon
+ * a call to available() until a read is performed.
+ *
+ * This means that if you construct a bufferedreader for an SSLSocket's inputstream, the ready()
+ * method will always return false. (This has something to do with just-in-time
+ * decryption. Might be a bug or a feature) This class overwrites ready() to force a quick read
+ * to see if the stream has any data available.
+ *
+ * Please send comments on whether this introduces security risks to paul@sims.berkeley.edu
+ */
+public class SSLSocketReader extends BufferedReader
+{
+ private SSLSocket sock;
+
+ public SSLSocketReader( SSLSocket sock) throws IOException
+ {
+ super( new InputStreamReader( sock.getInputStream(), "UTF-8"));
+ this.sock = sock;
+ }
+
+ /**
+ * HACK!
+ * This method does a quick read from the input stream, to see if data is
+ * actually available, then resets to the point before the read.
+ */
+ public boolean ready()
+ {
+ int oldTimeout;
+ try {
+ oldTimeout = sock.getSoTimeout();
+ sock.setSoTimeout( 10 );
+
+ mark(1);
+
+ try {
+ read();
+ } catch (SocketTimeoutException e) {
+ sock.setSoTimeout(oldTimeout);
+ return false;
+ }
+
+ reset();
+ sock.setSoTimeout(oldTimeout);
+
+ return true;
+
+ } catch (SocketException e1) {
+ throw new RuntimeException( "SSLSocketReader unable to set socket timeout: \n" + e1);
+ } catch (IOException e) {
+ throw new RuntimeException( "SSLSocketReader unable to access inputstream: \n" + e);
+ }
+ }
+}
diff --git a/src/com/anzsoft/server/JabberHTTPBind/Session.java b/src/com/anzsoft/server/JabberHTTPBind/Session.java
new file mode 100644
index 0000000..b30a307
--- /dev/null
+++ b/src/com/anzsoft/server/JabberHTTPBind/Session.java
@@ -0,0 +1,932 @@
+/*
+ * Copyright (C) 2005-2006 Stefan Strigler
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+package com.anzsoft.server.JabberHTTPBind;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.Random;
+import java.util.TreeMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.NodeList;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+/**
+ * this class reflects a session within http binding definition
+ *
+ * @author Stefan Strigler
+ */
+public class Session {
+
+ /**
+ * Default HTTP Content-Type header.
+ */
+ public static final String DEFAULT_CONTENT = "text/xml; charset=utf-8";
+
+ /**
+ * Longest allowable inactivity period (in seconds).
+ */
+ public static final int MAX_INACTIVITY = 60;
+
+ /**
+ * Maximum number of simultaneous requests allowed.
+ */
+ public static final int MAX_REQUESTS = 2;
+
+ /*
+ * ####### CONSTANTS #######
+ */
+
+ /**
+ * Default value for longest time (in seconds) that the connection manager
+ * is allowed to wait before responding to any request during the session.
+ * This enables the client to prevent its TCP connection from expiring due
+ * to inactivity, as well as to limit the delay before it discovers any
+ * network failure.
+ */
+ public static final int MAX_WAIT = 300;
+
+ /**
+ * Shortest allowable polling interval (in seconds).
+ */
+ public static final int MIN_POLLING = 2;
+
+ /**
+ * Time to sleep on reading in MSEC.
+ */
+ private static final int READ_TIMEOUT = 1;
+
+ private static final int SOCKET_TIMEOUT = 6000;
+
+ public static final int DEFAULT_XMPPPORT = 5222;
+
+ protected static final String SESS_START = "starting";
+
+ protected static final String SESS_ACTIVE = "active";
+
+ protected static final String SESS_TERM = "term";
+
+ /*
+ * ####### static #######
+ */
+
+ private static Hashtable sessions = new Hashtable();
+
+ private static TransformerFactory tff = TransformerFactory.newInstance();
+
+ private static String createSessionID(int len) {
+ String charlist = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
+
+ Random rand = new Random();
+
+ String str = new String();
+ for (int i = 0; i < len; i++)
+ str += charlist.charAt(rand.nextInt(charlist.length()));
+ return str;
+ }
+
+ public static Session getSession(String sid) {
+ return (Session) sessions.get(sid);
+ }
+
+ public static Enumeration getSessions() {
+ return sessions.elements();
+ }
+
+ public static int getNumSessions() {
+ return sessions.size();
+ }
+
+ public static void stopSessions() {
+ for (Enumeration e = sessions.elements(); e.hasMoreElements();)
+ ((Session) e.nextElement()).terminate();
+ }
+
+ /***************************************************************************
+ * END static
+ */
+
+ private String authid; // stream id given by remote jabber server
+
+ boolean authidSent = false;
+
+ boolean streamFeatures = false;
+
+ private String content = DEFAULT_CONTENT;
+
+ private DocumentBuilder db;
+
+ private int hold = MAX_REQUESTS - 1;
+
+ private String inQueue = "";
+
+ private BufferedReader br;
+
+ private String key;
+
+ private long lastActive;
+
+ private long lastPoll = 0;
+
+ // private int lastSentRid = 0;
+ private OutputStreamWriter osw;
+
+ // private TreeMap outQueue;
+ private TreeMap responses;
+
+ private String status = SESS_START;
+
+ private String sid;
+
+ public Socket sock;
+
+ private String to;
+
+ private DNSUtil.HostAddress host = null;
+
+ private int wait = MAX_WAIT;
+
+ private String xmllang = "en";
+
+ private boolean reinit = false;
+
+ private boolean secure = false;
+
+ private boolean pauseForHandshake = false;
+
+ private Pattern streamPattern;
+
+ private Pattern stream10Test;
+
+ private Pattern stream10Pattern;
+
+ /**
+ * Create a new session and connect to jabber server host denoted by
+ * route or to.
+ *
+ * @param to
+ * domain of the server to connect to.
+ * @param route
+ * optional hostname of the server to connect to (might be null).
+ *
+ * @throws UnknownHostException
+ * @throws IOException
+ */
+ public Session(String to, String route) throws UnknownHostException,
+ IOException {
+ this.to = to;
+
+ int port = DEFAULT_XMPPPORT;
+
+ this.sock = new Socket();
+ this.setLastActive();
+
+ try {
+ this.db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+ } catch (Exception e) {
+ }
+
+ // first, try connecting throught the 'route' attribute.
+ if (route != null && !route.equals("")) {
+ JHBServlet.dbg(
+ "Trying to use 'route' attribute to open a socket...", 3);
+ if (route.startsWith("xmpp:")) {
+ route = route.substring("xmpp:".length());
+ }
+
+ int i;
+ // has 'route' the optional port?
+ if ((i = route.lastIndexOf(":")) != -1) {
+ try {
+ int p = Integer.parseInt(route.substring(i + 1));
+ if (p >= 0 && p <= 65535) {
+ port = p;
+ JHBServlet.dbg(
+ "...route attribute holds a valid port ("
+ + port + ").", 3);
+ }
+ } catch (NumberFormatException nfe) {
+ }
+
+ route = route.substring(0, i);
+ }
+
+ JHBServlet.dbg("Trying to open a socket to '" + route
+ + "', using port " + port + ".", 3);
+
+ try {
+ this.sock.connect(new InetSocketAddress(route, port),
+ SOCKET_TIMEOUT);
+ } catch (Exception e) {
+ JHBServlet.dbg(
+ "Failed to open a socket using the 'route' attribute",
+ 3);
+ /*
+ * none of the exceptions possible should be reason to throw
+ * anything. If the socket isn't opened, we'll get a retry using
+ * the 'to' attribute anyway.
+ */
+ }
+ }
+
+ // If no socket has been opened, try connecting trough the 'to'
+ // attribute.
+ if (this.sock == null || !this.sock.isConnected()) {
+ JHBServlet.dbg("Trying to use 'to' attribute to open a socket...",
+ 3);
+ host = DNSUtil.resolveXMPPServerDomain(to, DEFAULT_XMPPPORT);
+ try {
+ JHBServlet.dbg("Trying to open a socket to '" + host.getHost()
+ + "', using port " + host.getPort() + ".", 3);
+ this.sock.connect(new InetSocketAddress(host.getHost(), host
+ .getPort()), SOCKET_TIMEOUT);
+ } catch (UnknownHostException uhe) {
+ JHBServlet.dbg(
+ "Failed to open a socket using the 'to' attribute", 3);
+ throw uhe;
+ } catch (IOException ioe) {
+ JHBServlet.dbg(
+ "Failed to open a socket using the 'to' attribute", 3);
+ throw ioe;
+ }
+ }
+
+ // at this point, we either have a socket, or an exception has already
+ // been thrown.
+
+ try {
+ if (this.sock.isConnected())
+ JHBServlet.dbg("Succesfully connected to " + to, 2);
+
+ this.sock.setSoTimeout(SOCKET_TIMEOUT);
+ // instantiate
+ this.osw = new OutputStreamWriter(this.sock.getOutputStream(),
+ "UTF-8");
+
+ this.osw.write("");
+ this.osw.flush();
+
+ // create unique session id
+ while (sessions.get(this.sid = createSessionID(24)) != null)
+ ;
+
+ JHBServlet.dbg("creating session with id " + this.sid, 2);
+
+ // register session
+ sessions.put(this.sid, this);
+
+ // create list of responses
+ responses = new TreeMap();
+
+ this.br = new BufferedReader(new InputStreamReader(this.sock
+ .getInputStream(), "UTF-8"));
+
+ this.streamPattern = Pattern.compile(
+ ".*]*id=['|\"]([^'|^\"]+)['|\"][^>]*>.*",
+ Pattern.DOTALL);
+
+ this.stream10Pattern = Pattern
+ .compile(
+ ".*]*id=['|\"]([^'|^\"]+)['|\"][^>]*>.*(]*version=['|\"]1.0['|\"][^>]*>.*",
+ Pattern.DOTALL);
+
+ this.setStatus(SESS_ACTIVE);
+ } catch (IOException ioe) {
+ throw ioe;
+ }
+ }
+
+ /**
+ * Adds new response to list of known responses. Truncates list to allowed
+ * size.
+ *
+ * @param r
+ * the response to add
+ * @return this session object
+ */
+ public synchronized Response addResponse(Response r) {
+ while (this.responses.size() > 0
+ && this.responses.size() >= Session.MAX_REQUESTS)
+ this.responses.remove(this.responses.firstKey());
+ return (Response) this.responses.put(new Long(r.getRID()), r);
+ }
+
+ /**
+ * checks InputStream from server for incoming packets blocks until request
+ * timeout or packets available
+ *
+ * @return nl - NodeList of incoming Nodes
+ */
+ private int init_retry = 0;
+
+ public NodeList checkInQ(long rid) throws IOException {
+
+ NodeList nl = null;
+
+ inQueue += this.readFromSocket(rid);
+
+ JHBServlet.dbg("inQueue: " + inQueue, 2);
+
+ if (init_retry < 1000 && (this.authid == null || this.isReinit())
+ && inQueue.length() > 0) {
+ init_retry++;
+ if (stream10Test.matcher(inQueue).matches()) {
+ Matcher m = stream10Pattern.matcher(inQueue);
+ if (m.matches()) {
+ this.authid = m.group(1);
+ inQueue = m.group(2);
+ JHBServlet.dbg("inQueue: " + inQueue, 2);
+ /*
+ * whether there are stream features present we need to
+ * filter them and strip (start)tls information
+ */
+ streamFeatures = inQueue.length() > 0;
+ } else {
+ JHBServlet.dbg("failed to get stream features", 2);
+ try {
+ Thread.sleep(5);
+ } catch (InterruptedException ie) {
+ }
+ return this.checkInQ(rid); // retry
+ }
+ } else {
+ // legacy jabber stream
+ Matcher m = streamPattern.matcher(inQueue);
+ if (m.matches()) {
+ this.authid = m.group(1);
+ } else {
+ JHBServlet.dbg("failed to get authid", 2);
+ try {
+ Thread.sleep(5);
+ } catch (InterruptedException ie) {
+ }
+ return this.checkInQ(rid); // retry
+ }
+ }
+ init_retry = 0; // reset
+ }
+
+ // try to parse it
+ if (!inQueue.equals("")) {
+ try {
+ /*
+ * wrap inQueue with element so that multiple nodes can be
+ * parsed
+ */
+ Document doc = null;
+ if (streamFeatures)
+ doc = db.parse(new InputSource(new StringReader(""
+ + inQueue + "")));
+ else
+ try {
+ doc = db.parse(new InputSource(new StringReader(
+ "" + inQueue
+ + "")));
+ } catch (SAXException sex) {
+ try {
+ // stream closed?
+ doc = db.parse(new InputSource(new StringReader(
+ "" + inQueue)));
+ this.terminate();
+ } catch (SAXException sex2) {
+ }
+ }
+ if (doc != null)
+ nl = doc.getFirstChild().getChildNodes();
+ if (streamFeatures) {// check for starttls
+ for (int i = 0; i < nl.item(0).getChildNodes().getLength(); i++) {
+ if (nl.item(0).getChildNodes().item(i).getNodeName()
+ .equals("starttls")) {
+ if (!this.isReinit()) {
+ JHBServlet
+ .dbg(
+ "starttls present, trying to use it",
+ 2);
+ this.osw
+ .write("");
+ this.osw.flush();
+ String response = this.readFromSocket(rid);
+ JHBServlet.dbg(response, 2);
+
+ try {
+ SSLSocketFactory sslFact = (SSLSocketFactory) SSLSocketFactory
+ .getDefault();
+ SSLSocket tls;
+ tls = (SSLSocket) sslFact.createSocket(
+ this.sock, this.sock
+ .getInetAddress()
+ .getHostName(), this.sock
+ .getPort(), false);
+ tls
+ .addHandshakeCompletedListener(new HandShakeFinished(
+ this));
+ this.pauseForHandshake = true;
+ JHBServlet.dbg("initiating handshake");
+ tls.startHandshake();
+ try {
+ while (this.pauseForHandshake) {
+ JHBServlet.dbg(".");
+ Thread.sleep(5);
+ }
+ } catch (InterruptedException ire) {
+ }
+
+ JHBServlet.dbg("TLS Handshake complete", 2);
+
+ this.sock = tls;
+ this.sock.setSoTimeout(SOCKET_TIMEOUT);
+
+ this.br = new SSLSocketReader(
+ (SSLSocket) tls);
+
+ this.osw = new OutputStreamWriter(tls
+ .getOutputStream(), "UTF-8");
+
+ this.inQueue = ""; // reset
+ this.setReinit(true);
+ this.osw
+ .write("");
+ this.osw.flush();
+
+ return this.checkInQ(rid);
+ } catch (Exception ssle) {
+ JHBServlet.dbg("STARTTLS failed: "
+ + ssle.toString(), 1);
+ this.setReinit(false);
+ if (this.isSecure()) {
+ if (!this.sock.getInetAddress()
+ .getHostName().equals(
+ "localhost")
+ && !this
+ .getResponse(rid)
+ .getReq()
+ .getServerName()
+ .equals(
+ this.sock
+ .getInetAddress()
+ .getHostName())) {
+ JHBServlet
+ .dbg(
+ "secure connection requested but failed",
+ 2);
+ throw new IOException();
+ } else {
+ // we trust localhost and hostnames
+ // that are the same as ours
+ JHBServlet
+ .dbg(
+ "secure requested and we're local",
+ 1);
+ }
+
+ } else {
+ JHBServlet
+ .dbg(
+ "tls failed but we don't need to be secure",
+ 2);
+ }
+ if (this.sock.isClosed()) {
+ JHBServlet.dbg("socket closed", 1);
+ // reconnect
+ Socket s = new Socket();
+ s.connect(this.sock
+ .getRemoteSocketAddress(),
+ SOCKET_TIMEOUT);
+ this.sock = s;
+ this.sock.setSoTimeout(SOCKET_TIMEOUT);
+ this.br = new BufferedReader(
+ new InputStreamReader(this.sock
+ .getInputStream(),
+ "UTF-8"));
+ this.osw = new OutputStreamWriter(
+ this.sock.getOutputStream(),
+ "UTF-8");
+
+ this.inQueue = ""; // reset
+ this.setReinit(true);
+
+ this.osw
+ .write("");
+ this.osw.flush();
+
+ return this.checkInQ(rid);
+ }
+ }
+ } else
+ nl.item(0).removeChild(
+ nl.item(0).getChildNodes().item(i));
+ }
+ }
+ }
+ inQueue = ""; // reset!
+ } catch (SAXException sex3) { /* skip this */
+ this.setReinit(false);
+ JHBServlet.dbg("failed to parse inQueue: " + inQueue + "\n"
+ + sex3.toString(), 1);
+ return null;
+ }
+ }
+ this.setReinit(false);
+ this.setLastActive();
+ return nl;
+ }
+
+ private class HandShakeFinished implements
+ javax.net.ssl.HandshakeCompletedListener {
+ private Session sess;
+
+ public HandShakeFinished(Session sess) {
+ this.sess = sess;
+ }
+
+ public void handshakeCompleted(
+ javax.net.ssl.HandshakeCompletedEvent event) {
+
+ JHBServlet.dbg("startTLS: Handshake is complete", 2);
+
+ this.sess.pauseForHandshake = false;
+ return;
+ }
+ }
+
+ /**
+ * Checks whether given request ID is valid within context of this session.
+ *
+ * @param rid
+ * Request ID to be checked
+ * @return true if rid is valid
+ */
+ public synchronized boolean checkValidRID(long rid) {
+ try {
+ if (rid <= ((Long) this.responses.lastKey()).longValue()
+ + MAX_REQUESTS
+ && rid >= ((Long) this.responses.firstKey()).longValue())
+ return true;
+ else {
+ JHBServlet.dbg("invalid request id: " + rid + " (last: "
+ + ((Long) this.responses.lastKey()).longValue() + ")",
+ 1);
+ return false;
+ }
+ } catch (NoSuchElementException e) {
+ return false;
+ }
+ }
+
+ public String getAuthid() {
+ return this.authid;
+ }
+
+ public String getContent() {
+ return this.content;
+ }
+
+ public int getHold() {
+ return this.hold;
+ }
+
+ /**
+ * @return Returns the key.
+ */
+ public synchronized String getKey() {
+ return key;
+ }
+
+ /**
+ * @return Returns the lastActive.
+ */
+ public synchronized long getLastActive() {
+ return lastActive;
+ }
+
+ /**
+ * @return Returns the lastPoll.
+ */
+ public synchronized long getLastPoll() {
+ return lastPoll;
+ }
+
+ /**
+ * lookup response for given request id
+ *
+ * @param rid
+ * Request id associated with response
+ * @return the response if found, null otherwise
+ */
+ public synchronized Response getResponse(long rid) {
+ return (Response) this.responses.get(new Long(rid));
+ }
+
+ public String getSID() {
+ return this.sid;
+ }
+
+ /*
+ * ######## getters #########
+ */
+
+ public String getTo() {
+ return this.to;
+ }
+
+ public int getWait() {
+ return this.wait;
+ }
+
+ public String getXMLLang() {
+ return this.xmllang;
+ }
+
+ public synchronized int numPendingRequests() {
+ int num_pending = 0;
+ Iterator it = this.responses.values().iterator();
+ while (it.hasNext()) {
+ Response r = (Response) it.next();
+ if (!r.getStatus().equals(Response.STATUS_DONE))
+ num_pending++;
+ }
+ return num_pending;
+ }
+
+ private long lastDoneRID;
+
+ public synchronized long getLastDoneRID() {
+ return this.lastDoneRID;
+ }
+
+ /**
+ * reads from socket
+ *
+ * @return string that was read
+ */
+ private String readFromSocket(long rid) throws IOException {
+ String retval = "";
+ char buf[] = new char[16];
+ int c = 0;
+
+ Response r = this.getResponse(rid);
+
+ while (!this.sock.isClosed() && !this.isStatus(SESS_TERM)) {
+ this.setLastActive();
+ try {
+ if (this.br.ready()) {
+ while (this.br.ready()
+ && (c = this.br.read(buf, 0, buf.length)) >= 0)
+ retval += new String(buf, 0, c);
+ break; // got sth. to send
+ } else {
+ if ((this.hold == 0 && r != null && System
+ .currentTimeMillis()
+ - r.getCDate() > 200)
+ ||
+ /*
+ * makes polling clients feel a little bit more
+ * responsive
+ */
+ (this.hold > 0 && ((r != null && System
+ .currentTimeMillis()
+ - r.getCDate() >= this.getWait() * 1000)
+ || this.numPendingRequests() > this
+ .getHold() || !retval.equals("")))
+ || r.isAborted()) {
+
+ JHBServlet.dbg("readFromSocket done for " + rid, 3);
+ break; // time exeeded
+ }
+
+ try {
+ Thread.sleep(READ_TIMEOUT); // wait for incoming
+ // packets
+ } catch (InterruptedException ie) {
+ System.err.println(ie.toString());
+ }
+ }
+ } catch (IOException e) {
+ System.err.println("Can't read from socket");
+ this.terminate();
+ }
+ }
+
+ if (this.sock.isClosed()) {
+ throw new IOException();
+ }
+ return retval;
+ }
+
+ /**
+ * sends all nodes in list to remote jabber server make sure that nodes get
+ * sent in requested order
+ *
+ * @param nl
+ * list of nodes to send
+ * @return the session itself
+ */
+
+ public Session sendNodes(NodeList nl) {
+ // build a string
+ String out = "";
+ StreamResult strResult = new StreamResult();
+
+ try {
+ Transformer tf = tff.newTransformer();
+ tf.setOutputProperty("omit-xml-declaration", "yes");
+ // loop list
+ for (int i = 0; i < nl.getLength(); i++) {
+ strResult.setWriter(new StringWriter());
+ tf.transform(new DOMSource(nl.item(i)), strResult);
+ String tStr = strResult.getWriter().toString();
+ out += tStr;
+ }
+ } catch (Exception e) {
+ JHBServlet.dbg("XML.toString(Document): " + e, 1);
+ }
+
+ try {
+ if (this.isReinit()) {
+ JHBServlet.dbg("Reinitializing Stream!", 2);
+ this.osw.write("");
+ }
+ this.osw.write(out);
+ this.osw.flush();
+ } catch (IOException ioe) {
+ JHBServlet.dbg(this.sid + " failed to write to stream", 1);
+ }
+
+ return this;
+ }
+
+ public Session setContent(String content) {
+ this.content = content;
+ return this;
+ }
+
+ /*
+ * ######## setters #########
+ */
+
+ public Session setHold(int hold) {
+ if (hold < MAX_REQUESTS && hold >= 0)
+ this.hold = hold;
+ return this;
+ }
+
+ /**
+ * @param key
+ * The key to set.
+ */
+ public synchronized void setKey(String key) {
+ this.key = key;
+ }
+
+ /**
+ * set lastActive to current timestamp.
+ */
+ public synchronized void setLastActive() {
+ this.lastActive = System.currentTimeMillis();
+ }
+
+ public synchronized void setLastDoneRID(long rid) {
+ this.lastDoneRID = rid;
+ }
+
+ /**
+ * set lastPoll to current timestamp.
+ */
+ public synchronized void setLastPoll() {
+ this.lastPoll = System.currentTimeMillis();
+ }
+
+ public int setWait(int wait) {
+ if (wait < 0)
+ wait = 0;
+ if (wait > MAX_WAIT)
+ wait = MAX_WAIT;
+ this.wait = wait;
+ return wait;
+ }
+
+ public Session setXMLLang(String xmllang) {
+ this.xmllang = xmllang;
+ return this;
+ }
+
+ /**
+ * @return Returns the reinit.
+ */
+ public synchronized boolean isReinit() {
+ return reinit;
+ }
+
+ /**
+ * @return the secure
+ */
+ public synchronized boolean isSecure() {
+ return secure;
+ }
+
+ /**
+ * @param reinit
+ * The reinit to set.
+ */
+ public synchronized void setReinit(boolean reinit) {
+ this.reinit = reinit;
+ }
+
+ public synchronized void setStatus(String status) {
+ this.status = status;
+ }
+
+ public synchronized boolean isStatus(String status) {
+ return (this.status == status);
+ }
+
+ /**
+ * kill this session
+ *
+ */
+ public void terminate() {
+ JHBServlet.dbg("terminating session " + this.getSID(), 2);
+ this.setStatus(SESS_TERM);
+ synchronized (this.sock) {
+ if (!this.sock.isClosed()) {
+ try {
+ this.osw.write("");
+ this.osw.flush();
+ this.sock.close();
+ } catch (IOException ie) {
+ }
+ }
+ this.sock.notifyAll();
+ }
+ sessions.remove(this.sid);
+ }
+
+ /**
+ * @param secure
+ * the secure to set
+ */
+ public synchronized void setSecure(boolean secure) {
+ this.secure = secure;
+ }
+
+}
diff --git a/tomcat/conf/web.xml b/tomcat/conf/web.xml
new file mode 100644
index 0000000..fee85f3
--- /dev/null
+++ b/tomcat/conf/web.xml
@@ -0,0 +1,566 @@
+
+
+
+
+
+ 30
+
+
+
+ abs
+ audio/x-mpeg
+
+
+ ai
+ application/postscript
+
+
+ aif
+ audio/x-aiff
+
+
+ aifc
+ audio/x-aiff
+
+
+ aiff
+ audio/x-aiff
+
+
+ aim
+ application/x-aim
+
+
+ art
+ image/x-jg
+
+
+ asf
+ video/x-ms-asf
+
+
+ asx
+ video/x-ms-asf
+
+
+ au
+ audio/basic
+
+
+ avi
+ video/x-msvideo
+
+
+ avx
+ video/x-rad-screenplay
+
+
+ bcpio
+ application/x-bcpio
+
+
+ bin
+ application/octet-stream
+
+
+ bmp
+ image/bmp
+
+
+ body
+ text/html
+
+
+ cdf
+ application/x-cdf
+
+
+ cer
+ application/x-x509-ca-cert
+
+
+ class
+ application/java
+
+
+ cpio
+ application/x-cpio
+
+
+ csh
+ application/x-csh
+
+
+ css
+ text/css
+
+
+ dib
+ image/bmp
+
+
+ doc
+ application/msword
+
+
+ dtd
+ text/plain
+
+
+ dv
+ video/x-dv
+
+
+ dvi
+ application/x-dvi
+
+
+ eps
+ application/postscript
+
+
+ etx
+ text/x-setext
+
+
+ exe
+ application/octet-stream
+
+
+ gif
+ image/gif
+
+
+ gtar
+ application/x-gtar
+
+
+ gz
+ application/x-gzip
+
+
+ hdf
+ application/x-hdf
+
+
+ hqx
+ application/mac-binhex40
+
+
+ htc
+ text/x-component
+
+
+ htm
+ text/html
+
+
+ html
+ text/html
+
+
+ hqx
+ application/mac-binhex40
+
+
+ ief
+ image/ief
+
+
+ jad
+ text/vnd.sun.j2me.app-descriptor
+
+
+ jar
+ application/java-archive
+
+
+ java
+ text/plain
+
+
+ jnlp
+ application/x-java-jnlp-file
+
+
+ jpe
+ image/jpeg
+
+
+ jpeg
+ image/jpeg
+
+
+ jpg
+ image/jpeg
+
+
+ js
+ text/javascript
+
+
+ jsf
+ text/plain
+
+
+ jspf
+ text/plain
+
+
+ kar
+ audio/x-midi
+
+
+ latex
+ application/x-latex
+
+
+ m3u
+ audio/x-mpegurl
+
+
+ mac
+ image/x-macpaint
+
+
+ man
+ application/x-troff-man
+
+
+ me
+ application/x-troff-me
+
+
+ mid
+ audio/x-midi
+
+
+ midi
+ audio/x-midi
+
+
+ mif
+ application/x-mif
+
+
+ mov
+ video/quicktime
+
+
+ movie
+ video/x-sgi-movie
+
+
+ mp1
+ audio/x-mpeg
+
+
+ mp2
+ audio/x-mpeg
+
+
+ mp3
+ audio/x-mpeg
+
+
+ mpa
+ audio/x-mpeg
+
+
+ mpe
+ video/mpeg
+
+
+ mpeg
+ video/mpeg
+
+
+ mpega
+ audio/x-mpeg
+
+
+ mpg
+ video/mpeg
+
+
+ mpv2
+ video/mpeg2
+
+
+ ms
+ application/x-wais-source
+
+
+ nc
+ application/x-netcdf
+
+
+ oda
+ application/oda
+
+
+ pbm
+ image/x-portable-bitmap
+
+
+ pct
+ image/pict
+
+
+ pdf
+ application/pdf
+
+
+ pgm
+ image/x-portable-graymap
+
+
+ pic
+ image/pict
+
+
+ pict
+ image/pict
+
+
+ pls
+ audio/x-scpls
+
+
+ png
+ image/png
+
+
+ pnm
+ image/x-portable-anymap
+
+
+ pnt
+ image/x-macpaint
+
+
+ ppm
+ image/x-portable-pixmap
+
+
+ ppt
+ application/powerpoint
+
+
+ ps
+ application/postscript
+
+
+ psd
+ image/x-photoshop
+
+
+ qt
+ video/quicktime
+
+
+ qti
+ image/x-quicktime
+
+
+ qtif
+ image/x-quicktime
+
+
+ ras
+ image/x-cmu-raster
+
+
+ rgb
+ image/x-rgb
+
+
+ rm
+ application/vnd.rn-realmedia
+
+
+ roff
+ application/x-troff
+
+
+ rtf
+ application/rtf
+
+
+ rtx
+ text/richtext
+
+
+ sh
+ application/x-sh
+
+
+ shar
+ application/x-shar
+
+
+ smf
+ audio/x-midi
+
+
+ sit
+ application/x-stuffit
+
+
+ snd
+ audio/basic
+
+
+ src
+ application/x-wais-source
+
+
+ sv4cpio
+ application/x-sv4cpio
+
+
+ sv4crc
+ application/x-sv4crc
+
+
+ swf
+ application/x-shockwave-flash
+
+
+ t
+ application/x-troff
+
+
+ tar
+ application/x-tar
+
+
+ tcl
+ application/x-tcl
+
+
+ tex
+ application/x-tex
+
+
+ texi
+ application/x-texinfo
+
+
+ texinfo
+ application/x-texinfo
+
+
+ tif
+ image/tiff
+
+
+ tiff
+ image/tiff
+
+
+ tr
+ application/x-troff
+
+
+ tsv
+ text/tab-separated-values
+
+
+ txt
+ text/plain
+
+
+ ulw
+ audio/basic
+
+
+ ustar
+ application/x-ustar
+
+
+ xbm
+ image/x-xbitmap
+
+
+ xht
+ application/xhtml+xml
+
+
+ xhtml
+ application/xhtml+xml
+
+
+ xml
+ text/xml
+
+
+ xpm
+ image/x-xpixmap
+
+
+ xsl
+ text/xml
+
+
+ xwd
+ image/x-xwindowdump
+
+
+ wav
+ audio/x-wav
+
+
+ svg
+ image/svg+xml
+
+
+ svgz
+ image/svg+xml
+
+
+ vsd
+ application/x-visio
+
+
+
+ wbmp
+ image/vnd.wap.wbmp
+
+
+
+ wml
+ text/vnd.wap.wml
+
+
+
+ wmlc
+ application/vnd.wap.wmlc
+
+
+
+ wmls
+ text/vnd.wap.wmlscript
+
+
+
+ wmlscriptc
+ application/vnd.wap.wmlscriptc
+
+
+ wrl
+ x-world/x-vrml
+
+
+ Z
+ application/x-compress
+
+
+ z
+ application/x-compress
+
+
+ zip
+ application/zip
+
+
diff --git a/tomcat/webapps/ROOT/WEB-INF/web.xml b/tomcat/webapps/ROOT/WEB-INF/web.xml
new file mode 100644
index 0000000..e600b2f
--- /dev/null
+++ b/tomcat/webapps/ROOT/WEB-INF/web.xml
@@ -0,0 +1,14 @@
+
+
+
+
+ shell
+ com.google.gwt.dev.shell.GWTShellServlet
+
+
+
+ shell
+ /*
+
+
+
diff --git a/tomcat/work/gwt/localhost/_/SESSIONS.ser b/tomcat/work/gwt/localhost/_/SESSIONS.ser
new file mode 100644
index 0000000..e555e0b
Binary files /dev/null and b/tomcat/work/gwt/localhost/_/SESSIONS.ser differ
diff --git a/tomcat/work/gwt/localhost/_/tldCache.ser b/tomcat/work/gwt/localhost/_/tldCache.ser
new file mode 100644
index 0000000..9fa6832
Binary files /dev/null and b/tomcat/work/gwt/localhost/_/tldCache.ser differ
diff --git a/www/.gwt-tmp/shell/com.anzsoft.iJab/9CB84EDB480FE0AE074E62C05EE124EB.cache.png b/www/.gwt-tmp/shell/com.anzsoft.iJab/9CB84EDB480FE0AE074E62C05EE124EB.cache.png
new file mode 100644
index 0000000..1976d3f
Binary files /dev/null and b/www/.gwt-tmp/shell/com.anzsoft.iJab/9CB84EDB480FE0AE074E62C05EE124EB.cache.png differ
diff --git a/www/.gwt-tmp/shell/com.anzsoft.iJab/Thumbs.db b/www/.gwt-tmp/shell/com.anzsoft.iJab/Thumbs.db
new file mode 100644
index 0000000..74fc0da
Binary files /dev/null and b/www/.gwt-tmp/shell/com.anzsoft.iJab/Thumbs.db differ