/*

   * JBoss, Home of Professional Open Source

   * Copyright 2005, JBoss Inc., and individual contributors as indicated

   * by the @authors tag. See the copyright.txt in the distribution for a

   * full listing of individual contributors.

   *

   * This is free software; you can redistribute it and/or modify it

   * under the terms of the GNU Lesser General Public License as

   * published by the Free Software Foundation; either version 2.1 of

  * the License, or (at your option) any later version.

  *

  * This software is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

  * Lesser General Public License for more details.

  *

  * You should have received a copy of the GNU Lesser General Public

  * License along with this software; if not, write to the Free

  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.

  */

  /*

   * Created on Jul 22, 2005

   */

  package org.jboss.remoting.transport.multiplex;

  import  org.jboss.logging.Logger;

  import java.io.IOException;

  import java.io.InputStream;

  import java.io.OutputStream;

  import java.net.InetAddress;

  import java.net.InetSocketAddress;

  import java.net.Socket;

  import java.net.SocketAddress;

  import java.net.SocketException;

  import java.net.SocketImpl;

  import java.net.SocketTimeoutException;

  import java.net.UnknownHostException;

  import java.nio.channels.SocketChannel;

  import java.util.HashMap;

  import java.util.HashSet;

  import java.util.Iterator;

  import java.util.Map;

  import java.util.Set;

  public class VirtualSocket extends Socket

  {

     protected static final Logger log = Logger.getLogger(VirtualSocket.class);

     protected static Thread closingThread;

     private Map configuration = new HashMap();

     private MultiplexingManager manager;

     private Protocol protocol;

     private Socket actualSocket;

     private SocketId remoteSocketId;

     private SocketId localSocketId;

     private MultiplexingInputStream inputStream;

     private MultiplexingOutputStream outputStream;

     private Set disconnectListeners = new HashSet();

     private boolean bound = false;

     private boolean closed = false;

     private boolean connected = false;

     private boolean inputShutdown = false;

     private boolean outputShutdown = false;

     private boolean receivedDisconnectMessage = false;

     private int     timeout;

     private Socket  dummySocket;

     private boolean functional = true;

     private boolean trace;

     private boolean debug;

     private boolean info;


   

    public interface DisconnectListener

    {

       void notifyDisconnected(VirtualSocket virtualSocket);

    }

    public VirtualSocket(MultiplexingManager manager, SocketId remoteSocketId, Map configuration) throws IOException

    {

       this.manager = manager;

       this.actualSocket = manager.getSocket();

       this.remoteSocketId = remoteSocketId;

       this.configuration.putAll(configuration);

       protocol = manager.getProtocol();

       localSocketId = new SocketId();

       inputStream = manager.registerSocket(this);

 //      outputStream = new MultiplexingOutputStream(manager, this, remoteSocketId);

       outputStream = manager.getAnOutputStream(this, remoteSocketId);

       bound = true;

       connected = true;

       trace = log.isTraceEnabled();

       debug = log.isDebugEnabled();

       info = log.isInfoEnabled();

       if (debug) log.debug("created virtual socket on port: " + localSocketId.getPort());

    }

    public VirtualSocket(Map configuration)

    {

       this.configuration.putAll(configuration);

    }

 //////////////////////////////////////////////////////////////////////////////////////////////////

 ///           The following constructors duplicate those of the parent class Socket           '///

 //////////////////////////////////////////////////////////////////////////////////////////////////

    public VirtualSocket()

    {

       log.debug("created unbound virtual socket");

    }

    public VirtualSocket(String host, int port) throws UnknownHostException, IOException

    {

       InetSocketAddress address = null;

       if (host == null)

          address = new InetSocketAddress(InetAddress.getByName(null), port);

       else

          address = new InetSocketAddress(host, port);

       connect(address);

       if (debug) log.debug("created virtual socket on port: " + localSocketId.getPort());

    }

    public VirtualSocket(String host, int port, boolean stream) throws IOException

    {

       if (!stream)

       {

          throw new SocketException("Deprecated: use DataGramSocket instead of stream = false");

       }

       InetSocketAddress address = null;

       if (host == null)

          address = new InetSocketAddress(InetAddress.getByName(null), port);

       else

          address = new InetSocketAddress(host, port);

       connect(address);

       if (debug) log.debug("created virtual socket on port: " + localSocketId.getPort());

    }

    public VirtualSocket(InetAddress address, int port) throws IOException

    {

       connect(new InetSocketAddress(address, port));

       if (debug) log.debug("created virtual socket on port: " + localSocketId.getPort());

    }

    public VirtualSocket(InetAddress host, int port, boolean stream) throws IOException

    {

       if (!stream)

       {

          throw new SocketException("Deprecated: use DataGramSocket instead of stream = false");

       }

       connect(new InetSocketAddress(host, port));

       if (debug) log.debug("created virtual socket on port: " + localSocketId.getPort());

    }

    public VirtualSocket(SocketImpl impl) throws SocketException

    {

       throw new SocketException("VirtualSocket does not use SocketImpl");

    }

    public VirtualSocket(String host, int port, InetAddress localAddr, int localPort) throws IOException

    {

       this(InetAddress.getByName(host), port, localAddr, localPort);

    }

    public VirtualSocket(InetAddress address, int port, InetAddress localAddr, int localPort) throws IOException

    {

       this();

       connect(new InetSocketAddress(address, port), new InetSocketAddress(localAddr, localPort), 0);

       if (debug) log.debug("created virtual socket on port: " + localSocketId.getPort());

    }

 //////////////////////////////////////////////////////////////////////////////////////////////////

 ///                     The following methods are required of all Socket's                    '///

 //////////////////////////////////////////////////////////////////////////////////////////////////

    public void bind(SocketAddress address) throws IOException

    {

       if (isClosed())

          throw new SocketException("Socket is closed");

       if (isBound())

          throw new SocketException("Already bound");

       if (address != null && (!(address instanceof InetSocketAddress)))

          throw new IllegalArgumentException("Unsupported address type");

       InetSocketAddress inetAddress = (InetSocketAddress) address;

       if (inetAddress != null && inetAddress.isUnresolved())

          throw new SocketException("Unresolved address");

       manager = MultiplexingManager.getaManagerByLocalAddress(inetAddress, configuration);

       actualSocket = manager.getSocket();

       localSocketId = new SocketId();

       if (debug) log.debug("bound virtual socket to port: " + localSocketId.getPort());

       bound = true;

    }

    public void close() throws IOException

    {

       if (closed)

          return;

       log.debug("closing: " + localSocketId);

       closed = true;

       if (connected && !receivedDisconnectMessage)

          protocol.disconnect(remoteSocketId);

       if (inputStream != null)

          inputStream.close();

       if (outputStream != null)

       {

          outputStream.flush();

          outputStream.close();

       }

       if (localSocketId != null)

          localSocketId.releasePort();

       // This VirtualSocket might have been unregistered when connect() failed.

       if (manager.isSocketRegistered(this.localSocketId))

       {

          MultiplexingManager.addToPendingActions(new PendingClose(this));

       }

       if (debug) log.debug("virtual socket closed on port: " + localSocketId.getPort());

    }


   

    public void connect(SocketAddress socketAddress) throws IOException

    {

       connect(socketAddress, null, timeout);

    }

    public void connect(SocketAddress socketAddress, int timeout) throws IOException

    {

       connect(socketAddress, null, timeout);

    }

    public SocketChannel getChannel()

    {

       return null;

    }

    public InetAddress getInetAddress()

    {

       if (actualSocket == null)

          return null;

       return actualSocket.getInetAddress();

    }

    public InputStream getInputStream() throws IOException

    {

       if (isClosed())

          throw new SocketException("Socket is closed");

       if (actualSocket == null || !connected)

          throw new SocketException("Socket is not connected");

       if (isInputShutdown())

          throw new SocketException("Socket input is shutdown");

       return inputStream;

    }

    public boolean getKeepAlive() throws SocketException

    {

       if (actualSocket == null)

          return false;

       return actualSocket.getKeepAlive();

    }

    public InetAddress getLocalAddress()

    {

       if (actualSocket == null)

       {

          if (dummySocket == null)

             dummySocket = new Socket();

          return dummySocket.getLocalAddress();

       }

       // The following is a workaround for a problem in NIO sockets, which sometimes

       // return "0.0.0.0" instead of "127.0.0.1".

       InetAddress address = actualSocket.getLocalAddress();

       try

       {

          if ("0.0.0.0".equals(address.getHostAddress()))

             return InetAddress.getByName("localhost");

       }

       catch (UnknownHostException e)

       {

          return address;

       }

       return address;

    }

    public int getLocalPort()

    {

       if (actualSocket == null)

          return -1;

       return actualSocket.getLocalPort();

    }

    public SocketAddress getLocalSocketAddress()

    {

       if (actualSocket == null)

          return null;

       SocketAddress address = actualSocket.getLocalSocketAddress();

       InetSocketAddress socketAddress = null;

       // The following is a workaround for a problem in NIO sockets, which sometimes

       // return "0.0.0.0" instead of "127.0.0.1".

       if (address instanceof InetSocketAddress)

       {

          socketAddress = (InetSocketAddress) address;

          if ("0.0.0.0".equals(socketAddress.getHostName()) ||

              socketAddress.getAddress() == null)

             return new InetSocketAddress("localhost", socketAddress.getPort());

       }

       return address;

    }

    public boolean getOOBInline() throws SocketException

    {

       return false;

    }

    public OutputStream getOutputStream() throws IOException

    {

       if (isClosed())

          throw new SocketException("Socket is closed");

       if (actualSocket == null || !connected)

          throw new SocketException("Socket is not connected");

       if (isOutputShutdown())

          throw new SocketException("Socket output is shutdown");

       // TODO: return distinct output streams? See PlainSocketImpl.

       //return new SocketOutputStream(this);

       return outputStream;

    }

    public int getPort()

    {

       if (actualSocket == null)

          return 0;

       return actualSocket.getPort();

    }

    public int getReceiveBufferSize() throws SocketException

    {

       if (actualSocket == null)

       {

          if (dummySocket == null)

             dummySocket = new Socket();

          return dummySocket.getReceiveBufferSize();

       }

       return actualSocket.getReceiveBufferSize();

    }

    public SocketAddress getRemoteSocketAddress()

    {

       if (actualSocket == null)

          return null;

       return actualSocket.getRemoteSocketAddress();

    }

    public boolean getReuseAddress() throws SocketException

    {

       if (actualSocket == null)

          return false;

       return actualSocket.getReuseAddress();

    }

    public int getSendBufferSize() throws SocketException

    {

       if (actualSocket == null)

       {

          if (dummySocket == null)

             dummySocket = new Socket();

          return dummySocket.getSendBufferSize();

       }

       return actualSocket.getSendBufferSize();

    }

    public int getSoLinger() throws SocketException

    {

       if (actualSocket == null)

          return -1;

       return actualSocket.getSoLinger();

    }

    public int getSoTimeout() throws SocketException

    {

       if (isClosed())

          throw new SocketException("Socket is closed");

       return timeout;

    }

    public boolean getTcpNoDelay() throws SocketException

    {

       if (actualSocket == null)

          return false;

       return actualSocket.getTcpNoDelay();

    }

    public int getTrafficClass() throws SocketException

    {

       if (actualSocket == null)

          return 0;

       return actualSocket.getTrafficClass();

    }


 

    public boolean isBound()

    {

       return bound;

    }

    public boolean isClosed()

    {

       return closed;

    }

    public boolean isConnected()

    {

       return connected;

    }

    public boolean isInputShutdown()

    {

       return inputShutdown;

    }

    public boolean isOutputShutdown()

    {

       return outputShutdown;

    }

    public void sendUrgentData(int data) throws IOException

    {

       log.warn("sendUrgentData() called: ignored");

       if (isClosed())

          throw new IOException("Socket Closed");

    }

    public void setKeepAlive(boolean on) throws SocketException

    {

       if (actualSocket != null)

          actualSocket.setKeepAlive(on);

    }

    public void setOOBInline(boolean on) throws SocketException

    {

       log.warn("setOOBInLine() called: ignored");

       if (isClosed())

          throw new SocketException("Socket is closed");

    }

    public void setReceiveBufferSize(int size) throws SocketException

    {

       if (actualSocket != null)

          actualSocket.setReceiveBufferSize(size);

    }

    public void setReuseAddress(boolean on) throws SocketException

    {

       if (actualSocket != null)

          actualSocket.setReuseAddress(on);

    }

    public void setSendBufferSize(int size) throws SocketException

    {

       if (actualSocket != null)

          actualSocket.setSendBufferSize(size);

    }

    public void setSoLinger(boolean on, int linger) throws SocketException

    {

       if (actualSocket != null)

          actualSocket.setSoLinger(on, linger);

    }

    public void setSoTimeout(int timeout) throws SocketException

    {

       if (isClosed())

          throw new SocketException("Socket is closed");

       if (timeout < 0)

          throw new IllegalArgumentException("timeout can't be negative");

       this.timeout = timeout;

       if (inputStream != null)

          inputStream.setTimeout(timeout);

    }

    public void setTcpNoDelay(boolean on) throws SocketException

    {

       if (actualSocket != null)

          actualSocket.setTcpNoDelay(on);

    }

    public void setTrafficClass(int tc) throws SocketException

    {

       if (actualSocket != null)

          actualSocket.setTrafficClass(tc);

    }

    public void shutdownInput() throws IOException

    {

       if (isClosed())

          throw new SocketException("Socket is closed");

       if (!isConnected())

          throw new SocketException("Socket is not connected");

       if (isInputShutdown())

          throw new SocketException("Socket input is already shutdown");

       inputStream.setEOF();

       inputShutdown = true;

       //         protocol.notifyInputShutdown(localSocketId);

    }

    public void shutdownOutput() throws IOException

    {

       if (isClosed())

          throw new SocketException("Socket is closed");

       if (!isConnected())

          throw new SocketException("Socket is not connected");

       if (isOutputShutdown())

          throw new SocketException("Socket output is already shutdown");

       outputStream.shutdown();

       outputShutdown = true;