An {@code SCTPServerChannel} is created by invoking the * {@link #open open} method of this class. A newly-created SCTP server * channel is open but not yet bound. An attempt to invoke the * {@link #accept accept} method of an unbound channel will cause the * {@link java.nio.channels.NotYetBoundException} to be thrown. An SCTP server * channel can be bound by invoking one of the * {@link #bind(java.net.SocketAddress,int) bind} methods defined by this class. * *
Socket options are configured using the * {@link #setOption(SctpSocketOption,Object) setOption} method. SCTP server socket * channels support the following options: *
** Additional (implementation specific) options may also be supported. The list * of options supported is obtained by invoking the {@link #supportedOptions() * supportedOptions} method. * **
** *Option Name *Description ** *{@link SctpStandardSocketOptions#SCTP_INIT_MAXSTREAMS * SCTP_INIT_MAXSTREAMS} *The maximum number of streams requested by the local endpoint during * association initialization *
SCTP server channels are safe for use by multiple concurrent threads. * * @since 1.7 */ public abstract class SctpServerChannel extends AbstractSelectableChannel { /** * Initializes a new instance of this class. * * @param provider * The selector provider for this channel */ protected SctpServerChannel(SelectorProvider provider) { super(provider); } /** * Opens an SCTP server channel. * *
The new channel's socket is initially unbound; it must be bound * to a specific address via one of its socket's {@link #bind bind} * methods before associations can be accepted. * * @return A new SCTP server channel * * @throws UnsupportedOperationException * If the SCTP protocol is not supported * * @throws IOException * If an I/O error occurs */ public static SctpServerChannel open() throws IOException { return new sun.nio.ch.SctpServerChannelImpl((SelectorProvider)null); } /** * Accepts an association on this channel's socket. * *
If this channel is in non-blocking mode then this method will * immediately return {@code null} if there are no pending associations. * Otherwise it will block indefinitely until a new association is * available or an I/O error occurs. * *
The {@code SCTPChannel} returned by this method, if any, will be in * blocking mode regardless of the blocking mode of this channel. * *
If a security manager has been installed then for each new * association this method verifies that the address and port number of the * assocaitions's remote peer are permitted by the security manager's {@link * java.lang.SecurityManager#checkAccept(String,int) checkAccept} method. * * @return The SCTP channel for the new association, or {@code null} * if this channel is in non-blocking mode and no association is * available to be accepted * * @throws java.nio.channels.ClosedChannelException * If this channel is closed * * @throws java.nio.channels.AsynchronousCloseException * If another thread closes this channel * while the accept operation is in progress * * @throws java.nio.channels.ClosedByInterruptException * If another thread interrupts the current thread * while the accept operation is in progress, thereby * closing the channel and setting the current thread's * interrupt status * * @throws java.nio.channels.NotYetBoundException * If this channel's socket has not yet been bound * * @throws SecurityException * If a security manager has been installed and it does not permit * access to the remote peer of the new association * * @throws IOException * If some other I/O error occurs */ public abstract SctpChannel accept() throws IOException; /** * Binds the channel's socket to a local address and configures the socket * to listen for associations. * *
This method works as if invoking it were equivalent to evaluating the * expression: *
* bind(local, 0);
* This method is used to establish a relationship between the socket * and the local address. Once a relationship is established then * the socket remains bound until the channel is closed. This relationship * may not necesssarily be with the address {@code local} as it may be * removed by {@link #unbindAddress unbindAddress}, but there will always be * at least one local address bound to the channel's socket once an * invocation of this method successfully completes. * *
Once the channel's socket has been successfully bound to a specific * address, that is not automatically assigned, more addresses * may be bound to it using {@link #bindAddress bindAddress}, or removed * using {@link #unbindAddress unbindAddress}. * *
The backlog parameter is the maximum number of pending associations * on the socket. Its exact semantics are implementation specific. An * implementation may impose an implementation specific maximum length or * may choose to ignore the parameter. If the backlog parameter has the * value {@code 0}, or a negative value, then an implementation specific * default is used. * * @param local * The local address to bind the socket, or {@code null} to * bind the socket to an automatically assigned socket address * * @param backlog * The maximum number number of pending associations * * @return This channel * * @throws java.nio.channels.ClosedChannelException * If this channel is closed * * @throws java.nio.channels.AlreadyBoundException * If this channel is already bound * * @throws java.nio.channels.UnsupportedAddressTypeException * If the type of the given address is not supported * * @throws SecurityException * If a security manager has been installed and its {@link * java.lang.SecurityManager#checkListen(int) checkListen} method * denies the operation * * @throws IOException * If some other I/O error occurs */ public abstract SctpServerChannel bind(SocketAddress local, int backlog) throws IOException; /** * Adds the given address to the bound addresses for the channel's * socket. * *
The given address must not be the {@link * java.net.InetAddress#isAnyLocalAddress wildcard} address. * The channel must be first bound using {@link #bind bind} before * invoking this method, otherwise {@link * java.nio.channels.NotYetBoundException} is thrown. The {@link #bind bind} * method takes a {@code SocketAddress} as its argument which typically * contains a port number as well as an address. Addresses subquently bound * using this method are simply addresses as the SCTP port number remains * the same for the lifetime of the channel. * *
New associations accepted after this method successfully completes * will be associated with the given address. * * @param address * The address to add to the bound addresses for the socket * * @return This channel * * @throws java.nio.channels.ClosedChannelException * If this channel is closed * * @throws java.nio.channels.NotYetBoundException * If this channel is not yet bound * * @throws java.nio.channels.AlreadyBoundException * If this channel is already bound to the given address * * @throws IllegalArgumentException * If address is {@code null} or the {@link * java.net.InetAddress#isAnyLocalAddress wildcard} address * * @throws IOException * If some other I/O error occurs */ public abstract SctpServerChannel bindAddress(InetAddress address) throws IOException; /** * Removes the given address from the bound addresses for the channel's * socket. * *
The given address must not be the {@link * java.net.InetAddress#isAnyLocalAddress wildcard} address. * The channel must be first bound using {@link #bind bind} before * invoking this method, otherwise * {@link java.nio.channels.NotYetBoundException} is thrown. * If this method is invoked on a channel that does not have * {@code address} as one of its bound addresses, or that has only one * local address bound to it, then this method throws {@link * IllegalUnbindException}. * The initial address that the channel's socket is bound to using * {@link #bind bind} may be removed from the bound addresses for the * channel's socket. * *
New associations accepted after this method successfully completes
* will not be associated with the given address.
*
* @param address
* The address to remove from the bound addresses for the socket
*
* @return This channel
*
* @throws java.nio.channels.ClosedChannelException
* If this channel is closed
*
* @throws java.nio.channels.NotYetBoundException
* If this channel is not yet bound
*
* @throws IllegalArgumentException
* If address is {@code null} or the {@link
* java.net.InetAddress#isAnyLocalAddress wildcard} address
*
* @throws IllegalUnbindException
* If the implementation does not support removing addresses from a
* listening socket, {@code address} is not bound to the channel's
* socket, or the channel has only one address bound to it
*
* @throws IOException
* If some other I/O error occurs
*/
public abstract SctpServerChannel unbindAddress(InetAddress address)
throws IOException;
/**
* Returns all of the socket addresses to which this channel's socket is
* bound.
*
* @return All the socket addresses that this channel's socket is
* bound to, or an empty {@code Set} if the channel's socket is not
* bound
*
* @throws java.nio.channels.ClosedChannelException
* If the channel is closed
*
* @throws IOException
* If an I/O error occurs
*/
public abstract Set This method will continue to return the set of options even after the
* channel has been closed.
*
* @return A set of the socket options supported by this channel
*/
public abstract Set SCTP server channels only support the accepting of new
* associations, so this method returns
* {@link java.nio.channels.SelectionKey#OP_ACCEPT}.
*
* @return The valid-operation set
*/
@Override
public final int validOps() {
return SelectionKey.OP_ACCEPT;
}
}