diff --git a/src/main/java/org/ice4j/ice/harvest/AbstractUdpListener.java b/src/main/java/org/ice4j/ice/harvest/AbstractUdpListener.java
new file mode 100644
index 0000000..8145fe1
--- /dev/null
+++ b/src/main/java/org/ice4j/ice/harvest/AbstractUdpListener.java
@@ -0,0 +1,625 @@
+/*
+ * ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
+ *
+ * Copyright @ 2015 Atlassian Pty Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.ice4j.ice.harvest;
+
+import org.ice4j.*;
+import org.ice4j.attribute.*;
+import org.ice4j.ice.*;
+import org.ice4j.message.*;
+import org.ice4j.socket.*;
+import org.ice4j.stack.*;
+import org.ice4j.util.*;
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.logging.*;
+import java.util.logging.Logger;
+
+/**
+ * A class which holds a {@link DatagramSocket} and runs a thread
+ * ({@link #thread}) which perpetually reads from it.
+ *
+ * When a datagram from an unknown source is received, it is parsed as a STUN
+ * Binding Request, and if it has a USERNAME attribute, its ufrag is extracted.
+ * At this point, an implementing class may choose to create a mapping for
+ * the remote address of the datagram, which will be used for further packets
+ * from this address.
+ *
+ * @author Boris Grozev
+ */
+public abstract class AbstractUdpListener
+{
+ /**
+ * Our class logger.
+ */
+ private static final Logger logger
+ = Logger.getLogger(AbstractUdpListener.class.getName());
+
+ /**
+ * The size for newly allocated Buffer instances. This limits the
+ * maximum size of datagrams we can receive.
+ *
+ * XXX should we increase this in case of other MTUs, or set it dynamically
+ * according to the available network interfaces?
+ */
+ private static final int BUFFER_SIZE
+ = /* assumed MTU */ 1500 - /* IPv4 header */ 20 - /* UDP header */ 8;
+
+ /**
+ * The number of Buffer instances to keep in {@link #pool}.
+ */
+ private static final int POOL_SIZE = 256;
+
+ /**
+ * Returns the list of {@link TransportAddress}es, one for each allowed IP
+ * address found on each allowed network interface, with the given port.
+ *
+ * @param port the UDP port number.
+ * @return the list of allowed transport addresses.
+ */
+ public static List getAllowedAddresses(int port)
+ {
+ List addresses = new LinkedList<>();
+ boolean isIPv6Disabled = StackProperties.getBoolean(
+ StackProperties.DISABLE_IPv6,
+ false);
+ boolean isIPv6LinkLocalDisabled = StackProperties.getBoolean(
+ StackProperties.DISABLE_LINK_LOCAL_ADDRESSES,
+ false);
+
+ try
+ {
+ for (NetworkInterface iface
+ : Collections.list(NetworkInterface.getNetworkInterfaces()))
+ {
+ if (NetworkUtils.isInterfaceLoopback(iface)
+ || !NetworkUtils.isInterfaceUp(iface)
+ || !HostCandidateHarvester.isInterfaceAllowed(iface))
+ {
+ continue;
+ }
+
+ Enumeration ifaceAddresses
+ = iface.getInetAddresses();
+ while (ifaceAddresses.hasMoreElements())
+ {
+ InetAddress address = ifaceAddresses.nextElement();
+
+ if (!HostCandidateHarvester.isAddressAllowed(address))
+ continue;
+
+ if (isIPv6Disabled && address instanceof Inet6Address)
+ continue;
+ if (isIPv6LinkLocalDisabled
+ && address instanceof Inet6Address
+ && address.isLinkLocalAddress())
+ continue;
+
+ addresses.add(
+ new TransportAddress(address, port, Transport.UDP));
+ }
+ }
+ }
+ catch (SocketException se)
+ {
+ logger.info("Failed to get network interfaces: " + se);
+ }
+
+ return addresses;
+ }
+
+ /**
+ * The map which keeps the known remote addresses and their associated
+ * candidateSockets.
+ * {@link #thread} is the only thread which adds new entries, while
+ * other threads remove entries when candidates are freed.
+ */
+ private final Map sockets
+ = new ConcurrentHashMap<>();
+
+ /**
+ * A pool of Buffer instances used to avoid creating of new java
+ * objects.
+ */
+ private final ArrayBlockingQueue pool
+ = new ArrayBlockingQueue<>(POOL_SIZE);
+
+ /**
+ * The local address that this harvester is bound to.
+ */
+ protected final TransportAddress localAddress;
+
+ /**
+ * The "main" socket that this harvester reads from.
+ */
+ private final DatagramSocket socket;
+
+ /**
+ * The thread reading from {@link #socket}.
+ */
+ private final Thread thread;
+
+ /**
+ * Initializes a new SinglePortUdpHarvester instance which is to
+ * bind on the specified local address.
+ * @param localAddress the address to bind to.
+ * @throws IOException if initialization fails.
+ */
+ protected AbstractUdpListener(TransportAddress localAddress)
+ throws IOException
+ {
+ this.localAddress = localAddress;
+ this.socket = new DatagramSocket(localAddress);
+
+ thread = new Thread()
+ {
+ @Override
+ public void run()
+ {
+ AbstractUdpListener.this.runInHarvesterThread();
+ }
+ };
+
+ thread.setName(AbstractUdpListener.class.getName() + " thread for "
+ + localAddress);
+ thread.setDaemon(true);
+ thread.start();
+ }
+
+ /**
+ * Perpetually reads datagrams from {@link #socket} and handles them
+ * accordingly.
+ *
+ * It is important that this blocks are little as possible (except on
+ * socket.receive(), of course), because it could potentially delay the
+ * reception of both ICE and media packets for the whole application.
+ */
+ private void runInHarvesterThread()
+ {
+ Buffer buf;
+ DatagramPacket pkt = null;
+ MySocket destinationSocket;
+ InetSocketAddress remoteAddress;
+
+ do
+ {
+ // TODO: implement stopping the thread with a switch?
+
+ buf = getFreeBuffer();
+
+ if (pkt == null)
+ pkt = new DatagramPacket(buf.buffer, 0, buf.buffer.length);
+ else
+ pkt.setData(buf.buffer, 0, buf.buffer.length);
+
+ try
+ {
+ socket.receive(pkt);
+ }
+ catch (IOException ioe)
+ {
+ logger.severe("Failed to receive from socket: " + ioe);
+ break;
+ }
+ buf.len = pkt.getLength();
+
+
+ remoteAddress = (InetSocketAddress) pkt.getSocketAddress();
+ destinationSocket = sockets.get(remoteAddress);
+ if (destinationSocket != null)
+ {
+ //make 'pkt' available for reading through destinationSocket
+ destinationSocket.addBuffer(buf);
+ }
+ else
+ {
+ // Packet from an unknown source. Is it a STUN Binding Request?
+ String ufrag = getUfrag(buf.buffer, 0, buf.len);
+ if (ufrag == null)
+ {
+ // Not a STUN Binding Request or doesn't have a valid
+ // USERNAME attribute. Drop it.
+ continue;
+ }
+
+ maybeAcceptNewSession(buf, remoteAddress, ufrag);
+ // Maybe add to #sockets here in the base class?
+ }
+ }
+ while (true);
+
+ // TODO we are all done, clean up.
+ }
+
+ /**
+ * Handles the reception of a STUN Binding Request with a valid USERNAME
+ * attribute, from a "new" remote address (one which is not in
+ * {@link #sockets}).
+ * Implementations may choose to e.g. create a socket and pass it to their
+ * ICE stack.
+ *
+ * Note that this is meant to only be executed by
+ * {@link AbstractUdpListener}'s read thread, and should not be called from
+ * implementing classes.
+ *
+ * @param buf the UDP payload of the first datagram received on the newly
+ * accepted socket.
+ * @param remoteAddress the remote address from which the datagram was
+ * received.
+ * @param ufrag the local ICE username fragment of the received STUN Binding
+ * Request.
+ */
+ protected abstract void maybeAcceptNewSession(
+ Buffer buf,
+ InetSocketAddress remoteAddress,
+ String ufrag);
+
+ /**
+ * Gets an unused Buffer instance, creating it if necessary.
+ * @return an unused Buffer instance, creating it if necessary.
+ */
+ private Buffer getFreeBuffer()
+ {
+ Buffer buf = pool.poll();
+ if (buf == null)
+ {
+ buf = new Buffer(new byte[BUFFER_SIZE], 0);
+ }
+
+ return buf;
+ }
+
+ /**
+ * Tries to parse the bytes in buf at offset off (and
+ * length len) as a STUN Binding Request message. If successful,
+ * looks for a USERNAME attribute and returns the local username fragment
+ * part (see RFC5245 Section 7.1.2.3).
+ * In case of any failure returns null.
+ *
+ * @param buf the bytes.
+ * @param off the offset.
+ * @param len the length.
+ * @return the local ufrag from the USERNAME attribute of the STUN message
+ * contained in buf, or null.
+ */
+ private String getUfrag(byte[] buf, int off, int len)
+ {
+ // RFC5389, Section 6:
+ // All STUN messages MUST start with a 20-byte header followed by zero
+ // or more Attributes.
+ if (buf == null || buf.length < off + len || len < 20)
+ {
+ return null;
+ }
+
+ // RFC5389, Section 6:
+ // The magic cookie field MUST contain the fixed value 0x2112A442 in
+ // network byte order.
+ if ( !( (buf[off + 4] & 0xFF) == 0x21 &&
+ (buf[off + 5] & 0xFF) == 0x12 &&
+ (buf[off + 6] & 0xFF) == 0xA4 &&
+ (buf[off + 7] & 0xFF) == 0x42))
+ {
+ if (logger.isLoggable(Level.FINE))
+ {
+ logger.fine("Not a STUN packet, magic cookie not found.");
+ }
+ return null;
+ }
+
+ try
+ {
+ Message stunMessage
+ = Message.decode(buf,
+ (char) off,
+ (char) len);
+
+ if (stunMessage.getMessageType()
+ != Message.BINDING_REQUEST)
+ {
+ return null;
+ }
+
+ UsernameAttribute usernameAttribute
+ = (UsernameAttribute)
+ stunMessage.getAttribute(Attribute.USERNAME);
+ if (usernameAttribute == null)
+ return null;
+
+ String usernameString
+ = new String(usernameAttribute.getUsername());
+ return usernameString.split(":")[0];
+ }
+ catch (Exception e)
+ {
+ // Catch everything. We are going to log, and then drop the packet
+ // anyway.
+ if (logger.isLoggable(Level.FINE))
+ {
+ logger.fine("Failed to extract local ufrag: " + e);
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Creates a new {@link MySocket} instance and associates it with the given
+ * remote address. Returns the created instance.
+ *
+ * Note that this is meant to only execute in {@link AbstractUdpListener}'s
+ * read thread.
+ *
+ * @param remoteAddress the remote address with which to associate the new
+ * socket instance.
+ * @return the created socket instance.
+ */
+ protected MySocket addSocket(InetSocketAddress remoteAddress)
+ throws SocketException
+ {
+ MySocket newSocket = new MySocket(remoteAddress);
+ sockets.put(remoteAddress, newSocket);
+ return newSocket;
+ }
+
+
+ /**
+ * Implements a DatagramSocket for the purposes of a specific
+ * MyCandidate.
+ *
+ * It is not bound to a specific port, but shares the same local address
+ * as the bound socket held by the harvester.
+ */
+ protected class MySocket
+ extends DatagramSocket
+ {
+ /**
+ * The size of {@link #queue}.
+ */
+ private static final int QUEUE_SIZE = 128;
+
+ /**
+ * The FIFO which acts as a buffer for this socket.
+ */
+ private final ArrayBlockingQueue queue
+ = new ArrayBlockingQueue<>(QUEUE_SIZE);
+
+ /**
+ * The {@link QueueStatistics} instance optionally used to collect and
+ * print detailed statistics about {@link #queue}.
+ */
+ private final QueueStatistics queueStatistics;
+
+ /**
+ * The remote address that is associated with this socket.
+ */
+ private SocketAddress remoteAddress;
+
+ /**
+ * The flag which indicates that this DatagramSocket has been
+ * closed.
+ */
+ private boolean closed = false;
+
+ /**
+ * Initializes a new MySocket instance with the given
+ * remote address.
+ * @param remoteAddress the remote address to be associated with the
+ * new instance.
+ * @throws SocketException
+ */
+ public MySocket(SocketAddress remoteAddress)
+ throws SocketException
+ {
+ // unbound
+ super((SocketAddress)null);
+
+ this.remoteAddress = remoteAddress;
+ if (logger.isLoggable(Level.FINEST))
+ {
+ queueStatistics = new QueueStatistics(
+ "SinglePort" + remoteAddress.toString().replace('/', '-'));
+ }
+ else
+ {
+ queueStatistics = null;
+ }
+ }
+
+ /**
+ * Adds pkt to this socket. If the queue is full, drops a packet. Does
+ * not block.
+ */
+ protected void addBuffer(Buffer buf)
+ {
+ synchronized (queue)
+ {
+ // Drop the first rather than the current packet, so that
+ // receivers can notice the loss earlier.
+ if (queue.size() == QUEUE_SIZE)
+ {
+ logger.info("Dropping a packet because the queue is full.");
+ if (queueStatistics != null)
+ {
+ queueStatistics.remove(System.currentTimeMillis());
+ }
+ queue.poll();
+ }
+
+ queue.offer(buf);
+ if (queueStatistics != null)
+ {
+ queueStatistics.add(System.currentTimeMillis());
+ }
+
+ queue.notifyAll();
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Delegates to the actual socket of the harvester.
+ */
+ @Override
+ public InetAddress getLocalAddress()
+ {
+ return localAddress.getAddress();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Delegates to the actual socket of the harvester.
+ */
+ @Override
+ public int getLocalPort()
+ {
+ return localAddress.getPort();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Delegates to the actual socket of the harvester.
+ */
+ @Override
+ public SocketAddress getLocalSocketAddress()
+ {
+ return localAddress;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Removes the association of the remote address with this socket from
+ * the harvester's map.
+ */
+ @Override
+ public void close()
+ {
+ closed = true;
+
+ synchronized (queue)
+ {
+ // Wake up any threads still in receive()
+ queue.notifyAll();
+ }
+
+ // We could be called by the super-class constructor, in which
+ // case this.removeAddress is not initialized yet.
+ if (remoteAddress != null)
+ AbstractUdpListener.this.sockets.remove(remoteAddress);
+
+ super.close();
+ }
+
+ /**
+ * Reads the data from the first element of {@link #queue} into
+ * p. Blocks until {@link #queue} has an element.
+ * @param p
+ * @throws IOException
+ */
+ @Override
+ public void receive(DatagramPacket p)
+ throws IOException
+ {
+ Buffer buf = null;
+
+ while (buf == null)
+ {
+ if (closed)
+ throw new SocketException("Socket closed");
+
+ synchronized (queue)
+ {
+ if (queue.isEmpty())
+ {
+ try
+ {
+ queue.wait();
+ }
+ catch (InterruptedException ie)
+ {}
+ }
+
+ buf = queue.poll();
+ if (queueStatistics != null)
+ {
+ queueStatistics.remove(System.currentTimeMillis());
+ }
+ }
+ }
+
+ byte[] pData = p.getData();
+
+ // XXX Should we use p.setData() here with a buffer of our own?
+ if (pData == null || pData.length < buf.len)
+ throw new IOException("packet buffer not available");
+
+ System.arraycopy(buf.buffer, 0, pData, 0, buf.len);
+ p.setLength(buf.len);
+ p.setSocketAddress(remoteAddress);
+
+ pool.offer(buf);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Delegates to the actual socket of the harvester.
+ */
+ @Override
+ public void send(DatagramPacket p)
+ throws IOException
+ {
+ socket.send(p);
+ }
+ }
+
+ /**
+ * Represents a buffer for the purposes of SinglePortUdpHarvester.
+ * Wraps a byte[] and adds a length field specifying the number of elements
+ * actually used.
+ */
+ protected class Buffer
+ {
+ /**
+ * The actual data.
+ */
+ byte[] buffer;
+
+ /**
+ * The number of elements of {@link #buffer} actually used.
+ */
+ int len;
+
+ /**
+ * Initializes a new Buffer instance.
+ * @param buffer the data.
+ * @param len the length.
+ */
+ private Buffer(byte[] buffer, int len)
+ {
+ this.buffer = buffer;
+ this.len = len;
+ }
+ }
+}
diff --git a/src/main/java/org/ice4j/ice/harvest/SinglePortUdpHarvester.java b/src/main/java/org/ice4j/ice/harvest/SinglePortUdpHarvester.java
index c03f2ac..d9adfaa 100644
--- a/src/main/java/org/ice4j/ice/harvest/SinglePortUdpHarvester.java
+++ b/src/main/java/org/ice4j/ice/harvest/SinglePortUdpHarvester.java
@@ -43,17 +43,16 @@ import java.util.logging.Logger; // Disambiguation
* and associates the component's local username fragment (ufrag) with this
* candidate.
*
- * When a datagram from an unknown source is received, it is parsed as a STUN
- * Binding Request, and if it has a USERNAME attribute, its ufrag is extracted.
- * If this ufrag is associated with a candidate of this harvester, a new socket
- * is created and added to the candidate, and the remote address of the datagram
- * is associated with this socket. This mapping is then used to de-multiplex
- * received datagrams based on their remote address.
+ * When a STUN Binding Request with a given ufrag is received, if the ufrag
+ * matches one of the registered candidates, then a new socket is created, which
+ * is to receive further packets from the remote address, and the socket is
+ * added to the candidate.
*
* @author Boris Grozev
*/
public class SinglePortUdpHarvester
- extends AbstractCandidateHarvester
+ extends AbstractUdpListener
+ implements CandidateHarvester
{
/**
* Our class logger.
@@ -61,21 +60,6 @@ public class SinglePortUdpHarvester
private static final Logger logger
= Logger.getLogger(SinglePortUdpHarvester.class.getName());
- /**
- * The size for newly allocated Buffer instances. This limits the
- * maximum size of datagrams we can receive.
- *
- * XXX should we increase this in case of other MTUs, or set it dynamically
- * according to the available network interfaces?
- */
- private static final int BUFFER_SIZE
- = /* assumed MTU */ 1500 - /* IPv4 header */ 20 - /* UDP header */ 8;
-
- /**
- * The number of Buffer instances to keep in {@link #pool}.
- */
- private static final int POOL_SIZE = 256;
-
/**
* Creates a new SinglePortUdpHarvester instance for each allowed
* IP address found on each allowed network interface, with the given port.
@@ -83,58 +67,12 @@ public class SinglePortUdpHarvester
* @param port the UDP port number to use.
* @return the list of created SinglePortUdpHarvesters.
*/
- public static List
- createHarvesters(int port)
+ public static List createHarvesters(int port)
{
List harvesters = new LinkedList<>();
- List addresses = new LinkedList<>();
- boolean isIPv6Disabled = StackProperties.getBoolean(
- StackProperties.DISABLE_IPv6,
- false);
- boolean isIPv6LinkLocalDisabled = StackProperties.getBoolean(
- StackProperties.DISABLE_LINK_LOCAL_ADDRESSES,
- false);
-
- try
- {
- for (NetworkInterface iface
- : Collections.list(NetworkInterface.getNetworkInterfaces()))
- {
- if (NetworkUtils.isInterfaceLoopback(iface)
- || !NetworkUtils.isInterfaceUp(iface)
- || !HostCandidateHarvester.isInterfaceAllowed(iface))
- {
- continue;
- }
-
- Enumeration ifaceAddresses
- = iface.getInetAddresses();
- while (ifaceAddresses.hasMoreElements())
- {
- InetAddress address = ifaceAddresses.nextElement();
-
- if (!HostCandidateHarvester.isAddressAllowed(address))
- continue;
-
- if (isIPv6Disabled && address instanceof Inet6Address)
- continue;
- if (isIPv6LinkLocalDisabled
- && address instanceof Inet6Address
- && address.isLinkLocalAddress())
- continue;
-
- addresses.add(
- new TransportAddress(address, port, Transport.UDP));
- }
- }
- }
- catch (SocketException se)
- {
- logger.info("Failed to get network interfaces: " + se);
- }
-
- for (TransportAddress address : addresses)
+ for (TransportAddress address
+ : AbstractUdpListener.getAllowedAddresses(port))
{
try
{
@@ -151,15 +89,6 @@ public class SinglePortUdpHarvester
return harvesters;
}
- /**
- * The map which keeps the known remote addresses and their associated
- * candidateSockets.
- * {@link #thread} is the only thread which adds new entries, while
- * other threads remove entries when candidates are freed.
- */
- private final Map sockets
- = new ConcurrentHashMap<>();
-
/**
* The map which keeps all currently active Candidates created by
* this harvester. The keys are the local username fragments (ufrags) of
@@ -169,26 +98,9 @@ public class SinglePortUdpHarvester
= new ConcurrentHashMap<>();
/**
- * A pool of Buffer instances used to avoid creating of new java
- * objects.
+ * Manages statistics about harvesting time.
*/
- private final ArrayBlockingQueue pool
- = new ArrayBlockingQueue<>(POOL_SIZE);
-
- /**
- * The local address that this harvester is bound to.
- */
- private final TransportAddress localAddress;
-
- /**
- * The "main" socket that this harvester reads from.
- */
- private final DatagramSocket socket;
-
- /**
- * The thread reading from {@link #socket}.
- */
- private final Thread thread;
+ private HarvestStatistics harvestStatistics = new HarvestStatistics();
/**
* Initializes a new SinglePortUdpHarvester instance which is to
@@ -199,214 +111,61 @@ public class SinglePortUdpHarvester
public SinglePortUdpHarvester(TransportAddress localAddress)
throws IOException
{
- this.localAddress = localAddress;
- this.socket = new DatagramSocket(localAddress);
+ super(localAddress);
logger.info("Initialized SinglePortUdpHarvester with address "
+ localAddress);
-
- thread = new Thread()
- {
- @Override
- public void run()
- {
- SinglePortUdpHarvester.this.runInHarvesterThread();
- }
- };
-
- thread.setName(SinglePortUdpHarvester.class.getName() + " thread");
- thread.setDaemon(true);
- thread.start();
}
/**
- * Perpetually reads datagrams from {@link #socket} and handles them
- * accordingly.
+ * {@inheritDoc}
+ */
+ public HarvestStatistics getHarvestStatistics()
+ {
+ return harvestStatistics;
+ }
+
+ /**
+ * {@inheritDoc}
*
- * It is important that this blocks are little as possible (except on
- * socket.receive(), of course), because it could potentially delay the
- * reception of both ICE and media packets for the whole application.
+ * Looks for an ICE candidate registered with this harvester, which has a
+ * local ufrag of {@code ufrag}, and if one is found it accepts the new
+ * socket and adds it to the candidate.
*/
- private void runInHarvesterThread()
+ protected void maybeAcceptNewSession(Buffer buf,
+ InetSocketAddress remoteAddress,
+ String ufrag)
{
- Buffer buf;
- DatagramPacket pkt = null;
- Component component;
- MyCandidate candidate;
- MySocket destinationSocket;
- InetSocketAddress remoteAddress;
-
- do
+ MyCandidate candidate = candidates.get(ufrag);
+ if (candidate == null)
{
- // TODO: implement stopping the thread with a switch?
-
- buf = getFreeBuffer();
-
- if (pkt == null)
- pkt = new DatagramPacket(buf.buffer, 0, buf.buffer.length);
- else
- pkt.setData(buf.buffer, 0, buf.buffer.length);
-
- try
- {
- socket.receive(pkt);
- }
- catch (IOException ioe)
- {
- logger.severe("Failed to receive from socket: " + ioe);
- break;
- }
- buf.len = pkt.getLength();
-
-
- remoteAddress = (InetSocketAddress) pkt.getSocketAddress();
- destinationSocket = sockets.get(remoteAddress);
- if (destinationSocket != null)
- {
- //make 'pkt' available for reading through destinationSocket
- destinationSocket.addBuffer(buf);
- }
- else
- {
- // Packet from an unknown source. Is it a STUN Binding Request?
- String ufrag = getUfrag(buf.buffer, 0, buf.len);
- if (ufrag == null)
- {
- // Not a STUN Binding Request or doesn't have a valid
- // USERNAME attribute. Drop it.
- continue;
- }
-
- candidate = candidates.get(ufrag);
- component
- = candidate == null ? null : candidate.getParentComponent();
- if (component != null)
- {
- // This is a STUN Binding Request destined for this
- // specific Candidate/Component/Agent.
-
- try
- {
- // 1. Create a socket for this remote address
- MySocket newSocket = new MySocket(remoteAddress);
-
- // 2. Set-up de-multiplexing for future datagrams
- // with this address to this socket.
- sockets.put(remoteAddress, newSocket);
-
- // 3. Let the candidate and its STUN stack no about the
- // new socket.
- candidate.addSocket(newSocket, remoteAddress);
-
- // 4. Add the original datagram to the new socket.
- newSocket.addBuffer(buf);
- }
- catch (SocketException se)
- {
- logger.info("Could not create a socket: " + se);
- }
- catch (IOException ioe)
- {
- logger.info("Failed to handle new socket: " + ioe);
- }
- }
- else
- {
- // A STUN Binding Request with an unknown USERNAME. Drop it.
- }
- }
- }
- while (true);
-
- // TODO we are all done, clean up.
- }
-
- /**
- * Gets an unused Buffer instance, creating it if necessary.
- * @return an unused Buffer instance, creating it if necessary.
- */
- private Buffer getFreeBuffer()
- {
- Buffer buf = pool.poll();
- if (buf == null)
- {
- buf = new Buffer(new byte[BUFFER_SIZE], 0);
- }
-
- return buf;
- }
-
- /**
- * Tries to parse the bytes in buf at offset off (and
- * length len) as a STUN Binding Request message. If successful,
- * looks for a USERNAME attribute and returns the local username fragment
- * part (see RFC5245 Section 7.1.2.3).
- * In case of any failure returns null.
- *
- * @param buf the bytes.
- * @param off the offset.
- * @param len the length.
- * @return the local ufrag from the USERNAME attribute of the STUN message
- * contained in buf, or null.
- */
- private String getUfrag(byte[] buf, int off, int len)
- {
- // RFC5389, Section 6:
- // All STUN messages MUST start with a 20-byte header followed by zero
- // or more Attributes.
- if (buf == null || buf.length < off + len || len < 20)
- {
- return null;
- }
-
- // RFC5389, Section 6:
- // The magic cookie field MUST contain the fixed value 0x2112A442 in
- // network byte order.
- if ( !( (buf[off + 4] & 0xFF) == 0x21 &&
- (buf[off + 5] & 0xFF) == 0x12 &&
- (buf[off + 6] & 0xFF) == 0xA4 &&
- (buf[off + 7] & 0xFF) == 0x42))
- {
- if (logger.isLoggable(Level.FINE))
- {
- logger.fine("Not a STUN packet, magic cookie not found.");
- }
- return null;
+ // A STUN Binding Request with an unknown USERNAME. Drop it.
+ return;
}
+ // This is a STUN Binding Request destined for this
+ // specific Candidate/Component/Agent.
try
{
- Message stunMessage
- = Message.decode(buf,
- (char) off,
- (char) len);
+ // 1. Create a socket for this remote address
+ // 2. Set-up de-multiplexing for future datagrams
+ // with this address to this socket.
+ MySocket newSocket = addSocket(remoteAddress);
- if (stunMessage.getMessageType()
- != Message.BINDING_REQUEST)
- {
- return null;
- }
+ // 3. Let the candidate and its STUN stack no about the
+ // new socket.
+ candidate.addSocket(newSocket, remoteAddress);
- UsernameAttribute usernameAttribute
- = (UsernameAttribute)
- stunMessage.getAttribute(Attribute.USERNAME);
- if (usernameAttribute == null)
- return null;
-
- String usernameString
- = new String(usernameAttribute.getUsername());
- return usernameString.split(":")[0];
+ // 4. Add the original datagram to the new socket.
+ newSocket.addBuffer(buf);
}
- catch (Exception e)
+ catch (SocketException se)
{
- // Catch everything. We are going to log, and then drop the packet
- // anyway.
- if (logger.isLoggable(Level.FINE))
- {
- logger.fine("Failed to extract local ufrag: " + e);
- }
+ logger.info("Could not create a socket: " + se);
+ }
+ catch (IOException ioe)
+ {
+ logger.info("Failed to handle new socket: " + ioe);
}
-
- return null;
}
/**
@@ -449,249 +208,6 @@ public class SinglePortUdpHarvester
return true;
}
- /**
- * Implements a DatagramSocket for the purposes of a specific
- * MyCandidate.
- *
- * It is not bound to a specific port, but shares the same local address
- * as the bound socket held by the harvester.
- */
- private class MySocket
- extends DatagramSocket
- {
- /**
- * The size of {@link #queue}.
- */
- private static final int QUEUE_SIZE = 128;
-
- /**
- * The FIFO which acts as a buffer for this socket.
- */
- private final ArrayBlockingQueue queue
- = new ArrayBlockingQueue<>(QUEUE_SIZE);
-
- /**
- * The {@link QueueStatistics} instance optionally used to collect and
- * print detailed statistics about {@link #queue}.
- */
- private final QueueStatistics queueStatistics;
-
- /**
- * The remote address that is associated with this socket.
- */
- private SocketAddress remoteAddress;
-
- /**
- * The flag which indicates that this DatagramSocket has been
- * closed.
- */
- private boolean closed = false;
-
- /**
- * Initializes a new MySocket instance with the given
- * remote address.
- * @param remoteAddress the remote address to be associated with the
- * new instance.
- * @throws SocketException
- */
- public MySocket(SocketAddress remoteAddress)
- throws SocketException
- {
- // unbound
- super((SocketAddress)null);
-
- this.remoteAddress = remoteAddress;
- if (logger.isLoggable(Level.FINEST))
- {
- queueStatistics = new QueueStatistics(
- "SinglePort" + remoteAddress.toString().replace('/', '-'));
- }
- else
- {
- queueStatistics = null;
- }
- }
-
- /**
- * Adds pkt to this socket. If the queue is full, drops a packet. Does
- * not block.
- */
- private void addBuffer(Buffer buf)
- {
- synchronized (queue)
- {
- // Drop the first rather than the current packet, so that
- // receivers can notice the loss earlier.
- if (queue.size() == QUEUE_SIZE)
- {
- logger.info("Dropping a packet because the queue is full.");
- if (queueStatistics != null)
- {
- queueStatistics.remove(System.currentTimeMillis());
- }
- queue.poll();
- }
-
- queue.offer(buf);
- if (queueStatistics != null)
- {
- queueStatistics.add(System.currentTimeMillis());
- }
-
- queue.notifyAll();
- }
- }
-
- /**
- * {@inheritDoc}
- *
- * Delegates to the actual socket of the harvester.
- */
- @Override
- public InetAddress getLocalAddress()
- {
- return localAddress.getAddress();
- }
-
- /**
- * {@inheritDoc}
- *
- * Delegates to the actual socket of the harvester.
- */
- @Override
- public int getLocalPort()
- {
- return localAddress.getPort();
- }
-
- /**
- * {@inheritDoc}
- *
- * Delegates to the actual socket of the harvester.
- */
- @Override
- public SocketAddress getLocalSocketAddress()
- {
- return localAddress;
- }
-
- /**
- * {@inheritDoc}
- *
- * Removes the association of the remote address with this socket from
- * the harvester's map.
- */
- @Override
- public void close()
- {
- closed = true;
-
- synchronized (queue)
- {
- // Wake up any threads still in receive()
- queue.notifyAll();
- }
-
- // We could be called by the super-class constructor, in which
- // case this.removeAddress is not initialized yet.
- if (remoteAddress != null)
- SinglePortUdpHarvester.this.sockets.remove(remoteAddress);
-
- super.close();
- }
-
- /**
- * Reads the data from the first element of {@link #queue} into
- * p. Blocks until {@link #queue} has an element.
- * @param p
- * @throws IOException
- */
- @Override
- public void receive(DatagramPacket p)
- throws IOException
- {
- Buffer buf = null;
-
- while (buf == null)
- {
- if (closed)
- throw new SocketException("Socket closed");
-
- synchronized (queue)
- {
- if (queue.isEmpty())
- {
- try
- {
- queue.wait();
- }
- catch (InterruptedException ie)
- {}
- }
-
- buf = queue.poll();
- if (queueStatistics != null)
- {
- queueStatistics.remove(System.currentTimeMillis());
- }
- }
- }
-
- byte[] pData = p.getData();
-
- // XXX Should we use p.setData() here with a buffer of our own?
- if (pData == null || pData.length < buf.len)
- throw new IOException("packet buffer not available");
-
- System.arraycopy(buf.buffer, 0, pData, 0, buf.len);
- p.setLength(buf.len);
- p.setSocketAddress(remoteAddress);
-
- pool.offer(buf);
- }
-
- /**
- * {@inheritDoc}
- *
- * Delegates to the actual socket of the harvester.
- */
- @Override
- public void send(DatagramPacket p)
- throws IOException
- {
- socket.send(p);
- }
- }
-
- /**
- * Represents a buffer for the purposes of SinglePortUdpHarvester.
- * Wraps a byte[] and adds a length field specifying the number of elements
- * actually used.
- */
- private class Buffer
- {
- /**
- * The actual data.
- */
- byte[] buffer;
-
- /**
- * The number of elements of {@link #buffer} actually used.
- */
- int len;
-
- /**
- * Initializes a new Buffer instance.
- * @param buffer the data.
- * @param len the length.
- */
- private Buffer(byte[] buffer, int len)
- {
- this.buffer = buffer;
- this.len = len;
- }
- }
-
/**
* Implements a Candidate for the purposes of this
* SinglePortUdpHarvester.