/* * @(#)Socket.java 1.109 05/09/26 * * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * SUN 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.io.InterruptedIOException; 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. *
* The actual work of the socket is performed by an instance of the
* 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
* @version 1.109, 09/26/05
* @see java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
* @see java.net.SocketImpl
* @see java.nio.channels.SocketChannel
* @since JDK1.0
*/
public
class Socket {
/**
* 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.
*
* If there is a security manager, its checkConnect
method
* is called with the proxy host address and port number
* as its arguments. This could result in a SecurityException.
*
* Examples: *
Socket s = new Socket(Proxy.NO_PROXY);
will create
* a plain socket ignoring any other proxy configuration.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.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) {
if (proxy != null && proxy.type() == Proxy.Type.SOCKS) {
SecurityManager security = System.getSecurityManager();
InetSocketAddress epoint = (InetSocketAddress) proxy.address();
if (security != null) {
if (epoint.isUnresolved())
security.checkConnect(epoint.getHostName(),
epoint.getPort());
else
security.checkConnect(epoint.getAddress().getHostAddress(),
epoint.getPort());
}
impl = new SocksSocketImpl(proxy);
impl.setSocket(this);
} else {
if (proxy == 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.
* * @param impl an instance of a SocketImpl * 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. *
* If the specified host is null it is the equivalent of * specifying the address as {@link java.net.InetAddress#getByName InetAddress.getByName}(null). * In other words, it is equivalent to specifying an address of the * loopback interface.
*
* If the application has specified a server socket factory, that
* factory's createSocketImpl
method is called to create
* the actual socket implementation. Otherwise a "plain" socket is created.
*
* If there is a security manager, its
* checkConnect
method is called
* with the host address and port
* as its arguments. This could result in a SecurityException.
*
* @param host the host name, or 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
* checkConnect
method doesn't allow the operation.
* @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),
new InetSocketAddress(0), true);
}
/**
* Creates a stream socket and connects it to the specified port
* number at the specified IP address.
*
* If the application has specified a socket factory, that factory's
* createSocketImpl
method is called to create the
* actual socket implementation. Otherwise a "plain" socket is created.
*
* If there is a security manager, its
* checkConnect
method is called
* with the host address and 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
* checkConnect
method doesn't allow the operation.
* @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,
new InetSocketAddress(0), 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.
*
* If the specified host is null it is the equivalent of * specifying the address as {@link java.net.InetAddress#getByName InetAddress.getByName}(null). * In other words, it is equivalent to specifying an address of the * loopback interface.
*
* If there is a security manager, its
* checkConnect
method is called
* with the host address and port
* as its arguments. This could result in a SecurityException.
*
* @param host the name of the remote host, or null
for the loopback address.
* @param port the remote port
* @param localAddr the local address the socket is bound to
* @param localPort the local port the socket is bound to
* @exception IOException if an I/O error occurs when creating the socket.
* @exception SecurityException if a security manager exists and its
* checkConnect
method doesn't allow the operation.
* @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.
*
* If there is a security manager, its
* checkConnect
method is called
* with the host address and 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
* @param localPort the local port the socket is bound to
* @exception IOException if an I/O error occurs when creating the socket.
* @exception SecurityException if a security manager exists and its
* checkConnect
method doesn't allow the operation.
* @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.
*
* If the specified host is null it is the equivalent of * specifying the address as {@link java.net.InetAddress#getByName InetAddress.getByName}(null). * In other words, it is equivalent to specifying an address of the * loopback interface.
*
* If the stream argument is true
, this creates a
* stream socket. If the stream argument is false
, it
* creates a datagram socket.
*
* If the application has specified a server socket factory, that
* factory's createSocketImpl
method is called to create
* the actual socket implementation. Otherwise a "plain" socket is created.
*
* If there is a security manager, its
* checkConnect
method is called
* with the host address and port
* as its arguments. This could result in a SecurityException.
*
* If a UDP socket is used, TCP/IP related socket options will not apply.
*
* @param host the host name, or null
for the loopback address.
* @param port the port number.
* @param stream a 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
* checkConnect
method doesn't allow the operation.
* @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),
new InetSocketAddress(0), stream);
}
/**
* Creates a socket and connects it to the specified port number at
* the specified IP address.
*
* If the stream argument is true
, this creates a
* stream socket. If the stream argument is false
, it
* creates a datagram socket.
*
* If the application has specified a server socket factory, that
* factory's createSocketImpl
method is called to create
* the actual socket implementation. Otherwise a "plain" socket is created.
*
*
If there is a security manager, its
* checkConnect
method is called
* with host.getHostAddress()
and port
* as its arguments. This could result in a SecurityException.
*
* 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 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
* checkConnect
method doesn't allow the operation.
* @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)
localAddr = new InetSocketAddress(0);
bind(localAddr);
if (address != null)
connect(address);
} catch (IOException e) {
close();
throw e;
}
}
/**
* Creates the socket implementation.
*
* @param stream a boolean
value : true
for a TCP socket,
* 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
Boolean tmpBool = (Boolean) AccessController.doPrivileged (new PrivilegedAction() {
public Boolean run() {
Class[] cl = new Class[2];
cl[0] = SocketAddress.class;
cl[1] = Integer.TYPE;
Class clazz = impl.getClass();
while (true) {
try {
clazz.getDeclaredMethod("connect", cl);
return Boolean.FALSE;
} catch (NoSuchMethodException e) {
clazz = clazz.getSuperclass();
if (clazz.equals (Object.class)) {
return Boolean.TRUE;
}
}
}
}
});
oldImpl = tmpBool.booleanValue();
}
/**
* 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 SocketImpl
attached to this socket, creating
* it if necessary.
*
* @return the 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 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 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;
SecurityManager security = System.getSecurityManager();
if (security != null) {
if (epoint.isUnresolved())
security.checkConnect(epoint.getHostName(),
epoint.getPort());
else
security.checkConnect(epoint.getAddress().getHostAddress(),
epoint.getPort());
}
if (!created)
createImpl(true);
if (!oldImpl)
impl.connect(epoint, timeout);
else if (timeout == 0) {
if (epoint.isUnresolved())
impl.connect(epoint.getAddress().getHostName(),
epoint.getPort());
else
impl.connect(epoint.getAddress(), epoint.getPort());
} 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.
*
* If the address is null
, then the system will pick up
* an ephemeral port and a valid local address to bind the socket.
*
* @param bindpoint the 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
*
* @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 (bindpoint == null)
getImpl().bind(InetAddress.anyLocalAddress(), 0);
else
getImpl().bind(epoint.getAddress(),
epoint.getPort());
bound = true;
}
/**
* 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.
*
* @return the remote IP address to which this socket is connected,
* or 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.
*
* @return the local address to which the socket is bound or
* InetAddress.anyLocalAddress()
* if the socket is not bound yet.
* @since JDK1.1
*/
public InetAddress getLocalAddress() {
// This is for backward compatibility
if (!isBound())
return InetAddress.anyLocalAddress();
InetAddress in = null;
try {
in = (InetAddress) getImpl().getOption(SocketOptions.SO_BINDADDR);
if (in.isAnyLocalAddress()) {
in = InetAddress.anyLocalAddress();
}
} catch (Exception e) {
in = InetAddress.anyLocalAddress(); // "0.0.0.0"
}
return in;
}
/**
* Returns the remote port to which this socket is connected.
*
* @return the remote port number to which this socket is connected, or
* 0 if the socket is not connected yet.
*/
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 to which this socket is bound.
*
* @return the local port number to which this socket is bound or -1
* if the socket is not bound yet.
*/
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
* null
if it is unconnected.
* @return a SocketAddress
reprensenting the remote endpoint of this
* socket, or 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, or
* null
if it is not bound yet.
*
* @return a SocketAddress
representing the local endpoint of this
* socket, or null
if it is not bound yet.
* @see #getLocalAddress()
* @see #getLocalPort()
* @see #bind(SocketAddress)
* @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.
*
*
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 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. * *
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 read operations * will throw an {@link java.nio.channels.IllegalBlockingModeException}. * *
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 :- * *
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}. * *
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}. * *
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 0
.
*
*
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 write
* operations will throw an {@link
* java.nio.channels.IllegalBlockingModeException}.
*
* @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 = (OutputStream)
AccessController.doPrivileged(new PrivilegedExceptionAction() {
public Object run() throws IOException {
return impl.getOutputStream();
}
});
} catch (java.security.PrivilegedActionException e) {
throw (IOException) e.getException();
}
return os;
}
/**
* Enable/disable TCP_NODELAY (disable/enable Nagle's algorithm).
*
* @param on true
to enable TCP_NODELAY,
* 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 TCP_NODELAY is enabled.
*
* @return a boolean
indicating whether or not TCP_NODELAY is enabled.
* @exception SocketException if there is an error
* in the underlying protocol, such as a TCP error.
* @since JDK1.1
* @see #setTcpNoDelay(boolean)
*/
public boolean getTcpNoDelay() throws SocketException {
if (isClosed())
throw new SocketException("Socket is closed");
return ((Boolean) getImpl().getOption(SocketOptions.TCP_NODELAY)).booleanValue();
}
/**
* Enable/disable SO_LINGER with the specified linger time in seconds.
* The maximum timeout value is platform specific.
*
* The setting only affects socket close.
*
* @param on whether or not to linger on.
* @param linger how long to linger for, if on is true.
* @exception SocketException if there is an error
* in the underlying protocol, such as a TCP error.
* @exception IllegalArgumentException if the linger value is negative.
* @since JDK1.1
* @see #getSoLinger()
*/
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 SO_LINGER. -1 returns implies that the
* option is disabled.
*
* The setting only affects socket close.
*
* @return the setting for SO_LINGER.
* @exception SocketException if there is an error
* in the underlying protocol, such as a TCP error.
* @since JDK1.1
* @see #setSoLinger(boolean, int)
*/
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 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.
*
* 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 true
to enable OOBINLINE,
* 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 OOBINLINE is enabled.
*
* @return a boolean
indicating whether or not OOBINLINE is enabled.
* @exception SocketException if there is an error
* in the underlying protocol, such as a TCP error.
* @since 1.4
* @see #setOOBInline(boolean)
*/
public boolean getOOBInline() throws SocketException {
if (isClosed())
throw new SocketException("Socket is closed");
return ((Boolean) getImpl().getOption(SocketOptions.SO_OOBINLINE)).booleanValue();
}
/**
* Enable/disable SO_TIMEOUT with the specified timeout, in
* milliseconds. With this option set to a non-zero timeout,
* a read() call on the InputStream associated with this Socket
* will block for only this amount of time. If the timeout expires,
* a java.net.SocketTimeoutException is raised, though the
* Socket is still valid. The option must be enabled
* prior to entering the blocking operation to have effect. The
* timeout must be > 0.
* A timeout of zero is interpreted as an infinite timeout.
* @param timeout the specified timeout, in milliseconds.
* @exception SocketException if there is an error
* in the underlying protocol, such as a TCP error.
* @since JDK 1.1
* @see #getSoTimeout()
*/
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 SO_TIMEOUT. 0 returns implies that the
* option is disabled (i.e., timeout of infinity).
* @return the setting for SO_TIMEOUT
* @exception SocketException if there is an error
* in the underlying protocol, such as a TCP error.
* @since JDK1.1
* @see #setSoTimeout(int)
*/
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 SO_SNDBUF option to the specified value for this
* Socket. The SO_SNDBUF option is used by the platform's
* networking code as a hint for the size to set
* the underlying network I/O buffers.
*
*
Because SO_SNDBUF is a hint, applications that want to * verify what size the buffers were set to should call * {@link #getSendBufferSize()}. * * @exception SocketException if there is an error * in the underlying protocol, such as a TCP error. * * @param size the size to which to set the send buffer * size. This value must be greater than 0. * * @exception IllegalArgumentException if the * value is 0 or is negative. * * @see #getSendBufferSize() * @since 1.2 */ 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 SO_SNDBUF option for this Socket, * that is the buffer size used by the platform * for output on this Socket. * @return the value of the SO_SNDBUF option for this 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 SO_RCVBUF option to the specified value for this * Socket. The SO_RCVBUF option is used by the platform's * networking code as a hint for the size to set * the underlying network I/O buffers. * *
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. * *
Because SO_RCVBUF is a hint, applications that want to * verify what size the buffers were set to should call * {@link #getReceiveBufferSize()}. * *
The value of SO_RCVBUF is also used to set the TCP receive window * that is advertized to the remote peer. Generally, the window size * can be modified at any time when a socket is connected. However, if * a receive window larger than 64K is required then this must be requested * before the socket is connected to the remote peer. There are two * cases to be aware of:
*
boolean
indicating whether or not SO_KEEPALIVE is enabled.
* @exception SocketException if there is an error
* in the underlying protocol, such as a TCP error.
* @since 1.3
* @see #setKeepAlive(boolean)
*/
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.
*
* The tc must be in the range 0 <= tc <=
* 255
or an IllegalArgumentException will be thrown.
*
Notes: *
for Internet Protocol v4 the value consists of an octet * with precedence and TOS fields as detailed in RFC 1349. The * TOS field is bitset created by bitwise-or'ing values such * the following :- *
*
IPTOS_LOWCOST (0x02)
IPTOS_RELIABILITY (0x04)
IPTOS_THROUGHPUT (0x08)
IPTOS_LOWDELAY (0x10)
* Setting bits in the precedence field may result in a * SocketException indicating that the operation is not * permitted. *
* for Internet Protocol v6 tc
is the value that
* would be placed into the sin6_flowinfo field of the IP header.
*
* @param tc an 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
*/
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");
getImpl().setOption(SocketOptions.IP_TOS, new Integer(tc));
}
/**
* Gets traffic class or type-of-service in the IP header
* for packets sent from this Socket
*
* 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) */ public int getTrafficClass() throws SocketException { return ((Integer) (getImpl().getOption(SocketOptions.IP_TOS))).intValue(); } /** * Enable/disable the SO_REUSEADDR socket option. *
* 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 TIME_WAIT state * or 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 * SocketAddress if there is a connection in the * timeout state involving the socket address or port. *
* Enabling 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. *
* When a Socket is created the initial setting * of SO_REUSEADDR is disabled. *
* The behaviour when 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 SO_RESUEADDR 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 SO_REUSEADDR is enabled.
*
* @return a boolean
indicating whether or not SO_REUSEADDR is enabled.
* @exception SocketException if there is an error
* in the underlying protocol, such as a TCP error.
* @since 1.4
* @see #setReuseAddress(boolean)
*/
public boolean getReuseAddress() throws SocketException {
if (isClosed())
throw new SocketException("Socket is closed");
return ((Boolean) (getImpl().getOption(SocketOptions.SO_REUSEADDR))).booleanValue();
}
/**
* Closes this socket.
*
* Any thread currently blocked in an I/O operation upon this socket * will throw a {@link SocketException}. *
* 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. * *
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. *
* If you read from a socket input stream after invoking
* shutdownInput() on the socket, the stream will return EOF.
*
* @exception IOException if an I/O error occurs when shutting down this
* socket.
*
* @since 1.3
* @see java.net.Socket#shutdownOutput()
* @see java.net.Socket#close()
* @see java.net.Socket#setSoLinger(boolean, int)
* @see #isInputShutdown
*/
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 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.
*
* @return true if the socket 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.
*
* @return true if the socket 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.
*
* When an application creates a new client socket, the socket
* implementation factory's createSocketImpl
method is
* called to create the actual socket implementation.
*
* Passing null
to the method is a no-op unless the factory
* was already set.
*
If there is a security manager, this method first calls
* the security manager's 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
* 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.
*
*
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. * *
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 * (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 (0, 1, 2). * *
Invoking this method after this socket has been connected * will have no effect. * * @param connectionTime * An int expressing the relative importance of a short * connection time * * @param latency * An int expressing the relative importance of low * latency * * @param bandwidth * An int expressing the relative importance of high * bandwidth * * @since 1.5 */ public void setPerformancePreferences(int connectionTime, int latency, int bandwidth) { /* Not implemented yet */ } }