/*
* Copyright (c) 1995, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net;
import jdk.internal.misc.JavaNetSocketAccess;
import jdk.internal.misc.SharedSecrets;
import sun.security.util.SecurityConstants;
import java.io.FileDescriptor;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.nio.channels.ServerSocketChannel;
import java.security.AccessController;
import java.security.PrivilegedExceptionAction;
import java.util.Set;
import java.util.Collections;
This class implements server sockets. A server socket waits for
requests to come in over the network. It performs some operation
based on that request, and then possibly returns a result to the requester.
The actual work of the server socket is performed by an instance of the SocketImpl
class. An application can change the socket factory that creates the socket implementation to configure itself to create sockets appropriate to the local firewall.
Author: unascribed See Also: Since: 1.0
/**
* This class implements server sockets. A server socket waits for
* requests to come in over the network. It performs some operation
* based on that request, and then possibly returns a result to the requester.
* <p>
* The actual work of the server socket is performed by an instance
* of the {@code SocketImpl} class. An application can
* change the socket factory that creates the socket
* implementation to configure itself to create sockets
* appropriate to the local firewall.
*
* @author unascribed
* @see java.net.SocketImpl
* @see java.net.ServerSocket#setSocketFactory(java.net.SocketImplFactory)
* @see java.nio.channels.ServerSocketChannel
* @since 1.0
*/
public
class ServerSocket implements java.io.Closeable {
Various states of this socket.
/**
* Various states of this socket.
*/
private boolean created = false;
private boolean bound = false;
private boolean closed = false;
private Object closeLock = new Object();
The implementation of this Socket.
/**
* The implementation of this Socket.
*/
private SocketImpl impl;
Are we using an older SocketImpl?
/**
* Are we using an older SocketImpl?
*/
private boolean oldImpl = false;
Package-private constructor to create a ServerSocket associated with
the given SocketImpl.
Throws: - SecurityException – if a security manager is set and its
checkPermission
method doesn't allow NetPermission("setSocketImpl")
.
/**
* Package-private constructor to create a ServerSocket associated with
* the given SocketImpl.
*
* @throws SecurityException if a security manager is set and
* its {@code checkPermission} method doesn't allow
* {@code NetPermission("setSocketImpl")}.
*/
ServerSocket(SocketImpl impl) {
checkPermission();
this.impl = impl;
impl.setServerSocket(this);
}
private static Void checkPermission() {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(SecurityConstants.SET_SOCKETIMPL_PERMISSION);
}
return null;
}
Creates an unbound server socket.
Throws: - IOException – IO error when opening the socket.
@revised 1.4
/**
* Creates an unbound server socket.
*
* @exception IOException IO error when opening the socket.
* @revised 1.4
*/
public ServerSocket() throws IOException {
setImpl();
}
Creates a server socket, bound to the specified port. A port number of 0
means that the port number is automatically allocated, typically from an ephemeral port range. This port number can then be retrieved by calling getLocalPort
. The maximum queue length for incoming connection indications (a request to connect) is set to 50
. If a connection indication arrives when the queue is full, the connection is refused.
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 checkListen
method is called with the port
argument as its argument to ensure the operation is allowed. This could result in a SecurityException.
Params: - port – the port number, or
0
to use a port number that is automatically allocated.
Throws: - IOException – if an I/O error occurs when opening the socket.
- SecurityException – if a security manager exists and its
checkListen
method doesn't allow the operation. - IllegalArgumentException – if the port parameter is outside
the specified range of valid port values, which is between
0 and 65535, inclusive.
See Also:
/**
* Creates a server socket, bound to the specified port. A port number
* of {@code 0} means that the port number is automatically
* allocated, typically from an ephemeral port range. This port
* number can then be retrieved by calling {@link #getLocalPort getLocalPort}.
* <p>
* The maximum queue length for incoming connection indications (a
* request to connect) is set to {@code 50}. If a connection
* indication arrives when the queue is full, the connection is refused.
* <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 checkListen} method is called
* with the {@code port} argument
* as its argument to ensure the operation is allowed.
* This could result in a SecurityException.
*
*
* @param port the port number, or {@code 0} to use a port
* number that is automatically allocated.
*
* @exception IOException if an I/O error occurs when opening the socket.
* @exception SecurityException
* if a security manager exists and its {@code checkListen}
* 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.SocketImpl
* @see java.net.SocketImplFactory#createSocketImpl()
* @see java.net.ServerSocket#setSocketFactory(java.net.SocketImplFactory)
* @see SecurityManager#checkListen
*/
public ServerSocket(int port) throws IOException {
this(port, 50, null);
}
Creates a server socket and binds it to the specified local port number, with the specified backlog. A port number of 0
means that the port number is automatically allocated, typically from an ephemeral port range. This port number can then be retrieved by calling getLocalPort
. The maximum queue length for incoming connection indications (a request to connect) is set to the backlog
parameter. If a connection indication arrives when the queue is full, the connection is refused.
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 checkListen
method is called with the port
argument as its argument to ensure the operation is allowed. This could result in a SecurityException. The backlog
argument is the requested maximum number of pending connections on the socket. Its exact semantics are implementation specific. In particular, an implementation may impose a maximum length or may choose to ignore the parameter altogther. The value provided should be greater than 0
. If it is less than or equal to 0
, then an implementation specific default will be used.
Params: - port – the port number, or
0
to use a port number that is automatically allocated. - backlog – requested maximum length of the queue of incoming
connections.
Throws: - IOException – if an I/O error occurs when opening the socket.
- SecurityException – if a security manager exists and its
checkListen
method doesn't allow the operation. - IllegalArgumentException – if the port parameter is outside
the specified range of valid port values, which is between
0 and 65535, inclusive.
See Also:
/**
* Creates a server socket and binds it to the specified local port
* number, with the specified backlog.
* A port number of {@code 0} means that the port number is
* automatically allocated, typically from an ephemeral port range.
* This port number can then be retrieved by calling
* {@link #getLocalPort getLocalPort}.
* <p>
* The maximum queue length for incoming connection indications (a
* request to connect) is set to the {@code backlog} parameter. If
* a connection indication arrives when the queue is full, the
* connection is refused.
* <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 checkListen} method is called
* with the {@code port} argument
* as its argument to ensure the operation is allowed.
* This could result in a SecurityException.
*
* The {@code backlog} argument is the requested maximum number of
* pending connections on the socket. Its exact semantics are implementation
* specific. In particular, an implementation may impose a maximum length
* or may choose to ignore the parameter altogther. The value provided
* should be greater than {@code 0}. If it is less than or equal to
* {@code 0}, then an implementation specific default will be used.
*
* @param port the port number, or {@code 0} to use a port
* number that is automatically allocated.
* @param backlog requested maximum length of the queue of incoming
* connections.
*
* @exception IOException if an I/O error occurs when opening the socket.
* @exception SecurityException
* if a security manager exists and its {@code checkListen}
* 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.SocketImpl
* @see java.net.SocketImplFactory#createSocketImpl()
* @see java.net.ServerSocket#setSocketFactory(java.net.SocketImplFactory)
* @see SecurityManager#checkListen
*/
public ServerSocket(int port, int backlog) throws IOException {
this(port, backlog, null);
}
Create a server with the specified port, listen backlog, and
local IP address to bind to. The bindAddr argument
can be used on a multi-homed host for a ServerSocket that
will only accept connect requests to one of its addresses.
If bindAddr is null, it will default accepting connections on any/all local addresses. The port must be between 0 and 65535, inclusive. A port number of 0
means that the port number is automatically allocated, typically from an ephemeral port range. This port number can then be retrieved by calling getLocalPort
. If there is a security manager, this method calls its checkListen
method with the port
argument as its argument to ensure the operation is allowed. This could result in a SecurityException. The backlog
argument is the requested maximum number of pending connections on the socket. Its exact semantics are implementation specific. In particular, an implementation may impose a maximum length or may choose to ignore the parameter altogther. The value provided should be greater than 0
. If it is less than or equal to 0
, then an implementation specific default will be used.
Params: - port – the port number, or
0
to use a port number that is automatically allocated. - backlog – requested maximum length of the queue of incoming
connections.
- bindAddr – the local InetAddress the server will bind to
Throws: - SecurityException – if a security manager exists and its
checkListen
method doesn't allow the operation. - IOException – if an I/O error occurs when opening the socket.
- IllegalArgumentException – if the port parameter is outside
the specified range of valid port values, which is between
0 and 65535, inclusive.
See Also: Since: 1.1
/**
* Create a server with the specified port, listen backlog, and
* local IP address to bind to. The <i>bindAddr</i> argument
* can be used on a multi-homed host for a ServerSocket that
* will only accept connect requests to one of its addresses.
* If <i>bindAddr</i> is null, it will default accepting
* connections on any/all local addresses.
* The port must be between 0 and 65535, inclusive.
* A port number of {@code 0} means that the port number is
* automatically allocated, typically from an ephemeral port range.
* This port number can then be retrieved by calling
* {@link #getLocalPort getLocalPort}.
*
* <P>If there is a security manager, this method
* calls its {@code checkListen} method
* with the {@code port} argument
* as its argument to ensure the operation is allowed.
* This could result in a SecurityException.
*
* The {@code backlog} argument is the requested maximum number of
* pending connections on the socket. Its exact semantics are implementation
* specific. In particular, an implementation may impose a maximum length
* or may choose to ignore the parameter altogther. The value provided
* should be greater than {@code 0}. If it is less than or equal to
* {@code 0}, then an implementation specific default will be used.
*
* @param port the port number, or {@code 0} to use a port
* number that is automatically allocated.
* @param backlog requested maximum length of the queue of incoming
* connections.
* @param bindAddr the local InetAddress the server will bind to
*
* @throws SecurityException if a security manager exists and
* its {@code checkListen} method doesn't allow the operation.
*
* @throws IOException if an I/O error occurs when opening the socket.
* @exception IllegalArgumentException if the port parameter is outside
* the specified range of valid port values, which is between
* 0 and 65535, inclusive.
*
* @see SocketOptions
* @see SocketImpl
* @see SecurityManager#checkListen
* @since 1.1
*/
public ServerSocket(int port, int backlog, InetAddress bindAddr) throws IOException {
setImpl();
if (port < 0 || port > 0xFFFF)
throw new IllegalArgumentException(
"Port value out of range: " + port);
if (backlog < 1)
backlog = 50;
try {
bind(new InetSocketAddress(bindAddr, port), backlog);
} catch(SecurityException e) {
close();
throw e;
} catch(IOException e) {
close();
throw e;
}
}
Get the SocketImpl
attached to this socket, creating it if necessary. Throws: - SocketException – if creation fails.
Returns: the SocketImpl
attached to that ServerSocket. Since: 1.4
/**
* 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();
return impl;
}
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
try {
AccessController.doPrivileged(
new PrivilegedExceptionAction<Void>() {
public Void run() throws NoSuchMethodException {
impl.getClass().getDeclaredMethod("connect",
SocketAddress.class,
int.class);
return null;
}
});
} catch (java.security.PrivilegedActionException e) {
oldImpl = true;
}
}
private 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.setServerSocket(this);
}
Creates the socket implementation.
Throws: - IOException – if creation fails
Since: 1.4
/**
* Creates the socket implementation.
*
* @throws IOException if creation fails
* @since 1.4
*/
void createImpl() throws SocketException {
if (impl == null)
setImpl();
try {
impl.create(true);
created = true;
} catch (IOException e) {
throw new SocketException(e.getMessage());
}
}
Binds the ServerSocket
to a specific address (IP address and port number). If the address is null
, then the system will pick up an ephemeral port and a valid local address to bind the socket.
Params: - endpoint – The IP address and port number to bind to.
Throws: - IOException – if the bind operation fails, or if the socket
is already bound.
- SecurityException – if a
SecurityManager
is present and its checkListen
method doesn't allow the operation. - IllegalArgumentException – if endpoint is a
SocketAddress subclass not supported by this socket
Since: 1.4
/**
*
* Binds the {@code ServerSocket} to a specific address
* (IP address and port number).
* <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 endpoint The IP address and port number to bind to.
* @throws IOException if the bind operation fails, or if the socket
* is already bound.
* @throws SecurityException if a {@code SecurityManager} is present and
* its {@code checkListen} method doesn't allow the operation.
* @throws IllegalArgumentException if endpoint is a
* SocketAddress subclass not supported by this socket
* @since 1.4
*/
public void bind(SocketAddress endpoint) throws IOException {
bind(endpoint, 50);
}
Binds the ServerSocket
to a specific address (IP address and port number). If the address is null
, then the system will pick up an ephemeral port and a valid local address to bind the socket.
The backlog
argument is the requested maximum number of pending connections on the socket. Its exact semantics are implementation specific. In particular, an implementation may impose a maximum length or may choose to ignore the parameter altogther. The value provided should be greater than 0
. If it is less than or equal to 0
, then an implementation specific default will be used.
Params: - endpoint – The IP address and port number to bind to.
- backlog – requested maximum length of the queue of
incoming connections.
Throws: - IOException – if the bind operation fails, or if the socket
is already bound.
- SecurityException – if a
SecurityManager
is present and its checkListen
method doesn't allow the operation. - IllegalArgumentException – if endpoint is a
SocketAddress subclass not supported by this socket
Since: 1.4
/**
*
* Binds the {@code ServerSocket} to a specific address
* (IP address and port number).
* <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.
* <P>
* The {@code backlog} argument is the requested maximum number of
* pending connections on the socket. Its exact semantics are implementation
* specific. In particular, an implementation may impose a maximum length
* or may choose to ignore the parameter altogther. The value provided
* should be greater than {@code 0}. If it is less than or equal to
* {@code 0}, then an implementation specific default will be used.
* @param endpoint The IP address and port number to bind to.
* @param backlog requested maximum length of the queue of
* incoming connections.
* @throws IOException if the bind operation fails, or if the socket
* is already bound.
* @throws SecurityException if a {@code SecurityManager} is present and
* its {@code checkListen} method doesn't allow the operation.
* @throws IllegalArgumentException if endpoint is a
* SocketAddress subclass not supported by this socket
* @since 1.4
*/
public void bind(SocketAddress endpoint, int backlog) throws IOException {
if (isClosed())
throw new SocketException("Socket is closed");
if (!oldImpl && isBound())
throw new SocketException("Already bound");
if (endpoint == null)
endpoint = new InetSocketAddress(0);
if (!(endpoint instanceof InetSocketAddress))
throw new IllegalArgumentException("Unsupported address type");
InetSocketAddress epoint = (InetSocketAddress) endpoint;
if (epoint.isUnresolved())
throw new SocketException("Unresolved address");
if (backlog < 1)
backlog = 50;
try {
SecurityManager security = System.getSecurityManager();
if (security != null)
security.checkListen(epoint.getPort());
getImpl().bind(epoint.getAddress(), epoint.getPort());
getImpl().listen(backlog);
bound = true;
} catch(SecurityException e) {
bound = false;
throw e;
} catch(IOException e) {
bound = false;
throw e;
}
}
Returns the local address of this server socket.
If the socket was bound prior to being closed
, then this method will continue to return the local address after the socket is closed.
If there is a security manager set, its checkConnect
method is called with the local address and -1
as its arguments to see if the operation is allowed. If the operation is not allowed, the loopback
address is returned.
See Also: Returns: the address to which this socket is bound, or the loopback address if denied by the security manager, or null
if the socket is unbound.
/**
* Returns the local address of this server socket.
* <p>
* If the socket was bound prior to being {@link #close closed},
* then this method will continue to return the local address
* after the socket is closed.
* <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 address to which this socket is bound,
* or the loopback address if denied by the security manager,
* or {@code null} if the socket is unbound.
*
* @see SecurityManager#checkConnect
*/
public InetAddress getInetAddress() {
if (!isBound())
return null;
try {
InetAddress in = getImpl().getInetAddress();
SecurityManager sm = System.getSecurityManager();
if (sm != null)
sm.checkConnect(in.getHostAddress(), -1);
return in;
} catch (SecurityException e) {
return InetAddress.getLoopbackAddress();
} catch (SocketException e) {
// nothing
// If we're bound, the impl has been created
// so we shouldn't get here
}
return null;
}
Returns the port number on which this socket is listening.
If the socket was bound prior to being closed
, then this method will continue to return the port number after the socket is closed.
Returns: the port number to which this socket is listening or
-1 if the socket is not bound yet.
/**
* Returns the port number on which this socket is listening.
* <p>
* If the socket was bound prior to being {@link #close closed},
* then this method will continue to return the port number
* after the socket is closed.
*
* @return the port number to which this socket is listening or
* -1 if the socket is not bound yet.
*/
public int getLocalPort() {
if (!isBound())
return -1;
try {
return getImpl().getLocalPort();
} catch (SocketException e) {
// nothing
// If we're bound, the impl has been created
// so we shouldn't get here
}
return -1;
}
Returns the address of the endpoint this socket is bound to.
If the socket was bound prior to being closed
, then this method will continue to return the address of the endpoint after the socket is closed.
If there is a security manager set, its checkConnect
method is called with the local address and -1
as its arguments to see if the operation is allowed. If the operation is not allowed, a SocketAddress
representing the loopback
address and the local port to which the socket is bound is returned.
See Also: Returns: a SocketAddress
representing the local endpoint of this socket, or a SocketAddress
representing the loopback address if denied by the security manager, or null
if the socket is not bound yet. Since: 1.4
/**
* Returns the address of the endpoint this socket is bound to.
* <p>
* If the socket was bound prior to being {@link #close closed},
* then this method will continue to return the address of the endpoint
* after the socket is closed.
* <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 the 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 #getInetAddress()
* @see #getLocalPort()
* @see #bind(SocketAddress)
* @see SecurityManager#checkConnect
* @since 1.4
*/
public SocketAddress getLocalSocketAddress() {
if (!isBound())
return null;
return new InetSocketAddress(getInetAddress(), getLocalPort());
}
Listens for a connection to be made to this socket and accepts
it. The method blocks until a connection is made.
A new Socket s
is created and, if there is a security manager, the security manager's checkAccept
method is called with s.getInetAddress().getHostAddress()
and s.getPort()
as its arguments to ensure the operation is allowed. This could result in a SecurityException.
Throws: - IOException – if an I/O error occurs when waiting for a
connection.
- SecurityException – if a security manager exists and its
checkAccept
method doesn't allow the operation. - SocketTimeoutException – if a timeout was previously set with setSoTimeout and
the timeout has been reached.
- IllegalBlockingModeException –
if this socket has an associated channel, the channel is in
non-blocking mode, and there is no connection ready to be
accepted
See Also: Returns: the new Socket @revised 1.4 @spec JSR-51
/**
* Listens for a connection to be made to this socket and accepts
* it. The method blocks until a connection is made.
*
* <p>A new Socket {@code s} is created and, if there
* is a security manager,
* the security manager's {@code checkAccept} method is called
* with {@code s.getInetAddress().getHostAddress()} and
* {@code s.getPort()}
* as its arguments to ensure the operation is allowed.
* This could result in a SecurityException.
*
* @exception IOException if an I/O error occurs when waiting for a
* connection.
* @exception SecurityException if a security manager exists and its
* {@code checkAccept} method doesn't allow the operation.
* @exception SocketTimeoutException if a timeout was previously set with setSoTimeout and
* the timeout has been reached.
* @exception java.nio.channels.IllegalBlockingModeException
* if this socket has an associated channel, the channel is in
* non-blocking mode, and there is no connection ready to be
* accepted
*
* @return the new Socket
* @see SecurityManager#checkAccept
* @revised 1.4
* @spec JSR-51
*/
public Socket accept() throws IOException {
if (isClosed())
throw new SocketException("Socket is closed");
if (!isBound())
throw new SocketException("Socket is not bound yet");
Socket s = new Socket((SocketImpl) null);
implAccept(s);
return s;
}
Subclasses of ServerSocket use this method to override accept()
to return their own subclass of socket. So a FooServerSocket
will typically hand this method an empty FooSocket. On
return from implAccept the FooSocket will be connected to a client.
Params: - s – the Socket
Throws: - IllegalBlockingModeException –
if this socket has an associated channel,
and the channel is in non-blocking mode
- IOException – if an I/O error occurs when waiting
for a connection.
Since: 1.1 @revised 1.4 @spec JSR-51
/**
* Subclasses of ServerSocket use this method to override accept()
* to return their own subclass of socket. So a FooServerSocket
* will typically hand this method an <i>empty</i> FooSocket. On
* return from implAccept the FooSocket will be connected to a client.
*
* @param s the Socket
* @throws java.nio.channels.IllegalBlockingModeException
* if this socket has an associated channel,
* and the channel is in non-blocking mode
* @throws IOException if an I/O error occurs when waiting
* for a connection.
* @since 1.1
* @revised 1.4
* @spec JSR-51
*/
protected final void implAccept(Socket s) throws IOException {
SocketImpl si = null;
try {
if (s.impl == null)
s.setImpl();
else {
s.impl.reset();
}
si = s.impl;
s.impl = null;
si.address = new InetAddress();
si.fd = new FileDescriptor();
getImpl().accept(si);
SocketCleanable.register(si.fd); // raw fd has been set
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkAccept(si.getInetAddress().getHostAddress(),
si.getPort());
}
} catch (IOException e) {
if (si != null)
si.reset();
s.impl = si;
throw e;
} catch (SecurityException e) {
if (si != null)
si.reset();
s.impl = si;
throw e;
}
s.impl = si;
s.postAccept();
}
Closes this socket. Any thread currently blocked in accept()
will throw a SocketException
. If this socket has an associated channel then the channel is closed
as well.
Throws: - IOException – if an I/O error occurs when closing the socket.
@revised 1.4 @spec JSR-51
/**
* Closes this socket.
*
* Any thread currently blocked in {@link #accept()} will throw
* a {@link SocketException}.
*
* <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 the socket.
* @revised 1.4
* @spec JSR-51
*/
public void close() throws IOException {
synchronized(closeLock) {
if (isClosed())
return;
if (created)
impl.close();
closed = true;
}
}
Returns the unique ServerSocketChannel
object associated with this socket, if any. A server socket will have a channel if, and only if, the channel itself was created via the ServerSocketChannel.open
method.
Returns: the server-socket channel associated with this socket, or null
if this socket was not created for a channel Since: 1.4 @spec JSR-51
/**
* Returns the unique {@link java.nio.channels.ServerSocketChannel} object
* associated with this socket, if any.
*
* <p> A server socket will have a channel if, and only if, the channel
* itself was created via the {@link
* java.nio.channels.ServerSocketChannel#open ServerSocketChannel.open}
* method.
*
* @return the server-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 ServerSocketChannel getChannel() {
return null;
}
Returns the binding state of the ServerSocket.
Returns: true if the ServerSocket successfully bound to an address Since: 1.4
/**
* Returns the binding state of the ServerSocket.
*
* @return true if the ServerSocket successfully bound to an address
* @since 1.4
*/
public boolean isBound() {
// Before 1.3 ServerSockets were always bound during creation
return bound || oldImpl;
}
Returns the closed state of the ServerSocket.
Returns: true if the socket has been closed Since: 1.4
/**
* Returns the closed state of the ServerSocket.
*
* @return true if the socket has been closed
* @since 1.4
*/
public boolean isClosed() {
synchronized(closeLock) {
return closed;
}
}
Enable/disable SO_TIMEOUT
with the specified timeout, in milliseconds. With this option set to a non-zero timeout, a call to accept() for this ServerSocket will block for only this amount of time. If the timeout expires, a java.net.SocketTimeoutException is raised, though the
ServerSocket 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. Params: - timeout – the specified timeout, in milliseconds
Throws: - SocketException – if there is an error in
the underlying protocol, such as a TCP error.
See Also: Since: 1.1
/**
* Enable/disable {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT} with the
* specified timeout, in milliseconds. With this option set to a non-zero
* timeout, a call to accept() for this ServerSocket
* will block for only this amount of time. If the timeout expires,
* a <B>java.net.SocketTimeoutException</B> is raised, though the
* ServerSocket 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 1.1
* @see #getSoTimeout()
*/
public synchronized void setSoTimeout(int timeout) throws SocketException {
if (isClosed())
throw new SocketException("Socket is closed");
getImpl().setOption(SocketOptions.SO_TIMEOUT, timeout);
}
Retrieve setting for SO_TIMEOUT
. 0 returns implies that the option is disabled (i.e., timeout of infinity). Throws: - IOException – if an I/O error occurs
See Also: Returns: the SO_TIMEOUT
value Since: 1.1
/**
* Retrieve setting for {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT}.
* 0 returns implies that the option is disabled (i.e., timeout of infinity).
* @return the {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT} value
* @exception IOException if an I/O error occurs
* @since 1.1
* @see #setSoTimeout(int)
*/
public synchronized int getSoTimeout() throws IOException {
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;
}
}
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 bind(SocketAddress)
allows the socket to be bound even though a previous connection is in a timeout state.
When a ServerSocket
is created the initial setting of SO_REUSEADDR
is not defined. Applications can use getReuseAddress()
to determine the initial setting of SO_REUSEADDR
.
The behaviour when SO_REUSEADDR
is enabled or disabled after a socket is bound (See isBound()
) is not defined.
Params: - on – whether to enable or disable the socket option
Throws: - SocketException – if an error occurs enabling or disabling the
SO_REUSEADDR
socket option, or the socket is closed.
See Also: Since: 1.4
/**
* 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 ServerSocket} is created the initial setting
* of {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is not defined.
* Applications can use {@link #getReuseAddress()} to determine the initial
* setting of {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR}.
* <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 #isBound()
* @see #isClosed()
*/
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. Throws: - SocketException – if there is an error
in the underlying protocol, such as a TCP error.
See Also: Returns: a boolean
indicating whether or not SO_REUSEADDR
is enabled. Since: 1.4
/**
* 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();
}
Returns the implementation address and implementation port of this socket as a String
. If there is a security manager set, its checkConnect
method is called with the local address and -1
as its arguments to see if the operation is allowed. If the operation is not allowed, an InetAddress
representing the loopback
address is returned as the implementation address.
Returns: a string representation of this socket.
/**
* Returns the implementation address and implementation port of
* this socket as a {@code String}.
* <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,
* an {@code InetAddress} representing the
* {@link InetAddress#getLoopbackAddress loopback} address is returned as
* the implementation address.
*
* @return a string representation of this socket.
*/
public String toString() {
if (!isBound())
return "ServerSocket[unbound]";
InetAddress in;
if (System.getSecurityManager() != null)
in = InetAddress.getLoopbackAddress();
else
in = impl.getInetAddress();
return "ServerSocket[addr=" + in +
",localport=" + impl.getLocalPort() + "]";
}
void setBound() {
bound = true;
}
void setCreated() {
created = true;
}
The factory for all server sockets.
/**
* The factory for all server sockets.
*/
private static SocketImplFactory factory = null;
Sets the server socket implementation factory for the
application. The factory can be specified only once.
When an application creates a new server 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.
Params: - fac – the desired factory.
Throws: - IOException – if an I/O error occurs when setting the
socket factory.
- SocketException – if the factory has already been defined.
- SecurityException – if a security manager exists and its
checkSetFactory
method doesn't allow the operation.
See Also:
/**
* Sets the server socket implementation factory for the
* application. The factory can be specified only once.
* <p>
* When an application creates a new server 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 has already been 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 setSocketFactory(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 a default proposed value for the SO_RCVBUF
option for sockets accepted from this ServerSocket
. The value actually set in the accepted socket must be determined by calling Socket.getReceiveBufferSize()
after the socket is returned by accept()
. The value of SO_RCVBUF
is used both to set the size of the internal socket receive buffer, and to set the size of the TCP receive window that is advertized to the remote peer.
It is possible to change the value subsequently, by calling Socket.setReceiveBufferSize(int)
. However, if the application wishes to allow a receive window larger than 64K bytes, as defined by RFC1323 then the proposed value must be set in the ServerSocket before
it is bound to a local address. This implies, that the ServerSocket must be
created with the no-argument constructor, then setReceiveBufferSize() must
be called and lastly the ServerSocket is bound to an address by calling bind().
Failure to do this will not cause an error, and the buffer size may be set to the
requested value but the TCP receive window in sockets accepted from
this ServerSocket will be no larger than 64K bytes.
Params: - size – the size to which to set the receive buffer
size. This value must be greater than 0.
Throws: - SocketException – if there is an error
in the underlying protocol, such as a TCP error.
- IllegalArgumentException – if the
value is 0 or is negative.
See Also: Since: 1.4
/**
* Sets a default proposed value for the
* {@link SocketOptions#SO_RCVBUF SO_RCVBUF} option for sockets
* accepted from this {@code ServerSocket}. The value actually set
* in the accepted socket must be determined by calling
* {@link Socket#getReceiveBufferSize()} after the socket
* is returned by {@link #accept()}.
* <p>
* The value of {@link SocketOptions#SO_RCVBUF SO_RCVBUF} is used both to
* set the size of the internal socket receive buffer, and to set the size
* of the TCP receive window that is advertized to the remote peer.
* <p>
* It is possible to change the value subsequently, by calling
* {@link Socket#setReceiveBufferSize(int)}. However, if the application
* wishes to allow a receive window larger than 64K bytes, as defined by RFC1323
* then the proposed value must be set in the ServerSocket <B>before</B>
* it is bound to a local address. This implies, that the ServerSocket must be
* created with the no-argument constructor, then setReceiveBufferSize() must
* be called and lastly the ServerSocket is bound to an address by calling bind().
* <p>
* Failure to do this will not cause an error, and the buffer size may be set to the
* requested value but the TCP receive window in sockets accepted from
* this ServerSocket will be no larger than 64K bytes.
*
* @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 receive buffer
* size. This value must be greater than 0.
*
* @exception IllegalArgumentException if the
* value is 0 or is negative.
*
* @since 1.4
* @see #getReceiveBufferSize
*/
public synchronized void setReceiveBufferSize (int size) throws SocketException {
if (!(size > 0)) {
throw new IllegalArgumentException("negative receive size");
}
if (isClosed())
throw new SocketException("Socket is closed");
getImpl().setOption(SocketOptions.SO_RCVBUF, size);
}
Gets the value of the SO_RCVBUF
option for this ServerSocket
, that is the proposed buffer size that will be used for Sockets accepted from this ServerSocket
. Note, the value actually set in the accepted socket is determined by calling Socket.getReceiveBufferSize()
.
Throws: - SocketException – if there is an error
in the underlying protocol, such as a TCP error.
See Also: Returns: the value of the SO_RCVBUF
option for this Socket
. Since: 1.4
/**
* Gets the value of the {@link SocketOptions#SO_RCVBUF SO_RCVBUF} option
* for this {@code ServerSocket}, that is the proposed buffer size that
* will be used for Sockets accepted from this {@code ServerSocket}.
*
* <p>Note, the value actually set in the accepted socket is determined by
* calling {@link Socket#getReceiveBufferSize()}.
* @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.4
*/
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;
}
Sets performance preferences for this ServerSocket.
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. 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 bound
will have no effect. This implies that in order to use this capability
requires the socket to be created with the no-argument constructor.
Params: - connectionTime – An
int
expressing the relative importance of a short connection time - latency – An
int
expressing the relative importance of low latency - bandwidth – An
int
expressing the relative importance of high bandwidth
Since: 1.5
/**
* Sets performance preferences for this ServerSocket.
*
* <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. 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 bound
* will have no effect. This implies that in order to use this capability
* requires the socket to be created with the no-argument constructor.
*
* @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 */
}
Sets the value of a socket option.
Params: - name – The socket option
- value – The value of the socket option. A value of
null
may be valid for some options.
Type parameters: - <T> – The type of the socket option value
Throws: - UnsupportedOperationException – if the server socket does not
support the option.
- IllegalArgumentException – if the value is not valid for
the option.
- IOException – if an I/O error occurs, or if the socket is closed.
- NullPointerException – if name is
null
- SecurityException – if a security manager is set and if the socket option requires a security permission and if the caller does not have the required permission.
StandardSocketOptions
do not require any security permission.
Returns: this ServerSocket Since: 9
/**
* Sets the value of a socket option.
*
* @param <T> The type of the socket option value
* @param name The socket option
* @param value The value of the socket option. A value of {@code null}
* may be valid for some options.
* @return this ServerSocket
*
* @throws UnsupportedOperationException if the server socket does not
* support the option.
*
* @throws IllegalArgumentException if the value is not valid for
* the option.
*
* @throws IOException if an I/O error occurs, or if the socket is closed.
*
* @throws NullPointerException if name is {@code null}
*
* @throws SecurityException if a security manager is set and if the socket
* option requires a security permission and if the caller does
* not have the required permission.
* {@link java.net.StandardSocketOptions StandardSocketOptions}
* do not require any security permission.
*
* @since 9
*/
public <T> ServerSocket setOption(SocketOption<T> name, T value)
throws IOException
{
getImpl().setOption(name, value);
return this;
}
Returns the value of a socket option.
Params: - name – The socket option
Type parameters: - <T> – The type of the socket option value
Throws: - UnsupportedOperationException – if the server socket does not
support the option.
- IOException – if an I/O error occurs, or if the socket is closed.
- NullPointerException – if name is
null
- SecurityException – if a security manager is set and if the socket option requires a security permission and if the caller does not have the required permission.
StandardSocketOptions
do not require any security permission.
Returns: The value of the socket option. Since: 9
/**
* Returns the value of a socket option.
*
* @param <T> The type of the socket option value
* @param name The socket option
*
* @return The value of the socket option.
*
* @throws UnsupportedOperationException if the server socket does not
* support the option.
*
* @throws IOException if an I/O error occurs, or if the socket is closed.
*
* @throws NullPointerException if name is {@code null}
*
* @throws SecurityException if a security manager is set and if the socket
* option requires a security permission and if the caller does
* not have the required permission.
* {@link java.net.StandardSocketOptions StandardSocketOptions}
* do not require any security permission.
*
* @since 9
*/
public <T> T getOption(SocketOption<T> name) throws IOException {
return getImpl().getOption(name);
}
private static Set<SocketOption<?>> options;
private static boolean optionsSet = false;
Returns a set of the socket options supported by this server socket.
This method will continue to return the set of options even after
the socket has been closed.
Returns: A set of the socket options supported by this socket. This set
may be empty if the socket's SocketImpl cannot be created. Since: 9
/**
* Returns a set of the socket options supported by this server socket.
*
* This method will continue to return the set of options even after
* the socket has been closed.
*
* @return A set of the socket options supported by this socket. This set
* may be empty if the socket's SocketImpl cannot be created.
*
* @since 9
*/
public Set<SocketOption<?>> supportedOptions() {
synchronized (ServerSocket.class) {
if (optionsSet) {
return options;
}
try {
SocketImpl impl = getImpl();
options = Collections.unmodifiableSet(impl.supportedOptions());
} catch (IOException e) {
options = Collections.emptySet();
}
optionsSet = true;
return options;
}
}
static {
SharedSecrets.setJavaNetSocketAccess(
new JavaNetSocketAccess() {
@Override
public ServerSocket newServerSocket(SocketImpl impl) {
return new ServerSocket(impl);
}
@Override
public SocketImpl newSocketImpl(Class<? extends SocketImpl> implClass) {
try {
Constructor<? extends SocketImpl> ctor =
implClass.getDeclaredConstructor();
return ctor.newInstance();
} catch (NoSuchMethodException | InstantiationException |
IllegalAccessException | InvocationTargetException e) {
throw new AssertionError(e);
}
}
}
);
}
}