/* * 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 Socket which delegates its calls to a specific * Socket. * * @author Sebastien Vincent * @author Lyubomir Marinov */ public class DelegatingSocket extends Socket { /** * Receives an RFC4571-formatted frame from inputStream into * p, and sets p's port and address to port and * inetAddress. * * @param p the DatagramPacket 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 SocketChannel (to be) returned by {@link #getChannel()}. If * null, getChannel() forwards to {@link #delegate}. (If * delegate is null, getChannel() invokes the * super implementation. */ protected final SocketChannel channel; /** * Delegate Socket. */ protected final Socket delegate; /** * A DelegatingSocket view of {@link #delegate} if the latter * implements the former; otherwise, null. */ private final DelegatingSocket delegateAsDelegatingSocket; /** * The ByteBuffer 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 DelegatingSocket. */ public DelegatingSocket() { this((Socket) null); } /** * Initializes a new DelegatingSocket. * * @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 DelegatingSocket. * * @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 DelegatingSocket. * * @param proxy ignored * @see Socket#Socket(Proxy) */ public DelegatingSocket(Proxy proxy) { this((Socket) null); } /** * Initializes a new DelegatingSocket instance which is to delegate * (i.e. forwards) method calls to a specific Socket. * * @param delegate the Socket the new instance is to delegate to */ public DelegatingSocket(Socket delegate) { this(delegate, (delegate == null) ? null : delegate.getChannel()); } /** * Initializes a new DelegatingSocket instance which is to delegate * (i.e. forward) method calls to a specific Socket and to report * (i.e. return) an association with a specific SocketChannel. * * @param delegate the Socket the new instance is to delegate to * @param channel the SocketChannel to be returned by * {@link #getChannel()}. If null, getChannel() forwards * to delegate. */ 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 DelegatingSocket. * * @param impl ignored * @throws SocketException never thrown * @see Socket#Socket(SocketImpl) */ protected DelegatingSocket(SocketImpl impl) throws SocketException { this((Socket) null); } /** * Initializes a new DelegatingSocket. * * @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 DelegatingSocket. * * @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 DatagramPackets * returned by this method do not match any of the * DatagramPacketFilters of the MultiplexedSockets * associated with this instance at the time of their receipt. When this * method returns, the DatagramPacket'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. *
* This method blocks until a datagram is received. The length * 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. *
* * @param p the DatagramPacket 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 channel into * p, and sets p's port and address to the remote port * and address of this Socket. * * @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 DatagramPacket 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 InputStream. * * @param inputStream InputStream */ 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(); } }