Adds a harvester that binds to a specific local TCP port and
demultiplexes the accepted connections between the components that used it.
This commit is contained in:
parent
c23438f8c2
commit
40541920f4
@ -1400,13 +1400,11 @@ public class Agent
|
|||||||
|
|
||||||
if (knownPair != null)
|
if (knownPair != null)
|
||||||
{
|
{
|
||||||
boolean useCand = false;
|
boolean useCand = triggerPair.useCandidateReceived();
|
||||||
|
|
||||||
useCand = triggerPair.useCandidateReceived();
|
|
||||||
|
|
||||||
//if the incoming request contained a USE-CANDIDATE attribute then
|
//if the incoming request contained a USE-CANDIDATE attribute then
|
||||||
//make sure we don't lose this piece of info.
|
//make sure we don't lose this piece of info.
|
||||||
if (triggerPair.useCandidateReceived())
|
if (useCand)
|
||||||
knownPair.setUseCandidateReceived();
|
knownPair.setUseCandidateReceived();
|
||||||
|
|
||||||
triggerPair = knownPair;
|
triggerPair = knownPair;
|
||||||
|
|||||||
@ -263,7 +263,7 @@ public class HostCandidateHarvester
|
|||||||
* <tt>org.ice4j.ice.harvest.BLOCKED_INTERFACES</tt> list. It returns
|
* <tt>org.ice4j.ice.harvest.BLOCKED_INTERFACES</tt> list. It returns
|
||||||
* <tt>false</tt> otherwise.
|
* <tt>false</tt> otherwise.
|
||||||
*/
|
*/
|
||||||
private boolean isInterfaceAllowed(NetworkInterface iface)
|
static boolean isInterfaceAllowed(NetworkInterface iface)
|
||||||
{
|
{
|
||||||
if (iface == null)
|
if (iface == null)
|
||||||
throw new IllegalArgumentException("iface cannot be null");
|
throw new IllegalArgumentException("iface cannot be null");
|
||||||
|
|||||||
869
src/org/ice4j/ice/harvest/MultiplexingTcpHostHarvester.java
Normal file
869
src/org/ice4j/ice/harvest/MultiplexingTcpHostHarvester.java
Normal file
@ -0,0 +1,869 @@
|
|||||||
|
/*
|
||||||
|
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||||
|
* Maintained by the SIP Communicator community (http://sip-communicator.org).
|
||||||
|
*
|
||||||
|
* Distributable under LGPL license. See terms of license at gnu.org.
|
||||||
|
*/
|
||||||
|
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 java.io.*;
|
||||||
|
import java.lang.ref.*;
|
||||||
|
import java.net.*;
|
||||||
|
import java.nio.*;
|
||||||
|
import java.nio.channels.*;
|
||||||
|
import java.util.*;
|
||||||
|
import java.util.logging.*;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A <tt>CandidateHarvester</tt> implementation, which listens on a specified
|
||||||
|
* list of TCP server sockets. On {@link #harvest(org.ice4j.ice.Component)}, a
|
||||||
|
* TCP candidate with type "passive" is added for each of the server sockets.
|
||||||
|
*
|
||||||
|
* This instance runs two threads: {@link #acceptThread} and
|
||||||
|
* {@link #readThread}. The 'accept' thread just accepts new <tt>Socket</tt>s
|
||||||
|
* and passes them over to the 'read' thread. The 'read' thread reads a STUN
|
||||||
|
* message from an accepted socket and, based on the STUN username, passes it
|
||||||
|
* to the appropriate <tt>Component</tt>.
|
||||||
|
*
|
||||||
|
* @author Boris Grozev
|
||||||
|
*/
|
||||||
|
public class MultiplexingTcpHostHarvester
|
||||||
|
extends CandidateHarvester
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* Our class logger.
|
||||||
|
*/
|
||||||
|
private static final Logger logger
|
||||||
|
= Logger.getLogger(MultiplexingTcpHostHarvester.class.getName());
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Channels which we have failed to read from after at least
|
||||||
|
* <tt>READ_TIMEOUT</tt> milliseconds will be considered failed and will
|
||||||
|
* be closed.
|
||||||
|
*/
|
||||||
|
private static int READ_TIMEOUT = 10000;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The list of <tt>ServerSocketChannel</tt>s that we will <tt>accept</tt> on.
|
||||||
|
*/
|
||||||
|
private final List<ServerSocketChannel> serverSocketChannels
|
||||||
|
= new LinkedList<ServerSocketChannel>();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The list of transport addresses which we have found to be listening on,
|
||||||
|
* and which we will advertise as candidates in
|
||||||
|
* {@link #harvest(org.ice4j.ice.Component)}
|
||||||
|
*/
|
||||||
|
private final List<TransportAddress> localAddresses
|
||||||
|
= new LinkedList<TransportAddress>();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The thread which <tt>accept</tt>s TCP connections from the sockets in
|
||||||
|
* {@link #serverSocketChannels}.
|
||||||
|
*/
|
||||||
|
private AcceptThread acceptThread;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The thread which reads from the already <tt>accept</tt>ed sockets.
|
||||||
|
*/
|
||||||
|
private ReadThread readThread;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Triggers the termination of the threads of this instance.
|
||||||
|
*/
|
||||||
|
private boolean close = false;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Channels pending to be added to the list that {@link #readThread} reads
|
||||||
|
* from.
|
||||||
|
*/
|
||||||
|
private final List<SocketChannel> newChannels
|
||||||
|
= new LinkedList<SocketChannel>();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Maps a local "ufrag" to the single <tt>Component</tt> instance with that
|
||||||
|
* "ufrag".
|
||||||
|
*
|
||||||
|
* We only keep weak references, because we do not want to prevent
|
||||||
|
* <tt>Component</tt>s from being freed.
|
||||||
|
*/
|
||||||
|
private final Map<String, WeakReference<Component>> components
|
||||||
|
= new HashMap<String, WeakReference<Component>>();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The <tt>Pipe</tt> on which {@link #acceptThread} notifies
|
||||||
|
* {@link #readThread} about the existence of new accepted channels.
|
||||||
|
*/
|
||||||
|
private Pipe pipe;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes a new <tt>MultiplexingTcpHostHarvester</tt>, which is to
|
||||||
|
* listen on port number <tt>port</tt> on all IP addresses on all
|
||||||
|
* available interfaces.
|
||||||
|
*
|
||||||
|
* @param port the port to listen on.
|
||||||
|
*/
|
||||||
|
public MultiplexingTcpHostHarvester(int port)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
this(port, NetworkInterface.getNetworkInterfaces());
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes a new <tt>MultiplexingTcpHostHarvester</tt>, which is to
|
||||||
|
* listen on the specified list of <tt>TransportAddress</tt>es.
|
||||||
|
*
|
||||||
|
* @param transportAddresses the transport addresses to listen on.
|
||||||
|
*/
|
||||||
|
public MultiplexingTcpHostHarvester(
|
||||||
|
List<TransportAddress> transportAddresses)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
this.localAddresses.addAll(transportAddresses);
|
||||||
|
init();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes a new <tt>MultiplexingTcpHostHarvester</tt>, which is to
|
||||||
|
* listen on port number <tt>port</tt> on all the IP addresses on the
|
||||||
|
* specified <tt>NetworkInterface</tt>s.
|
||||||
|
*
|
||||||
|
* @param port the port to listen on.
|
||||||
|
* @param interfaces the interfaces to listen on.
|
||||||
|
*/
|
||||||
|
public MultiplexingTcpHostHarvester(int port,
|
||||||
|
Enumeration<NetworkInterface> interfaces)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
initializeLocalAddresses(port, interfaces);
|
||||||
|
init();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes {@link #serverSocketChannels}, creates and starts the threads
|
||||||
|
* used by this instance.
|
||||||
|
*/
|
||||||
|
private void init()
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
for (TransportAddress transportAddress : localAddresses)
|
||||||
|
{
|
||||||
|
ServerSocketChannel channel = ServerSocketChannel.open();
|
||||||
|
ServerSocket socket = channel.socket();
|
||||||
|
socket.bind(
|
||||||
|
new InetSocketAddress(transportAddress.getAddress(),
|
||||||
|
transportAddress.getPort()));
|
||||||
|
serverSocketChannels.add(channel);
|
||||||
|
}
|
||||||
|
|
||||||
|
pipe = Pipe.open();
|
||||||
|
|
||||||
|
acceptThread = new AcceptThread();
|
||||||
|
acceptThread.start();
|
||||||
|
|
||||||
|
readThread = new ReadThread();
|
||||||
|
readThread.start();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes {@link #localAddresses}.
|
||||||
|
*
|
||||||
|
* @param port the port to use.
|
||||||
|
* @param interfaces the list of interfaces to use.
|
||||||
|
*/
|
||||||
|
private void initializeLocalAddresses(
|
||||||
|
int port,
|
||||||
|
Enumeration<NetworkInterface> interfaces)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
boolean useIPv6 = !StackProperties.getBoolean(
|
||||||
|
StackProperties.DISABLE_IPv6,
|
||||||
|
false);
|
||||||
|
|
||||||
|
while (interfaces.hasMoreElements())
|
||||||
|
{
|
||||||
|
NetworkInterface iface = interfaces.nextElement();
|
||||||
|
if (NetworkUtils.isInterfaceLoopback(iface)
|
||||||
|
|| !NetworkUtils.isInterfaceUp(iface)
|
||||||
|
|| !HostCandidateHarvester.isInterfaceAllowed(iface))
|
||||||
|
{
|
||||||
|
//this one is obviously not going to do
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
Enumeration<InetAddress> addresses = iface.getInetAddresses();
|
||||||
|
|
||||||
|
while(addresses.hasMoreElements())
|
||||||
|
{
|
||||||
|
InetAddress addr = addresses.nextElement();
|
||||||
|
|
||||||
|
if (addr.isLoopbackAddress())
|
||||||
|
{
|
||||||
|
//loopback again
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if((addr instanceof Inet4Address) || useIPv6)
|
||||||
|
{
|
||||||
|
TransportAddress transportAddress
|
||||||
|
= new TransportAddress(addr, port, Transport.TCP);
|
||||||
|
localAddresses.add(transportAddress);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the <tt>Component</tt> instance, if any, for a given local
|
||||||
|
* "ufrag".
|
||||||
|
* @param localUfrag the local "ufrag"
|
||||||
|
* @return the <tt>Component</tt> instance, if any, for a given local
|
||||||
|
* "ufrag".
|
||||||
|
*/
|
||||||
|
private Component getComponent(String localUfrag)
|
||||||
|
{
|
||||||
|
synchronized (components)
|
||||||
|
{
|
||||||
|
WeakReference<Component> wr = components.get(localUfrag);
|
||||||
|
|
||||||
|
return wr == null ? null : wr.get();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* {@inheritDoc}
|
||||||
|
*
|
||||||
|
* Saves a (weak) reference to <tt>Component</tt>, so that it can be
|
||||||
|
* notified if/when a socket for one of it <tt>LocalCandidate</tt>s is
|
||||||
|
* accepted.
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public Collection<LocalCandidate> harvest(Component component)
|
||||||
|
{
|
||||||
|
IceMediaStream stream = component.getParentStream();
|
||||||
|
Agent agent = stream.getParentAgent();
|
||||||
|
if (stream.getComponentCount() != 1 || agent.getStreamCount() != 1)
|
||||||
|
{
|
||||||
|
/*
|
||||||
|
* MultiplexingTcpHostHarvester only works with streams with a
|
||||||
|
* single component, and agents with a single stream. This is
|
||||||
|
* because we use the local "ufrag" to de-multiplex the accept()-ed
|
||||||
|
* sockets between the known components.
|
||||||
|
*/
|
||||||
|
throw new IllegalStateException("More than one Component for an "
|
||||||
|
+ "Agent, cannot harvest.");
|
||||||
|
}
|
||||||
|
|
||||||
|
List<LocalCandidate> candidates = createLocalCandidates(component);
|
||||||
|
for (LocalCandidate candidate : candidates)
|
||||||
|
component.addLocalCandidate(candidate);
|
||||||
|
|
||||||
|
|
||||||
|
synchronized (components)
|
||||||
|
{
|
||||||
|
components.put(agent.getLocalUfrag(),
|
||||||
|
new WeakReference<Component>(component));
|
||||||
|
}
|
||||||
|
|
||||||
|
return candidates;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Creates and returns the list of <tt>LocalCandidate</tt>s which are to be added
|
||||||
|
* by this <tt>MultiplexingTcpHostHarvester</tt>to a specific
|
||||||
|
* <tt>Component</tt>.
|
||||||
|
*
|
||||||
|
* @param component the <tt>Component</tt> for which to create candidates.
|
||||||
|
* @return the list of <tt>LocalCandidate</tt>s which are to be added
|
||||||
|
* by this <tt>MultiplexingTcpHostHarvester</tt>to a specific
|
||||||
|
* <tt>Component</tt>.
|
||||||
|
*/
|
||||||
|
private List<LocalCandidate> createLocalCandidates(Component component)
|
||||||
|
{
|
||||||
|
List<LocalCandidate> candidates = new LinkedList<LocalCandidate>();
|
||||||
|
for (TransportAddress transportAddress : localAddresses)
|
||||||
|
{
|
||||||
|
TcpHostCandidate candidate
|
||||||
|
= new TcpHostCandidate(transportAddress, component);
|
||||||
|
candidate.setTcpType(CandidateTcpType.PASSIVE);
|
||||||
|
|
||||||
|
candidates.add(new TcpHostCandidate(transportAddress, component));
|
||||||
|
}
|
||||||
|
return candidates;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A <tt>Thread</tt> which will accept new <tt>SocketChannel</tt>s from all
|
||||||
|
* <tt>ServerSocketChannel</tt>s in {@link #serverSocketChannels}.
|
||||||
|
*/
|
||||||
|
private class AcceptThread
|
||||||
|
extends Thread
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* The <tt>Selector</tt> used to select a specific
|
||||||
|
* <tt>ServerSocketChannel</tt> which is ready to <tt>accept</tt>.
|
||||||
|
*/
|
||||||
|
private final Selector selector;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The channel to which this <tt>AcceptThread</tt> will write when a
|
||||||
|
* new socket has been <tt>accept</tt>ed in order to notify
|
||||||
|
* {@link #readThread}.
|
||||||
|
*/
|
||||||
|
private final Pipe.SinkChannel pipeSink;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A <tt>ByteBuffer</tt> used to write to {@link #pipeSink}.
|
||||||
|
*/
|
||||||
|
private final ByteBuffer buffer;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes a new <tt>AcceptThread</tt>.
|
||||||
|
*/
|
||||||
|
private AcceptThread()
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
setName("MultiplexingTcpHostHarvester AcceptThread");
|
||||||
|
|
||||||
|
pipeSink = pipe.sink();
|
||||||
|
buffer = ByteBuffer.allocate(1);
|
||||||
|
|
||||||
|
selector = Selector.open();
|
||||||
|
for (ServerSocketChannel channel : serverSocketChannels)
|
||||||
|
{
|
||||||
|
channel.configureBlocking(false);
|
||||||
|
channel.register(selector, SelectionKey.OP_ACCEPT);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* {@inheritDoc}
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void run()
|
||||||
|
{
|
||||||
|
int readyChannels;
|
||||||
|
SocketChannel channel;
|
||||||
|
IOException exception;
|
||||||
|
boolean added;
|
||||||
|
|
||||||
|
while (true)
|
||||||
|
{
|
||||||
|
if (close)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
// Allow to go on, so we can quit if closed
|
||||||
|
readyChannels = selector.select(3000);
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{
|
||||||
|
logger.info("Failed to select an accept-ready socket: "
|
||||||
|
+ ioe);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (readyChannels > 0)
|
||||||
|
{
|
||||||
|
synchronized (newChannels)
|
||||||
|
{
|
||||||
|
exception = null;
|
||||||
|
added = false;
|
||||||
|
|
||||||
|
for (SelectionKey key : selector.selectedKeys())
|
||||||
|
{
|
||||||
|
if (key.isAcceptable())
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
channel = ((ServerSocketChannel)
|
||||||
|
key.channel()).accept();
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{
|
||||||
|
exception = ioe;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Add the accepted socket to newChannels, so
|
||||||
|
// the 'read' thread can pick it up.
|
||||||
|
newChannels.add(channel);
|
||||||
|
added = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
selector.selectedKeys().clear();
|
||||||
|
|
||||||
|
if (added)
|
||||||
|
notifyReadThread();
|
||||||
|
|
||||||
|
if (exception != null)
|
||||||
|
{
|
||||||
|
logger.info("Failed to accept a socket, which"
|
||||||
|
+ "should have been ready to accept: "
|
||||||
|
+ exception);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} // while(true)
|
||||||
|
|
||||||
|
//now clean up and exit
|
||||||
|
for (ServerSocketChannel serverSocketChannel : serverSocketChannels)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
serverSocketChannel.close();
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
selector.close();
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Notifies {@link #readThread} that new channels have been added to
|
||||||
|
* {@link #newChannels} by writing to {@link #pipe}.
|
||||||
|
*/
|
||||||
|
private void notifyReadThread()
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
//XXX do we have to fill it each time?
|
||||||
|
buffer.clear();
|
||||||
|
buffer.put((byte) 0);
|
||||||
|
buffer.flip();
|
||||||
|
pipeSink.write(buffer);
|
||||||
|
buffer.flip();
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{
|
||||||
|
logger.info("Failed to write to pipe.");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private class ReadThread
|
||||||
|
extends Thread
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* Contains the <tt>SocketChanel</tt>s that we are currently reading
|
||||||
|
* from, mapped to the time they were initially added.
|
||||||
|
*/
|
||||||
|
private final Map<SocketChannel, Long> channels
|
||||||
|
= new HashMap<SocketChannel, Long>();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* <tt>Selector</tt> used to detect when one of {@link #channels} is
|
||||||
|
* ready to be read from.
|
||||||
|
*/
|
||||||
|
private final Selector selector;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The channel on which we will be notified when new channels are
|
||||||
|
* available in {@link #newChannels}.
|
||||||
|
*/
|
||||||
|
private final Pipe.SourceChannel pipeSource;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A buffer into which we will read away from {@link #pipeSource}.
|
||||||
|
*/
|
||||||
|
private final ByteBuffer buffer;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Used in {@link #cleanup()}, defined here to avoid allocating on
|
||||||
|
* every invocation.
|
||||||
|
*/
|
||||||
|
private final List<SocketChannel> toRemove
|
||||||
|
= new LinkedList<SocketChannel>();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A <tt>DatagramPacket</tt> into which we will try to read STUN
|
||||||
|
* messages.
|
||||||
|
*/
|
||||||
|
private final DatagramPacket datagramPacket;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes a new <tt>ReadThread</tt>.
|
||||||
|
* @throws IOException if the selector to be used fails to open.
|
||||||
|
*/
|
||||||
|
private ReadThread()
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
selector = Selector.open();
|
||||||
|
pipeSource = pipe.source();
|
||||||
|
pipeSource.register(selector, SelectionKey.OP_READ);
|
||||||
|
buffer = ByteBuffer.allocate(1);
|
||||||
|
datagramPacket = new DatagramPacket(new byte[1500], 1500);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* {@inheritDoc}
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void run()
|
||||||
|
{
|
||||||
|
Set<SelectionKey> selectedKeys;
|
||||||
|
int readyChannels = 0;
|
||||||
|
SelectableChannel selectedChannel;
|
||||||
|
|
||||||
|
while (true)
|
||||||
|
{
|
||||||
|
synchronized (MultiplexingTcpHostHarvester.this)
|
||||||
|
{
|
||||||
|
if (close)
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
// clean up stale channels
|
||||||
|
cleanup();
|
||||||
|
|
||||||
|
checkForNewChannels();
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
readyChannels = selector.select(READ_TIMEOUT / 2);
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{
|
||||||
|
logger.info("Failed to select a read-ready channel.");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (readyChannels > 0)
|
||||||
|
{
|
||||||
|
selectedKeys = selector.selectedKeys();
|
||||||
|
for (SelectionKey key : selectedKeys)
|
||||||
|
{
|
||||||
|
if (key.isReadable())
|
||||||
|
{
|
||||||
|
selectedChannel = key.channel();
|
||||||
|
if (selectedChannel == pipeSource)
|
||||||
|
{
|
||||||
|
// That's just the nudge that new channels are
|
||||||
|
// available. Just read from the pipe, so it
|
||||||
|
// doesn't get hogged.
|
||||||
|
try
|
||||||
|
{
|
||||||
|
pipeSource.read(buffer);
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{
|
||||||
|
logger.info("Failed to read from pipe.");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
/*
|
||||||
|
* We need this in order to de-register the
|
||||||
|
* channel from the selector.
|
||||||
|
*/
|
||||||
|
key.cancel();
|
||||||
|
|
||||||
|
readFromChannel((SocketChannel) selectedChannel);
|
||||||
|
channels.remove(selectedChannel);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
selectedKeys.clear();
|
||||||
|
}
|
||||||
|
|
||||||
|
} //while(true)
|
||||||
|
|
||||||
|
|
||||||
|
//we are all done, clean up.
|
||||||
|
synchronized (newChannels)
|
||||||
|
{
|
||||||
|
for (SocketChannel channel : newChannels)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
channel.close();
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{}
|
||||||
|
}
|
||||||
|
newChannels.clear();
|
||||||
|
}
|
||||||
|
|
||||||
|
for (SocketChannel channel : channels.keySet())
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
channel.close();
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{}
|
||||||
|
}
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
selector.close();
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Checks {@link #channels} for channels which have been added over
|
||||||
|
* {@link #READ_TIMEOUT} milliseconds ago and closes them.
|
||||||
|
*/
|
||||||
|
private void cleanup()
|
||||||
|
{
|
||||||
|
long now = System.currentTimeMillis();
|
||||||
|
toRemove.clear();
|
||||||
|
|
||||||
|
for (Map.Entry<SocketChannel, Long> entry : channels.entrySet())
|
||||||
|
{
|
||||||
|
if (now - entry.getValue() > READ_TIMEOUT)
|
||||||
|
{
|
||||||
|
SocketChannel channel = entry.getKey();
|
||||||
|
|
||||||
|
toRemove.add(channel);
|
||||||
|
logger.info("Read timeout for socket: " + channel);
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
channel.close();
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{
|
||||||
|
logger.info("Failed to close channel: " + ioe);
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (SocketChannel channel : toRemove)
|
||||||
|
{
|
||||||
|
channels.remove(channel);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Tries to read a STUN message from a specific <tt>SocketChannel</tt>
|
||||||
|
* and handles the channel accordingly.
|
||||||
|
*
|
||||||
|
* If a STUN message is successfully read, and it contains a USERNAME
|
||||||
|
* attribute, the local "ufrag" is extracted from the attribute value
|
||||||
|
* and the socket is passed on to the <tt>Component</tt> that
|
||||||
|
* this <tt>MultiplexingTcpHostHarvester</tt> has associated with that
|
||||||
|
* "ufrag".
|
||||||
|
* @param channel the <tt>SocketChannel</tt> to read from.
|
||||||
|
*/
|
||||||
|
private void readFromChannel(SocketChannel channel)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
// re-enable blocking mode, so that we can read from the
|
||||||
|
// socket's input stream
|
||||||
|
channel.configureBlocking(true);
|
||||||
|
|
||||||
|
// read an RFC4571 frame into datagramPacket
|
||||||
|
Socket socket = channel.socket();
|
||||||
|
DelegatingSocket.receiveFromNetwork(
|
||||||
|
datagramPacket,
|
||||||
|
socket.getInputStream(),
|
||||||
|
socket.getLocalAddress(),
|
||||||
|
socket.getLocalPort());
|
||||||
|
|
||||||
|
// Does this look like a STUN binding request?
|
||||||
|
// What's the username?
|
||||||
|
Message stunMessage
|
||||||
|
= Message.decode(datagramPacket.getData(),
|
||||||
|
(char) datagramPacket.getOffset(),
|
||||||
|
(char) datagramPacket.getLength());
|
||||||
|
|
||||||
|
if (stunMessage.getMessageType() != Message.BINDING_REQUEST)
|
||||||
|
throw new ReadThreadException("Not a binding request");
|
||||||
|
|
||||||
|
UsernameAttribute usernameAttribute
|
||||||
|
= (UsernameAttribute)
|
||||||
|
stunMessage.getAttribute(Attribute.USERNAME);
|
||||||
|
if (usernameAttribute == null)
|
||||||
|
throw new ReadThreadException(
|
||||||
|
"No USERNAME attribute present.");
|
||||||
|
|
||||||
|
String usernameString
|
||||||
|
= new String(usernameAttribute.getUsername());
|
||||||
|
String localUfrag = usernameString.split(":")[0];
|
||||||
|
Component component = getComponent(localUfrag);
|
||||||
|
if (component == null)
|
||||||
|
throw new ReadThreadException("No component found.");
|
||||||
|
|
||||||
|
|
||||||
|
//phew, finally
|
||||||
|
handSocketToComponent(socket, component);
|
||||||
|
}
|
||||||
|
catch (IOException e)
|
||||||
|
{
|
||||||
|
logger.info("Failed to read from socket: " + e);
|
||||||
|
}
|
||||||
|
catch (StunException e)
|
||||||
|
{
|
||||||
|
logger.info("Failed to read from socket: " + e);
|
||||||
|
}
|
||||||
|
catch (ReadThreadException e)
|
||||||
|
{
|
||||||
|
logger.info("Failed to read from socket: " + e);
|
||||||
|
}
|
||||||
|
finally
|
||||||
|
{
|
||||||
|
channels.remove(channel);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Makes <tt>socket</tt> available to <tt>component</tt>.
|
||||||
|
* @param socket the <tt>Socket</tt>.
|
||||||
|
* @param component the <tt>Component</tt>.
|
||||||
|
*/
|
||||||
|
private void handSocketToComponent(Socket socket, Component component)
|
||||||
|
{
|
||||||
|
IceProcessingState state
|
||||||
|
= component.getParentStream().getParentAgent().getState();
|
||||||
|
if (!IceProcessingState.WAITING.equals(state)
|
||||||
|
&& !IceProcessingState.RUNNING.equals(state))
|
||||||
|
{
|
||||||
|
logger.info("Not adding a socket to an ICE agent with state "
|
||||||
|
+ state);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Socket to add to the candidate
|
||||||
|
IceSocketWrapper candidateSocket = null;
|
||||||
|
|
||||||
|
// STUN-only filtered socket to add to the StunStack
|
||||||
|
IceSocketWrapper stunSocket = null;
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
MultiplexingSocket multiplexing = new MultiplexingSocket(socket);
|
||||||
|
candidateSocket = new IceTcpSocketWrapper(multiplexing);
|
||||||
|
|
||||||
|
stunSocket
|
||||||
|
= new IceTcpSocketWrapper(
|
||||||
|
multiplexing.getSocket(new StunDatagramPacketFilter()));
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{
|
||||||
|
logger.info("Failed to create sockets: " + ioe);
|
||||||
|
}
|
||||||
|
|
||||||
|
TcpHostCandidate candidate = findCandidate(component, socket);
|
||||||
|
if (candidate != null)
|
||||||
|
{
|
||||||
|
component.getParentStream().getParentAgent()
|
||||||
|
.getStunStack().addSocket(stunSocket);
|
||||||
|
candidate.addSocket(candidateSocket);
|
||||||
|
|
||||||
|
// the socket is not our responsibility anymore. It is up to
|
||||||
|
// the candidate/component to close/free it.
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
logger.info("Failed to find the local candidate for socket: "
|
||||||
|
+ socket);
|
||||||
|
try
|
||||||
|
{
|
||||||
|
socket.close();
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{}
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Searches among the local candidates of <tt>Component</tt> for a
|
||||||
|
* <tt>TcpHostCandidate</tt> with the same transport address as the
|
||||||
|
* local transport address of <tt>socket</tt>.
|
||||||
|
*
|
||||||
|
* We expect to find such a candidate, which has been added by this
|
||||||
|
* <tt>MultiplexingTcpHostHarvester</tt> while harvesting.
|
||||||
|
*
|
||||||
|
* @param component the <tt>Component</tt> to search.
|
||||||
|
* @param socket the <tt>Socket</tt> to match the local transport
|
||||||
|
* address of.
|
||||||
|
* @return a <tt>TcpHostCandidate</tt> among the local candidates of
|
||||||
|
* <tt>Component</tt> with the same transport address as the local
|
||||||
|
* address of <tt>Socket</tt>, or <tt>null</tt> if no such candidate
|
||||||
|
* exists.
|
||||||
|
*/
|
||||||
|
private TcpHostCandidate findCandidate(Component component, Socket socket)
|
||||||
|
{
|
||||||
|
InetAddress localAddress = socket.getLocalAddress();
|
||||||
|
int localPort = socket.getLocalPort();
|
||||||
|
|
||||||
|
for (LocalCandidate candidate : component.getLocalCandidates())
|
||||||
|
{
|
||||||
|
TransportAddress transportAddress
|
||||||
|
= candidate.getTransportAddress();
|
||||||
|
if (candidate instanceof TcpHostCandidate
|
||||||
|
&& Transport.TCP.equals(transportAddress.getTransport())
|
||||||
|
&& localPort == transportAddress.getPort()
|
||||||
|
&& localAddress.equals(transportAddress.getAddress()))
|
||||||
|
{
|
||||||
|
return (TcpHostCandidate) candidate;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Adds the channels from {@link #newChannels} to {@link #channels}
|
||||||
|
* and registers them in {@link #selector}.
|
||||||
|
*/
|
||||||
|
private void checkForNewChannels()
|
||||||
|
{
|
||||||
|
synchronized (newChannels)
|
||||||
|
{
|
||||||
|
for (SocketChannel channel : newChannels)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
channel.configureBlocking(false);
|
||||||
|
channel.register(selector, SelectionKey.OP_READ);
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{
|
||||||
|
logger.info("Failed to register channel: " + ioe);
|
||||||
|
try
|
||||||
|
{
|
||||||
|
channel.close();
|
||||||
|
}
|
||||||
|
catch (IOException ioe2)
|
||||||
|
{}
|
||||||
|
}
|
||||||
|
|
||||||
|
channels.put(channel, System.currentTimeMillis());
|
||||||
|
}
|
||||||
|
newChannels.clear();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private class ReadThreadException
|
||||||
|
extends Exception
|
||||||
|
{
|
||||||
|
private ReadThreadException(String s)
|
||||||
|
{
|
||||||
|
super(s);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
x
Reference in New Issue
Block a user