/*

* Copyright (c) 1995, 2019, Oracle and/or its affiliates. All rights reserved.

* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*/

package java.net;

import sun.security.util.SecurityConstants;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.IOException;

import java.nio.channels.SocketChannel;

import java.security.AccessController;

import java.security.PrivilegedExceptionAction;

import java.security.PrivilegedAction;

/**

* This class implements client sockets (also called just

* "sockets"). A socket is an endpoint for communication

* between two machines.

* <p>

* The actual work of the socket is performed by an instance of the

* {@code SocketImpl} class. An application, by changing

* the socket factory that creates the socket implementation,

* can configure itself to create sockets appropriate to the local

* firewall.

*

* @author unascribed

* @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)

* @see java.net.SocketImpl

* @see java.nio.channels.SocketChannel

* @since JDK1.0

*/

public

class Socket implements java.io.Closeable {

/**

* Various states of this socket.

*/

private boolean created = false;

private boolean bound = false;

private boolean connected = false;

private boolean closed = false;

private Object closeLock = new Object();

private boolean shutIn = false;

private boolean shutOut = false;

/**

* The implementation of this Socket.

*/

SocketImpl impl;

/**

* Are we using an older SocketImpl?

*/

private boolean oldImpl = false;

/**

* Creates an unconnected socket, with the

* system-default type of SocketImpl.

*

* @since JDK1.1

* @revised 1.4

*/

public Socket() {

setImpl();

}

/**

* Creates an unconnected socket, specifying the type of proxy, if any,

* that should be used regardless of any other settings.

* <P>

* If there is a security manager, its {@code checkConnect} method

* is called with the proxy host address and port number

* as its arguments. This could result in a SecurityException.

* <P>

* Examples:

* <UL> <LI>{@code Socket s = new Socket(Proxy.NO_PROXY);} will create

* a plain socket ignoring any other proxy configuration.</LI>

* <LI>{@code Socket s = new Socket(new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("socks.mydom.com", 1080)));}

* will create a socket connecting through the specified SOCKS proxy

* server.</LI>

* </UL>

*

* @param proxy a {@link java.net.Proxy Proxy} object specifying what kind

* of proxying should be used.

* @throws IllegalArgumentException if the proxy is of an invalid type

* or {@code null}.

* @throws SecurityException if a security manager is present and

* permission to connect to the proxy is

* denied.

* @see java.net.ProxySelector

* @see java.net.Proxy

*

* @since 1.5

*/

public Socket(Proxy proxy) {

// Create a copy of Proxy as a security measure

if (proxy == null) {

throw new IllegalArgumentException("Invalid Proxy");

}

Proxy p = proxy == Proxy.NO_PROXY ? Proxy.NO_PROXY

: sun.net.ApplicationProxy.create(proxy);

Proxy.Type type = p.type();

if (type == Proxy.Type.SOCKS || type == Proxy.Type.HTTP) {

SecurityManager security = System.getSecurityManager();

InetSocketAddress epoint = (InetSocketAddress) p.address();

if (epoint.getAddress() != null) {

checkAddress (epoint.getAddress(), "Socket");

}

if (security != null) {

if (epoint.isUnresolved())

epoint = new InetSocketAddress(epoint.getHostName(), epoint.getPort());

if (epoint.isUnresolved())

security.checkConnect(epoint.getHostName(), epoint.getPort());

else

security.checkConnect(epoint.getAddress().getHostAddress(),

epoint.getPort());

}

impl = type == Proxy.Type.SOCKS ? new SocksSocketImpl(p)

: new HttpConnectSocketImpl(p);

impl.setSocket(this);

} else {

if (p == Proxy.NO_PROXY) {

if (factory == null) {

impl = new PlainSocketImpl(false);

impl.setSocket(this);

} else

setImpl();

} else

throw new IllegalArgumentException("Invalid Proxy");

}

}

/**

* Creates an unconnected Socket with a user-specified

* SocketImpl.

* <P>

* @param impl an instance of a <B>SocketImpl</B>

* the subclass wishes to use on the Socket.

*

* @exception SocketException if there is an error in the underlying protocol,

* such as a TCP error.

* @since JDK1.1

*/

protected Socket(SocketImpl impl) throws SocketException {

this(checkPermission(impl), impl);

}

private Socket(Void ignore, SocketImpl impl) {

if (impl != null) {

this.impl = impl;

checkOldImpl();

impl.setSocket(this);

}

}

private static Void checkPermission(SocketImpl impl) {

if (impl == null) {

return null;

}

SecurityManager sm = System.getSecurityManager();

if (sm != null) {

sm.checkPermission(SecurityConstants.SET_SOCKETIMPL_PERMISSION);

}

return null;

}

/**

* Creates a stream socket and connects it to the specified port

* number on the named host.

* <p>

* If the specified host is {@code null} it is the equivalent of

* specifying the address as

* {@link java.net.InetAddress#getByName InetAddress.getByName}{@code (null)}.

* In other words, it is equivalent to specifying an address of the

* loopback interface. </p>

* <p>

* If the application has specified a server socket factory, that

* factory's {@code createSocketImpl} method is called to create

* the actual socket implementation. Otherwise a "plain" socket is created.

* <p>

* If there is a security manager, its

* {@code checkConnect} method is called

* with the host address and {@code port}

* as its arguments. This could result in a SecurityException.

*

* @param host the host name, or {@code null} for the loopback address.

* @param port the port number.

*

* @exception UnknownHostException if the IP address of

* the host could not be determined.

*

* @exception IOException if an I/O error occurs when creating the socket.

* @exception SecurityException if a security manager exists and its

* {@code checkConnect} method doesn't allow the operation.

* @exception IllegalArgumentException if the port parameter is outside

* the specified range of valid port values, which is between

* 0 and 65535, inclusive.

* @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)

* @see java.net.SocketImpl

* @see java.net.SocketImplFactory#createSocketImpl()

* @see SecurityManager#checkConnect

*/

public Socket(String host, int port)

throws UnknownHostException, IOException

{

this(host != null ? new InetSocketAddress(host, port) :

new InetSocketAddress(InetAddress.getByName(null), port),

(SocketAddress) null, true);

}

/**

* Creates a stream socket and connects it to the specified port

* number at the specified IP address.

* <p>

* If the application has specified a socket factory, that factory's

* {@code createSocketImpl} method is called to create the

* actual socket implementation. Otherwise a "plain" socket is created.

* <p>

* If there is a security manager, its

* {@code checkConnect} method is called

* with the host address and {@code port}

* as its arguments. This could result in a SecurityException.

*

* @param address the IP address.

* @param port the port number.

* @exception IOException if an I/O error occurs when creating the socket.

* @exception SecurityException if a security manager exists and its

* {@code checkConnect} method doesn't allow the operation.

* @exception IllegalArgumentException if the port parameter is outside

* the specified range of valid port values, which is between

* 0 and 65535, inclusive.

* @exception NullPointerException if {@code address} is null.

* @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)

* @see java.net.SocketImpl

* @see java.net.SocketImplFactory#createSocketImpl()

* @see SecurityManager#checkConnect

*/

public Socket(InetAddress address, int port) throws IOException {

this(address != null ? new InetSocketAddress(address, port) : null,

(SocketAddress) null, true);

}

/**

* Creates a socket and connects it to the specified remote host on

* the specified remote port. The Socket will also bind() to the local

* address and port supplied.

* <p>

* If the specified host is {@code null} it is the equivalent of

* specifying the address as

* {@link java.net.InetAddress#getByName InetAddress.getByName}{@code (null)}.

* In other words, it is equivalent to specifying an address of the

* loopback interface. </p>

* <p>

* A local port number of {@code zero} will let the system pick up a

* free port in the {@code bind} operation.</p>

* <p>

* If there is a security manager, its

* {@code checkConnect} method is called

* with the host address and {@code port}

* as its arguments. This could result in a SecurityException.

*

* @param host the name of the remote host, or {@code null} for the loopback address.

* @param port the remote port

* @param localAddr the local address the socket is bound to, or

* {@code null} for the {@code anyLocal} address.

* @param localPort the local port the socket is bound to, or

* {@code zero} for a system selected free port.

* @exception IOException if an I/O error occurs when creating the socket.

* @exception SecurityException if a security manager exists and its

* {@code checkConnect} method doesn't allow the connection

* to the destination, or if its {@code checkListen} method

* doesn't allow the bind to the local port.

* @exception IllegalArgumentException if the port parameter or localPort

* parameter is outside the specified range of valid port values,

* which is between 0 and 65535, inclusive.

* @see SecurityManager#checkConnect

* @since JDK1.1

*/

public Socket(String host, int port, InetAddress localAddr,

int localPort) throws IOException {

this(host != null ? new InetSocketAddress(host, port) :

new InetSocketAddress(InetAddress.getByName(null), port),

new InetSocketAddress(localAddr, localPort), true);

}

/**

* Creates a socket and connects it to the specified remote address on

* the specified remote port. The Socket will also bind() to the local

* address and port supplied.

* <p>

* If the specified local address is {@code null} it is the equivalent of

* specifying the address as the AnyLocal address

* (see {@link java.net.InetAddress#isAnyLocalAddress InetAddress.isAnyLocalAddress}{@code ()}).

* <p>

* A local port number of {@code zero} will let the system pick up a

* free port in the {@code bind} operation.</p>

* <p>

* If there is a security manager, its

* {@code checkConnect} method is called

* with the host address and {@code port}

* as its arguments. This could result in a SecurityException.

*

* @param address the remote address

* @param port the remote port

* @param localAddr the local address the socket is bound to, or

* {@code null} for the {@code anyLocal} address.

* @param localPort the local port the socket is bound to or

* {@code zero} for a system selected free port.

* @exception IOException if an I/O error occurs when creating the socket.

* @exception SecurityException if a security manager exists and its

* {@code checkConnect} method doesn't allow the connection

* to the destination, or if its {@code checkListen} method

* doesn't allow the bind to the local port.

* @exception IllegalArgumentException if the port parameter or localPort

* parameter is outside the specified range of valid port values,

* which is between 0 and 65535, inclusive.

* @exception NullPointerException if {@code address} is null.

* @see SecurityManager#checkConnect

* @since JDK1.1

*/

public Socket(InetAddress address, int port, InetAddress localAddr,

int localPort) throws IOException {

this(address != null ? new InetSocketAddress(address, port) : null,

new InetSocketAddress(localAddr, localPort), true);

}

/**

* Creates a stream socket and connects it to the specified port

* number on the named host.

* <p>

* If the specified host is {@code null} it is the equivalent of

* specifying the address as

* {@link java.net.InetAddress#getByName InetAddress.getByName}{@code (null)}.

* In other words, it is equivalent to specifying an address of the

* loopback interface. </p>

* <p>

* If the stream argument is {@code true}, this creates a

* stream socket. If the stream argument is {@code false}, it

* creates a datagram socket.

* <p>

* If the application has specified a server socket factory, that

* factory's {@code createSocketImpl} method is called to create

* the actual socket implementation. Otherwise a "plain" socket is created.

* <p>

* If there is a security manager, its

* {@code checkConnect} method is called

* with the host address and {@code port}

* as its arguments. This could result in a SecurityException.

* <p>

* If a UDP socket is used, TCP/IP related socket options will not apply.

*

* @param host the host name, or {@code null} for the loopback address.

* @param port the port number.

* @param stream a {@code boolean} indicating whether this is

* a stream socket or a datagram socket.

* @exception IOException if an I/O error occurs when creating the socket.

* @exception SecurityException if a security manager exists and its

* {@code checkConnect} method doesn't allow the operation.

* @exception IllegalArgumentException if the port parameter is outside

* the specified range of valid port values, which is between

* 0 and 65535, inclusive.

* @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)

* @see java.net.SocketImpl

* @see java.net.SocketImplFactory#createSocketImpl()

* @see SecurityManager#checkConnect

* @deprecated Use DatagramSocket instead for UDP transport.

*/

@Deprecated

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

this(host != null ? new InetSocketAddress(host, port) :

new InetSocketAddress(InetAddress.getByName(null), port),

(SocketAddress) null, stream);

}

/**

* Creates a socket and connects it to the specified port number at

* the specified IP address.

* <p>

* If the stream argument is {@code true}, this creates a

* stream socket. If the stream argument is {@code false}, it

* creates a datagram socket.

* <p>

* If the application has specified a server socket factory, that

* factory's {@code createSocketImpl} method is called to create

* the actual socket implementation. Otherwise a "plain" socket is created.

*

* <p>If there is a security manager, its

* {@code checkConnect} method is called

* with {@code host.getHostAddress()} and {@code port}

* as its arguments. This could result in a SecurityException.

* <p>

* If UDP socket is used, TCP/IP related socket options will not apply.

*

* @param host the IP address.

* @param port the port number.

* @param stream if {@code true}, create a stream socket;

* otherwise, create a datagram socket.

* @exception IOException if an I/O error occurs when creating the socket.

* @exception SecurityException if a security manager exists and its

* {@code checkConnect} method doesn't allow the operation.

* @exception IllegalArgumentException if the port parameter is outside

* the specified range of valid port values, which is between

* 0 and 65535, inclusive.

* @exception NullPointerException if {@code host} is null.

* @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)

* @see java.net.SocketImpl

* @see java.net.SocketImplFactory#createSocketImpl()

* @see SecurityManager#checkConnect

* @deprecated Use DatagramSocket instead for UDP transport.

*/

@Deprecated

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

this(host != null ? new InetSocketAddress(host, port) : null,

new InetSocketAddress(0), stream);

}

private Socket(SocketAddress address, SocketAddress localAddr,

boolean stream) throws IOException {

setImpl();

// backward compatibility

if (address == null)

throw new NullPointerException();

try {

createImpl(stream);

if (localAddr != null)

bind(localAddr);

connect(address);

} catch (IOException | IllegalArgumentException | SecurityException e) {

try {

close();

} catch (IOException ce) {

e.addSuppressed(ce);

}

throw e;

}

}

/**

* Creates the socket implementation.

*

* @param stream a {@code boolean} value : {@code true} for a TCP socket,

* {@code false} for UDP.

* @throws IOException if creation fails

* @since 1.4

*/

void createImpl(boolean stream) throws SocketException {

if (impl == null)

setImpl();

try {

impl.create(stream);

created = true;

} catch (IOException e) {

throw new SocketException(e.getMessage());

}

}

private void checkOldImpl() {

if (impl == null)

return;

// SocketImpl.connect() is a protected method, therefore we need to use

// getDeclaredMethod, therefore we need permission to access the member

oldImpl = AccessController.doPrivileged

(new PrivilegedAction<Boolean>() {

public Boolean run() {

Class<?> clazz = impl.getClass();

while (true) {

try {

clazz.getDeclaredMethod("connect", SocketAddress.class, int.class);

return Boolean.FALSE;

} catch (NoSuchMethodException e) {

clazz = clazz.getSuperclass();

// java.net.SocketImpl class will always have this abstract method.

// If we have not found it by now in the hierarchy then it does not

// exist, we are an old style impl.

if (clazz.equals(java.net.SocketImpl.class)) {

return Boolean.TRUE;

}

}

}

}

});

}

/**

* Sets impl to the system-default type of SocketImpl.

* @since 1.4

*/

void setImpl() {

if (factory != null) {

impl = factory.createSocketImpl();

checkOldImpl();

} else {

// No need to do a checkOldImpl() here, we know it's an up to date

// SocketImpl!

impl = new SocksSocketImpl();

}

if (impl != null)

impl.setSocket(this);

}

/**

* Get the {@code SocketImpl} attached to this socket, creating

* it if necessary.

*

* @return the {@code SocketImpl} attached to that ServerSocket.

* @throws SocketException if creation fails

* @since 1.4

*/

SocketImpl getImpl() throws SocketException {

if (!created)

createImpl(true);

return impl;

}

/**

* Connects this socket to the server.

*

* @param endpoint the {@code SocketAddress}

* @throws IOException if an error occurs during the connection

* @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

* @spec JSR-51

*/

public void connect(SocketAddress endpoint) throws IOException {

connect(endpoint, 0);

}

/**

* 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}

* @param timeout the timeout value to be used in milliseconds.

* @throws IOException if an error occurs during the connection

* @throws 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

* @spec JSR-51

*/

public void connect(SocketAddress endpoint, int timeout) throws IOException {

if (endpoint == null)

throw new IllegalArgumentException("connect: The address can't be null");

if (timeout < 0)

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

if (isClosed())

throw new SocketException("Socket is closed");

if (!oldImpl && isConnected())

throw new SocketException("already connected");

if (!(endpoint instanceof InetSocketAddress))

throw new IllegalArgumentException("Unsupported address type");

InetSocketAddress epoint = (InetSocketAddress) endpoint;

InetAddress addr = epoint.getAddress ();

int port = epoint.getPort();

checkAddress(addr, "connect");

SecurityManager security = System.getSecurityManager();

if (security != null) {

if (epoint.isUnresolved())

security.checkConnect(epoint.getHostName(), port);

else

security.checkConnect(addr.getHostAddress(), port);

}

if (!created)

createImpl(true);

if (!oldImpl)

impl.connect(epoint, timeout);

else if (timeout == 0) {

if (epoint.isUnresolved())

impl.connect(addr.getHostName(), port);

else

impl.connect(addr, port);

} else

throw new UnsupportedOperationException("SocketImpl.connect(addr, timeout)");

connected = true;

/*

* If the socket was not bound before the connect, it is now because

* the kernel will have picked an ephemeral port & a local address

*/

bound = true;

}

/**

* Binds the socket to a local address.

* <P>

* If the address is {@code null}, then the system will pick up

* an ephemeral port and a valid local address to bind the socket.

*

* @param bindpoint the {@code SocketAddress} 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

* @throws SecurityException if a security manager exists and its

* {@code checkListen} method doesn't allow the bind

* to the local port.

*

* @since 1.4

* @see #isBound

*/

public void bind(SocketAddress bindpoint) throws IOException {

if (isClosed())

throw new SocketException("Socket is closed");

if (!oldImpl && isBound())

throw new SocketException("Already bound");

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

throw new IllegalArgumentException("Unsupported address type");

InetSocketAddress epoint = (InetSocketAddress) bindpoint;

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

throw new SocketException("Unresolved address");

if (epoint == null) {

epoint = new InetSocketAddress(0);

}

InetAddress addr = epoint.getAddress();

int port = epoint.getPort();

checkAddress (addr, "bind");

SecurityManager security = System.getSecurityManager();

if (security != null) {

security.checkListen(port);

}

getImpl().bind (addr, port);

bound = true;

}

private void checkAddress (InetAddress addr, String op) {

if (addr == null) {

return;

}

if (!(addr instanceof Inet4Address || addr instanceof Inet6Address)) {

throw new IllegalArgumentException(op + ": invalid address type");

}

}

/**

* set the flags after an accept() call.

*/

final void postAccept() {

connected = true;

created = true;

bound = true;

}

void setCreated() {

created = true;

}

void setBound() {

bound = true;

}

void setConnected() {

connected = true;

}

/**

* Returns the address to which the socket is connected.

* <p>

* If the socket was connected prior to being {@link #close closed},

* then this method will continue to return the connected address

* after the socket is closed.

*

* @return the remote IP address to which this socket is connected,

* or {@code null} if the socket is not connected.

*/

public InetAddress getInetAddress() {

if (!isConnected())

return null;

try {

return getImpl().getInetAddress();

} catch (SocketException e) {

}

return null;

}

/**

* Gets the local address to which the socket is bound.

* <p>

* If there is a security manager set, its {@code checkConnect} method is

* called with the local address and {@code -1} as its arguments to see

* if the operation is allowed. If the operation is not allowed,

* the {@link InetAddress#getLoopbackAddress loopback} address is returned.

*

* @return the local address to which the socket is bound,

* the loopback address if denied by the security manager, or

* the wildcard address if the socket is closed or not bound yet.

* @since JDK1.1

*

* @see SecurityManager#checkConnect

*/

public InetAddress getLocalAddress() {

// This is for backward compatibility

if (!isBound())

return InetAddress.anyLocalAddress();

InetAddress in = null;

try {

in = (InetAddress) getImpl().getOption(SocketOptions.SO_BINDADDR);

SecurityManager sm = System.getSecurityManager();

if (sm != null)

sm.checkConnect(in.getHostAddress(), -1);

if (in.isAnyLocalAddress()) {

in = InetAddress.anyLocalAddress();

}

} catch (SecurityException e) {

in = InetAddress.getLoopbackAddress();

} catch (Exception e) {

in = InetAddress.anyLocalAddress(); // "0.0.0.0"

}

return in;

}

/**

* Returns the remote port number to which this socket is connected.

* <p>

* If the socket was connected prior to being {@link #close closed},

* then this method will continue to return the connected port number

* after the socket is closed.

*

* @return the remote port number to which this socket is connected, or

* 0 if the socket is not connected yet.

*/

public int getPort() {

if (!isConnected())

return 0;

try {

return getImpl().getPort();

} catch (SocketException e) {

// Shouldn't happen as we're connected

}

return -1;

}

/**

* Returns the local port number to which this socket is bound.

* <p>

* If the socket was bound prior to being {@link #close closed},

* then this method will continue to return the local port number

* after the socket is closed.

*

* @return the local port number to which this socket is bound or -1

* if the socket is not bound yet.

*/

public int getLocalPort() {

if (!isBound())

return -1;

try {

return getImpl().getLocalPort();

} catch(SocketException e) {

// shouldn't happen as we're bound

}

return -1;

}

/**

* Returns the address of the endpoint this socket is connected to, or

* {@code null} if it is unconnected.

* <p>

* If the socket was connected prior to being {@link #close closed},

* then this method will continue to return the connected address

* after the socket is closed.

*

* @return a {@code SocketAddress} representing the remote endpoint of this

* socket, or {@code null} if it is not connected yet.

* @see #getInetAddress()

* @see #getPort()

* @see #connect(SocketAddress, int)

* @see #connect(SocketAddress)

* @since 1.4

*/

public SocketAddress getRemoteSocketAddress() {

if (!isConnected())

return null;

return new InetSocketAddress(getInetAddress(), getPort());

}

/**

* Returns the address of the endpoint this socket is bound to.

* <p>

* If a socket bound to an endpoint represented by an

* {@code InetSocketAddress } is {@link #close closed},

* then this method will continue to return an {@code InetSocketAddress}

* after the socket is closed. In that case the returned

* {@code InetSocketAddress}'s address is the

* {@link InetAddress#isAnyLocalAddress wildcard} address

* and its port is the local port that it was bound to.

* <p>

* If there is a security manager set, its {@code checkConnect} method is

* called with the local address and {@code -1} as its arguments to see

* if the operation is allowed. If the operation is not allowed,

* a {@code SocketAddress} representing the

* {@link InetAddress#getLoopbackAddress loopback} address and the local

* port to which this socket is bound is returned.

*

* @return a {@code SocketAddress} representing the local endpoint of

* this socket, or a {@code SocketAddress} representing the

* loopback address if denied by the security manager, or

* {@code null} if the socket is not bound yet.

*

* @see #getLocalAddress()

* @see #getLocalPort()

* @see #bind(SocketAddress)

* @see SecurityManager#checkConnect

* @since 1.4

*/

public SocketAddress getLocalSocketAddress() {

if (!isBound())

return null;

return new InetSocketAddress(getLocalAddress(), getLocalPort());

}

/**

* 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 {@code null} if this socket was not created

* for a channel

*

* @since 1.4

* @spec JSR-51

*/

public SocketChannel getChannel() {

return null;

}

/**

* Returns an input stream for this socket.

*

* <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 {@code read} operations

* will throw an {@link java.nio.channels.IllegalBlockingModeException}.

*

* <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 :-

*

* <ul>

*

* <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}.

*

* <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}.

*

* <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}.

*

* </ul>

*

* <p> Closing the returned {@link java.io.InputStream InputStream}

* will close the associated socket.

*

* @return an input stream for reading bytes from this socket.

* @exception 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()}

*

* @revised 1.4

* @spec JSR-51

*/

public InputStream getInputStream() 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 shutdown");

final Socket s = this;

InputStream is = null;

try {

is = AccessController.doPrivileged(

new PrivilegedExceptionAction<InputStream>() {

public InputStream run() throws IOException {

return impl.getInputStream();

}

});

} catch (java.security.PrivilegedActionException e) {

throw (IOException) e.getException();

}

return is;

}

/**

* Returns an output stream for this socket.

*

* <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 {@code write}

* operations will throw an {@link

* java.nio.channels.IllegalBlockingModeException}.

*

* <p> Closing the returned {@link java.io.OutputStream OutputStream}

* will close the associated socket.

*

* @return an output stream for writing bytes to this socket.

* @exception IOException if an I/O error occurs when creating the

* output stream or if the socket is not connected.

* @revised 1.4

* @spec JSR-51

*/

public OutputStream getOutputStream() 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 shutdown");

final Socket s = this;

OutputStream os = null;

try {

os = AccessController.doPrivileged(

new PrivilegedExceptionAction<OutputStream>() {

public OutputStream run() throws IOException {

return impl.getOutputStream();

}

});

} catch (java.security.PrivilegedActionException e) {

throw (IOException) e.getException();

}

return os;

}

/**

* Enable/disable {@link SocketOptions#TCP_NODELAY TCP_NODELAY}

* (disable/enable Nagle's algorithm).

*

* @param on {@code true} to enable TCP_NODELAY,

* {@code false} to disable.

*

* @exception SocketException if there is an error

* in the underlying protocol, such as a TCP error.

*

* @since JDK1.1

*

* @see #getTcpNoDelay()

*/

public void setTcpNoDelay(boolean on) throws SocketException {

if (isClosed())

throw new SocketException("Socket is closed");

getImpl().setOption(SocketOptions.TCP_NODELAY, Boolean.valueOf(on));

}

/**