PlainSocketImpl() 
{
     
        java.security.AccessController.doPrivileged( new PrivilegedAction< Object >() {
                public Object run() {
                    version = 0;
                    try {
                        version = Float.parseFloat(System.getProperties().getProperty("os.version"));
                        preferIPv4Stack = Boolean.parseBoolean(
                                          System.getProperties().getProperty("java.net.preferIPv4Stack"));
                    } catch (NumberFormatException e ) {
                        assert false : e;
                    }
                    return null; // nothing to return
                } });
        // (version  >= 6.0) implies Vista or greater.
        if (version  >= 6.0 && !preferIPv4Stack) {
            useDualStackImpl = true;
        }
        if (useDualStackImpl) {
            impl = new DualStackPlainSocketImpl();
        } else {
            impl = new TwoStacksPlainSocketImpl();
        }
}

Constructs an empty instance.

 PlainSocketImpl(FileDescriptor fd) 
{
        if (useDualStackImpl) {
            impl = new DualStackPlainSocketImpl(fd);
        } else {
            impl = new TwoStacksPlainSocketImpl(fd);
        }
}

Constructs an instance with the given file descriptor.

 protected synchronized  void accept(SocketImpl s) throws IOException 
{
        // pass in the real impl not the wrapper.
        ((PlainSocketImpl)s).impl.address = new InetAddress();
        ((PlainSocketImpl)s).impl.fd = new FileDescriptor();
        impl.accept(((PlainSocketImpl)s).impl);
}

 FileDescriptor acquireFD() 
{
        return impl.acquireFD();
}

 protected synchronized  void bind(InetAddress address,
    int lport) throws IOException 
{
        impl.bind(address, lport);
}

 protected  void close() throws IOException 
{
        impl.close();
}

 protected  void connect(String host,
    int port) throws UnknownHostException, IOException 
{
        impl.connect(host, port);
}

 protected  void connect(InetAddress address,
    int port) throws IOException 
{
        impl.connect(address, port);
}

 protected  void connect(SocketAddress address,
    int timeout) throws IOException 
{
        impl.connect(address, timeout);
}

 protected synchronized  void create(boolean stream) throws IOException 
{
        impl.create(stream);
}

 synchronized  void doConnect(InetAddress address,
    int port,
    int timeout) throws IOException 
{
        impl.doConnect(address, port, timeout);
}

 protected FileDescriptor getFileDescriptor() 
{
        return impl.getFileDescriptor();
}

 protected InetAddress getInetAddress() 
{
        return impl.getInetAddress();
}

 protected synchronized InputStream getInputStream() throws IOException 
{
        return impl.getInputStream();
}

 protected int getLocalPort() 
{
        return impl.getLocalPort();
}

 public Object getOption(int opt) throws SocketException 
{
        return impl.getOption(opt);
}

 protected synchronized OutputStream getOutputStream() throws IOException 
{
        return impl.getOutputStream();
}

 protected int getPort() 
{
        return impl.getPort();
}

 ServerSocket getServerSocket() 
{
        return impl.getServerSocket();
}

 Socket getSocket() 
{
        return impl.getSocket();
}

 public int getTimeout() 
{
        return impl.getTimeout();
}

 public boolean isClosedOrPending() 
{
        return impl.isClosedOrPending();
}

 public boolean isConnectionReset() 
{
        return impl.isConnectionReset();
}

 public boolean isConnectionResetPending() 
{
        return impl.isConnectionResetPending();
}

  void releaseFD() 
{
        impl.releaseFD();
}

  void reset() throws IOException 
{
        impl.reset();
}

 protected  void sendUrgentData(int data) throws IOException 
{
        impl.sendUrgentData(data);
}

  void setAddress(InetAddress address) 
{
        impl.setAddress(address);
}

 public  void setConnectionReset() 
{
        impl.setConnectionReset();
}

 public  void setConnectionResetPending() 
{
        impl.setConnectionResetPending();
}

  void setFileDescriptor(FileDescriptor fd) 
{
        impl.setFileDescriptor(fd);
}

  void setInputStream(SocketInputStream in) 
{
        impl.setInputStream(in);
}

  void setLocalPort(int localPort) 
{
        impl.setLocalPort(localPort);
}

 public  void setOption(int opt,
    Object val) throws SocketException 
{
        impl.setOption(opt, val);
}

  void setPort(int port) 
{
        impl.setPort(port);
}

  void setServerSocket(ServerSocket soc) 
{
        impl.setServerSocket(soc);
}

  void setSocket(Socket soc) 
{
        impl.setSocket(soc);
}

 protected  void shutdownInput() throws IOException 
{
        impl.shutdownInput();
}

 protected  void shutdownOutput() throws IOException 
{
        impl.shutdownOutput();
}

  void socketAccept(SocketImpl s) throws IOException 
{
        impl.socketAccept(s);
}

 int socketAvailable() throws IOException 
{
        return impl.socketAvailable();
}

  void socketBind(InetAddress address,
    int port) throws IOException 
{
        impl.socketBind(address, port);
}

  void socketClose0(boolean useDeferredClose) throws IOException 
{
        impl.socketClose0(useDeferredClose);
}

  void socketConnect(InetAddress address,
    int port,
    int timeout) throws IOException 
{
        impl.socketConnect(address, port, timeout);
}

  void socketCreate(boolean isServer) throws IOException 
{
        impl.socketCreate(isServer);
}

 int socketGetOption(int opt,
    Object iaContainerObj) throws SocketException 
{
        return impl.socketGetOption(opt, iaContainerObj);
}

  void socketListen(int count) throws IOException 
{
        impl.socketListen(count);
}

  void socketSendUrgentData(int data) throws IOException 
{
        impl.socketSendUrgentData(data);
}

  void socketSetOption(int cmd,
    boolean on,
    Object value) throws SocketException 
{
        socketSetOption(cmd, on, value);
}

  void socketShutdown(int howto) throws IOException 
{
        impl.socketShutdown(howto);
}

 public String toString() 
{
        return impl.toString();
}