Socketpublic class Socket extends Object | 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. |
| Fields Summary |
|---|
| private boolean | createdVarious states of this socket. | | private boolean | bound | | private boolean | connected | | private boolean | closed | | private Object | closeLock | | private boolean | shutIn | | private boolean | shutOut | | SocketImpl | implThe implementation of this Socket. | | private boolean | oldImplAre we using an older SocketImpl? | | private static SocketImplFactory | factoryThe factory for all client sockets. |
| Constructors Summary |
|---|
public Socket()Creates an unconnected socket, with the
system-default type of SocketImpl.
setImpl();
| private Socket(SocketAddress address, SocketAddress localAddr, boolean stream)
setImpl();
// backward compatibility
if (address == null)
throw new NullPointerException();
try {
createImpl(stream);
if (localAddr != null)
bind(localAddr);
if (address != null)
connect(address);
} catch (IOException e) {
close();
throw e;
}
| public Socket(Proxy proxy)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.
if (proxy != null && proxy.type() == Proxy.Type.SOCKS) {
SecurityManager security = System.getSecurityManager();
InetSocketAddress epoint = (InetSocketAddress) proxy.address();
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 = 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");
}
| protected Socket(SocketImpl impl)Creates an unconnected Socket with a user-specified
SocketImpl.
this.impl = impl;
if (impl != null) {
checkOldImpl();
this.impl.setSocket(this);
}
| public Socket(String host, int port)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.
this(host != null ? new InetSocketAddress(host, port) :
new InetSocketAddress(InetAddress.getByName(null), port),
(SocketAddress) null, true);
| public Socket(InetAddress address, int port)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.
this(address != null ? new InetSocketAddress(address, port) : null,
(SocketAddress) null, true);
| public Socket(String host, int port, InetAddress localAddr, int localPort)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.
this(host != null ? new InetSocketAddress(host, port) :
new InetSocketAddress(InetAddress.getByName(null), port),
new InetSocketAddress(localAddr, localPort), true);
| public Socket(InetAddress address, int port, InetAddress localAddr, int localPort)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.
this(address != null ? new InetSocketAddress(address, port) : null,
new InetSocketAddress(localAddr, localPort), true);
| public Socket(String host, int port, boolean stream)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.
this(host != null ? new InetSocketAddress(host, port) :
new InetSocketAddress(InetAddress.getByName(null), port),
(SocketAddress) null, stream);
| public Socket(InetAddress host, int port, boolean 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.
this(host != null ? new InetSocketAddress(host, port) : null,
new InetSocketAddress(0), stream);
|
| Methods Summary |
|---|
| public void | bind(java.net.SocketAddress bindpoint)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.
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;
| | 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[] 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();
// 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;
}
}
}
}
});
| | public synchronized void | close()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.
Closing this socket will also close the socket's
{@link java.io.InputStream InputStream} and
{@link java.io.OutputStream OutputStream}.
If this socket has an associated channel then the channel is closed
as well.
synchronized(closeLock) {
if (isClosed())
return;
if (created)
impl.close();
closed = true;
}
| | public void | connect(java.net.SocketAddress endpoint)Connects this socket to the server.
connect(endpoint, 0);
| | public void | connect(java.net.SocketAddress endpoint, int timeout)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.
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;
| | void | createImpl(boolean stream)Creates the socket implementation.
if (impl == null)
setImpl();
try {
impl.create(stream);
created = true;
} catch (IOException e) {
throw new SocketException(e.getMessage());
}
| | public java.nio.channels.SocketChannel | getChannel()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 null;
| | java.net.SocketImpl | getImpl()Get the SocketImpl attached to this socket, creating
it if necessary.
if (!created)
createImpl(true);
return impl;
| | public java.net.InetAddress | getInetAddress()Returns the address to which the socket is connected.
if (!isConnected())
return null;
try {
return getImpl().getInetAddress();
} catch (SocketException e) {
}
return null;
| | public java.io.InputStream | getInputStream()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.
Closing the returned {@link java.io.InputStream InputStream}
will close the associated socket.
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 = (InputStream)
AccessController.doPrivileged(new PrivilegedExceptionAction() {
public Object run() throws IOException {
return impl.getInputStream();
}
});
} catch (java.security.PrivilegedActionException e) {
throw (IOException) e.getException();
}
return is;
| | public boolean | getKeepAlive()Tests if SO_KEEPALIVE is enabled.
if (isClosed())
throw new SocketException("Socket is closed");
return ((Boolean) getImpl().getOption(SocketOptions.SO_KEEPALIVE)).booleanValue();
| | public java.net.InetAddress | getLocalAddress()Gets the local address to which the socket is bound.
// 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;
| | public int | getLocalPort()Returns the local port to which this socket is bound.
if (!isBound())
return -1;
try {
return getImpl().getLocalPort();
} catch(SocketException e) {
// shouldn't happen as we're bound
}
return -1;
| | public java.net.SocketAddress | getLocalSocketAddress()Returns the address of the endpoint this socket is bound to, or
null if it is not bound yet.
if (!isBound())
return null;
return new InetSocketAddress(getLocalAddress(), getLocalPort());
| | public boolean | getOOBInline()Tests if OOBINLINE is enabled.
if (isClosed())
throw new SocketException("Socket is closed");
return ((Boolean) getImpl().getOption(SocketOptions.SO_OOBINLINE)).booleanValue();
| | public java.io.OutputStream | getOutputStream()Returns an output stream for this socket.
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}.
Closing the returned {@link java.io.OutputStream OutputStream}
will close the associated socket.
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;
| | public int | getPort()Returns the remote port to which this socket is connected.
if (!isConnected())
return 0;
try {
return getImpl().getPort();
} catch (SocketException e) {
// Shouldn't happen as we're connected
}
return -1;
| | public synchronized int | getReceiveBufferSize()Gets the value of the SO_RCVBUF option for this Socket,
that is the buffer size used by the platform for
input on this Socket.
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;
| | public java.net.SocketAddress | getRemoteSocketAddress()Returns the address of the endpoint this socket is connected to, or
null if it is unconnected.
if (!isConnected())
return null;
return new InetSocketAddress(getInetAddress(), getPort());
| | public boolean | getReuseAddress()Tests if SO_REUSEADDR is enabled.
if (isClosed())
throw new SocketException("Socket is closed");
return ((Boolean) (getImpl().getOption(SocketOptions.SO_REUSEADDR))).booleanValue();
| | public synchronized int | getSendBufferSize()Get value of the SO_SNDBUF option for this Socket,
that is the buffer size used by the platform
for output on this Socket.
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;
| | public int | getSoLinger()Returns setting for SO_LINGER. -1 returns implies that the
option is disabled.
The setting only affects socket close.
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;
}
| | public synchronized int | getSoTimeout()Returns setting for SO_TIMEOUT. 0 returns implies that the
option is disabled (i.e., timeout of infinity).
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;
}
| | public boolean | getTcpNoDelay()Tests if TCP_NODELAY is enabled.
if (isClosed())
throw new SocketException("Socket is closed");
return ((Boolean) getImpl().getOption(SocketOptions.TCP_NODELAY)).booleanValue();
| | public int | getTrafficClass()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 ((Integer) (getImpl().getOption(SocketOptions.IP_TOS))).intValue();
| | public boolean | isBound()Returns the binding state of the socket.
// Before 1.3 Sockets were always bound during creation
return bound || oldImpl;
| | public boolean | isClosed()Returns the closed state of the socket.
synchronized(closeLock) {
return closed;
}
| | public boolean | isConnected()Returns the connection state of the socket.
// Before 1.3 Sockets were always connected during creation
return connected || oldImpl;
| | public boolean | isInputShutdown()Returns whether the read-half of the socket connection is closed.
return shutIn;
| | public boolean | isOutputShutdown()Returns whether the write-half of the socket connection is closed.
return shutOut;
| | final void | postAccept()set the flags after an accept() call.
connected = true;
created = true;
bound = true;
| | public void | sendUrgentData(int data)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.
if (!getImpl().supportsUrgentData ()) {
throw new SocketException ("Urgent data not supported");
}
getImpl().sendUrgentData (data);
| | void | setBound()
bound = true;
| | void | setConnected()
connected = true;
| | void | setCreated()
created = true;
| | void | setImpl()Sets impl to the system-default type of SocketImpl.
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);
| | public void | setKeepAlive(boolean on)Enable/disable SO_KEEPALIVE.
if (isClosed())
throw new SocketException("Socket is closed");
getImpl().setOption(SocketOptions.SO_KEEPALIVE, Boolean.valueOf(on));
| | public void | setOOBInline(boolean on)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.
if (isClosed())
throw new SocketException("Socket is closed");
getImpl().setOption(SocketOptions.SO_OOBINLINE, Boolean.valueOf(on));
| | public void | setPerformancePreferences(int connectionTime, int latency, int bandwidth)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.
/* Not implemented yet */
| | public synchronized void | setReceiveBufferSize(int size)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:
- 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.
- For client sockets, setReceiveBufferSize() must be called before
connecting the socket to its remote peer.
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));
| | public void | setReuseAddress(boolean on)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.
if (isClosed())
throw new SocketException("Socket is closed");
getImpl().setOption(SocketOptions.SO_REUSEADDR, Boolean.valueOf(on));
| | public synchronized void | setSendBufferSize(int size)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()}.
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));
| | public void | setSoLinger(boolean on, int linger)Enable/disable SO_LINGER with the specified linger time in seconds.
The maximum timeout value is platform specific.
The setting only affects socket close.
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));
}
| | public synchronized void | setSoTimeout(int timeout)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.
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));
| | public static synchronized void | setSocketImplFactory(java.net.SocketImplFactory fac)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.
if (factory != null) {
throw new SocketException("factory already defined");
}
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkSetFactory();
}
factory = fac;
| | public void | setTcpNoDelay(boolean on)Enable/disable TCP_NODELAY (disable/enable Nagle's algorithm).
if (isClosed())
throw new SocketException("Socket is closed");
getImpl().setOption(SocketOptions.TCP_NODELAY, Boolean.valueOf(on));
| | public void | setTrafficClass(int tc)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)
The last low order bit is always ignored as this
corresponds to the MBZ (must be zero) bit.
Setting bits in the precedence field may result in a
SocketException indicating that the operation is not
permitted.
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.
For Internet Protocol v6 tc is the value that
would be placed into the sin6_flowinfo field of the IP header.
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));
| | public void | shutdownInput()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.
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;
| | public void | shutdownOutput()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.
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;
| | public java.lang.String | toString()Converts this socket to a String.
try {
if (isConnected())
return "Socket[addr=" + getImpl().getInetAddress() +
",port=" + getImpl().getPort() +
",localport=" + getImpl().getLocalPort() + "]";
} catch (SocketException e) {
}
return "Socket[unconnected]";
|
|
