ice4j/src/main/java/org/ice4j/socket/DelegatingSocket.java
Дамян Минков 9dc08bd299
feat: Adds checkstyle module. (#233)
* feat: Adds checkstyle module.
2021-09-02 12:54:33 -05:00

942 lines
24 KiB
Java

/*
* 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;
import org.ice4j.stack.*;
import java.io.*;
import java.net.*;
import java.nio.*;
import java.nio.channels.*;
/**
* Implements a <tt>Socket</tt> which delegates its calls to a specific
* <tt>Socket</tt>.
*
* @author Sebastien Vincent
* @author Lyubomir Marinov
*/
public class DelegatingSocket
extends Socket
{
/**
* Receives an RFC4571-formatted frame from <tt>inputStream</tt> into
* <tt>p</tt>, and sets <tt>p</tt>'s port and address to <tt>port</tt> and
* <tt>inetAddress</tt>.
*
* @param p the <tt>DatagramPacket</tt> into which to place the incoming
* data.
* @param inputStream The TCP stream to be read.
* @param inetAddress The receiver address (local address) to set to the
* datagram packet.
* @param port The receiver port (local port) to set to the datagram packet.
*
* @throws IOException if an I/O error occurs
* @see #receive(DatagramPacket)
*/
public static void receiveFromInputStream(
DatagramPacket p,
InputStream inputStream,
InetAddress inetAddress, int port)
throws IOException
{
int b0 = inputStream.read();
int b1 = inputStream.read();
// If we do not achieve to read the first bytes, then it was just a hole
// punch packet.
if (b0 == -1 || b1 == -1)
{
p.setLength(0);
throw new SocketException("read failed");
}
int frameLen = ((b0 & 0xFF) << 8) | (b1 & 0xFF);
int readLen = 0;
byte[] data = p.getData();
int off = 0;
while (readLen < frameLen)
{
int len = inputStream.read(data, off, frameLen - off);
if (len == -1)
{
throw new SocketException("read failed");
}
else
{
off += len;
readLen += len;
}
}
if (readLen == frameLen)
{
p.setAddress(inetAddress);
p.setData(data, 0, frameLen);
p.setPort(port);
}
else
{
throw new SocketException("Failed to receive data from socket");
}
}
/**
* The <tt>SocketChannel</tt> (to be) returned by {@link #getChannel()}. If
* <tt>null</tt>, <tt>getChannel()</tt> forwards to {@link #delegate}. (If
* <tt>delegate</tt> is <tt>null</tt>, <tt>getChannel()</tt> invokes the
* super implementation.
*/
protected final SocketChannel channel;
/**
* Delegate <tt>Socket</tt>.
*/
protected final Socket delegate;
/**
* A <tt>DelegatingSocket</tt> view of {@link #delegate} if the latter
* implements the former; otherwise, <tt>null</tt>.
*/
private final DelegatingSocket delegateAsDelegatingSocket;
/**
* The <tt>ByteBuffer</tt> instance used in
* {@link #receiveFromChannel(java.nio.channels.SocketChannel,
* java.net.DatagramPacket)} to read the 2-byte length field into.
*/
private final ByteBuffer frameLengthByteBuffer = ByteBuffer.allocate(2);
/**
* InputStream for this socket.
*/
private InputStream inputStream = null;
/**
* The number of non-STUN packets received for this socket.
*/
private long nbReceivedPackets = 0;
/**
* The number of non-STUN packets sent for this socket.
*/
private long nbSentPackets = 0;
/**
* OutputStream for this socket.
*/
private OutputStream outputStream = null;
/**
* Initializes a new <tt>DelegatingSocket</tt>.
*/
public DelegatingSocket()
{
this((Socket) null);
}
/**
* Initializes a new <tt>DelegatingSocket</tt>.
*
* @param address ignored
* @param port ignored
* @throws IOException never thrown
* @see Socket#Socket(InetAddress, int)
*/
public DelegatingSocket(InetAddress address, int port)
throws IOException
{
this((Socket) null);
}
/**
* Initializes a new <tt>DelegatingSocket</tt>.
*
* @param address ignored
* @param port ignored
* @param localAddr ignored
* @param localPort ignored
* @see Socket#Socket(InetAddress, int, InetAddress, int)
* @throws IOException never thrown
*/
public DelegatingSocket(
InetAddress address, int port,
InetAddress localAddr, int localPort)
throws IOException
{
this((Socket) null);
}
/**
* Initializes a new <tt>DelegatingSocket</tt>.
*
* @param proxy ignored
* @see Socket#Socket(Proxy)
*/
public DelegatingSocket(Proxy proxy)
{
this((Socket) null);
}
/**
* Initializes a new <tt>DelegatingSocket</tt> instance which is to delegate
* (i.e. forwards) method calls to a specific <tt>Socket</tt>.
*
* @param delegate the <tt>Socket</tt> the new instance is to delegate to
*/
public DelegatingSocket(Socket delegate)
{
this(delegate, (delegate == null) ? null : delegate.getChannel());
}
/**
* Initializes a new <tt>DelegatingSocket</tt> instance which is to delegate
* (i.e. forward) method calls to a specific <tt>Socket</tt> and to report
* (i.e. return) an association with a specific <tt>SocketChannel</tt>.
*
* @param delegate the <tt>Socket</tt> the new instance is to delegate to
* @param channel the <tt>SocketChannel</tt> to be returned by
* {@link #getChannel()}. If <tt>null</tt>, <tt>getChannel()</tt> forwards
* to <tt>delegate</tt>.
*/
public DelegatingSocket(Socket delegate, SocketChannel channel)
{
this.delegate = delegate;
this.channel = channel;
if (delegate instanceof DelegatingSocket)
{
// FIXME BaseDelegatingSocketChannel was in need of a Socket which
// wraps another Socket and reports a specific SocketChannel. Since
// DelegatingSocket does that, BaseDelegatingSocketChannel used it.
// Unfortunately, it turned out after much debugging that
// DelegatingSocket has the additional function of flagging where
// UDP packets sent over TCP are to be framed. As a temporary fix,
// do not treat the sockets of DelegatingSocketChannel as
// DelegatingSockets.
if (channel instanceof BaseDelegatingSocketChannel)
delegateAsDelegatingSocket = null;
else
delegateAsDelegatingSocket = (DelegatingSocket) delegate;
}
else
{
delegateAsDelegatingSocket = null;
}
}
/**
* Initializes a new <tt>DelegatingSocket</tt>.
*
* @param impl ignored
* @throws SocketException never thrown
* @see Socket#Socket(SocketImpl)
*/
protected DelegatingSocket(SocketImpl impl)
throws SocketException
{
this((Socket) null);
}
/**
* Initializes a new <tt>DelegatingSocket</tt>.
*
* @param host ignored
* @param port ignored
* @throws UnknownHostException never thrown
* @throws IOException never thrown
* @see Socket#Socket(String, int)
*/
public DelegatingSocket(String host, int port)
throws UnknownHostException, IOException
{
this((Socket) null);
}
/**
* Initializes a new <tt>DelegatingSocket</tt>.
*
* @param host ignored
* @param port ignored
* @param localAddr ignored
* @param localPort ignored
* @see Socket#Socket(String, int, InetAddress, int)
*/
public DelegatingSocket(
String host, int port,
InetAddress localAddr, int localPort)
{
this((Socket) null);
}
/**
* {@inheritDoc}
*/
@Override
public void bind(SocketAddress bindpoint) throws IOException
{
if (delegate == null)
super.bind(bindpoint);
else
delegate.bind(bindpoint);
}
/**
* {@inheritDoc}
*/
@Override
public void close() throws IOException
{
if (delegate == null)
super.close();
else
delegate.close();
}
/**
* {@inheritDoc}
*/
@Override
public void connect(SocketAddress endpoint) throws IOException
{
if (delegate == null)
super.connect(endpoint);
else
delegate.connect(endpoint);
}
/**
* {@inheritDoc}
*/
@Override
public void connect(SocketAddress endpoint, int timeout) throws IOException
{
if (delegate == null)
super.connect(endpoint, timeout);
else
delegate.connect(endpoint, timeout);
}
/**
* {@inheritDoc}
*/
@Override
public SocketChannel getChannel()
{
SocketChannel channel = this.channel;
if (channel == null)
{
Socket delegate = this.delegate;
channel
= (delegate == null)
? super.getChannel()
: delegate.getChannel();
}
return channel;
}
/**
* {@inheritDoc}
*/
@Override
public InetAddress getInetAddress()
{
return
(delegate == null)
? super.getInetAddress()
: delegate.getInetAddress();
}
/**
* {@inheritDoc}
*/
@Override
public InputStream getInputStream() throws IOException
{
return
(delegate == null)
? super.getInputStream()
: delegate.getInputStream();
}
/**
* {@inheritDoc}
*/
@Override
public boolean getKeepAlive() throws SocketException
{
return
(delegate == null) ? super.getKeepAlive() : delegate.getKeepAlive();
}
/**
* {@inheritDoc}
*/
@Override
public InetAddress getLocalAddress()
{
return
(delegate == null)
? super.getLocalAddress()
: delegate.getLocalAddress();
}
/**
* {@inheritDoc}
*/
@Override
public int getLocalPort()
{
return
(delegate == null) ? super.getLocalPort() : delegate.getLocalPort();
}
/**
* {@inheritDoc}
*/
@Override
public SocketAddress getLocalSocketAddress()
{
return
(delegate == null)
? super.getLocalSocketAddress()
: delegate.getLocalSocketAddress();
}
/**
* {@inheritDoc}
*/
@Override
public boolean getOOBInline() throws SocketException
{
return
(delegate == null) ? super.getOOBInline() : delegate.getOOBInline();
}
/**
* {@inheritDoc}
*/
@Override
public OutputStream getOutputStream() throws IOException
{
return
(delegate == null)
? super.getOutputStream()
: delegate.getOutputStream();
}
/**
* {@inheritDoc}
*/
@Override
public int getPort()
{
return (delegate == null) ? super.getPort() : delegate.getPort();
}
/**
* {@inheritDoc}
*/
@Override
public int getReceiveBufferSize() throws SocketException
{
return
(delegate == null)
? super.getReceiveBufferSize()
: delegate.getReceiveBufferSize();
}
/**
* {@inheritDoc}
*/
@Override
public SocketAddress getRemoteSocketAddress()
{
return
(delegate == null)
? super.getRemoteSocketAddress()
: delegate.getRemoteSocketAddress();
}
/**
* {@inheritDoc}
*/
@Override
public boolean getReuseAddress() throws SocketException
{
return
(delegate == null)
? super.getReuseAddress()
: delegate.getReuseAddress();
}
/**
* {@inheritDoc}
*/
@Override
public int getSendBufferSize() throws SocketException
{
return
(delegate == null)
? super.getSendBufferSize()
: delegate.getSendBufferSize();
}
/**
* {@inheritDoc}
*/
@Override
public int getSoLinger() throws SocketException
{
return
(delegate == null) ? super.getSoLinger() : delegate.getSoLinger();
}
/**
* {@inheritDoc}
*/
@Override
public int getSoTimeout() throws SocketException
{
return
(delegate == null) ? super.getSoTimeout() : delegate.getSoTimeout();
}
/**
* {@inheritDoc}
*/
@Override
public boolean getTcpNoDelay() throws SocketException
{
return
(delegate == null)
? super.getTcpNoDelay()
: delegate.getTcpNoDelay();
}
/**
* {@inheritDoc}
*/
@Override
public int getTrafficClass() throws SocketException
{
return
(delegate == null)
? super.getTrafficClass()
: delegate.getTrafficClass();
}
/**
* {@inheritDoc}
*/
@Override
public boolean isBound()
{
return (delegate == null) ? super.isBound() : delegate.isBound();
}
/**
* {@inheritDoc}
*/
@Override
public boolean isClosed()
{
return (delegate == null) ? super.isClosed() : delegate.isClosed();
}
/**
* {@inheritDoc}
*/
@Override
public boolean isConnected()
{
return
(delegate == null) ? super.isConnected() : delegate.isConnected();
}
/**
* {@inheritDoc}
*/
@Override
public boolean isInputShutdown()
{
return
(delegate == null)
? super.isInputShutdown()
: delegate.isInputShutdown();
}
/**
* {@inheritDoc}
*/
@Override
public boolean isOutputShutdown()
{
return
(delegate == null)
? super.isOutputShutdown()
: delegate.isOutputShutdown();
}
/**
* 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>MultiplexedSocket</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 #receive(DatagramPacket)
*/
public void receive(DatagramPacket p)
throws IOException
{
if (delegateAsDelegatingSocket != null)
{
delegateAsDelegatingSocket.receive(p);
}
else
{
SocketChannel channel = getChannel();
if (channel == null)
{
// Read from our InputStream
if (inputStream == null)
inputStream = getInputStream();
DelegatingSocket.receiveFromInputStream(
p,
inputStream,
getInetAddress(), getPort());
}
else
{
// For nio SocketChannel-s, the read() from the InputStream and
// the write() to the OutputStream both lock on the same object.
// So, read from the Channel directly in order to avoid
// preventing any writing threads from proceeding.
receiveFromChannel(channel, p);
}
InetSocketAddress localAddress
= (InetSocketAddress) super.getLocalSocketAddress();
if (StunDatagramPacketFilter.isStunPacket(p)
|| DelegatingDatagramSocket.logNonStun(++nbReceivedPackets))
{
StunStack.logPacketToPcap(
p,
false,
localAddress.getAddress(),
localAddress.getPort());
}
}
}
/**
* Receives an RFC4571-formatted frame from <tt>channel</tt> into
* <tt>p</tt>, and sets <tt>p</tt>'s port and address to the remote port
* and address of this <tt>Socket</tt>.
*
* @param channel
* @param p
* @throws IOException
*/
private synchronized void receiveFromChannel(
SocketChannel channel,
DatagramPacket p)
throws IOException
{
while (frameLengthByteBuffer.hasRemaining())
{
int read = channel.read(frameLengthByteBuffer);
if (read == -1)
{
throw new SocketException(
"Failed to receive data from socket.");
}
}
frameLengthByteBuffer.flip();
int b0 = frameLengthByteBuffer.get();
int b1 = frameLengthByteBuffer.get();
int frameLength = ((b0 & 0xFF) << 8) | (b1 & 0xFF);
frameLengthByteBuffer.flip();
byte[] data = p.getData();
if (data == null || data.length < frameLength)
data = new byte[frameLength];
ByteBuffer byteBuffer = ByteBuffer.wrap(data, 0, frameLength);
while (byteBuffer.hasRemaining())
{
int read = channel.read(byteBuffer);
if (read == -1)
{
throw new SocketException(
"Failed to receive data from socket.");
}
}
p.setAddress(getInetAddress());
p.setData(data, 0, frameLength);
p.setPort(getPort());
}
/**
* Send a datagram packet from this socket.
*
* @param p <tt>DatagramPacket</tt> to sent
* @throws IOException if something goes wrong during send
*/
public void send(DatagramPacket p) throws IOException
{
// The delegate socket will encapsulate the packet.
if (delegateAsDelegatingSocket != null)
{
delegateAsDelegatingSocket.send(p);
}
else
{
if (outputStream == null)
outputStream = getOutputStream();
// Else, sends the packet to the final socket (outputStream).
outputStream.write(p.getData(), p.getOffset(), p.getLength());
if (DelegatingDatagramSocket.logNonStun(++nbSentPackets))
{
InetSocketAddress localAddress
= (InetSocketAddress) super.getLocalSocketAddress();
StunStack.logPacketToPcap(
p,
true,
localAddress.getAddress(),
localAddress.getPort());
}
}
}
/**
* {@inheritDoc}
*/
@Override
public void sendUrgentData(int data) throws IOException
{
if (delegate == null)
super.sendUrgentData(data);
else
delegate.sendUrgentData(data);
}
/**
* {@inheritDoc}
*/
@Override
public void setKeepAlive(boolean on) throws SocketException
{
if (delegate == null)
super.setKeepAlive(on);
else
delegate.setKeepAlive(on);
}
/**
* {@inheritDoc}
*/
@Override
public void setOOBInline(boolean on) throws SocketException
{
if (delegate == null)
super.setOOBInline(on);
else
delegate.setOOBInline(on);
}
/**
* Set original <tt>InputStream</tt>.
*
* @param inputStream <tt>InputStream</tt>
*/
public void setOriginalInputStream(InputStream inputStream)
{
if (this.inputStream == null && inputStream != null)
this.inputStream = inputStream;
}
/**
* {@inheritDoc}
*/
@Override
public void setPerformancePreferences(
int connectionTime,
int latency,
int bandwidth)
{
if (delegate == null)
{
super.setPerformancePreferences(connectionTime, latency, bandwidth);
}
else
{
delegate.setPerformancePreferences(
connectionTime,
latency,
bandwidth);
}
}
/**
* {@inheritDoc}
*/
@Override
public void setReceiveBufferSize(int size) throws SocketException
{
if (delegate == null)
super.setReceiveBufferSize(size);
else
delegate.setReceiveBufferSize(size);
}
/**
* {@inheritDoc}
*/
@Override
public void setReuseAddress(boolean on) throws SocketException
{
if (delegate == null)
super.setReuseAddress(on);
else
delegate.setReuseAddress(on);
}
/**
* {@inheritDoc}
*/
@Override
public void setSendBufferSize(int size) throws SocketException
{
if (delegate == null)
super.setSendBufferSize(size);
else
delegate.setSendBufferSize(size);
}
/**
* {@inheritDoc}
*/
@Override
public void setSoLinger(boolean on, int linger) throws SocketException
{
if (delegate == null)
super.setSoLinger(on, linger);
else
delegate.setSoLinger(on, linger);
}
/**
* {@inheritDoc}
*/
@Override
public void setSoTimeout(int timeout) throws SocketException
{
if (delegate == null)
super.setSoTimeout(timeout);
else
delegate.setSoTimeout(timeout);
}
/**
* {@inheritDoc}
*/
@Override
public void setTcpNoDelay(boolean on) throws SocketException
{
if (delegate == null)
super.setTcpNoDelay(on);
else
delegate.setTcpNoDelay(on);
}
/**
* {@inheritDoc}
*/
@Override
public void setTrafficClass(int tc) throws SocketException
{
if (delegate == null)
super.setTrafficClass(tc);
else
delegate.setTrafficClass(tc);
}
/**
* {@inheritDoc}
*/
@Override
public void shutdownInput() throws IOException
{
if (delegate == null)
super.shutdownInput();
else
delegate.shutdownInput();
}
/**
* {@inheritDoc}
*/
@Override
public void shutdownOutput() throws IOException
{
if (delegate == null)
super.shutdownOutput();
else
delegate.shutdownOutput();
}
/**
* {@inheritDoc}
*/
@Override
public String toString()
{
return (delegate == null) ? super.toString() : delegate.toString();
}
}