content: /* The contents of this file are subject to the terms
   * of the Common Development and Distribution License
   * (the License). You may not use this file except in
   * compliance with the License.
   *
   * You can obtain a copy of the License at
   * http://www.sun.com/cddl/cddl.html or
   * install_dir/legal/LICENSE
   * See the License for the specific language governing
   * permission and limitations under the License.
   *
   * When distributing Covered Code, include this CDDL
   * Header Notice in each file and include the License file
   * at install_dir/legal/LICENSE.
   * If applicable, add the following below the CDDL Header,
   * with the fields enclosed by brackets [] replaced by
   * your own identifying information:
   * "Portions Copyrighted [year] [name of copyright owner]"
   *
   * $Id$
   *
   * Copyright 2005-2009 Sun Microsystems Inc. All Rights Reserved
   */
  package com.sun.faban.driver.transport.util;
  
  import com.sun.faban.driver.engine.DriverContext;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.net.InetAddress;
  import java.net.Socket;
  import java.net.SocketAddress;
  import java.net.SocketException;
  import java.nio.channels.SocketChannel;
  
  /**
   * The TimedSocketWrapper wraps an existing, opened socket
   * with the timed artifacts. If a socket can be created from scratch,
   * TimedSocket should be used. But if we obtain a socket from a factory,
   * such as an SSL socket, we cannot extend that socket implementation. We
   * need to wrap it with this wrapper to enable timing of the sockets.
   *
   * @author Akara Sucharitakul
   */
  public class TimedSocketWrapper extends Socket {
  
      private Socket delegate;
  
      /**
       * Creates a TimedSocketWrapper wrapping an existing socket.
       * @param socket The existing socket
       */
      public TimedSocketWrapper(Socket socket) {
          delegate = socket;
      }
  
      /**
       * Creates a blank TimedSocketWrapper and starts the timer. The
       * wrapper is not useful until setSocket(Socket) is being called.
       */
      public TimedSocketWrapper() {
          DriverContext ctx = DriverContext.getContext();
          if (ctx != null)
              ctx.recordStartTime();
      }
  
      /**
       * Sets the socket this wrapper represents. This is usually done
       * after the no-arg constructor is called. 
       * @param socket The existing socket
       */
      public void setSocket(Socket socket) {
          delegate = socket;
      }
  
      /**
       * Returns an input stream for this socket.
       * <p/>
       * <p> If this socket has an associated channel then the resulting input
       * stream delegates all of its operations to the channel.  If the channel
       * is in non-blocking mode then the input stream's <tt>read</tt> operations
       * will throw an {@link java.nio.channels.IllegalBlockingModeException}.
       * <p/>
       * <p>Under abnormal conditions the underlying connection may be
       * broken by the remote host or the network software (for example
       * a connection reset in the case of TCP connections). When a
       * broken connection is detected by the network software the
       * following applies to the returned input stream :-
       * <p/>
       * <ul>
       * <p/>
       * <li><p>The network software may discard bytes that are buffered
       * by the socket. Bytes that aren't discarded by the network
       * software can be read using {@link java.io.InputStream#read read}.
       * <p/>
       * <li><p>If there are no bytes buffered on the socket, or all
       * buffered bytes have been consumed by
       * {@link java.io.InputStream#read read}, then all subsequent
       * calls to {@link java.io.InputStream#read read} will throw an
       * {@link java.io.IOException IOException}.
       * <p/>
       * <li><p>If there are no bytes buffered on the socket, and the
       * socket has not been closed using {@link #close close}, then
       * {@link java.io.InputStream#available available} will
       * return <code>0</code>.
       * <p/>
       * </ul>
       *
       * @return an input stream for reading bytes from this socket.
       * @throws java.io.IOException if an I/O error occurs when creating the
       *                             input stream, the socket is closed, the socket is
       *                             not connected, or the socket input has been shutdown
       *                             using {@link #shutdownInput()}
       */
      @Override
  	public InputStream getInputStream() throws IOException {
          // The streams returned are all timed.
          return new TimedInputStream(delegate.getInputStream());
      }
  
      /**
       * Returns an output stream for this socket.
       * <p/>
       * <p> If this socket has an associated channel then the resulting output
       * stream delegates all of its operations to the channel.  If the channel
       * is in non-blocking mode then the output stream's <tt>write</tt>
       * operations will throw an {@link
       * java.nio.channels.IllegalBlockingModeException}.
       *
       * @return an output stream for writing bytes to this socket.
       * @throws java.io.IOException if an I/O error occurs when creating the
       *                             output stream or if the socket is not connected.
       */
      @Override
  	public OutputStream getOutputStream() throws IOException {
          // The streams returned are all timed.
          return new TimedOutputStream(delegate.getOutputStream());
      }
  
      /**
       * Enable/disable TCP_NODELAY (disable/enable Nagle's algorithm).
       *
       * @param on <code>true</code> to enable TCP_NODELAY,
       * <code>false</code> to disable.
       *
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       *
       * @since   JDK1.1
       *
       * @see #getTcpNoDelay()
       */
      @Override
      public void setTcpNoDelay(boolean on) throws SocketException {
          delegate.setTcpNoDelay(on);
      }
  
      /**
       * Tests if TCP_NODELAY is enabled.
       *
       * @return a <code>boolean</code> indicating whether or not TCP_NODELAY is enabled.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since   JDK1.1
       * @see #setTcpNoDelay(boolean)
       */
      @Override
      public boolean getTcpNoDelay() throws SocketException {
          return delegate.getTcpNoDelay();
      }
  
      /**
       * Enable/disable SO_LINGER with the specified linger time in seconds.
       * The maximum timeout value is platform specific.
       *
       * The setting only affects socket close.
       *
       * @param on     whether or not to linger on.
       * @param linger how long to linger for, if on is true.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @exception IllegalArgumentException if the linger value is negative.
       * @since JDK1.1
       * @see #getSoLinger()
       */
      @Override
      public void setSoLinger(boolean on, int linger) throws SocketException {
          delegate.setSoLinger(on, linger);
      }
  
      /**
       * Returns setting for SO_LINGER. -1 returns implies that the
       * option is disabled.
       *
       * The setting only affects socket close.
       *
       * @return the setting for SO_LINGER.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since   JDK1.1
       * @see #setSoLinger(boolean, int)
       */
      @Override
      public int getSoLinger() throws SocketException {
          return delegate.getSoLinger();
      }
  
      /**
       * Send one byte of urgent data on the socket. The byte to be sent is the lowest eight
       * bits of the data parameter. The urgent byte is
       * sent after any preceding writes to the socket OutputStream
       * and before any future writes to the OutputStream.
       * @param data The byte of data to send
       * @exception IOException if there is an error
       *  sending the data.
       * @since 1.4
       */
      @Override
      public void sendUrgentData (int data) throws IOException  {
          delegate.sendUrgentData(data);
      }
  
      /**
       * Enable/disable OOBINLINE (receipt of TCP urgent data)
       *
       * By default, this option is disabled and TCP urgent data received on a
       * socket is silently discarded. If the user wishes to receive urgent data, then
       * this option must be enabled. When enabled, urgent data is received
       * inline with normal data.
       * <p>
       * Note, only limited support is provided for handling incoming urgent
       * data. In particular, no notification of incoming urgent data is provided
       * and there is no capability to distinguish between normal data and urgent
       * data unless provided by a higher level protocol.
       *
       * @param on <code>true</code> to enable OOBINLINE,
       * <code>false</code> to disable.
       *
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       *
       * @since   1.4
       *
       * @see #getOOBInline()
       */
      @Override
      public void setOOBInline(boolean on) throws SocketException {
          delegate.setOOBInline(on);
      }
  
      /**
       * Tests if OOBINLINE is enabled.
       *
       * @return a <code>boolean</code> indicating whether or not OOBINLINE is enabled.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since   1.4
       * @see #setOOBInline(boolean)
       */
      @Override
      public boolean getOOBInline() throws SocketException {
          return delegate.getOOBInline();
      }
  
      /**
       *  Enable/disable SO_TIMEOUT with the specified timeout, in
       *  milliseconds.  With this option set to a non-zero timeout,
       *  a read() call on the InputStream associated with this Socket
       *  will block for only this amount of time.  If the timeout expires,
       *  a <B>java.net.SocketTimeoutException</B> is raised, though the
       *  Socket is still valid. The option <B>must</B> be enabled
       *  prior to entering the blocking operation to have effect. The
       *  timeout must be > 0.
       *  A timeout of zero is interpreted as an infinite timeout.
       * @param timeout the specified timeout, in milliseconds.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since   JDK 1.1
       * @see #getSoTimeout()
       */
      @Override
      public void setSoTimeout(int timeout) throws SocketException {
          delegate.setSoTimeout(timeout);
      }
  
      /**
       * Returns setting for SO_TIMEOUT.  0 returns implies that the
       * option is disabled (i.e., timeout of infinity).
       * @return the setting for SO_TIMEOUT
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since   JDK1.1
       * @see #setSoTimeout(int)
       */
      @Override
      public int getSoTimeout() throws SocketException {
          return delegate.getSoTimeout();
      }
  
      /**
       * Sets the SO_SNDBUF option to the specified value for this
       * <tt>Socket</tt>. The SO_SNDBUF option is used by the platform's
       * networking code as a hint for the size to set
       * the underlying network I/O buffers.
       *
       * <p>Because SO_SNDBUF is a hint, applications that want to
       * verify what size the buffers were set to should call
       * {@link #getSendBufferSize()}.
       *
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       *
       * @param size the size to which to set the send buffer
       * size. This value must be greater than 0.
       *
       * @exception IllegalArgumentException if the
       * value is 0 or is negative.
       *
       * @see #getSendBufferSize()
       * @since 1.2
       */
      @Override
      public void setSendBufferSize(int size)
      throws SocketException{
          delegate.setSendBufferSize(size);
      }
  
      /**
       * Get value of the SO_SNDBUF option for this <tt>Socket</tt>,
       * that is the buffer size used by the platform
       * for output on this <tt>Socket</tt>.
       * @return the value of the SO_SNDBUF option for this <tt>Socket</tt>.
       *
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       *
       * @see #setSendBufferSize(int)
       * @since 1.2
       */
      @Override
      public int getSendBufferSize() throws SocketException {
          return delegate.getSendBufferSize();
      }
  
      /**
       * Sets the SO_RCVBUF option to the specified value for this
       * <tt>Socket</tt>. The SO_RCVBUF option is used by the platform's
       * networking code as a hint for the size to set
       * the underlying network I/O buffers.
       *
       * <p>Increasing the receive buffer size can increase the performance of
       * network I/O for high-volume connection, while decreasing it can
       * help reduce the backlog of incoming data.
       *
       * <p>Because SO_RCVBUF is a hint, applications that want to
       * verify what size the buffers were set to should call
       * {@link #getReceiveBufferSize()}.
       *
       * <p>The value of SO_RCVBUF is also used to set the TCP receive window
       * that is advertized to the remote peer. Generally, the window size
       * can be modified at any time when a socket is connected. However, if
       * a receive window larger than 64K is required then this must be requested
       * <B>before</B> the socket is connected to the remote peer. There are two
       * cases to be aware of:<p>
       * <ol>
       * <li>For sockets accepted from a ServerSocket, this must be done by calling
       * ServerSocket.setReceiveBufferSize(int) before the ServerSocket
       * is bound to a local address.<p></li>
       * <li>For client sockets, setReceiveBufferSize() must be called before
       * connecting the socket to its remote peer.<p></li></ol>
       * @param size the size to which to set the receive buffer
       * size. This value must be greater than 0.
       *
       * @exception IllegalArgumentException if the value is 0 or is
       * negative.
       *
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       *
       * @see #getReceiveBufferSize()
       * @since 1.2
       */
      @Override
      public void setReceiveBufferSize(int size)
      throws SocketException{
          delegate.setReceiveBufferSize(size);
      }
  
      /**
       * Gets the value of the SO_RCVBUF option for this <tt>Socket</tt>,
       * that is the buffer size used by the platform for
       * input on this <tt>Socket</tt>.
       *
       * @return the value of the SO_RCVBUF option for this <tt>Socket</tt>.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @see #setReceiveBufferSize(int)
       * @since 1.2
       */
      @Override
      public int getReceiveBufferSize()
      throws SocketException{
          return delegate.getReceiveBufferSize();
      }
  
      /**
       * Enable/disable SO_KEEPALIVE.
       *
       * @param on     whether or not to have socket keep alive turned on.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since 1.3
       * @see #getKeepAlive()
       */
      @Override
      public void setKeepAlive(boolean on) throws SocketException {
          delegate.setKeepAlive(on);
      }
  
      /**
       * Tests if SO_KEEPALIVE is enabled.
       *
       * @return a <code>boolean</code> indicating whether or not SO_KEEPALIVE is enabled.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since   1.3
       * @see #setKeepAlive(boolean)
       */
      @Override
      public boolean getKeepAlive() throws SocketException {
          return delegate.getKeepAlive();
      }
  
      /**
       * Sets traffic class or type-of-service octet in the IP
       * header for packets sent from this Socket.
       * As the underlying network implementation may ignore this
       * value applications should consider it a hint.
       *
       * <P> The tc <B>must</B> be in the range <code> 0 <= tc <=
       * 255</code> or an IllegalArgumentException will be thrown.
       * <p>Notes:
       * <p> For Internet Protocol v4 the value consists of an octet
       * with precedence and TOS fields as detailed in RFC 1349. The
       * TOS field is bitset created by bitwise-or'ing values such
       * the following :-
       * <p>
       * <UL>
       * <LI><CODE>IPTOS_LOWCOST (0x02)</CODE></LI>
       * <LI><CODE>IPTOS_RELIABILITY (0x04)</CODE></LI>
       * <LI><CODE>IPTOS_THROUGHPUT (0x08)</CODE></LI>
       * <LI><CODE>IPTOS_LOWDELAY (0x10)</CODE></LI>
       * </UL>
       * The last low order bit is always ignored as this
       * corresponds to the MBZ (must be zero) bit.
       * <p>
       * Setting bits in the precedence field may result in a
       * SocketException indicating that the operation is not
       * permitted.
       * <p>
       * As RFC 1122 section 4.2.4.2 indicates, a compliant TCP
       * implementation should, but is not required to, let application
       * change the TOS field during the lifetime of a connection.
       * So whether the type-of-service field can be changed after the
       * TCP connection has been established depends on the implementation
       * in the underlying platform. Applications should not assume that
       * they can change the TOS field after the connection.
       * <p>
       * For Internet Protocol v6 <code>tc</code> is the value that
       * would be placed into the sin6_flowinfo field of the IP header.
       *
       * @param tc        an <code>int</code> value for the bitset.
       * @throws SocketException if there is an error setting the
       * traffic class or type-of-service
       * @since 1.4
       * @see #getTrafficClass
       */
      @Override
      public void setTrafficClass(int tc) throws SocketException {
          delegate.setTrafficClass(tc);
      }
  
      /**
       * Gets traffic class or type-of-service in the IP header
       * for packets sent from this Socket
       * <p>
       * As the underlying network implementation may ignore the
       * traffic class or type-of-service set using {@link #setTrafficClass(int)}
       * this method may return a different value than was previously
       * set using the {@link #setTrafficClass(int)} method on this Socket.
       *
       * @return the traffic class or type-of-service already set
       * @throws SocketException if there is an error obtaining the
       * traffic class or type-of-service value.
       * @since 1.4
       * @see #setTrafficClass(int)
       */    @Override
      public int getTrafficClass() throws SocketException {
          return delegate.getTrafficClass();
      }
  
      /**
       * Enable/disable the SO_REUSEADDR socket option.
       * <p>
       * When a TCP connection is closed the connection may remain
       * in a timeout state for a period of time after the connection
       * is closed (typically known as the <tt>TIME_WAIT</tt> state
       * or <tt>2MSL</tt> wait state).
       * For applications using a well known socket address or port
       * it may not be possible to bind a socket to the required
       * <tt>SocketAddress</tt> if there is a connection in the
       * timeout state involving the socket address or port.
       * <p>
       * Enabling <tt>SO_REUSEADDR</tt> prior to binding the socket
       * using {@link #bind(SocketAddress)} allows the socket to be
       * bound even though a previous connection is in a timeout
       * state.
       * <p>
       * When a <tt>Socket</tt> is created the initial setting
       * of <tt>SO_REUSEADDR</tt> is disabled.
       * <p>
       * The behaviour when <tt>SO_REUSEADDR</tt> is enabled or
       * disabled after a socket is bound (See {@link #isBound()})
       * is not defined.
       *
       * @param on  whether to enable or disable the socket option
       * @exception SocketException if an error occurs enabling or
       *            disabling the <tt>SO_RESUEADDR</tt> socket option,
       *		  or the socket is closed.
       * @since 1.4
       * @see #getReuseAddress()
       * @see #bind(SocketAddress)
       * @see #isClosed()
       * @see #isBound()
       */
      @Override
      public void setReuseAddress(boolean on) throws SocketException {
          delegate.setReuseAddress(on);
      }
  
      /**
       * Tests if SO_REUSEADDR is enabled.
       *
       * @return a <code>boolean</code> indicating whether or not SO_REUSEADDR is enabled.
       * @exception SocketException if there is an error
       * in the underlying protocol, such as a TCP error.
       * @since   1.4
       * @see #setReuseAddress(boolean)
       */
      @Override
      public boolean getReuseAddress() throws SocketException {
          return delegate.getReuseAddress();
      }
  
      /**
       * Closes this socket.
       * <p>
       * Any thread currently blocked in an I/O operation upon this socket
       * will throw a {@link SocketException}.
       * <p>
       * Once a socket has been closed, it is not available for further networking
       * use (i.e. can't be reconnected or rebound). A new socket needs to be
       * created.
       *
       * <p> Closing this socket will also close the socket's
       * {@link java.io.InputStream InputStream} and
       * {@link java.io.OutputStream OutputStream}.
       *
       * <p> If this socket has an associated channel then the channel is closed
       * as well.
       *
       * @exception  IOException  if an I/O error occurs when closing this socket.
       * @see #isClosed
       */
      @Override
      public void close() throws IOException {
          delegate.close();
      }
  
      /**
       * Places the input stream for this socket at "end of stream".
       * Any data sent to the input stream side of the socket is acknowledged
       * and then silently discarded.
       * <p>
       * If you read from a socket input stream after invoking
       * shutdownInput() on the socket, the stream will return EOF.
       *
       * @exception IOException if an I/O error occurs when shutting down this
       * socket.
       *
       * @since 1.3
       * @see java.net.Socket#shutdownOutput()
       * @see java.net.Socket#close()
       * @see java.net.Socket#setSoLinger(boolean, int)
       * @see #isInputShutdown
       */
      @Override
      public void shutdownInput() throws IOException {
          delegate.shutdownInput();
      }
  
      /**
       * Disables the output stream for this socket.
       * For a TCP socket, any previously written data will be sent
       * followed by TCP's normal connection termination sequence.
       *
       * If you write to a socket output stream after invoking
       * shutdownOutput() on the socket, the stream will throw
       * an IOException.
       *
       * @exception IOException if an I/O error occurs when shutting down this
       * socket.
       *
       * @since 1.3
       * @see java.net.Socket#shutdownInput()
       * @see java.net.Socket#close()
       * @see java.net.Socket#setSoLinger(boolean, int)
       * @see #isOutputShutdown
       */
      @Override
      public void shutdownOutput() throws IOException {
          delegate.shutdownOutput();
      }
  
      /**
       * Converts this socket to a <code>String</code>.
       *
       * @return  a string representation of this socket.
       */
      @Override
      public String toString() {
          return delegate.toString();
      }
  
      /**
       * Returns the connection state of the socket.
       *
       * @return true if the socket successfuly connected to a server
       * @since 1.4
       */
      @Override
      public boolean isConnected() {
          return delegate.isConnected();
      }
  
      /**
       * Returns the binding state of the socket.
       *
       * @return true if the socket successfuly bound to an address
       * @since 1.4
       * @see #bind
       */
      @Override
      public boolean isBound() {
          return delegate.isBound();
      }
  
      /**
       * Returns the closed state of the socket.
       *
       * @return true if the socket has been closed
       * @since 1.4
       * @see #close
       */
      @Override
      public boolean isClosed() {
          return delegate.isClosed();
      }
  
      /**
       * Returns whether the read-half of the socket connection is closed.
       *
       * @return true if the input of the socket has been shutdown
       * @since 1.4
       * @see #shutdownInput
       */
      @Override
      public boolean isInputShutdown() {
          return delegate.isInputShutdown();
      }
  
      /**
       * Returns whether the write-half of the socket connection is closed.
       *
       * @return true if the output of the socket has been shutdown
       * @since 1.4
       * @see #shutdownOutput
       */
      @Override
      public boolean isOutputShutdown() {
          return delegate.isOutputShutdown();
      }
  
      /**
       * Sets performance preferences for this socket.
       *
       * <p> Sockets use the TCP/IP protocol by default.  Some implementations
       * may offer alternative protocols which have different performance
       * characteristics than TCP/IP.  This method allows the application to
       * express its own preferences as to how these tradeoffs should be made
       * when the implementation chooses from the available protocols.
       *
       * <p> Performance preferences are described by three integers
       * whose values indicate the relative importance of short connection time,
       * low latency, and high bandwidth.  The absolute values of the integers
       * are irrelevant; in order to choose a protocol the values are simply
       * compared, with larger values indicating stronger preferences. Negative
       * values represent a lower priority than positive values. If the
       * application prefers short connection time over both low latency and high
       * bandwidth, for example, then it could invoke this method with the values
       * <tt>(1, 0, 0)</tt>.  If the application prefers high bandwidth above low
       * latency, and low latency above short connection time, then it could
       * invoke this method with the values <tt>(0, 1, 2)</tt>.
       *
       * <p> Invoking this method after this socket has been connected
       * will have no effect.
       *
       * @param  connectionTime
       *         An <tt>int</tt> expressing the relative importance of a short
       *         connection time
       *
       * @param  latency
       *         An <tt>int</tt> expressing the relative importance of low
       *         latency
       *
       * @param  bandwidth
       *         An <tt>int</tt> expressing the relative importance of high
       *         bandwidth
       *
       * @since 1.5
       */
      @Override
      public void setPerformancePreferences(int connectionTime,
                                            int latency,
                                            int bandwidth) {
          delegate.setPerformancePreferences(connectionTime, latency, bandwidth);
      }
  
      /**
       * Connects this socket to the server with a specified timeout value.
       * A timeout of zero is interpreted as an infinite timeout. The connection
       * will then block until established or an error occurs.
       *
       * @param	endpoint the <code>SocketAddress</code>
       * @param	timeout  the timeout value to be used in milliseconds.
       * @throws	IOException if an error occurs during the connection
       * @throws	java.net.SocketTimeoutException if timeout expires before connecting
       * @throws  java.nio.channels.IllegalBlockingModeException
       *          if this socket has an associated channel,
       *          and the channel is in non-blocking mode
       * @throws  IllegalArgumentException if endpoint is null or is a
       *          SocketAddress subclass not supported by this socket
       * @since 1.4
       */
      @Override
      public void connect(SocketAddress endpoint, int timeout)
              throws IOException {
          // Here we intercept the connect and capture the start time.
          DriverContext ctx = DriverContext.getContext();
          if (ctx != null)
              ctx.recordStartTime();
          if (timeout <= 0)
              timeout = 30000; // 30 second connect timeout.
          delegate.connect(endpoint, timeout);
          delegate.setSoTimeout(30000); // 30 second socket read timeout.
      }
  
      /**
       * Binds the socket to a local address.
       * <P>
       * If the address is <code>null</code>, then the system will pick up
       * an ephemeral port and a valid local address to bind the socket.
       *
       * @param	bindpoint the <code>SocketAddress</code> to bind to
       * @throws	IOException if the bind operation fails, or if the socket
       *			   is already bound.
       * @throws  IllegalArgumentException if bindpoint is a
       *          SocketAddress subclass not supported by this socket
       *
       * @since	1.4
       * @see #isBound
       */
      @Override
      public void bind(SocketAddress bindpoint) throws IOException {
          delegate.bind(bindpoint);
      }
  
      /**
       * Returns the address to which the socket is connected.
       *
       * @return  the remote IP address to which this socket is connected,
       *		or <code>null</code> if the socket is not connected.
       */
      @Override
      public InetAddress getInetAddress() {
          return delegate.getInetAddress();
      }
  
      /**
       * Gets the local address to which the socket is bound.
       *
       * @return the local address to which the socket is bound or
       *	       <code>InetAddress.anyLocalAddress()</code>
       *	       if the socket is not bound yet.
       * @since   JDK1.1
       */
      @Override
      public InetAddress getLocalAddress() {
          return delegate.getLocalAddress();
      }
  
      /**
       * Returns the remote port to which this socket is connected.
       *
       * @return  the remote port number to which this socket is connected, or
       *	        0 if the socket is not connected yet.
       */
      @Override
      public int getPort() {
          return delegate.getPort();
      }
  
      /**
       * Returns the local port to which this socket is bound.
       *
       * @return  the local port number to which this socket is bound or -1
       *	        if the socket is not bound yet.
       */
      @Override
      public int getLocalPort() {
          return delegate.getLocalPort();
      }
  
      /**
       * Returns the address of the endpoint this socket is connected to, or
       * <code>null</code> if it is unconnected.
       * @return a <code>SocketAddress</code> reprensenting the remote endpoint of this
       *	       socket, or <code>null</code> if it is not connected yet.
       * @see #getInetAddress()
       * @see #getPort()
       * @see #connect(SocketAddress, int)
       * @see #connect(SocketAddress)
       * @since 1.4
       */
      @Override
      public SocketAddress getRemoteSocketAddress() {
          return delegate.getRemoteSocketAddress();
      }
  
      /**
       * Returns the address of the endpoint this socket is bound to, or
       * <code>null</code> if it is not bound yet.
       *
       * @return a <code>SocketAddress</code> representing the local endpoint of this
       *	       socket, or <code>null</code> if it is not bound yet.
       * @see #getLocalAddress()
       * @see #getLocalPort()
       * @see #bind(SocketAddress)
       * @since 1.4
       */
      @Override
      public SocketAddress getLocalSocketAddress() {
          return delegate.getLocalSocketAddress();
      }
  
      /**
       * Returns the unique {@link java.nio.channels.SocketChannel SocketChannel}
       * object associated with this socket, if any.
       *
       * <p> A socket will have a channel if, and only if, the channel itself was
       * created via the {@link java.nio.channels.SocketChannel#open
       * SocketChannel.open} or {@link
       * java.nio.channels.ServerSocketChannel#accept ServerSocketChannel.accept}
       * methods.
       *
       * @return  the socket channel associated with this socket,
       *          or <tt>null</tt> if this socket was not created
       *          for a channel
       *
       * @since 1.4
       */
      @Override
      public SocketChannel getChannel() {
          return delegate.getChannel();
      }
  }
  