feat: Adds MergingDatagramSocket.
This commit is contained in:
parent
f9f2c0f3e9
commit
12a4ef19a0
809
src/main/java/org/ice4j/socket/MergingDatagramSocket.java
Normal file
809
src/main/java/org/ice4j/socket/MergingDatagramSocket.java
Normal file
@ -0,0 +1,809 @@
|
||||
/*
|
||||
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||
*
|
||||
* Copyright @ 2015-2016 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.socket;
|
||||
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import java.util.*;
|
||||
import java.util.concurrent.*;
|
||||
import java.util.logging.*;
|
||||
|
||||
/**
|
||||
* A {@link DatagramSocket} implementation which merges a set of sockets.
|
||||
*
|
||||
* It maintains a thread reading from each of the underlying sockets. Thus
|
||||
* received datagrams are provided via the {@link #receive(DatagramPacket)}
|
||||
* API, in the order in which they were originally received (or close to it,
|
||||
* since the implementation is only based on timestamps).
|
||||
*
|
||||
* One of the underlying sockets is used as a delegate, and handles sending
|
||||
* via {@link #send(DatagramPacket)} and calls to
|
||||
* {@link #getLocalPort()}, {@link #getLocalAddress()} and
|
||||
* {@link #getLocalSocketAddress()}.
|
||||
*
|
||||
* Currently the delegate is just the first socket, but the intention is to
|
||||
* allow it to change dynamically.
|
||||
*
|
||||
* @author Boris Grozev
|
||||
*/
|
||||
public class MergingDatagramSocket
|
||||
extends DatagramSocket
|
||||
{
|
||||
/**
|
||||
* The {@link Logger} used by the {@link MergingDatagramSocket} class and
|
||||
* its instances for logging output.
|
||||
*/
|
||||
private static final Logger logger
|
||||
= Logger.getLogger(MergingDatagramSocket.class.getName());
|
||||
|
||||
/**
|
||||
* Used to control access to {@link #socketContainers}.
|
||||
*/
|
||||
private final Object socketContainersSyncRoot = new Object();
|
||||
|
||||
/**
|
||||
* Stores the underlying sockets. Copy on write.
|
||||
*/
|
||||
private SocketContainer[] socketContainers = new SocketContainer[0];
|
||||
|
||||
/**
|
||||
* Calls to {@link #receive(java.net.DatagramPacket)} will wait on this
|
||||
* object in case no packet is available for reading.
|
||||
*/
|
||||
private final Object receiveLock = new Object();
|
||||
|
||||
/**
|
||||
* If non-zero, {@link #receive(java.net.DatagramPacket)} will attempt to
|
||||
* return within this many milliseconds, and will throw a
|
||||
* {@link SocketTimeoutException} if no packet has been read.
|
||||
*/
|
||||
private int soTimeout = 0;
|
||||
|
||||
/**
|
||||
* Initializes a new {@link MergingDatagramSocket} instance.
|
||||
* @throws SocketException
|
||||
*/
|
||||
public MergingDatagramSocket()
|
||||
throws SocketException
|
||||
{}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
@Override
|
||||
public void setSoTimeout(int soTimeout)
|
||||
{
|
||||
this.soTimeout = soTimeout;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
@Override
|
||||
public int getSoTimeout()
|
||||
{
|
||||
return soTimeout;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
* <p/>
|
||||
* The current implementation delegates to the first container, but this is
|
||||
* subject to change.
|
||||
*
|
||||
* @param pkt the datagram to send.
|
||||
* @throws IOException
|
||||
*/
|
||||
@Override
|
||||
public void send(DatagramPacket pkt)
|
||||
throws IOException
|
||||
{
|
||||
SocketContainer[] socketContainers = this.socketContainers;
|
||||
if (socketContainers != null && socketContainers.length > 0
|
||||
&& socketContainers[0] != null)
|
||||
{
|
||||
socketContainers[0].send(pkt);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new IOException("No sockets.");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a {@link DelegatingSocket} instance to this merging socket. Note
|
||||
* that this will start a thread reading from the added socket.
|
||||
* @param socket the socket to add.
|
||||
*/
|
||||
public void add(DelegatingSocket socket)
|
||||
{
|
||||
Objects.requireNonNull(socket, "socket");
|
||||
if (logger.isLoggable(Level.FINE))
|
||||
{
|
||||
logger.fine("Adding a DelegatingSocket instance: "
|
||||
+ socket.getLocalAddress());
|
||||
}
|
||||
doAdd(socket);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a {@link DatagramSocket} instance to this merging socket. Note
|
||||
* that this will start a thread reading from the added socket.
|
||||
* @param socket the socket to add.
|
||||
*/
|
||||
public void add(DatagramSocket socket)
|
||||
{
|
||||
Objects.requireNonNull(socket, "socket");
|
||||
if (logger.isLoggable(Level.FINE))
|
||||
{
|
||||
logger.fine("Adding a DatagramSocket instance: "
|
||||
+ socket.getLocalAddress());
|
||||
}
|
||||
doAdd(socket);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a socket (either a {@link DatagramSocket} or a
|
||||
* {@link DelegatingSocket}) to the list of underlying sockets merged by
|
||||
* this {@link MergingDatagramSocket}.
|
||||
* @param socket the socket to add.
|
||||
*/
|
||||
private void doAdd(Object socket)
|
||||
{
|
||||
if (!(socket instanceof DelegatingSocket) &&
|
||||
!(socket instanceof DatagramSocket))
|
||||
{
|
||||
logger.severe("Unsupported class: "
|
||||
+ (socket == null ? "null" : socket.getClass()));
|
||||
return;
|
||||
}
|
||||
|
||||
synchronized (socketContainersSyncRoot)
|
||||
{
|
||||
if (indexOf(socketContainers, socket) != -1)
|
||||
{
|
||||
logger.warning("Socket already added.");
|
||||
return;
|
||||
}
|
||||
|
||||
SocketContainer socketContainer;
|
||||
if (socket instanceof DelegatingSocket)
|
||||
{
|
||||
socketContainer = new SocketContainer((DelegatingSocket) socket);
|
||||
}
|
||||
else
|
||||
{
|
||||
socketContainer = new SocketContainer((DatagramSocket) socket);
|
||||
}
|
||||
|
||||
SocketContainer[] newSocketContainers
|
||||
= new SocketContainer[socketContainers.length + 1];
|
||||
System.arraycopy(socketContainers, 0,
|
||||
newSocketContainers, 0,
|
||||
socketContainers.length);
|
||||
newSocketContainers[socketContainers.length] = socketContainer;
|
||||
|
||||
socketContainers = newSocketContainers;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes a specific {@link DatagramSocket} from the list of sockets
|
||||
* merged by this {@link MergingDatagramSocket}.
|
||||
* @param socket the {@link DatagramSocket} to remove.
|
||||
*/
|
||||
public void remove(DatagramSocket socket)
|
||||
{
|
||||
doRemove(socket);
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes a specific {@link DelegatingSocket} from the list of sockets
|
||||
* merged by this {@link MergingDatagramSocket}.
|
||||
* @param socket the {@link DelegatingSocket} to remove.
|
||||
*/
|
||||
public void remove(DelegatingSocket socket)
|
||||
{
|
||||
doRemove(socket);
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes a socket from the list of sockets merged by this
|
||||
* {@link MergingDatagramSocket}.
|
||||
* @param socket the socket to remove.
|
||||
*/
|
||||
private void doRemove(Object socket)
|
||||
{
|
||||
SocketContainer socketContainer = null;
|
||||
|
||||
synchronized (socketContainersSyncRoot)
|
||||
{
|
||||
int i = indexOf(socketContainers, socket);
|
||||
if (i > 0)
|
||||
{
|
||||
socketContainer = socketContainers[i];
|
||||
|
||||
SocketContainer[] newSockets
|
||||
= new SocketContainer[socketContainers.length - 1];
|
||||
if (i > 0)
|
||||
{
|
||||
System.arraycopy(socketContainers, 0,
|
||||
newSockets, 0,
|
||||
i);
|
||||
}
|
||||
if (i < socketContainers.length - 1)
|
||||
{
|
||||
System.arraycopy(socketContainers, i + 1,
|
||||
newSockets, i,
|
||||
socketContainers.length - i - 1);
|
||||
}
|
||||
|
||||
socketContainers = newSockets;
|
||||
}
|
||||
else
|
||||
{
|
||||
logger.severe("Cannot find socket to remove.");
|
||||
}
|
||||
}
|
||||
|
||||
if (logger.isLoggable(Level.FINE))
|
||||
{
|
||||
logger.fine("Removed: " + socketContainer);
|
||||
}
|
||||
if (socketContainer != null)
|
||||
{
|
||||
// Stop the reading thread.
|
||||
// TODO: do we want to interrupt the thread here? This will not
|
||||
// help unless we set a soTimeout > 0
|
||||
socketContainer.closed = true;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the index in {@link #socketContainers} of the
|
||||
* {@link SocketContainer} with socket equal to {@code socket}, or -1 if
|
||||
* such a {@link SocketContainer} doesn't exist.
|
||||
*
|
||||
* @param socket the {@link DatagramSocket} to get the index of.
|
||||
* @return the index in {@link #socketContainers} of the
|
||||
* {@link SocketContainer} with socket equal to {@code socket}, or -1 if
|
||||
* such a {@link SocketContainer} doesn't exist.
|
||||
*/
|
||||
private int indexOf(SocketContainer[] socketContainers, Object socket)
|
||||
{
|
||||
for (int i = 0; i < socketContainers.length; i++)
|
||||
{
|
||||
if (socketContainers[i].datagramSocket == socket ||
|
||||
socketContainers[i].delegatingSocket == socket)
|
||||
{
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* TODO
|
||||
*/
|
||||
private SocketContainer getActiveSocket()
|
||||
{
|
||||
//TODO switch dynamically.
|
||||
SocketContainer[] socketContainers = this.socketContainers;
|
||||
if (socketContainers != null && socketContainers.length > 0)
|
||||
{
|
||||
return socketContainers[0];
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
* </p>
|
||||
* Delegates to the "active" socket, if one exists. Else returns
|
||||
* {@code null}.
|
||||
*/
|
||||
@Override
|
||||
public InetAddress getLocalAddress()
|
||||
{
|
||||
SocketContainer activeSocket = getActiveSocket();
|
||||
return activeSocket == null ? null : activeSocket.getLocalAddress();
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
* </p>
|
||||
* Delegates to the "active" socket, if one exists. Else returns
|
||||
* {@code 0}.
|
||||
* TODO: should we return 0 (unbound) or -1 (closed) if there are no
|
||||
* sockets?
|
||||
*/
|
||||
@Override
|
||||
public int getLocalPort()
|
||||
{
|
||||
SocketContainer activeSocket = getActiveSocket();
|
||||
return activeSocket == null ? 0 : activeSocket.getLocalPort();
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
* </p>
|
||||
* Delegates to the "active" socket, if one exists. Else returns
|
||||
* {@code null}.
|
||||
*/
|
||||
@Override
|
||||
public SocketAddress getLocalSocketAddress()
|
||||
{
|
||||
SocketContainer activeSocket = getActiveSocket();
|
||||
return
|
||||
activeSocket == null ? null : activeSocket.getLocalSocketAddress();
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
* </p>
|
||||
* Copies into {@code p} a packet already received from one of the
|
||||
* underlying sockets. The socket is chosen on the base of the timestamp
|
||||
* of the reception of the first packet in its queue (so that earlier
|
||||
* packets are received first).
|
||||
*/
|
||||
@Override
|
||||
public void receive(DatagramPacket p)
|
||||
throws SocketTimeoutException
|
||||
{
|
||||
long start = System.currentTimeMillis();
|
||||
int soTimeout = this.soTimeout;
|
||||
|
||||
// We need to hold the lock while checking for an available packet,
|
||||
// otherwise we might end up wait()-ing if a packet becomes available
|
||||
// after our check.
|
||||
// We keep the loop inside the lock, because this prevents us from
|
||||
// having to re-obtain the lock after wait() returns. All operations
|
||||
// inside the block are non-blocking, except for wait(), so we run no
|
||||
// risk of causing a deadlock by doing so.
|
||||
synchronized (receiveLock)
|
||||
{
|
||||
do
|
||||
{
|
||||
// Find the input socket with the oldest packet
|
||||
SocketContainer[] socketContainers = this.socketContainers;
|
||||
SocketContainer socketToReceiveFrom = null;
|
||||
long firstTime = -1;
|
||||
for (SocketContainer socketContainer : socketContainers)
|
||||
{
|
||||
long f = socketContainer.getFirstReceivedTime();
|
||||
if (f > 0)
|
||||
{
|
||||
if (firstTime == -1 || firstTime > f)
|
||||
{
|
||||
firstTime = f;
|
||||
socketToReceiveFrom = socketContainer;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If a packet is available read it
|
||||
if (socketToReceiveFrom != null)
|
||||
{
|
||||
socketToReceiveFrom.receive(p);
|
||||
return;
|
||||
}
|
||||
// Otherwise wait on receiveLock.
|
||||
else
|
||||
{
|
||||
try
|
||||
{
|
||||
if (soTimeout > 0)
|
||||
{
|
||||
long remaining
|
||||
= start + soTimeout
|
||||
- System.currentTimeMillis();
|
||||
if (remaining <= 0)
|
||||
throw new SocketTimeoutException();
|
||||
|
||||
receiveLock.wait(remaining);
|
||||
}
|
||||
else
|
||||
{
|
||||
receiveLock.wait();
|
||||
}
|
||||
}
|
||||
catch (InterruptedException ie)
|
||||
{
|
||||
Thread.currentThread().interrupt();
|
||||
// We haven't received a packet, but what else can we
|
||||
// do?
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
while (true);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Contains one of the sockets which this {@link MergingDatagramSocket}
|
||||
* merges, and objects associated with the socket, including a thread
|
||||
* which loops reading from it.
|
||||
*
|
||||
* The socket is either a {@link DatagramSocket} or a
|
||||
* {@link DelegatingSocket} instance, stored in {@link #datagramSocket} or
|
||||
* {@link #delegatingSocket} respectively. Exactly one of these fields must
|
||||
* be null.
|
||||
*/
|
||||
private class SocketContainer
|
||||
{
|
||||
/**
|
||||
* Either the socket represented by this instance, if it is a {@link
|
||||
* DatagramSocket} instance, or {@code null} if it is not.
|
||||
*/
|
||||
private final DatagramSocket datagramSocket;
|
||||
|
||||
/**
|
||||
* Either the socket represented by this instance, if it is a {@link
|
||||
* DelegatingSocket} instance, or {@code null}if it is not.
|
||||
*/
|
||||
private final DelegatingSocket delegatingSocket;
|
||||
|
||||
/**
|
||||
* The queue to which packets received from this instance's socket are
|
||||
* added.
|
||||
*/
|
||||
private final ArrayBlockingQueue<Buffer> queue
|
||||
= new ArrayBlockingQueue<>(100);
|
||||
|
||||
/**
|
||||
* A pool of unused {@link Buffer} instances.
|
||||
*/
|
||||
private final ArrayBlockingQueue<Buffer> pool
|
||||
= new ArrayBlockingQueue<>(10);
|
||||
|
||||
/**
|
||||
* A flag used to signal to {@link #thread} to finish.
|
||||
*/
|
||||
private boolean closed = false;
|
||||
|
||||
/**
|
||||
* The remote address of the last received packet.
|
||||
*/
|
||||
private SocketAddress remoteAddress = null;
|
||||
|
||||
/**
|
||||
* The thread which reads packets from this instance's socket and adds
|
||||
* them to {@link #queue}. If the queue is filled up, it will stop
|
||||
* receiving packets and will block waiting for the queue accept.
|
||||
*/
|
||||
private Thread thread;
|
||||
|
||||
/**
|
||||
* Initializes a {@link SocketContainer} instance using a {@link
|
||||
* DatagramSocket} as its socket.
|
||||
*
|
||||
* @param socket the socket.
|
||||
*/
|
||||
SocketContainer(DelegatingSocket socket)
|
||||
{
|
||||
this.datagramSocket = null;
|
||||
this.delegatingSocket = Objects.requireNonNull(socket, "socket");
|
||||
init();
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes a {@link SocketContainer} instance using a {@link
|
||||
* DatagramSocket} as its socket.
|
||||
*
|
||||
* @param socket the socket.
|
||||
*/
|
||||
SocketContainer(DatagramSocket socket)
|
||||
{
|
||||
this.datagramSocket = Objects.requireNonNull(socket, "socket");
|
||||
this.delegatingSocket = null;
|
||||
init();
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes and starts the thread of this instance.
|
||||
*/
|
||||
private void init()
|
||||
{
|
||||
thread = new Thread()
|
||||
{
|
||||
@Override
|
||||
public void run()
|
||||
{
|
||||
runInReaderThread();
|
||||
}
|
||||
};
|
||||
thread.setDaemon(true);
|
||||
thread.setName("MergingDatagramSocket reader thread for: "
|
||||
+ getLocalSocketAddress() + " -> "
|
||||
+ getRemoteSocketAddress());
|
||||
|
||||
if (logger.isLoggable(Level.FINE))
|
||||
{
|
||||
logger.fine("Starting the thread for socket "
|
||||
+ getLocalSocketAddress() + " -> "
|
||||
+ getRemoteSocketAddress());
|
||||
}
|
||||
thread.start();
|
||||
}
|
||||
|
||||
/**
|
||||
* @return an unused {@link Buffer} instance.
|
||||
*/
|
||||
private Buffer getFreeBuffer()
|
||||
{
|
||||
Buffer buffer = pool.poll();
|
||||
if (buffer == null)
|
||||
buffer = new Buffer();
|
||||
buffer.reset();
|
||||
return buffer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads from the underlying socket and adds the read packets to {@link
|
||||
* #queue}. Blocks if {@link #queue} is full.
|
||||
*/
|
||||
private void runInReaderThread()
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
if (closed || Thread.currentThread().isInterrupted())
|
||||
break;
|
||||
|
||||
// Read from the underlying socket
|
||||
Buffer buffer = getFreeBuffer();
|
||||
try
|
||||
{
|
||||
if (!doReceive(buffer))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
catch (IOException ioe)
|
||||
{
|
||||
logger.severe("Failed to receive: " + ioe);
|
||||
break;
|
||||
}
|
||||
|
||||
if (closed || Thread.currentThread().isInterrupted())
|
||||
break;
|
||||
|
||||
try
|
||||
{
|
||||
queue.put(buffer);
|
||||
synchronized (receiveLock)
|
||||
{
|
||||
receiveLock.notifyAll();
|
||||
}
|
||||
}
|
||||
catch (InterruptedException ie)
|
||||
{
|
||||
Thread.currentThread().interrupt();
|
||||
}
|
||||
}
|
||||
|
||||
if (logger.isLoggable(Level.FINE))
|
||||
{
|
||||
logger.fine("Finished: " + toString());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Tries to receive a packet from the underlying socket into {@code
|
||||
* buffer}.
|
||||
*
|
||||
* @param buffer the buffer into which to receive.
|
||||
* @return {@code true} if the method succeeded, or {@code false} if the
|
||||
* thread was interrupted or this {@link SocketContainer} was closed.
|
||||
* @throws IOException if receiving failed due to an I/O error from the
|
||||
* underlying socket.
|
||||
*/
|
||||
private boolean doReceive(Buffer buffer)
|
||||
throws IOException
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
if (closed || Thread.currentThread().isInterrupted())
|
||||
break;
|
||||
try
|
||||
{
|
||||
if (datagramSocket != null)
|
||||
{
|
||||
datagramSocket.receive(buffer.pkt);
|
||||
}
|
||||
else
|
||||
{
|
||||
delegatingSocket.receive(buffer.pkt);
|
||||
}
|
||||
|
||||
buffer.receivedTime = System.currentTimeMillis();
|
||||
remoteAddress = buffer.pkt.getSocketAddress();
|
||||
return true;
|
||||
}
|
||||
catch (SocketTimeoutException ste)
|
||||
{
|
||||
// Ignore timeouts and loop.
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copies a packet from this {@link SocketContainer}'s queue into
|
||||
* {@code p}. Does not block.
|
||||
*
|
||||
* @param p the {@link DatagramPacket} to receive into.
|
||||
*/
|
||||
private void receive(DatagramPacket p)
|
||||
{
|
||||
Buffer buffer = queue.poll();
|
||||
if (buffer == null)
|
||||
{
|
||||
throw new IllegalStateException("Queue empty.");
|
||||
}
|
||||
|
||||
byte[] dest = p.getData();
|
||||
int destOffset = p.getOffset();
|
||||
int len
|
||||
= Math.min(
|
||||
dest.length - destOffset,
|
||||
buffer.pkt.getLength());
|
||||
|
||||
System.arraycopy(buffer.pkt.getData(), buffer.pkt.getOffset(),
|
||||
dest, destOffset,
|
||||
len);
|
||||
p.setLength(len);
|
||||
p.setSocketAddress(buffer.pkt.getSocketAddress());
|
||||
|
||||
pool.offer(buffer);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return the time of reception of the first packet in the queue, or
|
||||
* {@code -1} if the queue is empty.
|
||||
*/
|
||||
private long getFirstReceivedTime()
|
||||
{
|
||||
Buffer nextBuffer = queue.peek();
|
||||
if (nextBuffer != null)
|
||||
{
|
||||
return nextBuffer.receivedTime;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
* <p>
|
||||
* Delegates to the underlying socket (either {@link #datagramSocket} or
|
||||
* {@link #delegatingSocket}).
|
||||
*/
|
||||
private InetAddress getLocalAddress()
|
||||
{
|
||||
return datagramSocket != null
|
||||
? datagramSocket.getLocalAddress()
|
||||
: delegatingSocket.getLocalAddress();
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
* <p>
|
||||
* Delegates to the underlying socket (either {@link #datagramSocket} or
|
||||
* {@link #delegatingSocket}).
|
||||
*/
|
||||
private int getLocalPort()
|
||||
{
|
||||
return datagramSocket != null
|
||||
? datagramSocket.getLocalPort()
|
||||
: delegatingSocket.getLocalPort();
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
* <p>
|
||||
* Delegates to the underlying socket (either {@link #datagramSocket} or
|
||||
* {@link #delegatingSocket}).
|
||||
*/
|
||||
public SocketAddress getLocalSocketAddress()
|
||||
{
|
||||
return datagramSocket != null
|
||||
? datagramSocket.getLocalSocketAddress()
|
||||
: delegatingSocket.getLocalSocketAddress();
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a {@link String} representation of this {@link
|
||||
* SocketContainer}.
|
||||
*/
|
||||
public String toString()
|
||||
{
|
||||
if (datagramSocket != null)
|
||||
{
|
||||
return datagramSocket.getLocalSocketAddress()
|
||||
+ " -> " + remoteAddress;
|
||||
}
|
||||
else
|
||||
{
|
||||
return delegatingSocket.getLocalSocketAddress()
|
||||
+ " -> " + remoteAddress;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends a {@link DatagramPacket} through the underlying socket (either
|
||||
* {@link #datagramSocket} or {@link #delegatingSocket}).
|
||||
*
|
||||
* @param pkt the packet to send.
|
||||
*/
|
||||
private void send(DatagramPacket pkt)
|
||||
throws IOException
|
||||
{
|
||||
if (datagramSocket != null)
|
||||
{
|
||||
datagramSocket.send(pkt);
|
||||
}
|
||||
else
|
||||
{
|
||||
delegatingSocket.send(pkt);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents a {@link DatagramPacket} for the purposes of {@link
|
||||
* SocketContainer}.
|
||||
*/
|
||||
private class Buffer
|
||||
{
|
||||
/**
|
||||
* The size of the buffer to allocate.
|
||||
*/
|
||||
private static final int MAX_PACKET_SIZE = 1500;
|
||||
|
||||
/**
|
||||
* The time at which this buffer was filled.
|
||||
*/
|
||||
long receivedTime = -1;
|
||||
|
||||
/**
|
||||
* The {@link DatagramPacket} wrapped by this {@link Buffer}.
|
||||
*/
|
||||
DatagramPacket pkt
|
||||
= new DatagramPacket(
|
||||
new byte[MAX_PACKET_SIZE],
|
||||
0,
|
||||
MAX_PACKET_SIZE);
|
||||
|
||||
/**
|
||||
* Prepares this {@link Buffer} for reuse.
|
||||
*/
|
||||
private void reset()
|
||||
{
|
||||
receivedTime = -1;
|
||||
|
||||
// We are going to receive from a socket into this packet. If
|
||||
// the length is insufficient it is going to truncate the data.
|
||||
// So reset it to what we know is the underlying byte[]'s
|
||||
// length.
|
||||
pkt.setLength(MAX_PACKET_SIZE);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user