Implements DatagramSocket multiplexing for the purposes of ICE.
This commit is contained in:
parent
3d1538865a
commit
ef3acb3028
32
src/org/ice4j/socket/DatagramPacketFilter.java
Normal file
32
src/org/ice4j/socket/DatagramPacketFilter.java
Normal file
@ -0,0 +1,32 @@
|
|||||||
|
/*
|
||||||
|
* 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.socket;
|
||||||
|
|
||||||
|
import java.net.*;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Represents a filter which selects or deselects <tt>DatagramPacket</tt>s.
|
||||||
|
*
|
||||||
|
* @author Lubomir Marinov
|
||||||
|
*/
|
||||||
|
public interface DatagramPacketFilter
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* Determines whether a specific <tt>DatagramPacket</tt> is accepted by this
|
||||||
|
* filter i.e. whether the caller should include the specified
|
||||||
|
* <tt>DatagramPacket</tt> in a selection based on this filter.
|
||||||
|
*
|
||||||
|
* @param p the <tt>DatagramPacket</tt> which is to be checked whether it is
|
||||||
|
* accepted by this filter
|
||||||
|
* @return <tt>true</tt> if this filter accepts the specified
|
||||||
|
* <tt>DatagramPacket</tt> i.e. if the caller should include the specified
|
||||||
|
* <tt>DatagramPacket</tt> in a selection based on this filter; otherwise,
|
||||||
|
* <tt>false</tt>
|
||||||
|
*/
|
||||||
|
public boolean accept(DatagramPacket p);
|
||||||
|
}
|
||||||
626
src/org/ice4j/socket/MultiplexedDatagramSocket.java
Normal file
626
src/org/ice4j/socket/MultiplexedDatagramSocket.java
Normal file
@ -0,0 +1,626 @@
|
|||||||
|
/*
|
||||||
|
* 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.socket;
|
||||||
|
|
||||||
|
import java.io.*;
|
||||||
|
import java.net.*;
|
||||||
|
import java.nio.channels.*;
|
||||||
|
import java.util.*;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Represents a <tt>DatagramSocket</tt> which receives <tt>DatagramPacket</tt>s
|
||||||
|
* selected by a <tt>DatagramPacketFilter</tt> from a
|
||||||
|
* <tt>MultiplexingDatagramSocket</tt>. The associated
|
||||||
|
* <tt>MultiplexingDatagramSocket</tt> is the actual <tt>DatagramSocket</tt>
|
||||||
|
* which reads the <tt>DatagramPacket</tt>s from the network. The
|
||||||
|
* <tt>DatagramPacket</tt>s received through the
|
||||||
|
* <tt>MultiplexedDatagramSocket</tt> will not be received through the
|
||||||
|
* associated <tt>MultiplexingDatagramSocket</tt>.
|
||||||
|
*
|
||||||
|
* @author Lubomir Marinov
|
||||||
|
*/
|
||||||
|
public class MultiplexedDatagramSocket
|
||||||
|
extends DatagramSocket
|
||||||
|
{
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The <tt>DatagramPacketFilter</tt> which determines which
|
||||||
|
* <tt>DatagramPacket</tt>s read from the network by {@link #multiplexing}
|
||||||
|
* are to be received through this instance.
|
||||||
|
*/
|
||||||
|
private final DatagramPacketFilter filter;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The <tt>MultiplexingDatagramSocket</tt> which does the actual reading
|
||||||
|
* from the network and which forwards <tt>DatagramPacket</tt>s accepted by
|
||||||
|
* {@link #filter} for receipt to this instance.
|
||||||
|
*/
|
||||||
|
private final MultiplexingDatagramSocket multiplexing;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The list of <tt>DatagramPacket</tt>s to be received through this
|
||||||
|
* <tt>DatagramSocket</tt> i.e. accepted by {@link #filter}.
|
||||||
|
*/
|
||||||
|
final List<DatagramPacket> received
|
||||||
|
= new LinkedList<DatagramPacket>();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes a new <tt>MultiplexedDatagramSocket</tt> which is unbound and
|
||||||
|
* filters <tt>DatagramPacket</tt>s away from a specific
|
||||||
|
* <tt>MultiplexingDatagramSocket</tt> using a specific
|
||||||
|
* <tt>DatagramPacketFilter</tt>.
|
||||||
|
*
|
||||||
|
* @param multiplexing the <tt>MultiplexingDatagramSocket</tt> which does
|
||||||
|
* the actual reading from the network and which forwards
|
||||||
|
* <tt>DatagramPacket</tt>s accepted by the specified <tt>filter</tt> to the
|
||||||
|
* new instance
|
||||||
|
* @param filter the <tt>DatagramPacketFilter</tt> which determines which
|
||||||
|
* <tt>DatagramPacket</tt>s read from the network by the specified
|
||||||
|
* <tt>multiplexing</tt> are to be received through the new instance
|
||||||
|
* @throws SocketException if the socket could not be opened
|
||||||
|
*/
|
||||||
|
MultiplexedDatagramSocket(
|
||||||
|
MultiplexingDatagramSocket multiplexing,
|
||||||
|
DatagramPacketFilter filter)
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
/*
|
||||||
|
* Even if MultiplexingDatagramSocket allows MultiplexedDatagramSocket
|
||||||
|
* to perform bind, binding in the super will not execute correctly this
|
||||||
|
* early in the construction because the multiplexing field is not set
|
||||||
|
* yet. That is why MultiplexedDatagramSocket does not currently support
|
||||||
|
* bind at construction time.
|
||||||
|
*/
|
||||||
|
super((SocketAddress) null);
|
||||||
|
|
||||||
|
if (multiplexing == null)
|
||||||
|
throw new NullPointerException("multiplexing");
|
||||||
|
|
||||||
|
this.multiplexing = multiplexing;
|
||||||
|
this.filter = filter;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Binds this <tt>DatagramSocket</tt> to a specific address and port.
|
||||||
|
* <p>
|
||||||
|
* If the address is <tt>null</tt>, then the system will pick up an
|
||||||
|
* ephemeral port and a valid local address to bind the socket.
|
||||||
|
*</p>
|
||||||
|
*
|
||||||
|
* @param addr the address and port to bind to
|
||||||
|
* @throws SocketException if any error happens during the bind, or if the
|
||||||
|
* socket is already bound
|
||||||
|
* @throws SecurityException if a security manager exists and its
|
||||||
|
* <tt>checkListen</tt> method doesn't allow the operation
|
||||||
|
* @throws IllegalArgumentException if <tt>addr</tt> is a
|
||||||
|
* <tt>SocketAddress</tt> subclass not supported by this socket
|
||||||
|
* @see DatagramSocket#bind(SocketAddress)
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void bind(SocketAddress addr)
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
multiplexing.bind(addr);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Closes this datagram socket.
|
||||||
|
* <p>
|
||||||
|
* Any thread currently blocked in {@link #receive(DatagramPacket)} upon
|
||||||
|
* this socket will throw a {@link SocketException}.
|
||||||
|
* </p>
|
||||||
|
*
|
||||||
|
* @see DatagramSocket#close()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void close()
|
||||||
|
{
|
||||||
|
multiplexing.close(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Connects the socket to a remote address for this socket. When a socket is
|
||||||
|
* connected to a remote address, packets may only be sent to or received
|
||||||
|
* from that address. By default a datagram socket is not connected.
|
||||||
|
* <p>
|
||||||
|
* If the remote destination to which the socket is connected does not
|
||||||
|
* exist, or is otherwise unreachable, and if an ICMP destination
|
||||||
|
* unreachable packet has been received for that address, then a subsequent
|
||||||
|
* call to {@link #send(DatagramPacket)} or {@link #receive(DatagramPacket)}
|
||||||
|
* may throw a <tt>PortUnreachableException</tt>. Note, there is no
|
||||||
|
* guarantee that the exception will be thrown.
|
||||||
|
* </p>
|
||||||
|
*
|
||||||
|
* @param address the remote address for the socket
|
||||||
|
* @param port the remote port for the socket
|
||||||
|
* @throws IllegalArgumentException if the address is <tt>null</tt>, or the
|
||||||
|
* port is out of range
|
||||||
|
* @throws SecurityException if the caller is not allowed to send datagrams
|
||||||
|
* to and receive datagrams from the address and port
|
||||||
|
* @see DatagramSocket#connect(InetAddress, int)
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void connect(InetAddress address, int port)
|
||||||
|
{
|
||||||
|
multiplexing.connect(address, port);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Connects this socket to a remote socket address.
|
||||||
|
*
|
||||||
|
* @param addr the remote address
|
||||||
|
* @throws SocketException if the connect fails
|
||||||
|
* @throws IllegalArgumentException if <tt>addr</tt> is <tt>null</tt> or a
|
||||||
|
* <tt>SocketAddress</tt> subclass not supported by this socket
|
||||||
|
* @see DatagramSocket#connect(SocketAddress)
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void connect(SocketAddress addr)
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
multiplexing.connect(addr);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Disconnects the socket. This does nothing if the socket is not connected.
|
||||||
|
*
|
||||||
|
* @see DatagramSocket#disconnect()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void disconnect()
|
||||||
|
{
|
||||||
|
multiplexing.disconnect();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Tests if <tt>SO_BROADCAST</tt> is enabled.
|
||||||
|
*
|
||||||
|
* @return a <tt>boolean</tt> indicating whether or not
|
||||||
|
* <tt>SO_BROADCAST</tt> is enabled
|
||||||
|
* @throws SocketException if there is an error in the underlying protocol,
|
||||||
|
* such as an UDP error
|
||||||
|
* @see DatagramSocket#getBroadcast()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public boolean getBroadcast()
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
return multiplexing.getBroadcast();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the unique {@link DatagramChannel} object associated with this
|
||||||
|
* datagram socket, if any.
|
||||||
|
* <p>
|
||||||
|
* A datagram socket will have a channel if, and only if, the channel itself
|
||||||
|
* was created via the {@link DatagramChannel#open()} method
|
||||||
|
* </p>
|
||||||
|
*
|
||||||
|
* @return the datagram channel associated with this datagram socket, or
|
||||||
|
* <tt>null</tt> if this socket was not created for a channel
|
||||||
|
* @see DatagramSocket#getChannel()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public DatagramChannel getChannel()
|
||||||
|
{
|
||||||
|
return multiplexing.getChannel();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the <tt>DatagramPacketFilter</tt> which determines which
|
||||||
|
* <tt>DatagramPacket</tt>s read from the network are to be received through
|
||||||
|
* this <tt>DatagramSocket</tt>.
|
||||||
|
*
|
||||||
|
* @return the <tt>DatagramPacketFilter</tt> which determines which
|
||||||
|
* <tt>DatagramPacket</tt>s read from the network are to be received through
|
||||||
|
* this <tt>DatagramSocket</tt>
|
||||||
|
*/
|
||||||
|
public DatagramPacketFilter getFilter()
|
||||||
|
{
|
||||||
|
return filter;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the address to which this socket is connected. Returns
|
||||||
|
* <tt>null</tt> if the socket is not connected.
|
||||||
|
*
|
||||||
|
* @return the address to which this socket is connected
|
||||||
|
* @see DatagramSocket#getInetAddress()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public InetAddress getInetAddress()
|
||||||
|
{
|
||||||
|
return multiplexing.getInetAddress();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the local address to which the socket is bound.
|
||||||
|
* <p>
|
||||||
|
* If there is a security manager, its <tt>checkConnect</tt> method is first
|
||||||
|
* called with the host address and <tt>-1</tt> as its arguments to see if
|
||||||
|
* the operation is allowed.
|
||||||
|
*
|
||||||
|
* @return the local address to which the socket is bound, or an
|
||||||
|
* <tt>InetAddress</tt> representing any local address if either the socket
|
||||||
|
* is not bound, or the security manager <tt>checkConnect</tt> method does
|
||||||
|
* not allow the operation
|
||||||
|
* @see DatagramSocket#getLocalAddress()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public InetAddress getLocalAddress()
|
||||||
|
{
|
||||||
|
return multiplexing.getLocalAddress();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the port number on the local host to which this socket is bound.
|
||||||
|
*
|
||||||
|
* @return the port number on the local host to which this socket is bound
|
||||||
|
* @see DatagramSocket#getLocalPort()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public int getLocalPort()
|
||||||
|
{
|
||||||
|
return multiplexing.getLocalPort();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the address of the endpoint this socket is bound to, or
|
||||||
|
* <tt>null</tt> if it is not bound yet.
|
||||||
|
*
|
||||||
|
* @return a <tt>SocketAddress</tt> representing the local endpoint of this
|
||||||
|
* socket, or <tt>null</tt> if it is not bound yet
|
||||||
|
* @see DatagramSocket#getLocalSocketAddress()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public SocketAddress getLocalSocketAddress()
|
||||||
|
{
|
||||||
|
return multiplexing.getLocalSocketAddress();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the port for this socket. Returns <tt>-1</tt> if the socket is
|
||||||
|
* not connected.
|
||||||
|
*
|
||||||
|
* @return the port to which this socket is connected
|
||||||
|
* @see DatagramSocket#getPort()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public int getPort()
|
||||||
|
{
|
||||||
|
return multiplexing.getPort();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the value of the <tt>SO_RCVBUF</tt> option for this
|
||||||
|
* <tt>DatagramSocket</tt>, that is the buffer size used by the platform for
|
||||||
|
* input on this <tt>DatagramSocket</tt>.
|
||||||
|
*
|
||||||
|
* @return the value of the <tt>SO_RCVBUF</tt> option for this
|
||||||
|
* <tt>DatagramSocket</tt>
|
||||||
|
* @throws SocketException if there is an error in the underlying protocol,
|
||||||
|
* such as an UDP error
|
||||||
|
* @see DatagramSocket#getReceiveBufferSize()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public int getReceiveBufferSize()
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
return multiplexing.getReceiveBufferSize();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the address of the endpoint this socket is connected to, or
|
||||||
|
* <tt>null</tt> if it is unconnected.
|
||||||
|
*
|
||||||
|
* @return a <tt>SocketAddress</tt> representing the remote endpoint of this
|
||||||
|
* socket, or <tt>null</tt> if it is not connected yet
|
||||||
|
* @see DatagramSocket#getRemoteSocketAddress()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public SocketAddress getRemoteSocketAddress()
|
||||||
|
{
|
||||||
|
return multiplexing.getRemoteSocketAddress();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Tests if <tt>SO_REUSEADDR</tt> is enabled.
|
||||||
|
*
|
||||||
|
* @return a <tt>boolean</tt> indicating whether or not
|
||||||
|
* <tt>SO_REUSEADDR</tt> is enabled
|
||||||
|
* @throws SocketException if there is an error in the underlying protocol,
|
||||||
|
* such as an UDP error
|
||||||
|
* @see DatagramSocket#getReuseAddress()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public boolean getReuseAddress()
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
return multiplexing.getReuseAddress();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the value of the <tt>SO_SNDBUF</tt> option for this
|
||||||
|
* <tt>DatagramSocket</tt>, that is the buffer size used by the platform for
|
||||||
|
* output on this <tt>DatagramSocket</tt>.
|
||||||
|
*
|
||||||
|
* @return the value of the <tt>SO_SNDBUF</tt> option for this
|
||||||
|
* <tt>DatagramSocket</tt>
|
||||||
|
* @throws SocketException if there is an error in the underlying protocol,
|
||||||
|
* such as an UDP error
|
||||||
|
* @see DatagramSocket#getSendBufferSize()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public int getSendBufferSize()
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
return multiplexing.getSendBufferSize();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieves setting for <tt>SO_TIMEOUT</tt>. Zero returned implies that
|
||||||
|
* the option is disabled (i.e., timeout of infinity).
|
||||||
|
*
|
||||||
|
* @return the setting for <tt>SO_TIMEOUT</tt>
|
||||||
|
* @throws SocketException if there is an error in the underlying protocol,
|
||||||
|
* such as an UDP error
|
||||||
|
* @see DatagramSocket#getSoTimeout()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public int getSoTimeout()
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
return multiplexing.getSoTimeout();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the traffic class or type-of-service in the IP datagram header for
|
||||||
|
* packets sent from this <tt>DatagramSocket</tt>.
|
||||||
|
* <p>
|
||||||
|
* As the underlying network implementation may ignore the traffic class or
|
||||||
|
* type-of-service set using {@link #setTrafficClass(int)} this method may
|
||||||
|
* return a different value than was previously set using the
|
||||||
|
* {@link #setTrafficClass(int)} method on this <tt>DatagramSocket</tt>.
|
||||||
|
* </p>
|
||||||
|
*
|
||||||
|
* @return the traffic class or type-of-service already set
|
||||||
|
* @throws SocketException if there is an error obtaining the traffic class
|
||||||
|
* or type-of-service value
|
||||||
|
* @see DatagramSocket#getTrafficClass()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public int getTrafficClass()
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
return multiplexing.getTrafficClass();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the binding state of the socket.
|
||||||
|
*
|
||||||
|
* @return <tt>true</tt> if the socket successfully bound to an address;
|
||||||
|
* otherwise, <tt>false</tt>
|
||||||
|
* @see DatagramSocket#isBound()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public boolean isBound()
|
||||||
|
{
|
||||||
|
return multiplexing.isBound();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns whether the socket is closed or not.
|
||||||
|
*
|
||||||
|
* @return <tt>true</tt> if the socket has been closed; otherwise,
|
||||||
|
* <tt>false</tt>
|
||||||
|
* @see DatagramSocket#isClosed()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public boolean isClosed()
|
||||||
|
{
|
||||||
|
return multiplexing.isClosed();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the connection state of the socket.
|
||||||
|
*
|
||||||
|
* @return <tt>true</tt> if the socket successfully connected to a server;
|
||||||
|
* otherwise, <tt>false</tt>
|
||||||
|
* @see DatagramSocket#isConnected()
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public boolean isConnected()
|
||||||
|
{
|
||||||
|
return multiplexing.isConnected();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Receives a datagram packet from this socket. When this method returns,
|
||||||
|
* the <tt>DatagramPacket</tt>'s buffer is filled with the data received.
|
||||||
|
* The datagram packet also contains the sender's IP address, and the port
|
||||||
|
* number on the sender's machine.
|
||||||
|
* <p>
|
||||||
|
* This method blocks until a datagram is received. The <tt>length</tt>
|
||||||
|
* field of the datagram packet object contains the length of the received
|
||||||
|
* message. If the message is longer than the packet's length, the message
|
||||||
|
* is truncated.
|
||||||
|
* </p>
|
||||||
|
* <p>
|
||||||
|
* If there is a security manager, a packet cannot be received if the
|
||||||
|
* security manager's <tt>checkAccept</tt> method does not allow it.
|
||||||
|
* </p>
|
||||||
|
*
|
||||||
|
* @param p the <tt>DatagramPacket</tt> into which to place the incoming
|
||||||
|
* data
|
||||||
|
* @throws IOException if an I/O error occurs
|
||||||
|
* @see DatagramSocket#receive(DatagramPacket)
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void receive(DatagramPacket p)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
multiplexing.receive(this, p);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Sends a datagram packet from this socket. The <tt>DatagramPacket</tt>
|
||||||
|
* includes information indicating the data to be sent, its length, the IP
|
||||||
|
* address of the remote host, and the port number on the remote host.
|
||||||
|
* <p>
|
||||||
|
* If there is a security manager, and the socket is not currently connected
|
||||||
|
* to a remote address, this method first performs some security checks.
|
||||||
|
* First, if <tt>p.getAddress().isMulticastAddress()</tt> is true, this
|
||||||
|
* method calls the security manager's <tt>checkMulticast</tt> method with
|
||||||
|
* <tt>p.getAddress()</tt> as its argument. If the evaluation of that
|
||||||
|
* expression is <tt>false</tt>, this method instead calls the security
|
||||||
|
* manager's <tt>checkConnect</tt> method with arguments
|
||||||
|
* <tt>p.getAddress().getHostAddress()</tt> and <tt>p.getPort()</tt>. Each
|
||||||
|
* call to a security manager method could result in a
|
||||||
|
* <tt>SecurityException</tt> if the operation is not allowed.
|
||||||
|
* </p>
|
||||||
|
*
|
||||||
|
* @param p the <tt>DatagramPacket</tt> to be sent
|
||||||
|
* @throws IOException if an I/O error occurs
|
||||||
|
* @see DatagramSocket#send(DatagramPacket)
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void send(DatagramPacket p)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
multiplexing.send(p);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Enables/disables <tt>SO_BROADCAST</tt>.
|
||||||
|
*
|
||||||
|
* @param on whether or not to have broadcast turned on
|
||||||
|
* @throws SocketException if there is an error in the underlying protocol,
|
||||||
|
* such as an UDP error
|
||||||
|
* @see DatagramSocket#setBroadcast(boolean)
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void setBroadcast(boolean on)
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
multiplexing.setBroadcast(on);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Sets the <tt>SO_RCVBUF</tt> option to the specified value for this
|
||||||
|
* <tt>DatagramSocket</tt>. The <tt>SO_RCVBUF</tt> option is used by the
|
||||||
|
* network implementation as a hint to size the underlying network I/O
|
||||||
|
* buffers. The <tt>SO_RCVBUF</tt> setting may also be used by the network
|
||||||
|
* implementation to determine the maximum size of the packet that can be
|
||||||
|
* received on this socket.
|
||||||
|
* <p>
|
||||||
|
* Because <tt>SO_RCVBUF</tt> is a hint, applications that want to verify
|
||||||
|
* what size the buffers were set to should call
|
||||||
|
* {@link #getReceiveBufferSize()}.
|
||||||
|
* </p>
|
||||||
|
*
|
||||||
|
* @param size the size to which to set the receive buffer size. The value
|
||||||
|
* must be greater than zero
|
||||||
|
* @throws SocketException if there is an error in the underlying protocol,
|
||||||
|
* such as an UDP error
|
||||||
|
* @throws IllegalArgumentException if the value is zero or is negative
|
||||||
|
* @see DatagramSocket#setReceiveBufferSize(int)
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void setReceiveBufferSize(int size)
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
multiplexing.setReceiveBufferSize(size);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Enables/disables the <tt>SO_REUSEADDR</tt> socket option.
|
||||||
|
*
|
||||||
|
* @param on whether to enable or disable the <tt>SO_REUSEADDR</tt> socket
|
||||||
|
* option
|
||||||
|
* @throws SocketException if an error occurs enabling or disabling the
|
||||||
|
* <tt>SO_RESUEADDR</tt> socket option, or the socket is closed
|
||||||
|
* @see DatagramSocket#setReuseAddress(boolean)
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void setReuseAddress(boolean on)
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
multiplexing.setReuseAddress(on);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Sets the <tt>SO_SNDBUF</tt> option to the specified value for this
|
||||||
|
* <tt>DatagramSocket</tt>. The <tt>SO_SNDBUF</tt> option is used by the
|
||||||
|
* network implementation as a hint to size the underlying network I/O
|
||||||
|
* buffers. The <tt>SO_SNDBUF</tt> setting may also be used by the network
|
||||||
|
* implementation to determine the maximum size of the packet that can be
|
||||||
|
* sent on this socket.
|
||||||
|
* <p>
|
||||||
|
* As <tt>SO_SNDBUF</tt> is a hint, applications that want to verify what
|
||||||
|
* size the buffer is should call {@link #getSendBufferSize()}.
|
||||||
|
* </p>
|
||||||
|
* <p>
|
||||||
|
* Increasing the buffer size may allow multiple outgoing packets to be
|
||||||
|
* queued by the network implementation when the send rate is high.
|
||||||
|
* </p>
|
||||||
|
*
|
||||||
|
* @param size the size to which to set the send buffer size. The value must
|
||||||
|
* be greater than zero
|
||||||
|
* @throws SocketException if there is an error in the underlying protocol,
|
||||||
|
* such as an UDP error
|
||||||
|
* @throws IllegalArgumentException if the value is zero or is negative
|
||||||
|
* @see DatagramSocket#setSendBufferSize(int)
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void setSendBufferSize(int size)
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
multiplexing.setSendBufferSize(size);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Enables/disables <tt>SO_TIMEOUT</tt> with the specified timeout, in
|
||||||
|
* milliseconds. With this option set to a non-zero timeout, a call to
|
||||||
|
* {@link #receive(DatagramPacket)} for this <tt>DatagramSocket</tt> will
|
||||||
|
* block for only this amount of time. If the timeout expires, a
|
||||||
|
* <tt>SocketTimeoutException</tt> is raised, though the
|
||||||
|
* <tt>DatagramSocket</tt> is still valid. The option must be enabled prior
|
||||||
|
* to entering the blocking operation to have effect. The timeout must be
|
||||||
|
* greater than zero. A timeout of zero is interpreted as an infinite
|
||||||
|
* timeout.
|
||||||
|
*
|
||||||
|
* @param timeout the specified timeout in milliseconds
|
||||||
|
* @throws SocketException if there is an error in the underlying protocol,
|
||||||
|
* such as an UDP error
|
||||||
|
* @see DatagramSocket#setSoTimeout(int)
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void setSoTimeout(int timeout)
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
multiplexing.setSoTimeout(timeout);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Sets traffic class or type-of-service octet in the IP datagram header for
|
||||||
|
* datagrams sent from this <tt>DatagramSocket</tt>. As the underlying
|
||||||
|
* network implementation may ignore this value applications should consider
|
||||||
|
* it a hint.
|
||||||
|
*
|
||||||
|
* @param tc an <tt>int</tt> value for the bitset
|
||||||
|
* @throws SocketException if there is an error setting the traffic class or
|
||||||
|
* type-of-service
|
||||||
|
* @see DatagramSocket#setTrafficClass(int)
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void setTrafficClass(int tc)
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
multiplexing.setTrafficClass(tc);
|
||||||
|
}
|
||||||
|
}
|
||||||
414
src/org/ice4j/socket/MultiplexingDatagramSocket.java
Normal file
414
src/org/ice4j/socket/MultiplexingDatagramSocket.java
Normal file
@ -0,0 +1,414 @@
|
|||||||
|
/*
|
||||||
|
* 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.socket;
|
||||||
|
|
||||||
|
import java.io.*;
|
||||||
|
import java.net.*;
|
||||||
|
import java.util.*;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Represents a <tt>DatagramSocket</tt> which allows filtering
|
||||||
|
* <tt>DatagramPacket</tt>s it reads from the network using
|
||||||
|
* <tt>DatagramPacketFilter</tt>s so that the <tt>DatagramPacket</tt>s do not
|
||||||
|
* get received through it but through associated
|
||||||
|
* <tt>MultiplexedDatagramSocket</tt>s.
|
||||||
|
*
|
||||||
|
* @author Lubomir Marinov
|
||||||
|
*/
|
||||||
|
public class MultiplexingDatagramSocket
|
||||||
|
extends DatagramSocket
|
||||||
|
{
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The constant which represents an empty array with
|
||||||
|
* <tt>MultiplexedDatagramSocket</tt> element type. Explicitly defined in
|
||||||
|
* order to reduce allocations.
|
||||||
|
*/
|
||||||
|
private static final MultiplexedDatagramSocket[] NO_SOCKETS
|
||||||
|
= new MultiplexedDatagramSocket[0];
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The indicator which determines whether this <tt>DatagramSocket</tt> is
|
||||||
|
* currently reading from the network using
|
||||||
|
* {@link DatagramSocket#receive(DatagramPacket)}. When <tt>true</tt>,
|
||||||
|
* subsequent requests to read from the network will be blocked until the
|
||||||
|
* current read is finished.
|
||||||
|
*/
|
||||||
|
private boolean inReceive = false;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The list of <tt>DatagramPacket</tt>s to be received through this
|
||||||
|
* <tt>DatagramSocket</tt> i.e. not accepted by the <tt>DatagramFilter</tt>s
|
||||||
|
* of {@link #sockets} at the time of the reading from the network.
|
||||||
|
*/
|
||||||
|
private final List<DatagramPacket> received
|
||||||
|
= new LinkedList<DatagramPacket>();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The <tt>Object</tt> which synchronizes the access to {@link #inReceive}.
|
||||||
|
*/
|
||||||
|
private final Object receiveSyncRoot = new Object();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The <tt>MultiplexedDatagramSocket</tt>s filtering
|
||||||
|
* <tt>DatagramPacket</tt>s away from this <tt>DatagramSocket</tt>.
|
||||||
|
*/
|
||||||
|
private MultiplexedDatagramSocket[] sockets = NO_SOCKETS;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The <tt>Object</tt> which synchronizes the access to the {@link #sockets}
|
||||||
|
* field of this instance.
|
||||||
|
*/
|
||||||
|
private final Object socketsSyncRoot = new Object();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes a new <tt>MultiplexingDatagramSocket</tt> instance which is
|
||||||
|
* to enable <tt>DatagramPacket</tt> filtering and binds it to any available
|
||||||
|
* port on the local host machine. The socket will be bound to the wildcard
|
||||||
|
* address, an IP address chosen by the kernel.
|
||||||
|
*
|
||||||
|
* @throws SocketException if the socket could not be opened, or the socket
|
||||||
|
* could not bind to the specified local port
|
||||||
|
* @see DatagramSocket#DatagramSocket()
|
||||||
|
*/
|
||||||
|
public MultiplexingDatagramSocket()
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
super();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes a new <tt>MultiplexingDatagramSocket</tt> instance which is
|
||||||
|
* to enable <tt>DatagramPacket</tt> filtering, bound to the specified local
|
||||||
|
* socket address.
|
||||||
|
* <p>
|
||||||
|
* If the specified local socket address is <tt>null</tt>, creates an
|
||||||
|
* unbound socket.
|
||||||
|
* </p>
|
||||||
|
*
|
||||||
|
* @param bindaddr local socket address to bind, or <tt>null</tt> for an
|
||||||
|
* unbound socket
|
||||||
|
* @throws SocketException if the socket could not be opened, or the socket
|
||||||
|
* could not bind to the specified local port
|
||||||
|
* @see DatagramSocket#DatagramSocket(SocketAddress)
|
||||||
|
*/
|
||||||
|
public MultiplexingDatagramSocket(SocketAddress bindaddr)
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
super(bindaddr);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes a new <tt>MultiplexingDatagramSocket</tt> instance which is
|
||||||
|
* to enable <tt>DatagramPacket</tt> filtering and binds it to the specified
|
||||||
|
* port on the local host machine. The socket will be bound to the wildcard
|
||||||
|
* address, an IP address chosen by the kernel.
|
||||||
|
*
|
||||||
|
* @param port the port to bind the new socket to
|
||||||
|
* @throws SocketException if the socket could not be opened, or the socket
|
||||||
|
* could not bind to the specified local port
|
||||||
|
* @see DatagramSocket#DatagramSocket(int)
|
||||||
|
*/
|
||||||
|
public MultiplexingDatagramSocket(int port)
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
super(port);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes a new <tt>MultiplexingDatagramSocket</tt> instance which is
|
||||||
|
* to enable <tt>DatagramPacket</tt> filtering, bound to the specified local
|
||||||
|
* address. The local port must be between 0 and 65535 inclusive. If the IP
|
||||||
|
* address is 0.0.0.0, the socket will be bound to the wildcard address, an
|
||||||
|
* IP address chosen by the kernel.
|
||||||
|
*
|
||||||
|
* @param port the local port to bind the new socket to
|
||||||
|
* @param laddr the local address to bind the new socket to
|
||||||
|
* @throws SocketException if the socket could not be opened, or the socket
|
||||||
|
* could not bind to the specified local port
|
||||||
|
* @see DatagramSocket#DatagramSocket(int, InetAddress)
|
||||||
|
*/
|
||||||
|
public MultiplexingDatagramSocket(int port, InetAddress laddr)
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
super(port, laddr);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes a new <tt>DatagramPacket</tt> instance which is a clone of a
|
||||||
|
* specific <tt>DatagramPacket</tt> i.e. the properties of the clone
|
||||||
|
* <tt>DatagramPacket</tt> are clones of the specified
|
||||||
|
* <tt>DatagramPacket</tt>.
|
||||||
|
*
|
||||||
|
* @param p the <tt>DatagramPacket</tt> to clone
|
||||||
|
* @return a new <tt>DatagramPacket</tt> instance which is a clone of the
|
||||||
|
* specified <tt>DatagramPacket</tt>
|
||||||
|
*/
|
||||||
|
static DatagramPacket clone(DatagramPacket p)
|
||||||
|
{
|
||||||
|
synchronized (p)
|
||||||
|
{
|
||||||
|
byte[] pData = p.getData();
|
||||||
|
byte[] cData = (pData == null) ? pData : pData.clone();
|
||||||
|
|
||||||
|
return
|
||||||
|
new DatagramPacket(
|
||||||
|
cData,
|
||||||
|
p.getOffset(),
|
||||||
|
p.getLength(),
|
||||||
|
p.getAddress(),
|
||||||
|
p.getPort());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Closes a specific <tt>MultiplexedDatagramSocket</tt> which filters
|
||||||
|
* <tt>DatagramPacket</tt>s away from this <tt>DatagramSocket</tt>.
|
||||||
|
*
|
||||||
|
* @param multiplexed the <tt>MultiplexedDatagramSocket</tt> to close
|
||||||
|
*/
|
||||||
|
void close(MultiplexedDatagramSocket multiplexed)
|
||||||
|
{
|
||||||
|
synchronized (socketsSyncRoot)
|
||||||
|
{
|
||||||
|
int socketCount = sockets.length;
|
||||||
|
|
||||||
|
for (int i = 0; i < socketCount; i++)
|
||||||
|
if (sockets[i].equals(multiplexed))
|
||||||
|
{
|
||||||
|
if (socketCount == 1)
|
||||||
|
sockets = NO_SOCKETS;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
MultiplexedDatagramSocket[] newSockets
|
||||||
|
= new MultiplexedDatagramSocket[socketCount - 1];
|
||||||
|
|
||||||
|
System.arraycopy(sockets, 0, newSockets, 0, i);
|
||||||
|
System
|
||||||
|
.arraycopy(
|
||||||
|
sockets,
|
||||||
|
i + 1,
|
||||||
|
newSockets,
|
||||||
|
i,
|
||||||
|
newSockets.length - i);
|
||||||
|
sockets = newSockets;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Copies the properties of a specific <tt>DatagramPacket</tt> to another
|
||||||
|
* <tt>DatagramPacket</tt>. The property values are not cloned.
|
||||||
|
*
|
||||||
|
* @param src the <tt>DatagramPacket</tt> which is to have its properties
|
||||||
|
* copied to <tt>dest</tt>
|
||||||
|
* @param dest the <tt>DatagramPacket</tt> which is to have its properties
|
||||||
|
* set to the value of the respective properties of <tt>src</tt>
|
||||||
|
*/
|
||||||
|
static void copy(DatagramPacket src, DatagramPacket dest)
|
||||||
|
{
|
||||||
|
synchronized (dest)
|
||||||
|
{
|
||||||
|
dest.setAddress(src.getAddress());
|
||||||
|
dest.setData(src.getData(), src.getOffset(), src.getLength());
|
||||||
|
dest.setPort(src.getPort());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets a <tt>MultiplexedDatagramSocket</tt> which filters
|
||||||
|
* <tt>DatagramPacket</tt>s away from this <tt>DatagramSocket</tt> using a
|
||||||
|
* specific <tt>DatagramPacketFilter</tt>. If such a
|
||||||
|
* <tt>MultiplexedDatagramSocket</tt> does not exist in this instance, it is
|
||||||
|
* created.
|
||||||
|
*
|
||||||
|
* @param filter the <tt>DatagramPacketFilter</tt> to get a
|
||||||
|
* <tt>MultiplexedDatagramSocket</tt> for
|
||||||
|
* @return a <tt>MultiplexedDatagramSocket</tt> which filters
|
||||||
|
* <tt>DatagramPacket</tt>s away from this <tt>DatagramSocket</tt> using the
|
||||||
|
* specified <tt>filter</tt>
|
||||||
|
* @throws SocketException if creating the
|
||||||
|
* <tt>MultiplexedDatagramSocket</tt> for the specified <tt>filter</tt>
|
||||||
|
* fails
|
||||||
|
*/
|
||||||
|
public MultiplexedDatagramSocket getSocket(DatagramPacketFilter filter)
|
||||||
|
throws SocketException
|
||||||
|
{
|
||||||
|
if (filter == null)
|
||||||
|
throw new NullPointerException("filter");
|
||||||
|
|
||||||
|
synchronized (socketsSyncRoot)
|
||||||
|
{
|
||||||
|
/*
|
||||||
|
* If a socket for the specified filter exists already, do not
|
||||||
|
* create a new one and return the existing.
|
||||||
|
*/
|
||||||
|
for (MultiplexedDatagramSocket socket : sockets)
|
||||||
|
if (filter.equals(socket.getFilter()))
|
||||||
|
return socket;
|
||||||
|
|
||||||
|
// Create a new socket for the specified filter.
|
||||||
|
MultiplexedDatagramSocket socket
|
||||||
|
= new MultiplexedDatagramSocket(this, filter);
|
||||||
|
|
||||||
|
// Remember the new socket.
|
||||||
|
int socketCount = sockets.length;
|
||||||
|
|
||||||
|
if (socketCount == 0)
|
||||||
|
sockets = new MultiplexedDatagramSocket[] { socket };
|
||||||
|
else
|
||||||
|
{
|
||||||
|
MultiplexedDatagramSocket[] newSockets
|
||||||
|
= new MultiplexedDatagramSocket[socketCount + 1];
|
||||||
|
|
||||||
|
System.arraycopy(sockets, 0, newSockets, 0, socketCount);
|
||||||
|
newSockets[socketCount] = socket;
|
||||||
|
sockets = newSockets;
|
||||||
|
}
|
||||||
|
|
||||||
|
return socket;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Receives a datagram packet from this socket. The <tt>DatagramPacket</tt>s
|
||||||
|
* returned by this method do not match any of the
|
||||||
|
* <tt>DatagramPacketFilter</tt>s of the <tt>MultiplexedDatagramSocket</tt>s
|
||||||
|
* associated with this instance at the time of their receipt. When this
|
||||||
|
* method returns, the <tt>DatagramPacket</tt>'s buffer is filled with the
|
||||||
|
* data received. The datagram packet also contains the sender's IP address,
|
||||||
|
* and the port number on the sender's machine.
|
||||||
|
* <p>
|
||||||
|
* This method blocks until a datagram is received. The <tt>length</tt>
|
||||||
|
* field of the datagram packet object contains the length of the received
|
||||||
|
* message. If the message is longer than the packet's length, the message
|
||||||
|
* is truncated.
|
||||||
|
* </p>
|
||||||
|
*
|
||||||
|
* @param p the <tt>DatagramPacket</tt> into which to place the incoming
|
||||||
|
* data
|
||||||
|
* @throws IOException if an I/O error occurs
|
||||||
|
* @see DatagramSocket#receive(DatagramPacket)
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
public void receive(DatagramPacket p)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
receive(received, p);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Receives a <tt>DatagramPacket</tt> from a specific list of
|
||||||
|
* <tt>DatagramPacket</tt>s if it is not empty or from the network if the
|
||||||
|
* specified list is empty. When this method returns, the
|
||||||
|
* <tt>DatagramPacket</tt>'s buffer is filled with the data received. The
|
||||||
|
* datagram packet also contains the sender's IP address, and the port
|
||||||
|
* number on the sender's machine.
|
||||||
|
*
|
||||||
|
* @param received the list of previously received <tt>DatagramPacket</tt>
|
||||||
|
* from which the first is to be removed and returned if available
|
||||||
|
* @param p the <tt>DatagramPacket</tt> into which to place the incoming
|
||||||
|
* data
|
||||||
|
* @throws IOException if an I/O error occurs
|
||||||
|
*/
|
||||||
|
private void receive(List<DatagramPacket> received, DatagramPacket p)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
DatagramPacket r = null;
|
||||||
|
|
||||||
|
do
|
||||||
|
{
|
||||||
|
boolean doReceive;
|
||||||
|
|
||||||
|
synchronized (receiveSyncRoot)
|
||||||
|
{
|
||||||
|
if (received.isEmpty())
|
||||||
|
{
|
||||||
|
if (inReceive)
|
||||||
|
{
|
||||||
|
doReceive = false;
|
||||||
|
try
|
||||||
|
{
|
||||||
|
receiveSyncRoot.wait();
|
||||||
|
}
|
||||||
|
catch (InterruptedException iex)
|
||||||
|
{
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
doReceive = true;
|
||||||
|
inReceive = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
doReceive = false;
|
||||||
|
r = received.remove(0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (doReceive)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
super.receive(p);
|
||||||
|
|
||||||
|
synchronized (receiveSyncRoot)
|
||||||
|
{
|
||||||
|
synchronized (socketsSyncRoot)
|
||||||
|
{
|
||||||
|
boolean accepted = false;
|
||||||
|
|
||||||
|
for (MultiplexedDatagramSocket socket : sockets)
|
||||||
|
if (socket.getFilter().accept(p))
|
||||||
|
{
|
||||||
|
socket.received.add(clone(p));
|
||||||
|
accepted = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!accepted)
|
||||||
|
this.received.add(clone(p));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
finally
|
||||||
|
{
|
||||||
|
synchronized (receiveSyncRoot)
|
||||||
|
{
|
||||||
|
inReceive = false;
|
||||||
|
receiveSyncRoot.notifyAll();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
while (r == null);
|
||||||
|
|
||||||
|
copy(r, p);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Receives a <tt>DatagramPacket</tt> from this <tt>DatagramSocket</tt> upon
|
||||||
|
* request from a specific <tt>MultiplexedDatagramSocket</tt>.
|
||||||
|
*
|
||||||
|
* @param multiplexed the <tt>MultiplexedDatagramSocket</tt> which requests
|
||||||
|
* the receipt of a <tt>DatagramPacket</tt> from the network
|
||||||
|
* @param p the <tt>DatagramPacket</tt> to receive the data from the network
|
||||||
|
* @throws IOException if an I/O error occurs
|
||||||
|
*/
|
||||||
|
void receive(
|
||||||
|
MultiplexedDatagramSocket multiplexed,
|
||||||
|
DatagramPacket p)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
receive(multiplexed.received, p);
|
||||||
|
}
|
||||||
|
}
|
||||||
50
src/org/ice4j/socket/StunDatagramPacketFilter.java
Normal file
50
src/org/ice4j/socket/StunDatagramPacketFilter.java
Normal file
@ -0,0 +1,50 @@
|
|||||||
|
/*
|
||||||
|
* 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.socket;
|
||||||
|
|
||||||
|
import java.net.*;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Implements a <tt>DatagramPacketFilter</tt> which only accepts
|
||||||
|
* <tt>DatagramPacket</tt>s which represent STUN messages.
|
||||||
|
*
|
||||||
|
* @author Lubomir Marinov
|
||||||
|
*/
|
||||||
|
public class StunDatagramPacketFilter
|
||||||
|
implements DatagramPacketFilter
|
||||||
|
{
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Determines whether a specific <tt>DatagramPacket</tt> represents a STUN
|
||||||
|
* message.
|
||||||
|
*
|
||||||
|
* @param p the <tt>DatagramPacket</tt> which is to be checked whether it is
|
||||||
|
* a STUN message
|
||||||
|
* @return <tt>true</tt> if <tt>p</tt> represents a STUN message
|
||||||
|
*/
|
||||||
|
public boolean accept(DatagramPacket p)
|
||||||
|
{
|
||||||
|
/*
|
||||||
|
* All STUN messages MUST start with a 20-byte header followed by zero
|
||||||
|
* or more Attributes.
|
||||||
|
*/
|
||||||
|
if (p.getLength() >= 20)
|
||||||
|
{
|
||||||
|
/*
|
||||||
|
* The most significant 2 bits of every STUN message MUST be zeroes.
|
||||||
|
* This can be used to differentiate STUN packets from other
|
||||||
|
* protocols when STUN is multiplexed with other protocols on the
|
||||||
|
* same port.
|
||||||
|
*/
|
||||||
|
byte b0 = p.getData()[p.getOffset()];
|
||||||
|
|
||||||
|
return ((b0 & 0xC0) == 0);
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
x
Reference in New Issue
Block a user