/*
* Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package java.net;
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();
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.
impl =
impl;
if (
impl != null) {
checkOldImpl();
this.
impl.
setSocket(this);
}
}
/**
* 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));
}
/**
* Tests if {@link SocketOptions#TCP_NODELAY TCP_NODELAY} is enabled.
*
* @return a {@code boolean} indicating whether or not
* {@link SocketOptions#TCP_NODELAY 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)
*/
public boolean
getTcpNoDelay() throws
SocketException {
if (
isClosed())
throw new
SocketException("Socket is closed");
return ((
Boolean)
getImpl().
getOption(
SocketOptions.
TCP_NODELAY)).
booleanValue();
}
/**
* Enable/disable {@link SocketOptions#SO_LINGER 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()
*/
public void
setSoLinger(boolean
on, int
linger) throws
SocketException {
if (
isClosed())
throw new
SocketException("Socket is closed");
if (!
on) {
getImpl().
setOption(
SocketOptions.
SO_LINGER, new
Boolean(
on));
} else {
if (
linger < 0) {
throw new
IllegalArgumentException("invalid value for SO_LINGER");
}
if (
linger > 65535)
linger = 65535;
getImpl().
setOption(
SocketOptions.
SO_LINGER, new
Integer(
linger));
}
}
/**
* Returns setting for {@link SocketOptions#SO_LINGER SO_LINGER}.
* -1 returns implies that the
* option is disabled.
*
* The setting only affects socket close.
*
* @return the setting for {@link SocketOptions#SO_LINGER 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)
*/
public int
getSoLinger() throws
SocketException {
if (
isClosed())
throw new
SocketException("Socket is closed");
Object o =
getImpl().
getOption(
SocketOptions.
SO_LINGER);
if (
o instanceof
Integer) {
return ((
Integer)
o).
intValue();
} else {
return -1;
}
}
/**
* 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
*/
public void
sendUrgentData (int
data) throws
IOException {
if (!
getImpl().
supportsUrgentData ()) {
throw new
SocketException ("Urgent data not supported");
}
getImpl().
sendUrgentData (
data);
}
/**
* Enable/disable {@link SocketOptions#SO_OOBINLINE SO_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} to enable
* {@link SocketOptions#SO_OOBINLINE SO_OOBINLINE},
* {@code false} to disable.
*
* @exception SocketException if there is an error
* in the underlying protocol, such as a TCP error.
*
* @since 1.4
*
* @see #getOOBInline()
*/
public void
setOOBInline(boolean
on) throws
SocketException {
if (
isClosed())
throw new
SocketException("Socket is closed");
getImpl().
setOption(
SocketOptions.
SO_OOBINLINE,
Boolean.
valueOf(
on));
}
/**
* Tests if {@link SocketOptions#SO_OOBINLINE SO_OOBINLINE} is enabled.
*
* @return a {@code boolean} indicating whether or not
* {@link SocketOptions#SO_OOBINLINE SO_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)
*/
public boolean
getOOBInline() throws
SocketException {
if (
isClosed())
throw new
SocketException("Socket is closed");
return ((
Boolean)
getImpl().
getOption(
SocketOptions.
SO_OOBINLINE)).
booleanValue();
}
/**
* Enable/disable {@link SocketOptions#SO_TIMEOUT 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 {@code > 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()
*/
public synchronized 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");
getImpl().
setOption(
SocketOptions.
SO_TIMEOUT, new
Integer(
timeout));
}
/**
* Returns setting for {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT}.
* 0 returns implies that the option is disabled (i.e., timeout of infinity).
*
* @return the setting for {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT}
* @exception SocketException if there is an error
* in the underlying protocol, such as a TCP error.
*
* @since JDK1.1
* @see #setSoTimeout(int)
*/
public synchronized int
getSoTimeout() throws
SocketException {
if (
isClosed())
throw new
SocketException("Socket is closed");
Object o =
getImpl().
getOption(
SocketOptions.
SO_TIMEOUT);
/* extra type safety */
if (
o instanceof
Integer) {
return ((
Integer)
o).
intValue();
} else {
return 0;
}
}
/**
* Sets the {@link SocketOptions#SO_SNDBUF SO_SNDBUF} option to the
* specified value for this {@code Socket}.
* The {@link SocketOptions#SO_SNDBUF 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 {@link SocketOptions#SO_SNDBUF 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
*/
public synchronized void
setSendBufferSize(int
size)
throws
SocketException{
if (!(
size > 0)) {
throw new
IllegalArgumentException("negative send size");
}
if (
isClosed())
throw new
SocketException("Socket is closed");
getImpl().
setOption(
SocketOptions.
SO_SNDBUF, new
Integer(
size));
}
/**
* Get value of the {@link SocketOptions#SO_SNDBUF SO_SNDBUF} option
* for this {@code Socket}, that is the buffer size used by the platform
* for output on this {@code Socket}.
* @return the value of the {@link SocketOptions#SO_SNDBUF SO_SNDBUF}
* option for this {@code Socket}.
*
* @exception SocketException if there is an error
* in the underlying protocol, such as a TCP error.
*
* @see #setSendBufferSize(int)
* @since 1.2
*/
public synchronized int
getSendBufferSize() throws
SocketException {
if (
isClosed())
throw new
SocketException("Socket is closed");
int
result = 0;
Object o =
getImpl().
getOption(
SocketOptions.
SO_SNDBUF);
if (
o instanceof
Integer) {
result = ((
Integer)
o).
intValue();
}
return
result;
}
/**
* Sets the {@link SocketOptions#SO_RCVBUF SO_RCVBUF} option to the
* specified value for this {@code Socket}. The
* {@link SocketOptions#SO_RCVBUF 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 {@link SocketOptions#SO_RCVBUF 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 {@link SocketOptions#SO_RCVBUF 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:
* <ol>
* <li>For sockets accepted from a ServerSocket, this must be done by calling
* {@link 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.</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()
* @see ServerSocket#setReceiveBufferSize(int)
* @since 1.2
*/
public synchronized void
setReceiveBufferSize(int
size)
throws
SocketException{
if (
size <= 0) {
throw new
IllegalArgumentException("invalid receive size");
}
if (
isClosed())
throw new
SocketException("Socket is closed");
getImpl().
setOption(
SocketOptions.
SO_RCVBUF, new
Integer(
size));
}
/**
* Gets the value of the {@link SocketOptions#SO_RCVBUF SO_RCVBUF} option
* for this {@code Socket}, that is the buffer size used by the platform
* for input on this {@code Socket}.
*
* @return the value of the {@link SocketOptions#SO_RCVBUF SO_RCVBUF}
* option for this {@code Socket}.
* @exception SocketException if there is an error
* in the underlying protocol, such as a TCP error.
* @see #setReceiveBufferSize(int)
* @since 1.2
*/
public synchronized int
getReceiveBufferSize()
throws
SocketException{
if (
isClosed())
throw new
SocketException("Socket is closed");
int
result = 0;
Object o =
getImpl().
getOption(
SocketOptions.
SO_RCVBUF);
if (
o instanceof
Integer) {
result = ((
Integer)
o).
intValue();
}
return
result;
}
/**
* Enable/disable {@link SocketOptions#SO_KEEPALIVE 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()
*/
public void
setKeepAlive(boolean
on) throws
SocketException {
if (
isClosed())
throw new
SocketException("Socket is closed");
getImpl().
setOption(
SocketOptions.
SO_KEEPALIVE,
Boolean.
valueOf(
on));
}
/**
* Tests if {@link SocketOptions#SO_KEEPALIVE SO_KEEPALIVE} is enabled.
*
* @return a {@code boolean} indicating whether or not
* {@link SocketOptions#SO_KEEPALIVE 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)
*/
public boolean
getKeepAlive() throws
SocketException {
if (
isClosed())
throw new
SocketException("Socket is closed");
return ((
Boolean)
getImpl().
getOption(
SocketOptions.
SO_KEEPALIVE)).
booleanValue();
}
/**
* 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} or an IllegalArgumentException will be thrown.
* <p>Notes:
* <p>For Internet Protocol v4 the value consists of an
* {@code integer}, the least significant 8 bits of which
* represent the value of the TOS octet in IP packets sent by
* the socket.
* RFC 1349 defines the TOS values as follows:
*
* <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} is the value that
* would be placed into the sin6_flowinfo field of the IP header.
*
* @param tc an {@code int} value for the bitset.
* @throws SocketException if there is an error setting the
* traffic class or type-of-service
* @since 1.4
* @see #getTrafficClass
* @see SocketOptions#IP_TOS
*/
public void
setTrafficClass(int
tc) throws
SocketException {
if (
tc < 0 ||
tc > 255)
throw new
IllegalArgumentException("tc is not in range 0 -- 255");
if (
isClosed())
throw new
SocketException("Socket is closed");
try {
getImpl().
setOption(
SocketOptions.
IP_TOS,
tc);
} catch (
SocketException se) {
// not supported if socket already connected
// Solaris returns error in such cases
if(!
isConnected())
throw
se;
}
}
/**
* 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)
* @see SocketOptions#IP_TOS
*/
public int
getTrafficClass() throws
SocketException {
return ((
Integer) (
getImpl().
getOption(
SocketOptions.
IP_TOS))).
intValue();
}
/**
* Enable/disable the {@link SocketOptions#SO_REUSEADDR 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 {@code TIME_WAIT} state
* or {@code 2MSL} wait state).
* For applications using a well known socket address or port
* it may not be possible to bind a socket to the required
* {@code SocketAddress} if there is a connection in the
* timeout state involving the socket address or port.
* <p>
* Enabling {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR}
* 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 {@code Socket} is created the initial setting
* of {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is disabled.
* <p>
* The behaviour when {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} 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 {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR}
* socket option, or the socket is closed.
* @since 1.4
* @see #getReuseAddress()
* @see #bind(SocketAddress)
* @see #isClosed()
* @see #isBound()
*/
public void
setReuseAddress(boolean
on) throws
SocketException {
if (
isClosed())
throw new
SocketException("Socket is closed");
getImpl().
setOption(
SocketOptions.
SO_REUSEADDR,
Boolean.
valueOf(
on));
}
/**
* Tests if {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is enabled.
*
* @return a {@code boolean} indicating whether or not
* {@link SocketOptions#SO_REUSEADDR 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)
*/
public boolean
getReuseAddress() throws
SocketException {
if (
isClosed())
throw new
SocketException("Socket is closed");
return ((
Boolean) (
getImpl().
getOption(
SocketOptions.
SO_REUSEADDR))).
booleanValue();
}
/**
* 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.
* @revised 1.4
* @spec JSR-51
* @see #isClosed
*/
public synchronized void
close() throws
IOException {
synchronized(
closeLock) {
if (
isClosed())
return;
if (
created)
impl.
close();
closed = true;
}
}
/**
* 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 this method on the
* socket, the stream's {@code available} method will return 0, and its
* {@code read} methods will return {@code -1} (end of stream).
*
* @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
*/
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");
getImpl().
shutdownInput();
shutIn = true;
}
/**
* 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
*/
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");
getImpl().
shutdownOutput();
shutOut = true;
}
/**
* Converts this socket to a {@code String}.
*
* @return a string representation of this socket.
*/
public
String toString() {
try {
if (
isConnected())
return "Socket[addr=" +
getImpl().
getInetAddress() +
",port=" +
getImpl().
getPort() +
",localport=" +
getImpl().
getLocalPort() + "]";
} catch (
SocketException e) {
}
return "Socket[unconnected]";
}
/**
* Returns the connection state of the socket.
* <p>
* Note: Closing a socket doesn't clear its connection state, which means
* this method will return {@code true} for a closed socket
* (see {@link #isClosed()}) if it was successfuly connected prior
* to being closed.
*
* @return true if the socket was successfuly connected to a server
* @since 1.4
*/
public boolean
isConnected() {
// Before 1.3 Sockets were always connected during creation
return
connected ||
oldImpl;
}
/**
* Returns the binding state of the socket.
* <p>
* Note: Closing a socket doesn't clear its binding state, which means
* this method will return {@code true} for a closed socket
* (see {@link #isClosed()}) if it was successfuly bound prior
* to being closed.
*
* @return true if the socket was successfuly bound to an address
* @since 1.4
* @see #bind
*/
public boolean
isBound() {
// Before 1.3 Sockets were always bound during creation
return
bound ||
oldImpl;
}
/**
* Returns the closed state of the socket.
*
* @return true if the socket has been closed
* @since 1.4
* @see #close
*/
public boolean
isClosed() {
synchronized(
closeLock) {
return
closed;
}
}
/**
* 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
*/
public boolean
isInputShutdown() {
return
shutIn;
}
/**
* 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
*/
public boolean
isOutputShutdown() {
return
shutOut;
}
/**
* The factory for all client sockets.
*/
private static
SocketImplFactory factory = null;
/**
* Sets the client socket implementation factory for the
* application. The factory can be specified only once.
* <p>
* When an application creates a new client socket, the socket
* implementation factory's {@code createSocketImpl} method is
* called to create the actual socket implementation.
* <p>
* Passing {@code null} to the method is a no-op unless the factory
* was already set.
* <p>If there is a security manager, this method first calls
* the security manager's {@code checkSetFactory} method
* to ensure the operation is allowed.
* This could result in a SecurityException.
*
* @param fac the desired factory.
* @exception IOException if an I/O error occurs when setting the
* socket factory.
* @exception SocketException if the factory is already defined.
* @exception SecurityException if a security manager exists and its
* {@code checkSetFactory} method doesn't allow the operation.
* @see java.net.SocketImplFactory#createSocketImpl()
* @see SecurityManager#checkSetFactory
*/
public static synchronized void
setSocketImplFactory(
SocketImplFactory fac)
throws
IOException
{
if (
factory != null) {
throw new
SocketException("factory already defined");
}
SecurityManager security =
System.
getSecurityManager();
if (
security != null) {
security.
checkSetFactory();
}
factory =
fac;
}
/**
* 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
* {@code (1, 0, 0)}. 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 {@code (0, 1, 2)}.
*
* <p> Invoking this method after this socket has been connected
* will have no effect.
*
* @param connectionTime
* An {@code int} expressing the relative importance of a short
* connection time
*
* @param latency
* An {@code int} expressing the relative importance of low
* latency
*
* @param bandwidth
* An {@code int} expressing the relative importance of high
* bandwidth
*
* @since 1.5
*/
public void
setPerformancePreferences(int
connectionTime,
int
latency,
int
bandwidth)
{
/* Not implemented yet */
}
}