| /* |
| * Copyright (c) 2009, 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 com.sun.nio.sctp; |
| |
| import java.net.SocketAddress; |
| import sun.nio.ch.SctpStdSocketOption; |
| |
| /** |
| * SCTP channels supports the socket options defined by this class |
| * (as well as those listed in the particular channel class) and may support |
| * additional Implementation specific socket options. |
| * |
| * @since 1.7 |
| */ |
| public class SctpStandardSocketOptions { |
| private SctpStandardSocketOptions() {} |
| /** |
| * Enables or disables message fragmentation. |
| * |
| * <P> The value of this socket option is a {@code Boolean} that represents |
| * whether the option is enabled or disabled. If enabled no SCTP message |
| * fragmentation will be performed. Instead if a message being sent |
| * exceeds the current PMTU size, the message will NOT be sent and |
| * an error will be indicated to the user. |
| * |
| * <P> It is implementation specific whether or not this option is |
| * supported. |
| */ |
| public static final SctpSocketOption<Boolean> SCTP_DISABLE_FRAGMENTS = new |
| SctpStdSocketOption<Boolean>("SCTP_DISABLE_FRAGMENTS", Boolean.class, |
| sun.nio.ch.SctpStdSocketOption.SCTP_DISABLE_FRAGMENTS); |
| |
| /** |
| * Enables or disables explicit message completion. |
| * |
| * <p> The value of this socket option is a {@code Boolean} that represents |
| * whether the option is enabled or disabled. When this option is enabled, |
| * the {@code send} method may be invoked multiple times to a send message. |
| * The {@code isComplete} parameter of the {@link MessageInfo} must only |
| * be set to {@code true} for the final send to indicate that the message is |
| * complete. If this option is disabled then each individual {@code send} |
| * invocation is considered complete. |
| * |
| * <P> The default value of the option is {@code false} indicating that the |
| * option is disabled. It is implementation specific whether or not this |
| * option is supported. |
| */ |
| public static final SctpSocketOption<Boolean> SCTP_EXPLICIT_COMPLETE = new |
| SctpStdSocketOption<Boolean>("SCTP_EXPLICIT_COMPLETE", Boolean.class, |
| sun.nio.ch.SctpStdSocketOption.SCTP_EXPLICIT_COMPLETE); |
| |
| /** |
| * Fragmented interleave controls how the presentation of messages occur |
| * for the message receiver. There are three levels of fragment interleave |
| * defined. Two of the levels effect {@link SctpChannel}, while |
| * {@link SctpMultiChannel} is effected by all three levels. |
| * |
| * <P> This option takes an {@code Integer} value. It can be set to a value |
| * of {@code 0}, {@code 1} or {@code 2}. |
| * |
| * <P> Setting the three levels provides the following receiver |
| * interactions: |
| * |
| * <P> {@code level 0} - Prevents the interleaving of any messages. This |
| * means that when a partial delivery begins, no other messages will be |
| * received except the message being partially delivered. If another message |
| * arrives on a different stream (or association) that could be delivered, |
| * it will be blocked waiting for the user to read all of the partially |
| * delivered message. |
| * |
| * <P> {@code level 1} - Allows interleaving of messages that are from |
| * different associations. For {@code SctpChannel}, level 0 and |
| * level 1 have the same meaning since an {@code SctpChannel} always |
| * receives messages from the same association. Note that setting an {@code |
| * SctpMultiChannel} to this level may cause multiple partial |
| * delivers from different associations but for any given association, only |
| * one message will be delivered until all parts of a message have been |
| * delivered. This means that one large message, being read with an |
| * association identification of "X", will block other messages from |
| * association "X" from being delivered. |
| * |
| * <P> {@code level 2} - Allows complete interleaving of messages. This |
| * level requires that the sender carefully observe not only the peer |
| * {@code Association} but also must pay careful attention to the stream |
| * number. With this option enabled a partially delivered message may begin |
| * being delivered for association "X" stream "Y" and the next subsequent |
| * receive may return a message from association "X" stream "Z". Note that |
| * no other messages would be delivered for association "X" stream "Y" |
| * until all of stream "Y"'s partially delivered message was read. |
| * Note that this option effects both channel types. Also note that |
| * for an {@code SctpMultiChannel} not only may another streams |
| * message from the same association be delivered from the next receive, |
| * some other associations message may be delivered upon the next receive. |
| * |
| * <P> It is implementation specific whether or not this option is |
| * supported. |
| */ |
| public static final SctpSocketOption<Integer> SCTP_FRAGMENT_INTERLEAVE = |
| new SctpStdSocketOption<Integer>("SCTP_FRAGMENT_INTERLEAVE", |
| Integer.class, |
| sun.nio.ch.SctpStdSocketOption.SCTP_FRAGMENT_INTERLEAVE); |
| |
| /** |
| * The maximum number of streams requested by the local endpoint during |
| * association initialization. |
| * |
| * <P> The value of this socket option is an {@link |
| * SctpStandardSocketOptions.InitMaxStreams InitMaxStreams}, that represents |
| * the maximum number of inbound and outbound streams that an association |
| * on the channel is prepared to support. |
| * |
| * <P> For an {@link SctpChannel} this option may only be used to |
| * change the number of inbound/outbound streams prior to connecting. |
| * |
| * <P> For an {@link SctpMultiChannel} this option determines |
| * the maximum number of inbound/outbound streams new associations setup |
| * on the channel will be prepared to support. |
| * |
| * <P> For an {@link SctpServerChannel} this option determines the |
| * maximum number of inbound/outbound streams accepted sockets will |
| * negotiate with their connecting peer. |
| * |
| * <P> In all cases the value set by this option is used in the negotiation |
| * of new associations setup on the channel's socket and the actual |
| * maximum number of inbound/outbound streams that have been negotiated |
| * with the peer can be retrieved from the appropriate {@link |
| * Association}. The {@code Association} can be retrieved from the |
| * {@link AssociationChangeNotification.AssocChangeEvent#COMM_UP COMM_UP} |
| * {@link AssociationChangeNotification} belonging to that association. |
| * |
| * <p> This value is bounded by the actual implementation. In other |
| * words the user may be able to support more streams than the Operating |
| * System. In such a case, the Operating System limit may override the |
| * value requested by the user. The default value of 0 indicates to use |
| * the endpoints default value. |
| */ |
| public static final SctpSocketOption |
| <SctpStandardSocketOptions.InitMaxStreams> SCTP_INIT_MAXSTREAMS = |
| new SctpStdSocketOption<SctpStandardSocketOptions.InitMaxStreams>( |
| "SCTP_INIT_MAXSTREAMS", SctpStandardSocketOptions.InitMaxStreams.class); |
| |
| /** |
| * Enables or disables a Nagle-like algorithm. |
| * |
| * <P> The value of this socket option is a {@code Boolean} that represents |
| * whether the option is enabled or disabled. SCTP uses an algorithm like |
| * <em>The Nagle Algorithm</em> to coalesce short segments and |
| * improve network efficiency. |
| */ |
| public static final SctpSocketOption<Boolean> SCTP_NODELAY = |
| new SctpStdSocketOption<Boolean>("SCTP_NODELAY", Boolean.class, |
| sun.nio.ch.SctpStdSocketOption.SCTP_NODELAY); |
| |
| /** |
| * Requests that the local SCTP stack use the given peer address as |
| * the association primary. |
| * |
| * <P> The value of this socket option is a {@code SocketAddress} |
| * that represents the peer address that the local SCTP stack should use as |
| * the association primary. The address must be one of the association |
| * peer's addresses. |
| * |
| * <P> An {@code SctpMultiChannel} can control more than one |
| * association, the association parameter must be given when setting or |
| * retrieving this option. |
| * |
| * <P> Since {@code SctpChannel} only controls one association, |
| * the association parameter is not required and this option can be |
| * set or queried directly. |
| */ |
| public static final SctpSocketOption<SocketAddress> SCTP_PRIMARY_ADDR = |
| new SctpStdSocketOption<SocketAddress> |
| ("SCTP_PRIMARY_ADDR", SocketAddress.class); |
| |
| /** |
| * Requests that the peer mark the enclosed address as the association |
| * primary. |
| * |
| * <P> The value of this socket option is a {@code SocketAddress} |
| * that represents the local address that the peer should use as its |
| * primary address. The given address must be one of the association's |
| * locally bound addresses. |
| * |
| * <P> An {@code SctpMultiChannel} can control more than one |
| * association, the association parameter must be given when setting or |
| * retrieving this option. |
| * |
| * <P> Since {@code SctpChannel} only controls one association, |
| * the association parameter is not required and this option can be |
| * queried directly. |
| * |
| * <P> Note, this is a set only option and cannot be retrieved by {@code |
| * getOption}. It is implementation specific whether or not this |
| * option is supported. |
| */ |
| public static final SctpSocketOption<SocketAddress> SCTP_SET_PEER_PRIMARY_ADDR = |
| new SctpStdSocketOption<SocketAddress> |
| ("SCTP_SET_PEER_PRIMARY_ADDR", SocketAddress.class); |
| |
| /** |
| * The size of the socket send buffer. |
| * |
| * <p> The value of this socket option is an {@code Integer} that is the |
| * size of the socket send buffer in bytes. The socket send buffer is an |
| * output buffer used by the networking implementation. It may need to be |
| * increased for high-volume connections. The value of the socket option is |
| * a <em>hint</em> to the implementation to size the buffer and the actual |
| * size may differ. The socket option can be queried to retrieve the actual |
| * size. |
| * |
| * <p> For {@code SctpChannel}, this controls the amount of data |
| * the SCTP stack may have waiting in internal buffers to be sent. This |
| * option therefore bounds the maximum size of data that can be sent in a |
| * single send call. |
| * |
| * <P> For {@code SctpMultiChannel}, the effect is the same as for {@code |
| * SctpChannel}, except that it applies to all associations. The option |
| * applies to each association's window size separately. |
| * |
| * <p> An implementation allows this socket option to be set before the |
| * socket is bound or connected. Whether an implementation allows the |
| * socket send buffer to be changed after the socket is bound is system |
| * dependent. |
| */ |
| public static final SctpSocketOption<Integer> SO_SNDBUF = |
| new SctpStdSocketOption<Integer>("SO_SNDBUF", Integer.class, |
| sun.nio.ch.SctpStdSocketOption.SO_SNDBUF); |
| |
| /** |
| * The size of the socket receive buffer. |
| * |
| * <P> The value of this socket option is an {@code Integer} that is the |
| * size of the socket receive buffer in bytes. The socket receive buffer is |
| * an input buffer used by the networking implementation. It may need to be |
| * increased for high-volume connections or decreased to limit the possible |
| * backlog of incoming data. The value of the socket option is a |
| * <em>hint</em> to the implementation to size the buffer and the actual |
| * size may differ. |
| * |
| * <P> For {@code SctpChannel}, this controls the receiver window size. |
| * |
| * <P> For {@code SctpMultiChannel}, the meaning is implementation |
| * dependent. It might control the receive buffer for each association bound |
| * to the socket descriptor or it might control the receive buffer for the |
| * whole socket. |
| * |
| * <p> An implementation allows this socket option to be set before the |
| * socket is bound or connected. Whether an implementation allows the |
| * socket receive buffer to be changed after the socket is bound is system |
| * dependent. |
| */ |
| public static final SctpSocketOption<Integer> SO_RCVBUF = |
| new SctpStdSocketOption<Integer>("SO_RCVBUF", Integer.class, |
| sun.nio.ch.SctpStdSocketOption.SO_RCVBUF); |
| |
| /** |
| * Linger on close if data is present. |
| * |
| * <p> The value of this socket option is an {@code Integer} that controls |
| * the action taken when unsent data is queued on the socket and a method |
| * to close the socket is invoked. If the value of the socket option is zero |
| * or greater, then it represents a timeout value, in seconds, known as the |
| * <em>linger interval</em>. The linger interval is the timeout for the |
| * {@code close} method to block while the operating system attempts to |
| * transmit the unsent data or it decides that it is unable to transmit the |
| * data. If the value of the socket option is less than zero then the option |
| * is disabled. In that case the {@code close} method does not wait until |
| * unsent data is transmitted; if possible the operating system will transmit |
| * any unsent data before the connection is closed. |
| * |
| * <p> This socket option is intended for use with sockets that are configured |
| * in {@link java.nio.channels.SelectableChannel#isBlocking() blocking} mode |
| * only. The behavior of the {@code close} method when this option is |
| * enabled on a non-blocking socket is not defined. |
| * |
| * <p> The initial value of this socket option is a negative value, meaning |
| * that the option is disabled. The option may be enabled, or the linger |
| * interval changed, at any time. The maximum value of the linger interval |
| * is system dependent. Setting the linger interval to a value that is |
| * greater than its maximum value causes the linger interval to be set to |
| * its maximum value. |
| */ |
| public static final SctpSocketOption<Integer> SO_LINGER = |
| new SctpStdSocketOption<Integer>("SO_LINGER", Integer.class, |
| sun.nio.ch.SctpStdSocketOption.SO_LINGER); |
| |
| /** |
| * This class is used to set the maximum number of inbound/outbound streams |
| * used by the local endpoint during association initialization. An |
| * instance of this class is used to set the {@link |
| * SctpStandardSocketOptions#SCTP_INIT_MAXSTREAMS SCTP_INIT_MAXSTREAMS} |
| * socket option. |
| * |
| * @since 1.7 |
| */ |
| public static class InitMaxStreams { |
| private int maxInStreams; |
| private int maxOutStreams; |
| |
| private InitMaxStreams(int maxInStreams, int maxOutStreams) { |
| this.maxInStreams = maxInStreams; |
| this.maxOutStreams = maxOutStreams; |
| } |
| |
| /** |
| * Creates an InitMaxStreams instance. |
| * |
| * @param maxInStreams |
| * The maximum number of inbound streams, where |
| * {@code 0 <= maxInStreams <= 65536} |
| * |
| * @param maxOutStreams |
| * The maximum number of outbound streams, where |
| * {@code 0 <= maxOutStreams <= 65536} |
| * |
| * @return An {@code InitMaxStreams} instance |
| * |
| * @throws IllegalArgumentException |
| * If an argument is outside of specified bounds |
| */ |
| public static InitMaxStreams create |
| (int maxInStreams, int maxOutStreams) { |
| if (maxOutStreams < 0 || maxOutStreams > 65535) |
| throw new IllegalArgumentException( |
| "Invalid maxOutStreams value"); |
| if (maxInStreams < 0 || maxInStreams > 65535) |
| throw new IllegalArgumentException( |
| "Invalid maxInStreams value"); |
| |
| return new InitMaxStreams(maxInStreams, maxOutStreams); |
| } |
| |
| /** |
| * Returns the maximum number of inbound streams. |
| * |
| * @return Maximum inbound streams |
| */ |
| public int maxInStreams() { |
| return maxInStreams; |
| } |
| |
| /** |
| * Returns the maximum number of outbound streams. |
| * |
| * @return Maximum outbound streams |
| */ |
| public int maxOutStreams() { |
| return maxOutStreams; |
| } |
| |
| /** |
| * Returns a string representation of this init max streams, including |
| * the maximum in and out bound streams. |
| * |
| * @return A string representation of this init max streams |
| */ |
| @Override |
| public String toString() { |
| StringBuilder sb = new StringBuilder(); |
| sb.append(super.toString()).append(" ["); |
| sb.append("maxInStreams:").append(maxInStreams); |
| sb.append("maxOutStreams:").append(maxOutStreams).append("]"); |
| return sb.toString(); |
| } |
| |
| /** |
| * Returns true if the specified object is another {@code InitMaxStreams} |
| * instance with the same number of in and out bound streams. |
| * |
| * @param obj |
| * The object to be compared with this init max streams |
| * |
| * @return true if the specified object is another |
| * {@code InitMaxStreams} instance with the same number of in |
| * and out bound streams |
| */ |
| @Override |
| public boolean equals(Object obj) { |
| if (obj != null && obj instanceof InitMaxStreams) { |
| InitMaxStreams that = (InitMaxStreams) obj; |
| if (this.maxInStreams == that.maxInStreams && |
| this.maxOutStreams == that.maxOutStreams) |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Returns a hash code value for this init max streams. |
| */ |
| @Override |
| public int hashCode() { |
| int hash = 7 ^ maxInStreams ^ maxOutStreams; |
| return hash; |
| } |
| } |
| } |
