ofmeet plugin version 0.1.6

Added support for media relaying using the JingleNodes plugin

jinglenodes plugin 0.1.3
Replaced jingle nodes relay library jar file with latest source code
Added dependencies smack.jar and smackx.jar

src/plugins/jingleNodes/changelog.html

@@ -49,9 +49,15 @@
     Jingle Nodes Plugin Changelog
 </h1>
 
+<p><b>0.1.3</b> -- May 9th, 2015</p>
+<ul>
+     <li>Replaced jingle nodes relay library jar file with latest source code</li>
+     <li>Added dependencies smack.jar and smackx.jar</li>
+</ul>
+
 <p><b>0.1.2</b> -- Apr 22, 2015</p>
 <ul>
-     <li>Not an official ignite release - fixed the plugin to allow advanced configuration of ip addresses, port numbers, and servers. Previously the code could not work right behind a firewall and the test STUN server hardcoded into the file was not operational.</li>
+     <li>Fixed the plugin to allow advanced configuration of ip addresses, port numbers, and servers. Previously the code could not work right behind a firewall and the test STUN server hardcoded into the file was not operational.</li>
 </ul>
 
 <p><b>0.1.1</b> -- Jan 16, 2015</p>

src/plugins/jingleNodes/plugin.xml

@@ -3,10 +3,10 @@
 <plugin>
     <class>org.jinglenodes.JingleNodesPlugin</class>
     <name>Jingle Nodes Plugin</name>
-    <description>Provides support for Jingle Nodes. This version is a custom modified version of 1.1.1 with a more advanced admin page exposing more properties and the ability to work behind a firewall.</description>
+    <description>Provides support for Jingle Nodes</description>
     <author>Jingle Nodes (Rodrigo Martins)</author>
-    <version>0.1.2</version>
-    <date>04/22/2015</date>
+    <version>0.1.3</version>
+    <date>05/09/2015</date>
     <minServerVersion>3.9.0</minServerVersion>
 
     <adminconsole>

src/plugins/jingleNodes/src/java/org/jinglenodes/JingleNodesPlugin.java

@@ -43,12 +43,12 @@ public class JingleNodesPlugin implements Plugin {
 
     private static final Logger Log = LoggerFactory.getLogger(JingleNodesPlugin.class);
 
-    public static final String JN_LOCAL_IP_PROPERTY = "jinglenodes.localIP";
-    public static final String JN_PUBLIC_IP_PROPERTY = "jinglenodes.publicIP";
-    public static final String JN_MIN_PORT_PROPERTY = "jinglenodes.minPort";
-    public static final String JN_MAX_PORT_PROPERTY = "jinglenodes.maxPort";
-    public static final String JN_TEST_STUN_SERVER_PROPERTY = "jinglenodes.testSTUNServer";
-    public static final String JN_TEST_STUN_PORT_PROPERTY = "jinglenodes.testSTUNPort";
+    public static final String JN_LOCAL_IP_PROPERTY = "jinglenodes.localip";
+    public static final String JN_PUBLIC_IP_PROPERTY = "jinglenodes.publicip";
+    public static final String JN_MIN_PORT_PROPERTY = "jinglenodes.minport";
+    public static final String JN_MAX_PORT_PROPERTY = "jinglenodes.maxport";
+    public static final String JN_TEST_STUN_SERVER_PROPERTY = "jinglenodes.teststunserver";
+    public static final String JN_TEST_STUN_PORT_PROPERTY = "jinglenodes.teststunport";
 
     private ComponentManager componentManager;
 

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/RelayChannel.java

+package org.xmpp.jnodes;
+
+import org.xmpp.jnodes.nio.DatagramListener;
+import org.xmpp.jnodes.nio.SelDatagramChannel;
+
+import java.io.IOException;
+import java.net.BindException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.ByteBuffer;
+
+public class RelayChannel {
+
+    private final SelDatagramChannel channelA;
+    private final SelDatagramChannel channelB;
+    private final SocketAddress addressA;
+    private final SocketAddress addressB;
+    private SocketAddress lastReceivedA;
+    private SocketAddress lastReceivedB;
+    private final SelDatagramChannel channelA_;
+    private final SelDatagramChannel channelB_;
+    private SocketAddress lastReceivedA_;
+    private SocketAddress lastReceivedB_;        
+    private long lastReceivedTimeA;
+    private long lastReceivedTimeB;
+    private final int portA;
+    private final int portB;
+    private final String ip;
+    private Object attachment;
+
+    public static RelayChannel createLocalRelayChannel(final String host, final int minPort, final int maxPort) throws IOException {
+        int range = maxPort - minPort;
+        IOException be = null;
+
+        for (int t = 0; t < 50; t++) {
+            try {
+                int a = Math.round((int) (Math.random() * range)) + minPort;
+                a = a % 2 == 0 ? a : a + 1;
+                return new RelayChannel(host, a);
+            } catch (BindException e) {
+                be = e;
+            } catch (IOException e) {
+                be = e;
+            }
+        }
+        throw be;
+    }
+
+    public RelayChannel(final String host, final int portA) throws IOException {
+
+        final int portB = portA + 2;
+
+        addressA = new InetSocketAddress(host, portA);
+        addressB = new InetSocketAddress(host, portB);
+
+        channelA = SelDatagramChannel.open(null, addressA);
+        channelB = SelDatagramChannel.open(null, addressB);
+
+        channelA.setDatagramListener(new DatagramListener() {
+            public void datagramReceived(final SelDatagramChannel channel, final ByteBuffer buffer, final SocketAddress address) {
+                lastReceivedA = address;
+                lastReceivedTimeA = System.currentTimeMillis();
+
+                if (lastReceivedB != null) {
+                    try {
+                        buffer.flip();
+                        channelB.send(buffer, lastReceivedB);
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        });
+
+        channelB.setDatagramListener(new DatagramListener() {
+            public void datagramReceived(final SelDatagramChannel channel, final ByteBuffer buffer, final SocketAddress address) {
+                lastReceivedB = address;
+                lastReceivedTimeB = System.currentTimeMillis();
+                if (lastReceivedA != null) {
+                    try {
+                        buffer.flip();
+                        channelA.send(buffer, lastReceivedA);
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        });
+
+        this.portA = portA;
+        this.portB = portB;
+
+        // RTCP Support
+        SocketAddress addressA_ = new InetSocketAddress(host, portA + 1);
+        SocketAddress addressB_ = new InetSocketAddress(host, portB + 1);
+
+        channelA_ = SelDatagramChannel.open(null, addressA_);
+        channelB_ = SelDatagramChannel.open(null, addressB_);
+
+        channelA_.setDatagramListener(new DatagramListener() {
+            public void datagramReceived(final SelDatagramChannel channel, final ByteBuffer buffer, final SocketAddress address) {
+                lastReceivedA_ = address;
+
+                if (lastReceivedB_ != null) {
+                    try {
+                        buffer.flip();
+                        channelB_.send(buffer, lastReceivedB_);
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        });
+
+        channelB_.setDatagramListener(new DatagramListener() {
+            public void datagramReceived(final SelDatagramChannel channel, final ByteBuffer buffer, final SocketAddress address) {
+                lastReceivedB_ = address;
+                if (lastReceivedA_ != null) {
+                    try {
+                        buffer.flip();
+                        channelA_.send(buffer, lastReceivedA_);
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        });
+
+        this.ip = host;
+    }
+
+    public SocketAddress getAddressB() {
+        return addressB;
+    }
+
+    public SocketAddress getAddressA() {
+        return addressA;
+    }
+
+    public int getPortA() {
+        return portA;
+    }
+
+    public int getPortB() {
+        return portB;
+    }
+
+    public String getIp() {
+        return ip;
+    }
+
+    public long getLastReceivedTimeA() {
+        return lastReceivedTimeA;
+    }
+
+    public long getLastReceivedTimeB() {
+        return lastReceivedTimeB;
+    }
+
+    public Object getAttachment() {
+        return attachment;
+    }
+
+    public void setAttachment(Object attachment) {
+        this.attachment = attachment;
+    }
+
+    public void close() {
+        try {
+            channelA.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        try {
+            channelB.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        try {
+            channelA_.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        try {
+            channelB_.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public SelDatagramChannel getChannelA() {
+        return channelA;
+    }
+
+    public SelDatagramChannel getChannelB() {
+        return channelB;
+    }
+
+    public SelDatagramChannel getChannelA_() {
+        return channelA_;
+    }
+
+    public SelDatagramChannel getChannelB_() {
+        return channelB_;
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/RelayPublicMask.java

+package org.xmpp.jnodes;
+
+import org.xmpp.jnodes.nio.PublicIPResolver;
+
+import java.net.InetSocketAddress;
+
+public class RelayPublicMask {
+
+    private final RelayChannel channel;
+
+    private InetSocketAddress addressA, addressB, addressA_, addressB_;
+
+    public RelayPublicMask(final RelayChannel channel) {
+        this.channel = channel;
+    }
+
+    public void discover(final String stunServer, final int port) {
+        addressA = PublicIPResolver.getPublicAddress(channel.getChannelA(), stunServer, port);
+        addressA_ = PublicIPResolver.getPublicAddress(channel.getChannelA_(), stunServer, port);
+        addressB = PublicIPResolver.getPublicAddress(channel.getChannelB(), stunServer, port);
+        addressB_ = PublicIPResolver.getPublicAddress(channel.getChannelB_(), stunServer, port);
+    }
+
+    public InetSocketAddress getAddressA() {
+        return addressA;
+    }
+
+    public InetSocketAddress getAddressB() {
+        return addressB;
+    }
+
+    public InetSocketAddress getAddressA_() {
+        return addressA_;
+    }
+
+    public InetSocketAddress getAddressB_() {
+        return addressB_;
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/nio/DatagramListener.java

+package org.xmpp.jnodes.nio;
+
+import java.net.SocketAddress;
+import java.nio.ByteBuffer;
+
+public interface DatagramListener {
+
+    public void datagramReceived(SelDatagramChannel channel, ByteBuffer buffer, SocketAddress address);
+
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/nio/LocalIPResolver.java

+package org.xmpp.jnodes.nio;
+
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.util.Enumeration;
+
+public class LocalIPResolver {
+
+    private static String overrideIp;
+
+    public static String getLocalIP() {
+
+        if (overrideIp != null && overrideIp.length() >= 7) {
+            return overrideIp;
+        }
+
+        Enumeration ifaces;
+
+        try {
+            ifaces = NetworkInterface.getNetworkInterfaces();
+
+            while (ifaces.hasMoreElements()) {
+
+                NetworkInterface iface = (NetworkInterface) ifaces.nextElement();
+                Enumeration iaddresses = iface.getInetAddresses();
+
+                while (iaddresses.hasMoreElements()) {
+                    InetAddress iaddress = (InetAddress) iaddresses.nextElement();
+                    if (!iaddress.isLoopbackAddress() && !iaddress.isLinkLocalAddress() && !iaddress.isSiteLocalAddress()) {
+                        return iaddress.getHostAddress() != null ? iaddress.getHostAddress() : iaddress.getHostName();
+                    }
+                }
+            }
+
+            ifaces = NetworkInterface.getNetworkInterfaces();
+
+            while (ifaces.hasMoreElements()) {
+
+                NetworkInterface iface = (NetworkInterface) ifaces.nextElement();
+                Enumeration iaddresses = iface.getInetAddresses();
+
+                while (iaddresses.hasMoreElements()) {
+                    InetAddress iaddress = (InetAddress) iaddresses.nextElement();
+                    if (!iaddress.isLoopbackAddress() && !iaddress.isLinkLocalAddress()) {
+                        return iaddress.getHostAddress() != null ? iaddress.getHostAddress() : iaddress.getHostName();
+                    }
+                }
+            }
+
+            return InetAddress.getLocalHost().getHostAddress() != null ? InetAddress.getLocalHost().getHostAddress() : InetAddress.getLocalHost().getHostName();
+
+        }
+        catch (SocketException e) {
+            e.printStackTrace();
+        }
+        catch (UnknownHostException e) {
+            e.printStackTrace();
+        }
+
+        return "127.0.0.1";
+    }
+
+    public static String getOverrideIp() {
+        return overrideIp;
+    }
+
+    public static void setOverrideIp(String overrideIp) {
+        LocalIPResolver.overrideIp = overrideIp;
+    }   
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/nio/PublicIPResolver.java

+package org.xmpp.jnodes.nio;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.ByteBuffer;
+import java.util.Random;
+
+public class PublicIPResolver {
+
+    final static byte BINDING_REQUEST_ID = 0x0001;
+    final static int MAPPED_ADDRESS = 0x0001;
+    final static byte CHANGE_REQUEST_NO_CHANGE[] = {0, 3, 0, 4, 0, 0, 0, 0};
+    final static Random r = new Random(System.nanoTime());
+
+    private static byte[] getHeader(final int contentLenght) {
+        final byte header[] = new byte[20];
+        header[0] = 0;
+        header[1] = BINDING_REQUEST_ID;
+        header[2] = 0;
+        header[3] = (byte) contentLenght;
+        header[4] = (byte) (r.nextInt(9));
+        header[5] = (byte) (r.nextInt(8));
+        header[6] = (byte) (r.nextInt(7));
+        header[7] = (byte) (r.nextInt(6));
+        return header;
+    }
+
+    public static ByteBuffer createSTUNChangeRequest() {
+        final byte header[] = getHeader(CHANGE_REQUEST_NO_CHANGE.length);
+        final byte data[] = new byte[header.length + CHANGE_REQUEST_NO_CHANGE.length];
+        System.arraycopy(header, 0, data, 0, header.length);
+        System.arraycopy(CHANGE_REQUEST_NO_CHANGE, 0, data, header.length, CHANGE_REQUEST_NO_CHANGE.length);
+        return ByteBuffer.wrap(data);
+    }
+
+    public static Header parseResponse(byte[] data) {
+        byte[] lengthArray = new byte[2];
+        System.arraycopy(data, 2, lengthArray, 0, 2);
+        int length = unsignedShortToInt(lengthArray);
+        byte[] cuttedData;
+        int offset = 20;
+
+        while (length > 0) {
+            cuttedData = new byte[length];
+            System.arraycopy(data, offset, cuttedData, 0, length);
+            Header h = parseHeader(cuttedData);
+
+            if (h.getType() == MAPPED_ADDRESS) {
+                return h;
+            }
+            length -= h.getLength();
+            offset += h.getLength();
+        }
+        return null;
+    }
+
+    private static Header parseHeader(byte[] data) {
+        byte[] typeArray = new byte[2];
+        System.arraycopy(data, 0, typeArray, 0, 2);
+        int type = unsignedShortToInt(typeArray);
+        byte[] lengthArray = new byte[2];
+        System.arraycopy(data, 2, lengthArray, 0, 2);
+        int lengthValue = unsignedShortToInt(lengthArray);
+        byte[] valueArray = new byte[lengthValue];
+        System.arraycopy(data, 4, valueArray, 0, lengthValue);
+        if (data.length >= 8) {
+            int family = unsignedByteToInt(valueArray[1]);
+            if (family == 1) {
+                byte[] portArray = new byte[2];
+                System.arraycopy(valueArray, 2, portArray, 0, 2);
+                int port = unsignedShortToInt(portArray);
+                int firstOctet = unsignedByteToInt(valueArray[4]);
+                int secondOctet = unsignedByteToInt(valueArray[5]);
+                int thirdOctet = unsignedByteToInt(valueArray[6]);
+                int fourthOctet = unsignedByteToInt(valueArray[7]);
+                final StringBuilder ip = new StringBuilder().append(firstOctet).append(".").append(secondOctet).append(".").append(thirdOctet).append(".").append(fourthOctet);
+                return new Header(new InetSocketAddress(ip.toString(), port), type, lengthValue + 4);
+            }
+        }
+        return new Header(null, -1, lengthValue + 4);
+    }
+
+    public static int unsignedShortToInt(final byte[] b) {
+        int a = b[0] & 0xFF;
+        int aa = b[1] & 0xFF;
+        return ((a << 8) + aa);
+    }
+
+    public static int unsignedByteToInt(byte b) {
+        return (int) b & 0xFF;
+    }
+
+    public static class Header {
+        final InetSocketAddress address;
+        final int type;
+        final int length;
+
+        public Header(final InetSocketAddress address, int type, int length) {
+            this.address = address;
+            this.type = type;
+            this.length = length;
+        }
+
+        public int getType() {
+            return type;
+        }
+
+        public InetSocketAddress getAddress() {
+            return address;
+        }
+
+        public int getLength() {
+            return length;
+        }
+    }
+
+    public static InetSocketAddress getPublicAddress(final String stunServer, final int port) {
+        int lport = 10002;
+
+        for (int t = 0; t < 3; t++) {
+            try {
+                final SelDatagramChannel channel = SelDatagramChannel.open(null, new InetSocketAddress(System.getProperty("os.name")!=null&&System.getProperty("os.name").toLowerCase().indexOf("win") > -1 ? LocalIPResolver.getLocalIP() : "0.0.0.0", lport));
+
+                return getPublicAddress(channel, stunServer, port);
+
+            } catch (IOException e) {
+                lport += r.nextInt(10) + 1;
+            }
+        }
+        return null;
+    }
+
+    public static InetSocketAddress getPublicAddress(final SelDatagramChannel channel, final String stunServer, final int port) {
+        final Header[] h = new Header[1];
+
+        try {
+
+            channel.setDatagramListener(new DatagramListener() {
+                public void datagramReceived(SelDatagramChannel channel, ByteBuffer buffer, SocketAddress address) {
+                    final byte b[] = new byte[buffer.position()];
+                    buffer.rewind();
+                    buffer.get(b, 0, b.length);
+                    h[0] = parseResponse(b);
+                }
+            });
+
+            channel.send(createSTUNChangeRequest(), new InetSocketAddress(stunServer, port));
+            Thread.sleep(100);
+            for (int i = 0; i < 5; i++) {
+                Thread.sleep(100);
+                if (h[0] != null) {
+                    return h[0].getAddress();
+                }
+                if (i % 2 == 0) {
+                    channel.send(createSTUNChangeRequest(), new InetSocketAddress(stunServer, port));
+                }
+            }
+            return null;
+        } catch (IOException e) {
+            return null;
+        } catch (InterruptedException e) {
+            return null;
+        }
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/nio/SelDatagramChannel.java

+package org.xmpp.jnodes.nio;
+
+import java.io.IOException;
+import java.net.SocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.DatagramChannel;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class SelDatagramChannel {
+
+    private final static ExecutorService executorService = Executors.newFixedThreadPool(10);
+    private static Selector selector;
+
+    // Instance Properties
+    protected final DatagramChannel channel;
+    private DatagramListener datagramListener;
+    private final static Object obj = new Object();
+
+    private static void init() {
+        try {
+            selector = Selector.open();
+
+            while (!selector.isOpen()) {
+                Thread.yield();
+            }
+
+            final Runnable task = new Runnable() {
+                public void run() {
+                    while (true) {
+                        try {
+                            final int n;
+
+                            synchronized (obj) {
+                            }
+                            n = selector.select();
+
+                            if (n == 0) {
+                                Thread.sleep(50);
+                                Thread.yield();
+                                continue;
+                            }
+
+                            final Set keys = selector.selectedKeys();
+
+                            // Iterate through the Set of keys.
+                            for (Iterator i = keys.iterator(); i.hasNext();) {
+                                // Get a key from the set, and remove it from the set
+                                final SelectionKey key = (SelectionKey) i.next();
+                                i.remove();
+
+                                // Get the channel associated with the key
+                                final DatagramChannel c = (DatagramChannel) key.channel();
+
+                                if (key.isValid() && key.isReadable()) {
+                                    final SelDatagramChannel sdc = (SelDatagramChannel) key.attachment();
+
+                                    if (sdc == null) {
+                                        // Discard Packet
+                                        c.receive(ByteBuffer.allocate(0));
+                                        continue;
+                                    }
+
+                                    final ByteBuffer b = ByteBuffer.allocateDirect(1450);
+                                    final SocketAddress clientAddress;
+                                    synchronized (sdc) {
+                                        clientAddress = sdc.channel.receive(b);
+                                    }
+                                    // If we got the datagram successfully, broadcast the Event
+                                    if (clientAddress != null) {
+                                        // Execute in a different Thread avoid serialization
+                                        if (sdc.datagramListener != null) {
+                                            executorService.submit(new Runnable() {
+                                                public void run() {
+                                                    sdc.datagramListener.datagramReceived(sdc, b, clientAddress);
+                                                }
+                                            });
+                                        }
+                                    }
+
+                                }
+                            }
+
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                        }
+                        catch (Throwable t) {
+                            t.printStackTrace();
+                        }
+                    }
+                }
+            };
+
+            executorService.submit(task);
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    protected SelDatagramChannel(final DatagramChannel channel, final DatagramListener datagramListener) {
+        this.channel = channel;
+        this.datagramListener = datagramListener;
+    }
+
+    public static SelDatagramChannel open(final DatagramListener datagramListener, final SocketAddress localAddress) throws IOException {
+        synchronized (executorService) {
+            if (selector == null) {
+                init();
+            }
+        }
+
+        final DatagramChannel dc = DatagramChannel.open();
+        dc.configureBlocking(false);
+        dc.socket().bind(localAddress);
+        final SelDatagramChannel c = new SelDatagramChannel(dc, datagramListener);
+        synchronized (obj) {
+            selector.wakeup();
+            dc.register(selector, SelectionKey.OP_READ, c);
+        }
+        return c;
+    }
+
+    public int send(final ByteBuffer src, final SocketAddress target) throws IOException {
+        return this.channel.send(src, target);
+    }
+
+    public void close() throws IOException {
+        final SelectionKey k = channel.keyFor(selector);
+        if (k != null) {
+            synchronized (obj) {
+                selector.wakeup();
+                k.cancel();
+            }
+        }
+        synchronized (this) {
+            channel.close();
+        }
+    }
+
+    public void setDatagramListener(DatagramListener listener) {
+        this.datagramListener = listener;
+    }
+}
\ No newline at end of file

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/smack/JingleChannelIQ.java

+package org.xmpp.jnodes.smack;
+
+import org.jivesoftware.smack.packet.IQ;
+
+public class JingleChannelIQ extends IQ {
+
+    public static final String NAME = "channel";
+    public static final String NAMESPACE = "http://jabber.org/protocol/jinglenodes#channel";
+
+    public static final String UDP= "udp";
+    public static final String TCP= "tcp";
+
+    private String protocol = UDP;
+    private String host;
+    private int localport = -1;
+    private int remoteport = -1;
+    private String id;
+
+    public JingleChannelIQ() {
+        this.setType(Type.GET);
+        this.setPacketID(IQ.nextID());
+    }
+
+    public String getChildElementXML() {
+        final StringBuilder str = new StringBuilder();
+
+        str.append("<").append(NAME).append(" xmlns='").append(NAMESPACE).append("' protocol='").append(protocol).append("' ");
+        if (localport > 0 && remoteport > 0 && host != null) {
+            str.append("host='").append(host).append("' ");
+            str.append("localport='").append(localport).append("' ");
+            str.append("remoteport='").append(remoteport).append("' ");
+        }
+        str.append("/>");
+
+        return str.toString();
+    }
+
+    public boolean isRequest() {
+        return Type.GET.equals(this.getType());
+    }
+
+    public String getProtocol() {
+        return protocol;
+    }
+
+    public void setProtocol(String protocol) {
+        this.protocol = protocol;
+    }
+
+    public int getRemoteport() {
+        return remoteport;
+    }
+
+    public void setRemoteport(int remoteport) {
+        this.remoteport = remoteport;
+    }
+
+    public String getHost() {
+        return host;
+    }
+
+    public void setHost(String host) {
+        this.host = host;
+    }
+
+    public int getLocalport() {
+        return localport;
+    }
+
+    public void setLocalport(int localport) {
+        this.localport = localport;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public static IQ createEmptyResult(IQ iq) {
+        return createIQ(iq.getPacketID(), iq.getFrom(), iq.getTo(), IQ.Type.RESULT);
+    }
+
+    public static IQ createEmptyError(IQ iq) {
+        return createIQ(iq.getPacketID(), iq.getFrom(), iq.getTo(), IQ.Type.ERROR);
+    }
+
+    public static IQ createEmptyError() {
+        return createIQ(null, null, null, IQ.Type.ERROR);
+    }
+
+    public static IQ createIQ(String ID, String to, String from, IQ.Type type) {
+        IQ iqPacket = new IQ() {
+            public String getChildElementXML() {
+                return null;
+            }
+        };
+
+        iqPacket.setPacketID(ID);
+        iqPacket.setTo(to);
+        iqPacket.setFrom(from);
+        iqPacket.setType(type);
+
+        return iqPacket;
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/smack/JingleNodesProvider.java

+package org.xmpp.jnodes.smack;
+
+import org.jivesoftware.smack.provider.IQProvider;
+import org.xmlpull.v1.XmlPullParser;
+
+import java.util.IllegalFormatException;
+
+public class JingleNodesProvider implements IQProvider {
+
+    public JingleChannelIQ parseIQ(final XmlPullParser parser) throws Exception {
+
+        JingleChannelIQ iq = null;
+
+        boolean done = false;
+        int eventType;
+        String elementName;
+        String namespace;
+
+        while (!done) {
+
+            eventType = parser.getEventType();
+            elementName = parser.getName();
+            namespace = parser.getNamespace();
+
+            if (eventType == XmlPullParser.START_TAG) {
+                if (elementName.equals(JingleChannelIQ.NAME) && namespace.equals(JingleChannelIQ.NAMESPACE)) {
+
+                    final String protocol = parser.getAttributeValue(null, "protocol");
+                    final String porta = parser.getAttributeValue(null, "localport");
+                    final String portb = parser.getAttributeValue(null, "remoteport");
+                    final String host = parser.getAttributeValue(null, "host");
+
+                    try {
+                        iq = new JingleChannelIQ();
+                        iq.setProtocol(protocol == null ? JingleChannelIQ.UDP : protocol);
+                        if (host != null)
+                            iq.setHost(host);
+                        if (porta != null)
+                            iq.setLocalport(Integer.valueOf(porta));
+                        if (portb != null)
+                            iq.setRemoteport(Integer.valueOf(portb));
+                    } catch (final IllegalFormatException e) {
+                        e.printStackTrace();
+                    } catch (NumberFormatException e) {
+                        e.printStackTrace();
+                    }
+
+                }
+            } else if (eventType == XmlPullParser.END_TAG) {
+                done = true;
+            }
+            if (!done)
+                parser.next();
+        }
+
+        return iq;
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/smack/JingleTrackerIQ.java

+package org.xmpp.jnodes.smack;
+
+import org.jivesoftware.smack.packet.IQ;
+
+import java.util.Collection;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class JingleTrackerIQ extends IQ {
+
+    public static final String NAME = "services";
+    public static final String NAMESPACE = "http://jabber.org/protocol/jinglenodes";
+
+    private final ConcurrentHashMap<String, TrackerEntry> entries = new ConcurrentHashMap<String, TrackerEntry>();
+
+    public JingleTrackerIQ() {
+        this.setType(Type.GET);
+        this.setPacketID(IQ.nextID());
+    }
+
+    public boolean isRequest() {
+        return Type.GET.equals(this.getType());
+    }
+
+    public void addEntry(final TrackerEntry entry) {
+        entries.put(entry.getJid(), entry);
+    }
+
+    public void removeEntry(final TrackerEntry entry) {
+        entries.remove(entry.getJid());
+    }
+
+    public String getChildElementXML() {
+        final StringBuilder str = new StringBuilder();
+
+        str.append("<").append(NAME).append(" xmlns='").append(NAMESPACE).append("'>");
+        for (final TrackerEntry entry : entries.values()) {
+            str.append("<").append(entry.getType().toString());
+            str.append(" policy='").append(entry.getPolicy().toString()).append("'");
+            str.append(" address='").append(entry.getJid()).append("'");
+            str.append(" protocol='").append(entry.getProtocol()).append("'");
+            if (entry.isVerified()) {
+                str.append(" verified='").append(entry.isVerified()).append("'");
+            }
+            str.append("/>");
+        }
+        str.append("</").append(NAME).append(">");
+
+        return str.toString();
+    }
+
+    public Collection<TrackerEntry> getEntries() {
+        return entries.values();
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/smack/JingleTrackerProvider.java

+package org.xmpp.jnodes.smack;
+
+import org.jivesoftware.smack.provider.IQProvider;
+import org.xmlpull.v1.XmlPullParser;
+
+public class JingleTrackerProvider implements IQProvider {
+
+    public JingleTrackerIQ parseIQ(final XmlPullParser parser) throws Exception {
+
+        JingleTrackerIQ iq = new JingleTrackerIQ();
+
+        boolean done = false;
+        int eventType;
+        String elementName;
+
+        while (!done) {
+
+            eventType = parser.getEventType();
+            elementName = parser.getName();
+
+            if (eventType == XmlPullParser.START_TAG) {
+                final TrackerEntry.Type type;
+                if (elementName.equals(TrackerEntry.Type.relay.toString())) {
+                    type = TrackerEntry.Type.relay;
+                } else if (elementName.equals(TrackerEntry.Type.tracker.toString())) {
+                    type = TrackerEntry.Type.tracker;
+                } else {
+                    parser.next();
+                    continue;
+                }
+
+                final String protocol = parser.getAttributeValue(null, "protocol");
+                final TrackerEntry.Policy policy = TrackerEntry.Policy.valueOf("_" + parser.getAttributeValue(null, "policy"));
+                final String address = parser.getAttributeValue(null, "address");
+                final String verified = parser.getAttributeValue(null, "verified");
+
+                if (address != null && address.length() > 0) {
+                    final TrackerEntry entry = new TrackerEntry(type, policy, address, protocol);
+                    if (verified != null && verified.equals("true")) {
+                        entry.setVerified(true);
+                    }
+                    iq.addEntry(entry);
+                }
+
+            } else if (eventType == XmlPullParser.END_TAG) {
+                if (elementName.equals(JingleTrackerIQ.NAME)) {
+                    done = true;
+                }
+            }
+            if (!done) {
+                parser.next();
+            }
+        }
+
+        return iq;
+    }
+}

src/plugins/jingleNodes/src/java/org/xmpp/jnodes/smack/TrackerEntry.java

+package org.xmpp.jnodes.smack;
+
+public class TrackerEntry {
+
+    public enum Type {
+        relay, tracker
+    }
+
+    public enum Policy {
+        _public, _roster;
+
+        public String toString() {
+            return this.name().substring(1);
+        }
+    }
+
+    private Type type;
+    private Policy policy;
+    private boolean verified = false;
+    private String protocol = JingleChannelIQ.UDP;
+    private String jid;
+
+    public TrackerEntry(final Type type, final Policy policy, final String jid, final String protocol) {
+        this.type = type;
+        this.policy = policy;
+        this.jid = jid;
+        this.protocol = protocol;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public void setType(Type type) {
+        this.type = type;
+    }
+
+    public String getJid() {
+        return jid;
+    }
+
+    public void setJid(String jid) {
+        this.jid = jid;
+    }
+
+    public boolean isVerified() {
+        return verified;
+    }
+
+    public void setVerified(boolean verified) {
+        this.verified = verified;
+    }
+
+    public Policy getPolicy() {
+        return policy;
+    }
+
+    public void setPolicy(Policy policy) {
+        this.policy = policy;
+    }
+
+    public String getProtocol() {
+        return protocol;
+    }
+
+    public void setProtocol(String protocol) {
+        this.protocol = protocol;
+    }
+}

src/plugins/ofmeet/changelog.html

@@ -49,6 +49,12 @@
     Openfire Meetings Plugin Changelog
 </h1>
 
+<p><b>0.1.6</b> -- May 9th, 2015</p>
+
+<ul>
+    <li>Added support for media relaying using the JingleNodes plugin</li>
+</ul>
+
 <p><b>0.1.5</b> -- May 4th, 2015</p>
 
 <ul>

src/plugins/ofmeet/plugin.xml

@@ -5,8 +5,8 @@
     <name>Openfire Meetings</name>
     <description>Provides high quality, scalable video conferences using Jitsi Meet and Jitsi Videobridge</description>
     <author>Ignite Realtime</author>
-    <version>0.1.5</version>
-    <date>05/04/2015</date>
+    <version>0.1.6</version>
+    <date>05/09/2015</date>
     <minServerVersion>3.9.9</minServerVersion>
     
     <adminconsole>

src/plugins/ofmeet/readme.html

@@ -75,8 +75,12 @@
 	<p><span>Spark Plugin - </span>https://your-server.com:7443/ofmeet/spark/ofmeet-plugin.jar</p>
 	<p>Candy - https://your-server.com:7443/ofmeet/candy.html</p>
 	<p style="min-height: 8pt; padding: 0px;">&nbsp;</p><p><a href="https://community.igniterealtime.org/servlet/JiveServlet/showImage/38-1730-22278/ofmeet5.png"><img alt="ofmeet5.png" height="93" src="https://community.igniterealtime.org/servlet/JiveServlet/downloadImage/38-1730-22278/ofmeet5.png" style="height: auto;" width="300"/></a></p>
+</div>
+<div>
+	<p>It also has a meeting planner feature that enables you to schedule meetings in advance using a calendar.When you add a meeting to the calendar, a request to join the meeting is automatically generated and sent to each participant using Openfire's email service 15 mins before the meeting starts. Included in the email is a link to join the meeting from a Chrome web browser.</p><p><a href="https://community.igniterealtime.org/servlet/JiveServlet/showImage/38-1762-66498/Image2.jpg"><img alt="Image2.jpg" height="215" src="https://community.igniterealtime.org/servlet/JiveServlet/downloadImage/38-1762-66498/379-215/Image2.jpg" style="width:379px; height: 215.108108108108px;" width="379"></a><a href="https://community.igniterealtime.org/servlet/JiveServlet/showImage/38-1762-66502/Image5.jpg"><img alt="Image5.jpg" height="175" src="https://community.igniterealtime.org/servlet/JiveServlet/downloadImage/38-1762-66502/212-175/Image5.jpg" style="width:212px; height: 174.9px;" width="212"></a></p><p>In order to use this feature, you will need:<br><br></p><ul><li>Registered Openfire users with valid email address,</li><li>A persistent MUC room to host each planned meeting</li><li>The Openfire ClientControl plugin installed to create a room bookmark that links the room to users or user groups. Bookmarks with all users selected are ignored.<br><a href="https://community.igniterealtime.org/servlet/JiveServlet/showImage/38-1762-66501/Image6.jpg"><img alt="Image6.jpg"  height="210" src="https://community.igniterealtime.org/servlet/JiveServlet/downloadImage/38-1762-66501/375-210/Image6.jpg" style="width:375px; height: 209.879032258065px;" width="375"></a></li><li>The Openfire Email Service configured to deliver emails<br><a href="https://community.igniterealtime.org/servlet/JiveServlet/showImage/38-1762-66500/Image4.jpg"><img alt="Image4.jpg" height="408" src="https://community.igniterealtime.org/servlet/JiveServlet/downloadImage/38-1762-66500/Image4.jpg" style="width: 620px; height: 209px;" width="1210"></a></li></ul><p>The calendar is implemented using the excellent open source <a href="http://fullcalendar.io/" rel="nofollow" target="_blank">fullcalendar</a> jquery plugin by Adam Shaw.</p>
+</div>
 	<p>Discussion place is in the <a href="https://community.igniterealtime.org/community/plugins/commplugins/openfire-meetings/activity">community plugins, here</a></p>
+<div>
 </div>
-
 </body>
 </html>

src/plugins/ofmeet/src/inum/att.phonenumber.js

+/*global io MediaServices Phono*/
+(function () {
+    // Utils and references
+    var root = this,
+        att = {};
+
+    // global utils
+    var _ = att.util = {
+        _uuidCounter: 0,
+        uuid: function () {
+            return Math.random().toString(16).substring(2) + (_._uuidCounter++).toString(16);
+        },
+        slice: Array.prototype.slice,
+        isFunc: function (obj) {
+            return Object.prototype.toString.call(obj) == '[object Function]';
+        },
+        extend: function (obj) {
+            this.slice.call(arguments, 1).forEach(function (source) {
+                if (source) {
+                    for (var prop in source) {
+                        obj[prop] = source[prop];
+                    }
+                }
+            });
+            return obj;
+        },
+        each: function (obj, func) {
+            if (!obj) return;
+            if (obj instanceof Array) {
+                obj.forEach(func);
+            } else {
+                for (var key in obj) {
+                    func(key, obj[key]);
+                }
+            }
+        },
+        getQueryParam: function (name) {
+            // query string parser
+            var cleaned = name.replace(/[\[]/, "\\[").replace(/[\]]/, "\\]"),
+                regexS = "[\\?&]" + cleaned + "=([^&#]*)",
+                regex = new RegExp(regexS),
+                results = regex.exec(window.location.search);
+            return (results) ? decodeURIComponent(results[1].replace(/\+/g, " ")) : undefined;
+        },
+        // used to try to determine whether they're using the ericsson leif browser
+        // this is not an ideal way to check, but I'm not sure how to do it since
+        // leif if pretty much just stock chromium.
+        h2sSupport: function () {
+            return !!window.webkitPeerConnection00 && window.navigator.userAgent.indexOf('Chrome/24') !== -1;
+        }
+    };
+
+    var phoneNumber = {};
+    
+    phoneNumber.stringify = function (text) {
+        // strip all non numbers
+        var cleaned = phoneNumber.parse(text),
+            len = cleaned.length,
+            countryCode = (cleaned.charAt(0) === '1'),
+            arr = cleaned.split(''),
+            diff;
+    
+        // if it's long just return it unformatted
+        if (len > (countryCode ? 11 : 10)) return cleaned;
+    
+        // if it's too short to tell
+        if (!countryCode && len < 4) return cleaned;
+    
+        // remove country code if we have it
+        if (countryCode) arr.splice(0, 1);
+    
+        // the rules are different enough when we have
+        // country codes so we just split it out
+        if (countryCode) {
+            if (len > 1) {
+                diff = 4 - len;
+                diff = (diff > 0) ? diff : 0;
+                arr.splice(0, 0, " (");
+                // back fill with spaces
+                arr.splice(4, 0, (new Array(diff + 1).join(' ') + ") "));
+                
+                if (len > 7) {
+                    arr.splice(8, 0, '-');
+                }
+            }
+        } else {
+            if (len > 7) {
+                arr.splice(0, 0, "(");
+                arr.splice(4, 0, ") ");
+                arr.splice(8, 0, "-");
+            } else if (len > 3) {
+                arr.splice(3, 0, "-");
+            }
+        }
+    
+        // join it back when we're done with the CC if it's there
+        return (countryCode ? '1' : '') + arr.join('');
+    };
+    
+    phoneNumber.parse = function (input) {
+        return String(input)
+            .toUpperCase()
+            .replace(/[A-Z]/g, function (l) {
+                return (l.charCodeAt(0) - 65) / 3 + 2 - ("SVYZ".indexOf(l) > -1) | 0;
+            })
+            .replace(/\D/g, '');
+    };
+    
+    phoneNumber.getCallable = function (input, countryAbr) {
+        var country = countryAbr || 'us',
+            cleaned = phoneNumber.parse(input);
+        if (cleaned.length === 10) {
+            if (country == 'us') {
+                return '1' + cleaned;
+            }
+        } else if (country == 'us' && cleaned.length === 11 && cleaned.charAt(0) === '1') {
+            return cleaned;
+        } else {
+            return false;
+        }
+    };
+    
+    att.phoneNumber = phoneNumber;
+
+
+
+
+    // attach to window or export with commonJS
+    if (typeof exports !== 'undefined') {
+        module.exports = att;
+    } else {
+        // make sure we've got an "att" global
+        root.ATT || (root.ATT = {});
+        _.extend(root.ATT, att);
+    }
+
+}).call(this);

src/plugins/ofmeet/src/inum/index.html

+<html>
+<head>
+	<title>iNum Demo Application</title>
+	<link rel="import" href="ui-telephone.html"></link>
+    <script src="../chrome-extension/ofmeet-api.js"></script>
+	<script type="text/javascript" src="index.js"></script>
+	<style>
+      html, body {
+        height: 100%;
+        margin: 0;
+		background: #f0f0f0;
+        font-family: sans-serif;
+      }
+
+      inum-telephone {
+        height: 100%;
+        display: none;
+      }
+	</style>
+</head>
+<body>
+  	<h1 id='pleasewait'>Please Wait...</h1>
+	<inum-telephone id="telephone1"></inum-telephone>
+</body>
+</html>
\ No newline at end of file

src/plugins/ofmeet/src/inum/index.js

+
+var dialer = null;
+var offHook = false;
+var conn = null;
+var audioChannelId = null;
+var mixerId = null;
+var cleared = false;
+var ringtone = null;
+var domain = urlParam("domain");
+var username = urlParam("username");
+var password = urlParam("password");
+
+window.addEventListener("unload", function () 
+{
+	if (conn && mixerId && audioChannelId) conn.inum.expireWebrtcDevice(mixerId, audioChannelId);
+	if (conn) conn.disconnect();
+});
+                
+window.addEventListener("load", function()
+{
+	dialer = document.querySelector("inum-telephone");
+
+	dialer.addEventListener('Telephone.Dialer.Button', function (event)
+	{
+		//console.log("Telephone.Dialer.Button", event, dialer);
+
+		if (event.detail.label == "Call")
+			telephoneAction({action: "dial", destination: event.detail.number});
+
+		else if (dialer.call) {
+			telephoneAction({action: "hangup", call_id: dialer.call.id});
+		}
+	});
+
+	dialer.addEventListener('Telephone.Dialer.Number', function (event)
+	{
+		console.log("Telephone.Dialer.Number", event);
+		//telephoneAction({action: "dial", call_id: event.detail.number});						
+	});
+
+	dialer.addEventListener('Telephone.Dialer.Press', function (event)
+	{
+		//console.log("Telephone.Dialer.Press", event);	
+	});
+
+	dialer.addEventListener('Telephone.Dialer.Action', function (event)
+	{
+		console.log("Telephone.Dialer.Action", event);
+
+		if (event.detail.action == 'end') 	telephoneAction({action: "hangup", call_id: event.detail.call.id});
+		if (event.detail.action == 'hold') 	telephoneAction({action: "hold", call_id: event.detail.call.id});
+		if (event.detail.action == 'unhold') 	telephoneAction({action: "join", mixer: event.detail.call.mixer});
+				
+		if ("#*0123456789".indexOf(event.detail.action) > -1)
+		{
+			telephoneAction({action: "dtmf", tone: event.detail.action});
+		}		
+	});
+	
+	$(document).bind('ofmeet.connected', function (event, connection)
+	{
+		console.log("ofmeet connected", connection);
+		
+		ofmeet.visible(false);		
+		connection.inum.createWebrtcDevice();
+		conn = connection;
+	});
+	
+	$(document).bind('inum.offered', function (event, confId, audioId)
+	{
+		console.log("inum.offered", confId, audioId);
+		audioChannelId = audioId;
+		mixerId = confId;
+		
+		$("inum-telephone").css("display", "block");
+		$('#pleasewait').css("display", "none");
+	});
+
+	$(document).bind('inum.streamadded', function (event, confId, audioId, data)
+	{
+		console.log("inum.streamadded", confId, audioId, data);
+	});
+
+	$(document).bind('inum.delivered', function (event, confId, audioId)
+	{
+		console.log("inum.delivered", confId, audioId);
+	});
+	
+	$(document).bind('inum.cleared', function(event, callId)
+	{
+		console.log("inum.cleared", callId);	
+	});	
+
+	$(document).bind('inum.dialled', function (event, confId, to, callId)
+	{
+		console.log("inum.dialled", confId, to, callId);
+		
+		dialer.call = {id: callId, mixer: confId, to: to}		
+		dialer.setLabel("Hangup");
+	});
+
+
+	$(document).bind('inum.answered', function(event, callId, callerId, calledId)
+	{
+		console.log("inum.answered", callId, callerId, calledId);
+		dialer.setState("active");
+		stopTone();
+	});
+	
+	
+	$(document).bind('inum.hangup', function(event, callId, callerId, calledId)
+	{
+		console.log("inum.hangup", callId, callerId, calledId);
+		
+		dialer.setLabel("Call");
+		dialer.setState("inactive");				
+		dialer.call = null
+		stopTone();		
+	});
+
+
+	$(document).bind('ofmeet.ready', function ()
+	{
+		console.log("ofmeet.ready");
+		ofmeet.connect();
+	});	
+		
+	ofmeet.ready(username, password);	
+})
+
+
+function urlParam(name)
+{
+	var results = new RegExp('[\\?&]' + name + '=([^&#]*)').exec(window.location.href);
+	if (!results) { return undefined; }
+	return unescape(results[1] || undefined);
+};
+
+function telephoneAction(request)
+{
+	console.log("telephoneAction", request);
+	
+	if (request.action == "dial")
+	{
+		conn.inum.dial(mixerId, domain ? "sip:" + request.destination + "@" + domain : request.destination);
+		startTone("ringback-uk");
+	}
+	
+	if (request.action == "hangup")
+	{
+		conn.inum.hangup(request.call_id);	
+		stopTone();
+	}
+	
+	if (request.action == "dtmf") conn.inum.sendTones(request.tone);		
+}
+
+function startTone(name)
+{
+	if (!ringtone)
+	{
+		ringtone = new Audio();
+		ringtone.loop = true;
+		ringtone.src = "ringtones/" + name + ".mp3";
+		ringtone.play();
+	}
+}
+
+function stopTone()
+{
+	if (ringtone)
+	{
+		ringtone.pause();
+		ringtone = null;
+	}
+}

src/plugins/ofmeet/src/inum/ui-telephone.js

+(function () {
+	var importDoc = document.currentScript.ownerDocument;
+	var proto = Object.create( HTMLElement.prototype );
+	var phoney = window.ATT && window.ATT.phoneNumber || window.phoney;
+		
+	proto.createdCallback = function() {
+		var that = this;
+		var template = importDoc.querySelector('#dialerTemplate');		
+		this.readAttributes();
+
+		this.shadow = this.createShadowRoot();
+		this.shadow.appendChild(template.content.cloneNode(true));
+		
+		this.addClickHandlers();
+		this.number = '';
+		this.numberField = this.shadow.querySelector('.numberEntry');
+		this.callStatus = this.shadow.querySelector('#callStatus');
+		this.dialpad = this.shadow.querySelector('#screen');
+		
+		
+	    	this.button = this.shadow.querySelector('.call');  		
+
+		this.boundKeyHandler = function () 
+		{
+			that.handleKeyDown.apply(that, arguments);
+		};		
+    		document.addEventListener('keydown', this.boundKeyHandler, true);  		
+	};
+
+	proto.readAttributes = function() {
+
+	};
+
+	proto.attributeChangedCallback = function( attrName, oldVal, newVal ) {
+
+	};
+
+	proto.addClickHandlers = function () 
+	{
+	    var self = this;
+	    var buttons = this.shadow.querySelectorAll('button');
+	    var callButton = this.shadow.querySelector('.call');   
+
+	    Array.prototype.forEach.call(buttons, function (button) 
+	    {
+	      	button.addEventListener('click', function (e) 
+	      	{
+			var data = this.attributes['data-value'];
+			var value = data && data.nodeValue;
+
+			if (value)
+			{
+				if (value == 'del') {
+				  	self.removeLastNumber();
+				  	
+				} else if (self.call) {
+										
+					var myEvent = new CustomEvent("Telephone.Dialer.Action", {detail: {action: value, call: self.call}});
+					self.dispatchEvent(myEvent);					
+				
+				} else {
+				  	self.addNumber(value);
+				}
+			}
+			return false;
+	      }, true);
+	    });
+
+	    if (callButton) 
+	    {
+	      callButton.addEventListener('click', function () 
+	      {
+		var myEvent = new CustomEvent("Telephone.Dialer.Button", {detail: {number: self.getNumber(), label: callButton.innerHTML}});
+		self.dispatchEvent(myEvent);
+		
+	      }, false);
+	    }
+	};
+
+	proto.getNumber = function () 
+	{
+		return this.number;
+	};
+
+	proto.getLabel = function () 
+	{
+	    	return this.button.innerHTML;
+	};
+	
+	proto.setLabel = function (label) 
+	{
+	    	this.button.innerHTML = label
+	};	
+
+	proto.setNumber = function (number) 
+	{
+		var newNumber = phoney.parse(number);
+		var oldNumber = this.number;
+		var callable = phoney.getCallable(newNumber);
+		
+		this.number = newNumber;
+		this.numberField.innerHTML = phoney.stringify(this.number); 
+		
+		if (callable) 
+		{
+			var myEvent = new CustomEvent("Telephone.Dialer.Number", {detail: {number: callable}});
+			this.dispatchEvent(myEvent);
+		}
+	};
+
+	proto.clear = function () 
+	{
+		this.setNumber('');
+	};
+	
+	proto.addNumber = function (number) 
+	{
+		var newNumber = (this.getNumber() + '') + number;
+		var myEvent = new CustomEvent("Telephone.Dialer.Press", {detail: {number: number}});
+		this.dispatchEvent(myEvent);
+		this.setNumber(newNumber);
+	};
+
+	proto.removeLastNumber = function () 
+	{
+		this.setNumber(this.getNumber().slice(0, -1));
+	};
+
+    	proto.handleKeyDown = function(e)
+    	{
+	    var number, keyCode = e.which;
+
+	    if (keyCode >= 48 && keyCode <= 57) {
+	      number = keyCode - 48;
+	      this.addNumber(number + '');
+	    }
+
+	    if (keyCode === 8) {
+	      this.removeLastNumber();
+	      e.preventDefault();
+	    }
+
+	    if (keyCode === 13) {
+		var myEvent = new CustomEvent("Telephone.Dialer.Number", {detail: {number: this.getNumber()}});
+		this.dispatchEvent(myEvent);
+	    }    	
+    	}		
+
+	proto.startTimer = function () 
+	{
+		this.timerStartTime = Date.now();
+		this.timerStopped = false;
+		this.updateTimer();
+		return this;
+	};
+
+	proto.stopTimer = function () {
+		this.timerStopped = true;
+		return this;
+	};
+
+	proto.resetTimer = function () {
+		this.timerStopped = true;
+		this.setTimeInDom('0:00:00');
+		return this;
+	};
+
+	proto.updateTimer = function () 
+	{
+		if (this.timerStopped) return;
+
+		var diff = Date.now() - this.timerStartTime,
+		s = Math.floor(diff / 1000) % 60,
+		min = Math.floor((diff / 1000) / 60) % 60,
+		hr = Math.floor(((diff / 1000) / 60) / 60) % 60,
+		time = [hr, this.zeroPad(min), this.zeroPad(s)].join(':');
+
+		if (this.time !== time) {
+			this.time = time;
+			this.setTimeInDom(time);
+		}
+
+		setTimeout(this.updateTimer.bind(this), 100);
+	};
+
+	proto.setTimeInDom = function (timeString) {
+		if (!this.shadow) return;
+		this.shadow.querySelector('.callTime').innerHTML = timeString;
+	};
+
+	proto.zeroPad = function (num) {
+		return ((num + '').length === 1) ? '0' + num : num;
+	};
+	
+	proto.setState = function (state, number) 
+	{
+		var noRender = false;
+		var timer = false;
+		var self = this;
+		
+		this.shadow.querySelector('.callerNumber').innerHTML = number ? number : this.getNumber();			
+		
+		this.shadow.querySelector('button.end').classList.add('hidden');
+		this.shadow.querySelector('button.hold').classList.add('hidden');			
+		this.shadow.querySelector('button.unhold').classList.add('hidden');
+		
+		this.callStatus.classList.remove("active");
+		this.callStatus.classList.remove("inactive");		
+		this.callStatus.classList.remove("held");
+		this.callStatus.classList.remove("ending");		
+		
+		this.callStatus.classList.add(state);		
+
+		if (state == "active")
+		{
+			noRender = false;
+			timer = true;
+			this.shadow.querySelector('button.end').classList.remove('hidden');
+			this.shadow.querySelector('button.hold').classList.remove('hidden');						
+		}
+		
+		if (state == "held")
+		{
+			noRender = false;
+			timer = true;
+			this.shadow.querySelector('button.unhold').classList.remove('hidden');						
+		}
+		
+		if (state == "inactive")
+		{
+			noRender = true;
+			timer = false;			
+		}		
+		
+		if (noRender)
+		{
+			this.stopTimer();
+			this.callStatus.classList.add('ending');
+			
+			setTimeout(function () 
+			{
+				self.callStatus.classList.remove('visible');
+
+				setTimeout(function () 
+				{
+					self.callStatus.classList.remove('visible');
+					self.dialpad.classList.remove('candybarVisible');
+					//self.clearUser();
+				}, 1000);
+			}, 1000);
+			
+		} else {
+			this.callStatus.classList.add('visible');
+			this.dialpad.classList.add('candybarVisible');			
+			if (timer) this.startTimer(); 				
+		}		
+		      
+	}	
+	
+	document.registerElement( "inum-telephone", {
+		prototype: proto
+	});
+})(window);
\ No newline at end of file

src/plugins/ofmeet/src/libs/strophe/strophe.jingle.adapter.js

@@ -578,7 +578,7 @@ function setupRTC() {
             browser: 'chrome',
             getUserMedia: navigator.webkitGetUserMedia.bind(navigator),
             attachMediaStream: function (element, stream) {
-                element.attr('src', webkitURL.createObjectURL(stream));
+                element.attr('src', URL.createObjectURL(stream));
             },
             // DTLS should now be enabled by default but..
             pc_constraints: {'optional': [{'DtlsSrtpKeyAgreement': 'true'}]},

src/plugins/ofmeet/src/libs/strophe/strophe.jingle.js

@@ -3,7 +3,7 @@ Strophe.addConnectionPlugin('jingle', {
     connection: null,
     sessions: {},
     jid2session: {},
-    ice_config: {iceServers: []},
+    ice_config: config.iceServers ? config.iceServers : {'iceServers': [{ 'url': 'stun:stun.l.google.com:19302' }]},
     pc_constraints: {},
     media_constraints: {
         mandatory: {

src/plugins/ofmeet/src/libs/strophe/strophe.jingle.session.js

@@ -34,6 +34,10 @@ function JingleSession(me, sid, connection) {
     this.statsinterval = null;
 
     this.reason = null;
+    
+    this.relayHost = null;
+    this.relayLocalPort = null;
+    this.relayRemotePort = null;  
 
     this.wait = true;
     this.localStreamsSSRC = null;
@@ -54,6 +58,9 @@ JingleSession.prototype.initiate = function (peerjid, isInitiator) {
     this.hadstuncandidate = false;
     this.hadturncandidate = false;
     this.lasticecandidate = false;
+    this.relayHost = null;
+    this.relayLocalPort = null;
+    this.relayRemotePort = null;     
 
     this.peerconnection
         = new TraceablePeerConnection(
@@ -215,6 +222,7 @@ JingleSession.prototype.sendIceCandidate = function (candidate) {
                     // start 20ms callout
                     window.setTimeout(function () {
                         if (self.drip_container.length === 0) return;
+    			//console.log('sendIceCandidates timeout', self.usetrickle, self.usedrip, self.drip_container);                        
                         self.sendIceCandidates(self.drip_container);
                         self.drip_container = [];
                     }, 20);
@@ -223,7 +231,8 @@ JingleSession.prototype.sendIceCandidate = function (candidate) {
                 this.drip_container.push(candidate);
                 return;
             } else {
-                self.sendIceCandidate([candidate]);
+    		//console.log('sendIceCandidates single', self.usetrickle, self.usedrip, candidate);                 
+                self.sendIceCandidates([candidate]);
             }
         }
     } else {
@@ -286,6 +295,8 @@ JingleSession.prototype.sendIceCandidate = function (candidate) {
 
 JingleSession.prototype.sendIceCandidates = function (candidates) {
     console.log('sendIceCandidates', candidates);
+    var self = this; 
+    var relayDone = false;
     var cand = $iq({to: this.peerjid, type: 'set'})
         .c('jingle', {xmlns: 'urn:xmpp:jingle:1',
             action: 'transport-info',
@@ -301,8 +312,39 @@ JingleSession.prototype.sendIceCandidates = function (candidates) {
                 name: (cands[0].sdpMid? cands[0].sdpMid : mline.media)
             }).c('transport', ice);
             for (var i = 0; i < cands.length; i++) {
-                cand.c('candidate', SDPUtil.candidateToJingle(cands[i].candidate)).up();
+               cand.c('candidate', SDPUtil.candidateToJingle(cands[i].candidate)).up();
             }
+            
+            if (!self.relayDone)
+            {
+    		    console.log('sendIceCandidates: send jingle nodes request');            
+		    var iqRelay = $iq({type: "get", to: "relay." + self.connection.domain}).c('channel', {xmlns: "http://jabber.org/protocol/jinglenodes#channel", protocol: 'udp'});
+
+		    self.connection.sendIQ(iqRelay, function(response)
+		    {
+			if ($(response).attr('type') == "result")
+			{
+    		    		console.log('sendIceCandidates: jingle nodes response', response);  
+    		    		self.hadturncandidate = true;
+    		    		
+				$(response).find('channel').each(function() 
+				{
+					self.relayHost = $(this).attr('host');
+					self.relayLocalPort = $(this).attr('localport');
+					self.relayRemotePort = $(this).attr('remoteport');
+
+					var relayCandidate = "a=candidate:3707591233 1 udp 2113937151 " + self.relayHost + " " + self.relayRemotePort + " typ relay generation 0 ";
+
+					console.log("add JingleNodes candidate: " + self.relayHost + " " + self.relayLocalPort + " " + self.relayRemotePort); 
+					cand.c('candidate', SDPUtil.candidateToJingle(relayCandidate)).up();
+				});
+
+			}		
+		    }, function(err) {console.error("jingle nodes request error", err)});
+		    
+		    relayDone = true;		    
+	    }
+            
             // add fingerprint
             if (SDPUtil.find_line(this.localSDP.media[mid], 'a=fingerprint:', this.localSDP.session)) {
                 var tmp = SDPUtil.parse_fingerprint(SDPUtil.find_line(this.localSDP.media[mid], 'a=fingerprint:', this.localSDP.session));
@@ -318,6 +360,7 @@ JingleSession.prototype.sendIceCandidates = function (candidates) {
             cand.up(); // transport
             cand.up(); // content
         }
+	self.relayDone = relayDone;        
     }
     // might merge last-candidate notification into this, but it is called alot later. See webrtc issue #2340
     //console.log('was this the last candidate', this.lasticecandidate);
@@ -443,6 +486,13 @@ JingleSession.prototype.setRemoteDescription = function (elem, desctype) {
             this.remoteSDP.raw = this.remoteSDP.session + this.remoteSDP.media.join('');
         }
     }
+    
+    if (this.relayHost != null && this.relayLocalPort != null)
+    {
+	var candidate = new RTCIceCandidate({sdpMLineIndex: "0", candidate: "a=candidate:3707591233 1 udp 2113937151 " + this.relayHost + " " + this.relayLocalPort + " typ relay generation 0 "});
+	this.peerconnection.addIceCandidate(candidate);  
+	this.hadturncandidate = true;
+    }
     var remotedesc = new RTCSessionDescription({type: desctype, sdp: this.remoteSDP.raw});
 
     this.peerconnection.setRemoteDescription(remotedesc,