--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/java.base/share/classes/java/net/SocketImpl.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,479 @@
+/*
+ * Copyright (c) 1995, 2016, 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 java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.FileDescriptor;
+import java.util.Set;
+
+/**
+ * The abstract class {@code SocketImpl} is a common superclass
+ * of all classes that actually implement sockets. It is used to
+ * create both client and server sockets.
+ * <p>
+ * A "plain" socket implements these methods exactly as
+ * described, without attempting to go through a firewall or proxy.
+ *
+ * @author unascribed
+ * @since 1.0
+ */
+public abstract class SocketImpl implements SocketOptions {
+ /**
+ * The actual Socket object.
+ */
+ Socket socket = null;
+ ServerSocket serverSocket = null;
+
+ /**
+ * The file descriptor object for this socket.
+ */
+ protected FileDescriptor fd;
+
+ /**
+ * The IP address of the remote end of this socket.
+ */
+ protected InetAddress address;
+
+ /**
+ * The port number on the remote host to which this socket is connected.
+ */
+ protected int port;
+
+ /**
+ * The local port number to which this socket is connected.
+ */
+ protected int localport;
+
+ /**
+ * Creates either a stream or a datagram socket.
+ *
+ * @param stream if {@code true}, create a stream socket;
+ * otherwise, create a datagram socket.
+ * @exception IOException if an I/O error occurs while creating the
+ * socket.
+ */
+ protected abstract void create(boolean stream) throws IOException;
+
+ /**
+ * Connects this socket to the specified port on the named host.
+ *
+ * @param host the name of the remote host.
+ * @param port the port number.
+ * @exception IOException if an I/O error occurs when connecting to the
+ * remote host.
+ */
+ protected abstract void connect(String host, int port) throws IOException;
+
+ /**
+ * Connects this socket to the specified port number on the specified host.
+ *
+ * @param address the IP address of the remote host.
+ * @param port the port number.
+ * @exception IOException if an I/O error occurs when attempting a
+ * connection.
+ */
+ protected abstract void connect(InetAddress address, int port) throws IOException;
+
+ /**
+ * Connects this socket to the specified port number on the specified host.
+ * A timeout of zero is interpreted as an infinite timeout. The connection
+ * will then block until established or an error occurs.
+ *
+ * @param address the Socket address of the remote host.
+ * @param timeout the timeout value, in milliseconds, or zero for no timeout.
+ * @exception IOException if an I/O error occurs when attempting a
+ * connection.
+ * @since 1.4
+ */
+ protected abstract void connect(SocketAddress address, int timeout) throws IOException;
+
+ /**
+ * Binds this socket to the specified local IP address and port number.
+ *
+ * @param host an IP address that belongs to a local interface.
+ * @param port the port number.
+ * @exception IOException if an I/O error occurs when binding this socket.
+ */
+ protected abstract void bind(InetAddress host, int port) throws IOException;
+
+ /**
+ * Sets the maximum queue length for incoming connection indications
+ * (a request to connect) to the {@code count} argument. If a
+ * connection indication arrives when the queue is full, the
+ * connection is refused.
+ *
+ * @param backlog the maximum length of the queue.
+ * @exception IOException if an I/O error occurs when creating the queue.
+ */
+ protected abstract void listen(int backlog) throws IOException;
+
+ /**
+ * Accepts a connection.
+ *
+ * @param s the accepted connection.
+ * @exception IOException if an I/O error occurs when accepting the
+ * connection.
+ */
+ protected abstract void accept(SocketImpl s) throws IOException;
+
+ /**
+ * Returns an input stream for this socket.
+ *
+ * @return a stream for reading from this socket.
+ * @exception IOException if an I/O error occurs when creating the
+ * input stream.
+ */
+ protected abstract InputStream getInputStream() throws IOException;
+
+ /**
+ * Returns an output stream for this socket.
+ *
+ * @return an output stream for writing to this socket.
+ * @exception IOException if an I/O error occurs when creating the
+ * output stream.
+ */
+ protected abstract OutputStream getOutputStream() throws IOException;
+
+ /**
+ * Returns the number of bytes that can be read from this socket
+ * without blocking.
+ *
+ * @return the number of bytes that can be read from this socket
+ * without blocking.
+ * @exception IOException if an I/O error occurs when determining the
+ * number of bytes available.
+ */
+ protected abstract int available() throws IOException;
+
+ /**
+ * Closes this socket.
+ *
+ * @exception IOException if an I/O error occurs when closing this socket.
+ */
+ protected abstract void close() throws IOException;
+
+ /**
+ * Places the input stream for this socket at "end of stream".
+ * Any data sent to this socket is acknowledged and then
+ * silently discarded.
+ *
+ * If you read from a socket input stream after invoking this method on the
+ * socket, the stream's {@code available} method will return 0, and its
+ * {@code read} methods will return {@code -1} (end of stream).
+ *
+ * @exception IOException if an I/O error occurs when shutting down this
+ * socket.
+ * @see java.net.Socket#shutdownOutput()
+ * @see java.net.Socket#close()
+ * @see java.net.Socket#setSoLinger(boolean, int)
+ * @since 1.3
+ */
+ protected void shutdownInput() throws IOException {
+ throw new IOException("Method not implemented!");
+ }
+
+ /**
+ * Disables the output stream for this socket.
+ * For a TCP socket, any previously written data will be sent
+ * followed by TCP's normal connection termination sequence.
+ *
+ * If you write to a socket output stream after invoking
+ * shutdownOutput() on the socket, the stream will throw
+ * an IOException.
+ *
+ * @exception IOException if an I/O error occurs when shutting down this
+ * socket.
+ * @see java.net.Socket#shutdownInput()
+ * @see java.net.Socket#close()
+ * @see java.net.Socket#setSoLinger(boolean, int)
+ * @since 1.3
+ */
+ protected void shutdownOutput() throws IOException {
+ throw new IOException("Method not implemented!");
+ }
+
+ /**
+ * Returns the value of this socket's {@code fd} field.
+ *
+ * @return the value of this socket's {@code fd} field.
+ * @see java.net.SocketImpl#fd
+ */
+ protected FileDescriptor getFileDescriptor() {
+ return fd;
+ }
+
+ /**
+ * Returns the value of this socket's {@code address} field.
+ *
+ * @return the value of this socket's {@code address} field.
+ * @see java.net.SocketImpl#address
+ */
+ protected InetAddress getInetAddress() {
+ return address;
+ }
+
+ /**
+ * Returns the value of this socket's {@code port} field.
+ *
+ * @return the value of this socket's {@code port} field.
+ * @see java.net.SocketImpl#port
+ */
+ protected int getPort() {
+ return port;
+ }
+
+ /**
+ * Returns whether or not this SocketImpl supports sending
+ * urgent data. By default, false is returned
+ * unless the method is overridden in a sub-class
+ *
+ * @return true if urgent data supported
+ * @see java.net.SocketImpl#address
+ * @since 1.4
+ */
+ protected boolean supportsUrgentData () {
+ return false; // must be overridden in sub-class
+ }
+
+ /**
+ * Send one byte of urgent data on the socket.
+ * The byte to be sent is the low eight bits of the parameter
+ * @param data The byte of data to send
+ * @exception IOException if there is an error
+ * sending the data.
+ * @since 1.4
+ */
+ protected abstract void sendUrgentData (int data) throws IOException;
+
+ /**
+ * Returns the value of this socket's {@code localport} field.
+ *
+ * @return the value of this socket's {@code localport} field.
+ * @see java.net.SocketImpl#localport
+ */
+ protected int getLocalPort() {
+ return localport;
+ }
+
+ void setSocket(Socket soc) {
+ this.socket = soc;
+ }
+
+ Socket getSocket() {
+ return socket;
+ }
+
+ void setServerSocket(ServerSocket soc) {
+ this.serverSocket = soc;
+ }
+
+ ServerSocket getServerSocket() {
+ return serverSocket;
+ }
+
+ /**
+ * Returns the address and port of this socket as a {@code String}.
+ *
+ * @return a string representation of this socket.
+ */
+ public String toString() {
+ return "Socket[addr=" + getInetAddress() +
+ ",port=" + getPort() + ",localport=" + getLocalPort() + "]";
+ }
+
+ void reset() throws IOException {
+ address = null;
+ port = 0;
+ localport = 0;
+ }
+
+ /**
+ * Sets performance preferences for this socket.
+ *
+ * <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. Negative
+ * values represent a lower priority than positive values. If the
+ * application prefers short connection time over both low latency and high
+ * bandwidth, for example, then it could invoke this method with the values
+ * {@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)}.
+ *
+ * By default, this method does nothing, unless it is overridden in a
+ * a sub-class.
+ *
+ * @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
+ */
+ protected void setPerformancePreferences(int connectionTime,
+ int latency,
+ int bandwidth)
+ {
+ /* Not implemented yet */
+ }
+
+ /**
+ * Called to set 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.
+ *
+ * @throws UnsupportedOperationException if the SocketImpl does not
+ * support the option
+ *
+ * @throws IOException if an I/O error occurs, or if the socket is closed.
+ *
+ * @since 9
+ */
+ protected <T> void setOption(SocketOption<T> name, T value) throws IOException {
+ if (name == StandardSocketOptions.SO_KEEPALIVE &&
+ (getSocket() != null)) {
+ setOption(SocketOptions.SO_KEEPALIVE, value);
+ } else if (name == StandardSocketOptions.SO_SNDBUF &&
+ (getSocket() != null)) {
+ setOption(SocketOptions.SO_SNDBUF, value);
+ } else if (name == StandardSocketOptions.SO_RCVBUF) {
+ setOption(SocketOptions.SO_RCVBUF, value);
+ } else if (name == StandardSocketOptions.SO_REUSEADDR) {
+ setOption(SocketOptions.SO_REUSEADDR, value);
+ } else if (name == StandardSocketOptions.SO_REUSEPORT &&
+ supportedOptions().contains(name)) {
+ setOption(SocketOptions.SO_REUSEPORT, value);
+ } else if (name == StandardSocketOptions.SO_LINGER &&
+ (getSocket() != null)) {
+ setOption(SocketOptions.SO_LINGER, value);
+ } else if (name == StandardSocketOptions.IP_TOS) {
+ setOption(SocketOptions.IP_TOS, value);
+ } else if (name == StandardSocketOptions.TCP_NODELAY &&
+ (getSocket() != null)) {
+ setOption(SocketOptions.TCP_NODELAY, value);
+ } else {
+ throw new UnsupportedOperationException("unsupported option");
+ }
+ }
+
+ /**
+ * Called to get a socket option.
+ *
+ * @param <T> The type of the socket option value
+ * @param name The socket option
+ *
+ * @return the value of the named option
+ *
+ * @throws UnsupportedOperationException if the SocketImpl does not
+ * support the option.
+ *
+ * @throws IOException if an I/O error occurs, or if the socket is closed.
+ *
+ * @since 9
+ */
+ @SuppressWarnings("unchecked")
+ protected <T> T getOption(SocketOption<T> name) throws IOException {
+ if (name == StandardSocketOptions.SO_KEEPALIVE &&
+ (getSocket() != null)) {
+ return (T)getOption(SocketOptions.SO_KEEPALIVE);
+ } else if (name == StandardSocketOptions.SO_SNDBUF &&
+ (getSocket() != null)) {
+ return (T)getOption(SocketOptions.SO_SNDBUF);
+ } else if (name == StandardSocketOptions.SO_RCVBUF) {
+ return (T)getOption(SocketOptions.SO_RCVBUF);
+ } else if (name == StandardSocketOptions.SO_REUSEADDR) {
+ return (T)getOption(SocketOptions.SO_REUSEADDR);
+ } else if (name == StandardSocketOptions.SO_REUSEPORT &&
+ supportedOptions().contains(name)) {
+ return (T)getOption(SocketOptions.SO_REUSEPORT);
+ } else if (name == StandardSocketOptions.SO_LINGER &&
+ (getSocket() != null)) {
+ return (T)getOption(SocketOptions.SO_LINGER);
+ } else if (name == StandardSocketOptions.IP_TOS) {
+ return (T)getOption(SocketOptions.IP_TOS);
+ } else if (name == StandardSocketOptions.TCP_NODELAY &&
+ (getSocket() != null)) {
+ return (T)getOption(SocketOptions.TCP_NODELAY);
+ } else {
+ throw new UnsupportedOperationException("unsupported option");
+ }
+ }
+
+ private static final Set<SocketOption<?>> socketOptions;
+
+ private static final Set<SocketOption<?>> serverSocketOptions;
+
+ static {
+ socketOptions = Set.of(StandardSocketOptions.SO_KEEPALIVE,
+ StandardSocketOptions.SO_SNDBUF,
+ StandardSocketOptions.SO_RCVBUF,
+ StandardSocketOptions.SO_REUSEADDR,
+ StandardSocketOptions.SO_LINGER,
+ StandardSocketOptions.IP_TOS,
+ StandardSocketOptions.TCP_NODELAY);
+
+ serverSocketOptions = Set.of(StandardSocketOptions.SO_RCVBUF,
+ StandardSocketOptions.SO_REUSEADDR,
+ StandardSocketOptions.IP_TOS);
+ }
+
+ /**
+ * Returns a set of SocketOptions supported by this impl
+ * and by this impl's socket (Socket or ServerSocket)
+ *
+ * @return a Set of SocketOptions
+ *
+ * @since 9
+ */
+ protected Set<SocketOption<?>> supportedOptions() {
+ if (getSocket() != null) {
+ return socketOptions;
+ } else {
+ return serverSocketOptions;
+ }
+ }
+}