java.net.SocketOption Java Examples

@Override
public Object getOption(FileDescriptor fd,
                        SocketOption<?> option)
    throws SocketException
{
    SecurityManager sm = System.getSecurityManager();
    if (sm != null)
        sm.checkPermission(new NetworkPermission("getOption." + option.name()));

    if (fd == null || !fd.valid())
        throw new SocketException("socket closed");

    if (option == SO_FLOW_SLA) {
        assert flowSupported;
        SocketFlow flow = SocketFlow.create();
        getFlowOption(fd, flow);
        return flow;
    } else {
        throw new InternalError("Unexpected option " + option);
    }
}
 

@Override
public final <T> AsynchronousSocketChannel setOption(SocketOption<T> name, T value)
    throws IOException
{
    if (name == null)
        throw new NullPointerException();
    if (!supportedOptions().contains(name))
        throw new UnsupportedOperationException("'" + name + "' not supported");

    try {
        begin();
        if (writeShutdown)
            throw new IOException("Connection has been shutdown for writing");
        if (name == StandardSocketOptions.SO_REUSEADDR &&
                Net.useExclusiveBind())
        {
            // SO_REUSEADDR emulated when using exclusive bind
            isReuseAddress = (Boolean)value;
        } else {
            Net.setSocketOption(fd, Net.UNSPEC, name, value);
        }
        return this;
    } finally {
        end();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public final <T> T getOption(SocketOption<T> name) throws IOException {
    if (name == null)
        throw new NullPointerException();
    if (!supportedOptions().contains(name))
        throw new UnsupportedOperationException("'" + name + "' not supported");

    try {
        begin();
        if (name == StandardSocketOptions.SO_REUSEADDR &&
                Net.useExclusiveBind())
        {
            // SO_REUSEADDR emulated when using exclusive bind
            return (T)Boolean.valueOf(isReuseAddress);
        }
        return (T) Net.getSocketOption(fd, Net.UNSPEC, name);
    } finally {
        end();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public final <T> T getOption(SocketOption<T> name) throws IOException {
    if (name == null)
        throw new NullPointerException();
    if (!supportedOptions().contains(name))
        throw new UnsupportedOperationException("'" + name + "' not supported");

    try {
        begin();
        if (name == StandardSocketOptions.SO_REUSEADDR &&
                Net.useExclusiveBind())
        {
            // SO_REUSEADDR emulated when using exclusive bind
            return (T)Boolean.valueOf(isReuseAddress);
        }
        return (T) Net.getSocketOption(fd, Net.UNSPEC, name);
    } finally {
        end();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public final <T> T getOption(SocketOption<T> name) throws IOException {
    if (name == null)
        throw new NullPointerException();
    if (!supportedOptions().contains(name))
        throw new UnsupportedOperationException("'" + name + "' not supported");

    try {
        begin();
        if (name == StandardSocketOptions.SO_REUSEADDR &&
                Net.useExclusiveBind())
        {
            // SO_REUSEADDR emulated when using exclusive bind
            return (T)Boolean.valueOf(isReuseAddress);
        }
        return (T) Net.getSocketOption(fd, Net.UNSPEC, name);
    } finally {
        end();
    }
}
 

protected ExtendedSocketOptions(Set<SocketOption<?>> options) {
    this.options = options;
    var datagramOptions = new HashSet<SocketOption<?>>();
    var serverStreamOptions = new HashSet<SocketOption<?>>();
    var clientStreamOptions = new HashSet<SocketOption<?>>();
    for (var option : options) {
        if (isDatagramOption(option)) {
            datagramOptions.add(option);
        }
        if (isStreamOption(option, true)) {
            serverStreamOptions.add(option);
        }
        if (isStreamOption(option, false)) {
            clientStreamOptions.add(option);
        }
    }
    this.datagramOptions = Set.copyOf(datagramOptions);
    this.serverStreamOptions = Set.copyOf(serverStreamOptions);
    this.clientStreamOptions = Set.copyOf(clientStreamOptions);
}
 

@Override
public final <T> AsynchronousSocketChannel setOption(SocketOption<T> name, T value)
    throws IOException
{
    if (name == null)
        throw new NullPointerException();
    if (!supportedOptions().contains(name))
        throw new UnsupportedOperationException("'" + name + "' not supported");

    try {
        begin();
        if (writeShutdown)
            throw new IOException("Connection has been shutdown for writing");
        if (name == StandardSocketOptions.SO_REUSEADDR &&
                Net.useExclusiveBind())
        {
            // SO_REUSEADDR emulated when using exclusive bind
            isReuseAddress = (Boolean)value;
        } else {
            Net.setSocketOption(fd, Net.UNSPEC, name, value);
        }
        return this;
    } finally {
        end();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public final <T> T getOption(SocketOption<T> name) throws IOException {
    if (name == null)
        throw new NullPointerException();
    if (!supportedOptions().contains(name))
        throw new UnsupportedOperationException("'" + name + "' not supported");

    try {
        begin();
        if (name == StandardSocketOptions.SO_REUSEADDR &&
                Net.useExclusiveBind())
        {
            // SO_REUSEADDR emulated when using exclusive bind
            return (T)Boolean.valueOf(isReuseAddress);
        }
        return (T) Net.getSocketOption(fd, Net.UNSPEC, name);
    } finally {
        end();
    }
}
 

private void setBooleanOption(SocketOption<Boolean> name, boolean value)
    throws SocketException
{
    try {
        dc.setOption(name, value);
    } catch (IOException x) {
        Net.translateToSocketException(x);
    }
}
 

private void setIntOption(SocketOption<Integer> name, int value)
    throws SocketException
{
    try {
        dc.setOption(name, value);
    } catch (IOException x) {
        Net.translateToSocketException(x);
    }
}
 

private static Set<SocketOption<?>> defaultOptions() {
    HashSet<SocketOption<?>> set = new HashSet<SocketOption<?>>(5);
    set.add(StandardSocketOptions.SO_SNDBUF);
    set.add(StandardSocketOptions.SO_RCVBUF);
    set.add(StandardSocketOptions.SO_KEEPALIVE);
    set.add(StandardSocketOptions.SO_REUSEADDR);
    set.add(StandardSocketOptions.TCP_NODELAY);
    if (ExtendedOptionsImpl.flowSupported()) {
        set.add(jdk.net.ExtendedSocketOptions.SO_FLOW_SLA);
    }
    return Collections.unmodifiableSet(set);
}
 

private void setIntOption(SocketOption<Integer> name, int value)
    throws SocketException
{
    try {
        sc.setOption(name, value);
    } catch (IOException x) {
        Net.translateToSocketException(x);
    }
}
 

private static Set<SocketOption<?>> defaultOptions() {
    HashSet<SocketOption<?>> set = new HashSet<>(5);
    set.add(StandardSocketOptions.SO_SNDBUF);
    set.add(StandardSocketOptions.SO_RCVBUF);
    set.add(StandardSocketOptions.SO_KEEPALIVE);
    set.add(StandardSocketOptions.SO_REUSEADDR);
    if (Net.isReusePortAvailable()) {
        set.add(StandardSocketOptions.SO_REUSEPORT);
    }
    set.add(StandardSocketOptions.TCP_NODELAY);
    ExtendedSocketOptions extendedOptions =
            ExtendedSocketOptions.getInstance();
    set.addAll(extendedOptions.options());
    return Collections.unmodifiableSet(set);
}
 

private static Set<SocketOption<?>> defaultOptions() {
    HashSet<SocketOption<?>> set = new HashSet<SocketOption<?>>(5);
    set.add(StandardSocketOptions.SO_SNDBUF);
    set.add(StandardSocketOptions.SO_RCVBUF);
    set.add(StandardSocketOptions.SO_KEEPALIVE);
    set.add(StandardSocketOptions.SO_REUSEADDR);
    set.add(StandardSocketOptions.TCP_NODELAY);
    if (ExtendedOptionsImpl.flowSupported()) {
        set.add(jdk.net.ExtendedSocketOptions.SO_FLOW_SLA);
    }
    return Collections.unmodifiableSet(set);
}
 

private int getIntOption(SocketOption<Integer> name) throws SocketException {
    try {
        return sc.getOption(name).intValue();
    } catch (IOException x) {
        Net.translateToSocketException(x);
        return -1;          // keep compiler happy
    }
}
 

private int getIntOption(SocketOption<Integer> name) throws SocketException {
    try {
        return sc.getOption(name).intValue();
    } catch (IOException x) {
        Net.translateToSocketException(x);
        return -1;          // keep compiler happy
    }
}
 

private void setBooleanOption(SocketOption<Boolean> name, boolean value)
    throws SocketException
{
    try {
        dc.setOption(name, value);
    } catch (IOException x) {
        Net.translateToSocketException(x);
    }
}
 

private static Set<SocketOption<?>> defaultOptions() {
    HashSet<SocketOption<?>> set = new HashSet<>(2);
    set.add(StandardSocketOptions.SO_RCVBUF);
    set.add(StandardSocketOptions.SO_REUSEADDR);
    if (Net.isReusePortAvailable()) {
        set.add(StandardSocketOptions.SO_REUSEPORT);
    }
    set.addAll(ExtendedSocketOptions.serverSocketOptions());
    return Collections.unmodifiableSet(set);
}
 

private int getIntOption(SocketOption<Integer> name) throws SocketException {
    try {
        return dc.getOption(name).intValue();
    } catch (IOException x) {
        Net.translateToSocketException(x);
        return -1;          // keep compiler happy
    }
}
 

public static ReusePortSocketOptionHolder create(int socketCount) {
    SocketOption reusePortSocketOption = getReusePortSocketOption();
    if (reusePortSocketOption == null) {
        LOGGER.warn("Failed to get ReusePort SocketOption. Please use Jvm9+ for using ReusePort SocketOption");
        return null;
    }

    return new ReusePortSocketOptionHolder(reusePortSocketOption, true, socketCount);
}
 

private boolean getBooleanOption(SocketOption<Boolean> name) throws SocketException {
    try {
        return sc.getOption(name).booleanValue();
    } catch (IOException x) {
        Net.translateToSocketException(x);
        return false;       // keep compiler happy
    }
}
 

private Set<SocketOption<?>> options0(short type, boolean server) {
    switch (type) {
        case SOCK_DGRAM:
            return datagramOptions;
        case SOCK_STREAM:
            if (server) {
                return serverStreamOptions;
            } else {
                return clientStreamOptions;
            }
        default:
            //this will never happen
            throw new IllegalArgumentException("Invalid socket option type");
    }
}
 

private static Set<SocketOption<?>> defaultOptions() {
    HashSet<SocketOption<?>> set = new HashSet<>(5);
    set.add(StandardSocketOptions.SO_SNDBUF);
    set.add(StandardSocketOptions.SO_RCVBUF);
    set.add(StandardSocketOptions.SO_KEEPALIVE);
    set.add(StandardSocketOptions.SO_REUSEADDR);
    if (Net.isReusePortAvailable()) {
        set.add(StandardSocketOptions.SO_REUSEPORT);
    }
    set.add(StandardSocketOptions.TCP_NODELAY);
    set.addAll(ExtendedSocketOptions.clientSocketOptions());
    return Collections.unmodifiableSet(set);
}
 

private void setIntOption(SocketOption<Integer> name, int value)
    throws SocketException
{
    try {
        dc.setOption(name, value);
    } catch (IOException x) {
        Net.translateToSocketException(x);
    }
}
 

private int getIntOption(SocketOption<Integer> name) throws SocketException {
    try {
        return dc.getOption(name).intValue();
    } catch (IOException x) {
        Net.translateToSocketException(x);
        return -1;          // keep compiler happy
    }
}
 

@Override
public <T> T getOption(SocketOption<T> arg0) throws IOException {
	// TODO Auto-generated method stub
	return null;
}
 

@Override
public <T> GrpcClientBuilder<U, R> socketOption(final SocketOption<T> option, final T value) {
    httpClientBuilder.socketOption(option, value);
    return this;
}
 

@Override
public <T> T getOption(SocketOption<T> name) throws IOException {
    return null;
}
 

@Override
public Set<SocketOption<?>> supportedOptions() {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

static Set<SocketOption<?>> options() {
    if (flowSupported)
        return Set.of(SO_FLOW_SLA);
    else
        return Collections.<SocketOption<?>>emptySet();
}