Remove ServerSocketChannel muxing that used private JDK api

Closes #239
This commit is contained in:
Ingo Bauersachs 2021-11-08 21:05:54 +01:00
parent d4a145374f
commit 15d69b316c
13 changed files with 20 additions and 2580 deletions

View File

@ -19,7 +19,6 @@ package org.ice4j.ice.harvest;
import org.ice4j.*; import org.ice4j.*;
import org.ice4j.ice.*; import org.ice4j.ice.*;
import org.ice4j.message.*;
import org.ice4j.socket.*; import org.ice4j.socket.*;
import java.io.*; import java.io.*;
@ -61,7 +60,15 @@ public abstract class AbstractTcpListener
*/ */
static void closeNoExceptions(Channel channel) static void closeNoExceptions(Channel channel)
{ {
MuxServerSocketChannelFactory.closeNoExceptions(channel); try
{
channel.close();
}
catch (IOException ioe)
{
// The whole idea of the method is to close a specific Channel
// without caring about any possible IOException.
}
} }
/** /**
@ -75,7 +82,6 @@ public abstract class AbstractTcpListener
private static List<TransportAddress> getLocalAddresses( private static List<TransportAddress> getLocalAddresses(
int port, int port,
List<NetworkInterface> interfaces) List<NetworkInterface> interfaces)
throws IOException
{ {
List<TransportAddress> addresses = new LinkedList<>(); List<TransportAddress> addresses = new LinkedList<>();
@ -101,83 +107,6 @@ public abstract class AbstractTcpListener
return addresses; return addresses;
} }
/**
* Determines whether a specific {@link DatagramPacket} is the first
* expected (i.e. supported) to be received from an accepted
* {@link SocketChannel} by this {@link AbstractTcpListener}. This is true
* if it is contains the hard-coded SSL client handshake (
* {@link GoogleTurnSSLCandidateHarvester#SSL_CLIENT_HANDSHAKE}), or
* a STUN Binding Request.
*
* @param p the {@code DatagramPacket} to examine
* @return {@code true} if {@code p} looks like the first
* {@code DatagramPacket} expected to be received from an accepted
* {@code SocketChannel} by this {@code TcpHarvester};
* otherwise, {@code false}
*/
private static boolean isFirstDatagramPacket(DatagramPacket p)
{
int len = p.getLength();
boolean b = false;
if (len > 0)
{
byte[] buf = p.getData();
int off = p.getOffset();
// Check for Google TURN SSLTCP
final byte[] googleTurnSslTcp
= GoogleTurnSSLCandidateHarvester.SSL_CLIENT_HANDSHAKE;
if (len >= googleTurnSslTcp.length)
{
b = true;
for (int i = 0, iEnd = googleTurnSslTcp.length, j = off;
i < iEnd;
i++, j++)
{
if (googleTurnSslTcp[i] != buf[j])
{
b = false;
break;
}
}
}
// nothing found, lets check for stun binding requests
if (!b)
{
// 2 bytes uint16 length
// STUN Binding request:
// 2 bits 00
// 14 bits STUN Messsage Type
// 2 bytes Message Length
// 4 bytes Magic Cookie
// RFC 5389: For example, a Binding request has class=0b00
// (request) and method=0b000000000001 (Binding) and is encoded
// into the first 16 bits as 0x0001.
if (len >= 10 && buf[off + 2] == 0 && buf[off + 3] == 1)
{
final byte[] magicCookie = Message.MAGIC_COOKIE;
b = true;
for (int i = 0, iEnd = magicCookie.length, j = off + 6;
i < iEnd;
i++, j++)
{
if (magicCookie[i] != buf[j])
{
b = false;
break;
}
}
}
}
}
return b;
}
/** /**
* The thread which <tt>accept</tt>s TCP connections from the sockets in * The thread which <tt>accept</tt>s TCP connections from the sockets in
* {@link #serverSocketChannels}. * {@link #serverSocketChannels}.
@ -218,12 +147,6 @@ public abstract class AbstractTcpListener
private final List<ServerSocketChannel> serverSocketChannels private final List<ServerSocketChannel> serverSocketChannels
= new LinkedList<>(); = new LinkedList<>();
/**
* The object used to synchronize access to the collection of sessions that
* the implementation of this class uses.
*/
protected final Object sessionsSyncRoot = new Object();
/** /**
* Initializes a new <tt>TcpHarvester</tt>, which is to * Initializes a new <tt>TcpHarvester</tt>, which is to
* listen on port number <tt>port</tt> on all IP addresses on all available * listen on port number <tt>port</tt> on all IP addresses on all available
@ -432,21 +355,7 @@ public abstract class AbstractTcpListener
throws IOException throws IOException
{ {
ServerSocketChannel channel = MuxServerSocketChannelFactory ServerSocketChannel channel = MuxServerSocketChannelFactory
.openAndBindMuxServerSocketChannel( .openAndBindServerSocketChannel(null, address, 0);
/* properties */ null,
address,
/* backlog */ 0,
new DatagramPacketFilter()
{
/**
* {@inheritDoc}
*/
@Override
public boolean accept(DatagramPacket p)
{
return isFirstDatagramPacket(p);
}
});
serverSocketChannels.add(channel); serverSocketChannels.add(channel);
} }
@ -457,8 +366,6 @@ public abstract class AbstractTcpListener
* @param ufrag the local username fragment for the session. * @param ufrag the local username fragment for the session.
* @param pushback the first "datagram" (RFC4571-framed), already read from * @param pushback the first "datagram" (RFC4571-framed), already read from
* the socket's stream. * the socket's stream.
* @throws IllegalStateException
* @throws IOException
*/ */
protected abstract void acceptSession( protected abstract void acceptSession(
Socket socket, String ufrag, DatagramPacket pushback) Socket socket, String ufrag, DatagramPacket pushback)
@ -598,7 +505,9 @@ public abstract class AbstractTcpListener
selector.close(); selector.close();
} }
catch (IOException ioe) catch (IOException ioe)
{} {
// ignore
}
} }
} }
@ -613,11 +522,6 @@ public abstract class AbstractTcpListener
*/ */
public final SocketChannel channel; public final SocketChannel channel;
/**
* The time the channel was last found to be active.
*/
long lastActive = System.currentTimeMillis();
/** /**
* The buffer which stores the data so far read from the channel. * The buffer which stores the data so far read from the channel.
*/ */
@ -783,11 +687,8 @@ public abstract class AbstractTcpListener
{ {
/** /**
* Initializes a new <tt>ReadThread</tt>. * Initializes a new <tt>ReadThread</tt>.
*
* @throws IOException if the selector to be used fails to open.
*/ */
public ReadThread() public ReadThread()
throws IOException
{ {
setName("TcpHarvester ReadThread"); setName("TcpHarvester ReadThread");
setDaemon(true); setDaemon(true);
@ -821,50 +722,6 @@ public abstract class AbstractTcpListener
} }
} }
/**
* Closes any inactive channels registered with {@link #readSelector}.
* A channel is considered inactive if it hasn't been available for
* reading for
* {@link MuxServerSocketChannelFactory#SOCKET_CHANNEL_READ_TIMEOUT}
* milliseconds.
*/
private void cleanup()
{
long now = System.currentTimeMillis();
for (SelectionKey key : readSelector.keys())
{
// An invalid key specifies that either the channel was closed
// (in which case we do not have to do anything else to it) or
// that we no longer control the channel (i.e. we do not want to
// do anything else to it).
if (!key.isValid())
continue;
ChannelDesc channelDesc = (ChannelDesc) key.attachment();
if (channelDesc == null)
continue;
long lastActive = channelDesc.lastActive;
if (lastActive != -1
&& now - lastActive
> MuxServerSocketChannelFactory
.SOCKET_CHANNEL_READ_TIMEOUT)
{
// De-register from the Selector.
key.cancel();
SocketChannel channel = channelDesc.channel;
logger.info("Read timeout for socket: " + channel.socket());
closeNoExceptions(channel);
}
}
}
/** /**
* Tries to read, without blocking, from <tt>channel</tt> to its * Tries to read, without blocking, from <tt>channel</tt> to its
* buffer. If after reading the buffer is filled, handles the data in * buffer. If after reading the buffer is filled, handles the data in
@ -915,8 +772,6 @@ public abstract class AbstractTcpListener
if (read == -1) if (read == -1)
throw new IOException("End of stream!"); throw new IOException("End of stream!");
else if (read > 0)
channel.lastActive = System.currentTimeMillis();
if (!channel.buffer.hasRemaining()) if (!channel.buffer.hasRemaining())
{ {
@ -1102,9 +957,6 @@ public abstract class AbstractTcpListener
break; break;
} }
// clean up stale channels
cleanup();
checkForNewChannels(); checkForNewChannels();
for (SelectionKey key : readSelector.keys()) for (SelectionKey key : readSelector.keys())
@ -1164,7 +1016,9 @@ public abstract class AbstractTcpListener
readSelector.close(); readSelector.close();
} }
catch (IOException ioe) catch (IOException ioe)
{} {
// ignore
}
} }
} }
} }

View File

@ -1960,7 +1960,7 @@ public class PseudoTCPBase
options_specified.add(kind); options_specified.add(kind);
} }
if (options_specified.indexOf(TCP_OPT_WND_SCALE) == -1)//options_specified.size() - 1) if (!options_specified.contains(TCP_OPT_WND_SCALE))
{ {
logger.log(Level.WARNING, "Peer doesn't support window scaling"); logger.log(Level.WARNING, "Peer doesn't support window scaling");
if (getM_rwnd_scale() > 0) if (getM_rwnd_scale() > 0)

View File

@ -18,11 +18,9 @@
package org.ice4j.socket; package org.ice4j.socket;
import java.io.*; import java.io.*;
import java.lang.reflect.*;
import java.net.*; import java.net.*;
import java.nio.channels.*; import java.nio.channels.*;
import java.util.*; import java.util.*;
import java.util.logging.*;
/** /**
* If supported by the runtime, initializes {@link ServerSocketChannel}s which * If supported by the runtime, initializes {@link ServerSocketChannel}s which
@ -33,19 +31,6 @@ import java.util.logging.*;
*/ */
public class MuxServerSocketChannelFactory public class MuxServerSocketChannelFactory
{ {
/**
* The {@code Logger} used by the {@code MuxServerSocketChannelFactory}
* class (and its instances) to print debug information.
*/
private static final Logger logger
= Logger.getLogger(MuxServerSocketChannelFactory.class.getName());
/**
* The reflection of the {@code openAndBind} method of the
* {@code MuxServerSocketChannel} class.
*/
private static final Method OPEN_AND_BIND_METHOD;
/** /**
* The maximum number of milliseconds to wait for an accepted * The maximum number of milliseconds to wait for an accepted
* {@code SocketChannel} to provide incoming/readable data before it is * {@code SocketChannel} to provide incoming/readable data before it is
@ -56,158 +41,12 @@ public class MuxServerSocketChannelFactory
/** /**
* The name of the {@code boolean} property of the {@code socket} property * The name of the {@code boolean} property of the {@code socket} property
* of the {@code ServerSocketChannel} returned by * of the {@code ServerSocketChannel} returned by
* {@link #openAndBindMuxServerSocketChannel(Map, SocketAddress, int, * {@link #openAndBindServerSocketChannel(Map, SocketAddress, int)} which
* DatagramPacketFilter)} which specifies the value of the * specifies the value of the {@code SO_REUSEADDR} socket option.
* {@code SO_REUSEADDR} socket option.
*/ */
public static final String SOCKET_REUSE_ADDRESS_PROPERTY_NAME public static final String SOCKET_REUSE_ADDRESS_PROPERTY_NAME
= "socket.reuseAddress"; = "socket.reuseAddress";
static
{
Class<?> clazz;
try
{
clazz
= Class.forName("org.ice4j.socket.jdk8.MuxServerSocketChannel");
}
catch (ClassNotFoundException cnfex)
{
// The class cannot be located probably because ICE4J was not built
// on JDK 8.
clazz = null;
logger.warning(
"ICE4J does not support sharing of listening endpoints"
+ " (probably because it was not built on JDK 8).");
}
catch (LinkageError lerr)
{
// The linkage fails probably because ICE4J was built on JDK 8 but
// is not run on JDK 8.
clazz = null;
logger.warning(
"ICE4J does not support sharing of listening endpoints"
+ " (probably because it is not running on JDK 8).");
}
Method method;
if (clazz == null)
{
method = null;
}
else
{
try
{
method
= clazz.getDeclaredMethod(
"openAndBind",
Map.class,
SocketAddress.class,
int.class,
DatagramPacketFilter.class);
}
catch (NoSuchMethodException nsmex)
{
throw new RuntimeException(nsmex);
}
}
OPEN_AND_BIND_METHOD = method;
}
/**
* Closes a {@code Channel} and swallows any {@link IOException}.
*
* @param channel the {@code Channel} to close
*/
public static void closeNoExceptions(Channel channel)
{
try
{
channel.close();
}
catch (IOException ioe)
{
// The whole idea of the method is to close a specific Channel
// without caring about any possible IOException.
}
}
/**
* Opens and binds a new {@code MuxServerSocketChannel} instance if
* supported by the runtime. If there are other (existing)
* {@code MuxServerSocketChannel} open and bound on the specified listening
* {@code endpoint}, the new instance will share it with them. If the
* sharing of listening endpoints is not supported by the runtime, falls
* back to {@link #openAndBindServerSocketChannel(Map, SocketAddress, int)}.
*
* @param properties a {@code Map} of the values to be assigned to
* properties of the underlying {@link ServerSocketChannel} which is to
* actually listen on the specified {@code endpoint}. If the new instance is
* not the first to open and bind the specified {@code endpoint}, the
* {@code properties} and their respective values may not be used.
* @param endpoint the IP and port the new instance is to bind to
* @param backlog the requested maximum number of pending incoming
* connections to be queued. If the new instance is not the first to open
* and bind the specified {@code endpoint}, the value may not be used.
* @param filter the {@code DatagramPacketFilter} to demultiplex (i.e.
* recognize) the content meant for the new instance
* @return a new {@code MuxServerSocketChannel} instance open and bound on
* the specified listening {@code endpoint}
* @throws IOException if an I/O error occurs
*/
public static ServerSocketChannel openAndBindMuxServerSocketChannel(
Map<String, Object> properties,
SocketAddress endpoint,
int backlog,
DatagramPacketFilter filter)
throws IOException
{
Method method = OPEN_AND_BIND_METHOD;
if (method == null)
{
return
openAndBindServerSocketChannel(properties, endpoint, backlog);
}
else
{
try
{
return
(ServerSocketChannel)
method.invoke(
null,
properties, endpoint, backlog, filter);
}
catch (IllegalAccessException iaex)
{
IllegalAccessError iaerr
= new IllegalAccessError(iaex.getMessage());
iaerr.initCause(iaex);
throw iaerr;
}
catch (InvocationTargetException itex)
{
Throwable cause = itex.getCause();
if (cause == null)
throw new RuntimeException(itex);
else if (cause instanceof Error)
throw (Error) cause;
else if (cause instanceof IOException)
throw (IOException) cause;
else if (cause instanceof RuntimeException)
throw (RuntimeException) cause;
else
throw new RuntimeException(cause);
}
}
}
/** /**
* Opens and binds a new {@code ServerSocketChannel} instance. * Opens and binds a new {@code ServerSocketChannel} instance.
* *
@ -251,7 +90,7 @@ public class MuxServerSocketChannelFactory
else if (value instanceof Boolean) else if (value instanceof Boolean)
on = (Boolean) value; on = (Boolean) value;
else else
on = Boolean.valueOf(value.toString()); on = Boolean.parseBoolean(value.toString());
socket.setReuseAddress(on); socket.setReuseAddress(on);
} }

View File

@ -1,79 +0,0 @@
/*
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
*
* Copyright @ 2015 Atlassian Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ice4j.socket.jdk8;
import java.net.*;
import java.nio.*;
/**
* Associates a {@link ByteBuffer} with a {@link DatagramPacket} so that the
* {@code ByteBuffer} may be used for writing into a {@code byte} array and the
* {@code DatagramPacket} may be used for reading from the same {@code byte}
* array.
*
* @author Lyubomir Marinov
*/
class DatagramBuffer
extends Timestamped<ByteBuffer>
{
/**
* The {@code DatagramPacket} which is associated with the
* {@link ByteBuffer} {@link #o} and shares its {@code data} with.
*/
private final DatagramPacket datagramPacket;
/**
* Initializes a new {@code DatagramBuffer} instance with a specific
* capacity of {@code byte}s shared between a {@code ByteBuffer} and a
* {@code DatagramPacket}.
*
* @param capacity the maximum number of {@code byte}s to be written into
* and read from the new instance
*/
public DatagramBuffer(int capacity)
{
super(ByteBuffer.allocate(capacity));
datagramPacket
= new DatagramPacket(o.array(), /* offset */ 0, /* length */ 0);
}
/**
* Gets the {@code ByteBuffer} (view) of this instance.
*
* @return the {@code ByteBuffer} (view) of this instance
*/
public ByteBuffer getByteBuffer()
{
return o;
}
/**
* Gets the {@code DatagramPacket} (view) of this instance. The
* {@code length} of the {@code DatagramPacket} equals the {@code position}
* of the {@code ByteBuffer} so that the {@code byte}s written into the
* {@code ByteBuffer} may be read from the {@code DatagramPacket}.
*
* @return the {@code DatagramPacket} (view) of this instance
*/
public DatagramPacket getDatagramPacket()
{
datagramPacket.setLength(getByteBuffer().position());
return datagramPacket;
}
}

View File

@ -1,217 +0,0 @@
/*
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
*
* Copyright @ 2018 - present 8x8, Inc.
*
* 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.jdk8;
import java.io.*;
import java.lang.reflect.*;
import java.nio.channels.*;
import java.util.logging.*;
import org.ice4j.socket.*;
import sun.nio.ch.*;
/**
* Implements a {@code ServerSocketChannel} which delegates (its method calls)
* to another {@code ServerSocketChannel}. In other words, the former wraps the
* latter.
*
* @author Lyubomir Marinov
*/
class DelegatingServerSocketChannel<T extends ServerSocketChannel>
extends BaseDelegatingServerSocketChannel<T>
implements SelChImpl
{
/**
* The {@link Logger} used by the {@link DelegatingServerSocketChannel}
* class and its instances for logging output.
*/
private static final java.util.logging.Logger classLogger
= java.util.logging.Logger.getLogger(
DelegatingServerSocketChannel.class.getName());
/**
* The view of {@link #delegate} as a <tt>SelChImpl</tt> interface instance
* required by {@link Selector} and related functionality.
*/
protected final SelChImpl delegateAsSelChImpl;
/**
* The translateAndSetInterestOps method available in java 8.
*/
private final Method translateAndSetInterestOpsMethod;
/**
* The translateInterestOps method available in java 11.
*/
private final Method translateInterestOpsMethod;
/**
* Initializes a new {@code DelegatingServerSocketChannel} instance which is
* to delegate (its method calls) to a specific {@code ServerSocketChannel}.
*
* @param delegate the {@code ServerSocketChannel} the new instance is to
* delegate (its method calls) to
*/
public DelegatingServerSocketChannel(T delegate)
{
super(delegate);
delegateAsSelChImpl
= (delegate instanceof SelChImpl) ? (SelChImpl) delegate : null;
Method method;
try
{
method = SelChImpl.class.getMethod(
"translateAndSetInterestOps",
Integer.TYPE, SelectionKeyImpl.class);
}
catch(NoSuchMethodException e)
{
method = null;
}
translateAndSetInterestOpsMethod = method;
try
{
method = SelChImpl.class.getMethod(
"translateInterestOps", Integer.TYPE);
}
catch(NoSuchMethodException e)
{
method = null;
}
translateInterestOpsMethod = method;
if (translateInterestOpsMethod == null
&& translateAndSetInterestOpsMethod == null)
{
classLogger.log(
Level.SEVERE, "Cannot find translateInterestOps " +
"or translateAndSetInterestOps!");
}
}
/**
* {@inheritDoc}
*
* Forwards to {@link #delegate}.
*/
@Override
public FileDescriptor getFD()
{
return delegateAsSelChImpl.getFD();
}
/**
* {@inheritDoc}
*
* Forwards to {@link #delegate}.
*/
@Override
public int getFDVal()
{
return delegateAsSelChImpl.getFDVal();
}
/**
* {@inheritDoc}
*
* Forwards to {@link #delegate}.
*/
@Override
public void kill()
throws IOException
{
delegateAsSelChImpl.kill();
}
/**
* {@inheritDoc}
*
* Forwards to {@link #delegate}.
*/
@SuppressWarnings("unused")
public void translateAndSetInterestOps(int ops, SelectionKeyImpl sk)
{
try
{
if (translateAndSetInterestOpsMethod != null)
{
translateAndSetInterestOpsMethod.invoke(
delegateAsSelChImpl, ops, sk);
}
}
catch(IllegalAccessException | InvocationTargetException e)
{
classLogger.log(
Level.SEVERE,
"Cannot execute method translateAndSetInterestOpsMethod", e);
}
}
/**
* {@inheritDoc}
*
* Forwards to {@link #delegate}.
*/
@SuppressWarnings("unused")
public int translateInterestOps(int ops)
{
try
{
if (translateInterestOpsMethod != null)
{
return (Integer) translateInterestOpsMethod.invoke(
delegateAsSelChImpl, ops);
}
}
catch(IllegalAccessException | InvocationTargetException e)
{
classLogger.log(
Level.SEVERE,
"Cannot execute method translateInterestOpsMethod", e);
}
return 0;
}
/**
* {@inheritDoc}
*
* Forwards to {@link #delegate}.
*/
@Override
public boolean translateAndSetReadyOps(int ops, SelectionKeyImpl sk)
{
return delegateAsSelChImpl.translateAndSetReadyOps(ops, sk);
}
/**
* {@inheritDoc}
*
* Forwards to {@link #delegate}.
*/
@Override
public boolean translateAndUpdateReadyOps(int ops, SelectionKeyImpl sk)
{
return delegateAsSelChImpl.translateAndUpdateReadyOps(ops, sk);
}
}

View File

@ -1,216 +0,0 @@
/*
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
*
* Copyright @ 2018 - present 8x8, Inc.
*
* 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.jdk8;
import java.io.*;
import java.lang.reflect.*;
import java.nio.channels.*;
import java.util.logging.*;
import org.ice4j.socket.*;
import sun.nio.ch.*;
/**
* Implements a {@code SocketChannel} which delegates (its method calls) to
* another {@code SocketChannel}. In other words, the former wraps the latter.
*
* @author Lyubomir Marinov
*/
class DelegatingSocketChannel<T extends SocketChannel>
extends BaseDelegatingSocketChannel<T>
implements SelChImpl
{
/**
* The {@link Logger} used by the {@link DelegatingSocketChannel}
* class and its instances for logging output.
*/
private static final java.util.logging.Logger classLogger
= java.util.logging.Logger.getLogger(
DelegatingSocketChannel.class.getName());
/**
* The view of {@link #delegate} as a <tt>SelChImpl</tt> interface instance
* required by {@link Selector} and related functionality.
*/
protected final SelChImpl delegateAsSelChImpl;
/**
* The translateAndSetInterestOps method available in java 8.
*/
private final Method translateAndSetInterestOpsMethod;
/**
* The translateInterestOps method available in java 11.
*/
private final Method translateInterestOpsMethod;
/**
* Initializes a new {@code DelegatingSocketChannel} instance which is to
* delegate (its method calls) to a specific {@code SocketChannel}.
*
* @param delegate the {@code SocketChannel} the new instance is to delegate
* (its method calls) to
*/
public DelegatingSocketChannel(T delegate)
{
super(delegate);
delegateAsSelChImpl
= (delegate instanceof SelChImpl) ? (SelChImpl) delegate : null;
Method method;
try
{
method = SelChImpl.class.getMethod(
"translateAndSetInterestOps",
Integer.TYPE, SelectionKeyImpl.class);
}
catch(NoSuchMethodException e)
{
method = null;
}
translateAndSetInterestOpsMethod = method;
try
{
method = SelChImpl.class.getMethod(
"translateInterestOps", Integer.TYPE);
}
catch(NoSuchMethodException e)
{
method = null;
}
translateInterestOpsMethod = method;
if (translateInterestOpsMethod == null
&& translateAndSetInterestOpsMethod == null)
{
classLogger.log(
Level.SEVERE, "Cannot find translateInterestOps " +
"or translateAndSetInterestOps!");
}
}
/**
* {@inheritDoc}
*
* Forwards to {@link #delegate}.
*/
@Override
public FileDescriptor getFD()
{
return delegateAsSelChImpl.getFD();
}
/**
* {@inheritDoc}
*
* Forwards to {@link #delegate}.
*/
@Override
public int getFDVal()
{
return delegateAsSelChImpl.getFDVal();
}
/**
* {@inheritDoc}
*
* Forwards to {@link #delegate}.
*/
@Override
public void kill()
throws IOException
{
delegateAsSelChImpl.kill();
}
/**
* {@inheritDoc}
*
* Forwards to {@link #delegate}.
*/
@SuppressWarnings("unused")
public void translateAndSetInterestOps(int ops, SelectionKeyImpl sk)
{
try
{
if (translateAndSetInterestOpsMethod != null)
{
translateAndSetInterestOpsMethod.invoke(
delegateAsSelChImpl, ops, sk);
}
}
catch(IllegalAccessException | InvocationTargetException e)
{
classLogger.log(
Level.SEVERE,
"Cannot execute method translateAndSetInterestOpsMethod", e);
}
}
/**
* {@inheritDoc}
*
* Forwards to {@link #delegate}.
*/
@SuppressWarnings("unused")
public int translateInterestOps(int ops)
{
try
{
if (translateInterestOpsMethod != null)
{
return (Integer) translateInterestOpsMethod.invoke(
delegateAsSelChImpl, ops);
}
}
catch(IllegalAccessException | InvocationTargetException e)
{
classLogger.log(
Level.SEVERE,
"Cannot execute method translateInterestOpsMethod", e);
}
return 0;
}
/**
* {@inheritDoc}
*
* Forwards to {@link #delegate}.
*/
@Override
public boolean translateAndSetReadyOps(int ops, SelectionKeyImpl sk)
{
return delegateAsSelChImpl.translateAndSetReadyOps(ops, sk);
}
/**
* {@inheritDoc}
*
* Forwards to {@link #delegate}.
*/
@Override
public boolean translateAndUpdateReadyOps(int ops, SelectionKeyImpl sk)
{
return delegateAsSelChImpl.translateAndUpdateReadyOps(ops, sk);
}
}

View File

@ -1,56 +0,0 @@
/*
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
*
* Copyright @ 2015 Atlassian Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ice4j.socket.jdk8;
import java.io.*;
import java.net.*;
import java.util.*;
import org.ice4j.socket.*;
/**
* Represents a {@link ServerSocket} associated with a
* {@code MuxServerSocketChannel}.
*
* @author Lyubomir Marinov
*/
class MuxServerSocket
extends DelegatingServerSocket
{
/**
* Initializes a new {@code MuxServerSocket} instance which delegates (its
* method calls) to a specific {@code MuxingServerSocket} and is associated
* with a specific {@code MuxServerSocketChannel}.
*
* @param delegate the {@code MuxingServerSocket} the new instance is to
* delegate (its method calls) to. Technically, it is the {@code socket} of
* the {@code delegate} of {@code channel}.
* @param channel the {@code MuxServerSocketChannel} associated with the new
* instance
* @throws IOException if an I/O error occurs
*/
public MuxServerSocket(
MuxingServerSocket delegate,
MuxServerSocketChannel channel)
throws IOException
{
super(
Objects.requireNonNull(delegate, "delegate"),
Objects.requireNonNull(channel, "channel"));
}
}

View File

@ -1,298 +0,0 @@
/*
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
*
* Copyright @ 2015 Atlassian Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ice4j.socket.jdk8;
import java.io.*;
import java.net.*;
import java.nio.channels.*;
import java.util.*;
import org.ice4j.socket.*;
/**
* Implements a {@link ServerSocketChannel} which is capable of sharing its
* listening endpoint with multiple others like it.
*
* @author Lyubomir Marinov
*/
public class MuxServerSocketChannel
extends DelegatingServerSocketChannel<MuxingServerSocketChannel>
{
/**
* Opens and binds a new {@code MuxServerSocketChannel} instance. If there
* are other (existing) {@code MuxServerSocketChannel} open and bound on the
* specified listening {@code endpoint}, the new instance will share it with
* them.
*
* @param properties a {@code Map} of the values to be assigned to
* properties of the underlying {@link ServerSocketChannel} which is to
* actually listen on the specified {@code endpoint}. If the new instance is
* not the first to open and bind the specified {@code endpoint}, the
* {@code properties} and their respective values may not be used.
* @param endpoint the IP and port the new instance is to bind to
* @param backlog the requested maximum number of pending incoming
* connections to be queued. If the new instance is not the first to open
* and bind the specified {@code endpoint}, the value may not be used.
* @param filter the {@code DatagramPacketFilter} to demultiplex (i.e.
* recognize) the content meant for the new instance
* @return a new {@code MuxServerSocketChannel} instance open and bound on
* the specified listening {@code endpoint}
* @throws IOException if an I/O error occurs
*/
public static MuxServerSocketChannel openAndBind(
Map<String, Object> properties,
SocketAddress endpoint,
int backlog,
DatagramPacketFilter filter)
throws IOException
{
return
MuxingServerSocketChannel.openAndBind(
properties,
endpoint,
backlog,
filter);
}
/**
* The (ordered) list (i.e. queue) of <tt>SocketChannel</tt>s to be returned
* by {@link #accept()}.
*/
private final Queue<Timestamped<SocketChannel>> acceptQ
= new LinkedList<>();
/**
* The {@code DatagramPacketFilter} which demultiplexes
* {@code SocketChannel}s accepted by the associated
* {@code MuxingServerSocketChannel}.
*/
protected final DatagramPacketFilter filter;
/**
* The <tt>Object</tt> which synchronizes the access to the state of this
* <tt>MuxServerSocketChannel</tt> such as {@link #acceptQ}.
*/
private final Object syncRoot = new Object();
/**
* Initializes a new {@code MuxServerSocketChannel} instance which is to
* demultiplex {@link SocketChannel}s accepted by a specific
* {@link MuxingServerSocketChannel} using a specific
* {@link DatagramPacketFilter}. The new instance shares the listening
* endpoint of {@code delegate} with any other associated
* {@code MuxServerSocketChannel}s.
*
* @param delegate the {@code MuxingServerSocketChannel} which is actually
* open and bound to a listening endpoint and accepts {@code SocketChannel}s
* to be filtered by associated
* {@code MuxServerSocketChannel}s
* @param filter the {@code DatagramPacketFilter} which is to demultiplex
* {@code SocketChannel}s accepted by {@code delegate}
*/
protected MuxServerSocketChannel(
MuxingServerSocketChannel delegate,
DatagramPacketFilter filter)
{
super(Objects.requireNonNull(delegate, "delegate"));
this.filter = Objects.requireNonNull(filter, "filter");
}
/**
* {@inheritDoc}
*/
@Override
public SocketChannel accept()
throws IOException
{
SocketChannel accepted = null;
boolean interrupted = false;
// Pop a SocketChannel from acceptQ.
try
{
do
{
if (!isOpen())
{
throw new ClosedChannelException();
}
else if (!isBound())
{
throw new NotYetBoundException();
}
else
{
synchronized (syncRoot)
{
Timestamped<SocketChannel> timestamped = acceptQ.poll();
if (timestamped == null)
{
if (isBlocking())
{
try
{
syncRoot.wait();
}
catch (InterruptedException ie)
{
interrupted = true;
}
}
else
{
break;
}
}
else if ((accepted = timestamped.o).isOpen())
{
// Allow the MuxServerSocketChannel class and/or its
// super(s) to have a final say on the accepted
// SocketChannel such as wrapping it into a suitable
// specialization of DelegatingSocketChannel.
accepted = implAccept(accepted);
if (accepted != null)
break;
}
}
}
}
while (true);
}
finally
{
// Restore the interrupted state of the current thread if we've
// cleared it in the loop above.
if (interrupted)
Thread.currentThread().interrupt();
}
return accepted;
}
/**
* Weeds out abandoned {@code SocketChannels} from {@link #acceptQ} i.e.
* which were classified/filtered into this {@code MuxServerSocketChannel}
* but were not accepted (out of it) for a long time.
*
* @param now the (system) time in milliseconds at which the method is
* invoked
*/
void closeAbandonedSocketChannels(long now)
{
synchronized (syncRoot)
{
Collection<Timestamped<SocketChannel>> chs = acceptQ;
if (!chs.isEmpty())
{
for (Iterator<Timestamped<SocketChannel>> i = chs.iterator();
i.hasNext();)
{
Timestamped<SocketChannel> ch = i.next();
if (now - ch.timestamp
>= MuxingServerSocketChannel
.SOCKET_CHANNEL_READ_TIMEOUT)
{
i.remove();
MuxingServerSocketChannel.closeNoExceptions(ch.o);
}
}
}
}
}
/**
* Determines whether the {@link #filter} of this instance accepts a
* specific {@code SocketChannel} from which a specific
* {@code DatagramPacket} has been read and, if it does, queues the
* {@code channel} to be accepted through this instance.
*
* @param p the {@code DatagramPacket} which has been read from
* {@code channel} and which is to be analyzed by the {@code filter} of this
* instance
* @param channel the {@code SocketChannel} from which {@code p} has been
* read and which is to be queued for acceptance through this instance if
* the {@code filter} accepts {@code p}
* @return {@code true} if the {@code filter} of this instance accepts
* {@code p} and {@code channel} was queued for acceptance through this
* instance; otherwise, {@code false}
*/
protected boolean filterAccept(DatagramPacket p, SocketChannel channel)
{
return
filter.accept(p) && qAccept(new PreReadSocketChannel(p, channel));
}
/**
* {@inheritDoc}
*
* Adjusts the blocking mode of {@link #delegate}.
*/
@Override
protected void implConfigureBlocking(boolean block)
throws IOException
{
// If at least one MuxServerSocketChannel is configured as non-blocking,
// then MuxingServerSocketChannel has to be configured as non-blocking
// as well.
if (!block)
delegate.configureBlocking(block);
}
/**
* {@inheritDoc}
*
* Associates a {@link MuxServerSocket} with this
* {@code MuxServerSocketChannel}.
*/
@Override
protected MuxServerSocket implSocket(ServerSocket socket)
throws IOException
{
return new MuxServerSocket((MuxingServerSocket) socket, this);
}
/**
* Queues a {@link SocketChannel} for acceptance through this instance.
*
* @param channel the {@code SocketChannel} to queue for acceptance through
* this instance
* @return {@code true} if {@code channel} was queued for acceptance through
* this instance; otherwise, {@code false}
*/
boolean qAccept(SocketChannel channel)
{
boolean b;
synchronized (syncRoot)
{
if (acceptQ.offer(
new Timestamped<>(channel, System.currentTimeMillis())))
{
syncRoot.notifyAll();
b = true;
}
else
{
b = false;
}
}
return b;
}
}

View File

@ -1,56 +0,0 @@
/*
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
*
* Copyright @ 2015 Atlassian Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ice4j.socket.jdk8;
import java.io.*;
import java.net.*;
import java.util.*;
import org.ice4j.socket.*;
/**
* Represents a {@link ServerSocket} associated with a
* {@code MuxingServerSocketChannel}.
*
* @author Lyubomir Marinov
*/
class MuxingServerSocket
extends DelegatingServerSocket
{
/**
* Initializes a new {@code MuxingServerSocket} instance which delegates
* (its method calls) to a specific {@code ServerSocket} and is associated
* with a specific {@code MuxingServerSocketChannel}.
*
* @param delegate the {@code ServerSocket} the new instance is to delegate
* (its method calls) to. Technically, it is the {@code socket} of the
* {@code delegate} of {@code channel}.
* @param channel the {@code MuxingServerSocketChannel} associated with the
* new instance
* @throws IOException if an I/O error occurs
*/
public MuxingServerSocket(
ServerSocket delegate,
MuxingServerSocketChannel channel)
throws IOException
{
super(
Objects.requireNonNull(delegate, "delegate"),
Objects.requireNonNull(channel, "channel"));
}
}

View File

@ -1,108 +0,0 @@
/*
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
*
* Copyright @ 2015 Atlassian Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ice4j.socket.jdk8;
import java.io.*;
import java.net.*;
import java.nio.*;
import java.nio.channels.*;
/**
* Prepends a {@link DatagramPacket} to a {@link SocketChannel}. In other words,
* enables looking ahead at the {@code byte}s of a {@code SocketChannel}.
*
* @author Lyubomir Marinov
*/
class PreReadSocketChannel
extends DelegatingSocketChannel<SocketChannel>
{
/**
* The {@link DatagramPacket} which is to be prepended to the
* {@link SocketChannel} which is the {@link #delegate} of this
* {@link DelegatingSocketChannel}.
*/
private final DatagramPacket preRead;
/**
* Initializes a new {@code PreReadSocketChannel} instance which is to
* prepend a specific {@link DatagramPacket} to a specific
* {@link SocketChannel}.
*
* @param preRead the {@code DatagramPacket} to prepend to {@code delegate}
* @param delegate the {@code SocketChannel} to prepend {@code preRead} to
*/
public PreReadSocketChannel(DatagramPacket preRead, SocketChannel delegate)
{
super(delegate);
this.preRead = preRead;
}
/**
* {@inheritDoc}
*
* Reads from {@link #preRead} first (until it is fully read) and then
* continues with the {@code super} implementation.
*/
@Override
public int read(ByteBuffer dst)
throws IOException
{
synchronized (preRead)
{
int len = preRead.getLength();
int read;
if (len > 0)
{
int toRead = Math.min(len, dst.remaining());
if (toRead > 0)
{
byte[] buf = preRead.getData();
int off = preRead.getOffset();
dst.put(buf, off, toRead);
read = toRead;
preRead.setData(buf, off + read, len - read);
}
else
{
read = 0;
}
}
else
{
read = 0;
}
if (read == 0)
{
read = super.read(dst);
}
else if (dst.hasRemaining())
{
int superRead = super.read(dst);
if (superRead > 0)
read += superRead;
}
return read;
}
}
}

View File

@ -1,66 +0,0 @@
/*
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
*
* Copyright @ 2015 Atlassian Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ice4j.socket.jdk8;
/**
* Represents an {@code Object} with a timestamp.
*
* @param <T> the type of the {@code Object} which has a timestamp (associated)
* @author Lyubomir Marinov
*/
class Timestamped<T>
{
/**
* The {@code Object} associated with {@link #timestamp}.
*/
final T o;
/**
* The timestamp (in milliseconds) associated with {@link #o}.
*/
long timestamp;
/**
* Initializes a new {@code Timestamped} instance with a specific
* {@code Object} and a default timestamp (value).
*
* @param o the {@code Object} to associate with a timestamp
*/
public Timestamped(T o)
{
this(o, -1);
}
/**
* Initializes a new {@code Timestamped} instance with a specific
* {@code Object} and a specific timestamp (value).
*
* @param o the {@code Object} to associate with {@code timestamp}
* @param timestamp the timestamp (in milliseconds) to associate with
* {@code o}
*/
public Timestamped(T o, long timestamp)
{
// It makes no sense to associate a timestamp with a null.
if (o == null)
throw new NullPointerException("o");
this.o = o;
this.timestamp = timestamp;
}
}

View File

@ -1,32 +0,0 @@
package org.ice4j.socket.jdk8;
import static org.junit.jupiter.api.Assertions.*;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import org.junit.jupiter.api.*;
public class MuxServerSocketChannelTest
{
@Disabled
@Test
void testOpenAndBindReuseWhenBindingToAllInterfacesFirst()
throws IOException
{
SocketAddress allInterfaces = new InetSocketAddress("::", 4443);
SocketAddress oneInterface = new InetSocketAddress("localhost", 4443);
MuxServerSocketChannel channelForAllInterfaces =
MuxServerSocketChannel
.openAndBind(null, allInterfaces, 0, p -> false);
MuxServerSocketChannel channelForOneInterface =
MuxServerSocketChannel
.openAndBind(null, oneInterface, 0, p -> false);
assertEquals(channelForAllInterfaces.getFDVal(),
channelForOneInterface.getFDVal());
}
}