jdk/src/share/classes/java/net/Socket.java
author alanb
Mon, 10 Jun 2013 12:58:32 +0100
changeset 18156 edb590d448c5
parent 17469 e00a02431a8b
child 18274 7c4289125569
permissions -rw-r--r--
8016217: More javadoc warnings Reviewed-by: lancea, chegar, psandoz
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
10596
39b3a979e600 7090158: Networking Libraries don't build with javac -Werror
chegar
parents: 10439
diff changeset
     2
 * Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 5180
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 5180
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    20
 *
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 5180
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 5180
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 5180
diff changeset
    23
 * questions.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
package java.net;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
90ce3da70b43 Initial load
duke
parents:
diff changeset
    28
import java.io.InputStream;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    29
import java.io.OutputStream;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    30
import java.io.IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
import java.nio.channels.SocketChannel;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    32
import java.security.AccessController;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    33
import java.security.PrivilegedExceptionAction;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
import java.security.PrivilegedAction;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    35
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
/**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    37
 * This class implements client sockets (also called just
90ce3da70b43 Initial load
duke
parents:
diff changeset
    38
 * "sockets"). A socket is an endpoint for communication
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
 * between two machines.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
 * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
 * The actual work of the socket is performed by an instance of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
 * <code>SocketImpl</code> class. An application, by changing
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
 * the socket factory that creates the socket implementation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
 * can configure itself to create sockets appropriate to the local
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
 * firewall.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
 * @author  unascribed
90ce3da70b43 Initial load
duke
parents:
diff changeset
    48
 * @see     java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    49
 * @see     java.net.SocketImpl
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
 * @see     java.nio.channels.SocketChannel
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
 * @since   JDK1.0
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
public
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
class Socket implements java.io.Closeable {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
     * Various states of this socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
    private boolean created = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
    private boolean bound = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
    private boolean connected = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
    private boolean closed = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
    private Object closeLock = new Object();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
    private boolean shutIn = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
    private boolean shutOut = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    65
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
     * The implementation of this Socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
    SocketImpl impl;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
     * Are we using an older SocketImpl?
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
    private boolean oldImpl = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
90ce3da70b43 Initial load
duke
parents:
diff changeset
    76
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
     * Creates an unconnected socket, with the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
     * system-default type of SocketImpl.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
     * @since   JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
     * @revised 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
    public Socket() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
        setImpl();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
     * Creates an unconnected socket, specifying the type of proxy, if any,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
     * that should be used regardless of any other settings.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
     * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
     * If there is a security manager, its <code>checkConnect</code> method
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
     * is called with the proxy host address and port number
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
     * as its arguments. This could result in a SecurityException.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
     * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
     * Examples:
90ce3da70b43 Initial load
duke
parents:
diff changeset
    96
     * <UL> <LI><code>Socket s = new Socket(Proxy.NO_PROXY);</code> will create
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
     * a plain socket ignoring any other proxy configuration.</LI>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    98
     * <LI><code>Socket s = new Socket(new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("socks.mydom.com", 1080)));</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    99
     * will create a socket connecting through the specified SOCKS proxy
90ce3da70b43 Initial load
duke
parents:
diff changeset
   100
     * server.</LI>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   101
     * </UL>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   103
     * @param proxy a {@link java.net.Proxy Proxy} object specifying what kind
90ce3da70b43 Initial load
duke
parents:
diff changeset
   104
     *              of proxying should be used.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   105
     * @throws IllegalArgumentException if the proxy is of an invalid type
90ce3da70b43 Initial load
duke
parents:
diff changeset
   106
     *          or <code>null</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   107
     * @throws SecurityException if a security manager is present and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   108
     *                           permission to connect to the proxy is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   109
     *                           denied.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   110
     * @see java.net.ProxySelector
90ce3da70b43 Initial load
duke
parents:
diff changeset
   111
     * @see java.net.Proxy
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
     * @since   1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
    public Socket(Proxy proxy) {
3442
02df74328591 6801497: Proxy is assumed to be immutable but is non-final
jccollet
parents: 475
diff changeset
   116
        // Create a copy of Proxy as a security measure
02df74328591 6801497: Proxy is assumed to be immutable but is non-final
jccollet
parents: 475
diff changeset
   117
        if (proxy == null) {
02df74328591 6801497: Proxy is assumed to be immutable but is non-final
jccollet
parents: 475
diff changeset
   118
            throw new IllegalArgumentException("Invalid Proxy");
02df74328591 6801497: Proxy is assumed to be immutable but is non-final
jccollet
parents: 475
diff changeset
   119
        }
16061
c80133bafef0 6370908: Add support for HTTP_CONNECT proxy in Socket class
chegar
parents: 10596
diff changeset
   120
        Proxy p = proxy == Proxy.NO_PROXY ? Proxy.NO_PROXY
c80133bafef0 6370908: Add support for HTTP_CONNECT proxy in Socket class
chegar
parents: 10596
diff changeset
   121
                                          : sun.net.ApplicationProxy.create(proxy);
c80133bafef0 6370908: Add support for HTTP_CONNECT proxy in Socket class
chegar
parents: 10596
diff changeset
   122
        Proxy.Type type = p.type();
c80133bafef0 6370908: Add support for HTTP_CONNECT proxy in Socket class
chegar
parents: 10596
diff changeset
   123
        if (type == Proxy.Type.SOCKS || type == Proxy.Type.HTTP) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
            SecurityManager security = System.getSecurityManager();
3442
02df74328591 6801497: Proxy is assumed to be immutable but is non-final
jccollet
parents: 475
diff changeset
   125
            InetSocketAddress epoint = (InetSocketAddress) p.address();
5180
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   126
            if (epoint.getAddress() != null) {
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   127
                checkAddress (epoint.getAddress(), "Socket");
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   128
            }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
            if (security != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   130
                if (epoint.isUnresolved())
9775
1b128726e887 7042550: Reintegrate 6569621
michaelm
parents: 9550
diff changeset
   131
                    epoint = new InetSocketAddress(epoint.getHostName(), epoint.getPort());
1b128726e887 7042550: Reintegrate 6569621
michaelm
parents: 9550
diff changeset
   132
                if (epoint.isUnresolved())
1b128726e887 7042550: Reintegrate 6569621
michaelm
parents: 9550
diff changeset
   133
                    security.checkConnect(epoint.getHostName(), epoint.getPort());
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   134
                else
90ce3da70b43 Initial load
duke
parents:
diff changeset
   135
                    security.checkConnect(epoint.getAddress().getHostAddress(),
9775
1b128726e887 7042550: Reintegrate 6569621
michaelm
parents: 9550
diff changeset
   136
                                  epoint.getPort());
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   137
            }
16061
c80133bafef0 6370908: Add support for HTTP_CONNECT proxy in Socket class
chegar
parents: 10596
diff changeset
   138
            impl = type == Proxy.Type.SOCKS ? new SocksSocketImpl(p)
c80133bafef0 6370908: Add support for HTTP_CONNECT proxy in Socket class
chegar
parents: 10596
diff changeset
   139
                                            : new HttpConnectSocketImpl(p);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   140
            impl.setSocket(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   141
        } else {
3442
02df74328591 6801497: Proxy is assumed to be immutable but is non-final
jccollet
parents: 475
diff changeset
   142
            if (p == Proxy.NO_PROXY) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   143
                if (factory == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   144
                    impl = new PlainSocketImpl();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   145
                    impl.setSocket(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   146
                } else
90ce3da70b43 Initial load
duke
parents:
diff changeset
   147
                    setImpl();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   148
            } else
90ce3da70b43 Initial load
duke
parents:
diff changeset
   149
                throw new IllegalArgumentException("Invalid Proxy");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   150
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
     * Creates an unconnected Socket with a user-specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
     * SocketImpl.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
     * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
     * @param impl an instance of a <B>SocketImpl</B>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
     * the subclass wishes to use on the Socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
     * @exception SocketException if there is an error in the underlying protocol,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
     * such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   162
     * @since   JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
    protected Socket(SocketImpl impl) throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   165
        this.impl = impl;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
        if (impl != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   167
            checkOldImpl();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   168
            this.impl.setSocket(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   169
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   170
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   171
90ce3da70b43 Initial load
duke
parents:
diff changeset
   172
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   173
     * Creates a stream socket and connects it to the specified port
90ce3da70b43 Initial load
duke
parents:
diff changeset
   174
     * number on the named host.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   175
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
     * If the specified host is <tt>null</tt> it is the equivalent of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   177
     * specifying the address as <tt>{@link java.net.InetAddress#getByName InetAddress.getByName}(null)</tt>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
     * In other words, it is equivalent to specifying an address of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
     * loopback interface. </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
     * If the application has specified a server socket factory, that
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
     * factory's <code>createSocketImpl</code> method is called to create
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
     * the actual socket implementation. Otherwise a "plain" socket is created.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
     * If there is a security manager, its
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
     * <code>checkConnect</code> method is called
90ce3da70b43 Initial load
duke
parents:
diff changeset
   187
     * with the host address and <code>port</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
     * as its arguments. This could result in a SecurityException.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
     * @param      host   the host name, or <code>null</code> for the loopback address.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
     * @param      port   the port number.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
     * @exception  UnknownHostException if the IP address of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
     * the host could not be determined.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   195
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   196
     * @exception  IOException  if an I/O error occurs when creating the socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
     * @exception  SecurityException  if a security manager exists and its
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
     *             <code>checkConnect</code> method doesn't allow the operation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
     * @exception  IllegalArgumentException if the port parameter is outside
90ce3da70b43 Initial load
duke
parents:
diff changeset
   200
     *             the specified range of valid port values, which is between
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
     *             0 and 65535, inclusive.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
     * @see        java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
     * @see        java.net.SocketImpl
90ce3da70b43 Initial load
duke
parents:
diff changeset
   204
     * @see        java.net.SocketImplFactory#createSocketImpl()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   205
     * @see        SecurityManager#checkConnect
90ce3da70b43 Initial load
duke
parents:
diff changeset
   206
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
    public Socket(String host, int port)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
        throws UnknownHostException, IOException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   210
        this(host != null ? new InetSocketAddress(host, port) :
90ce3da70b43 Initial load
duke
parents:
diff changeset
   211
             new InetSocketAddress(InetAddress.getByName(null), port),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
             (SocketAddress) null, true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   213
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   214
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   216
     * Creates a stream socket and connects it to the specified port
90ce3da70b43 Initial load
duke
parents:
diff changeset
   217
     * number at the specified IP address.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   218
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   219
     * If the application has specified a socket factory, that factory's
90ce3da70b43 Initial load
duke
parents:
diff changeset
   220
     * <code>createSocketImpl</code> method is called to create the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   221
     * actual socket implementation. Otherwise a "plain" socket is created.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   222
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   223
     * If there is a security manager, its
90ce3da70b43 Initial load
duke
parents:
diff changeset
   224
     * <code>checkConnect</code> method is called
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
     * with the host address and <code>port</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
     * as its arguments. This could result in a SecurityException.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   228
     * @param      address   the IP address.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   229
     * @param      port      the port number.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   230
     * @exception  IOException  if an I/O error occurs when creating the socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   231
     * @exception  SecurityException  if a security manager exists and its
90ce3da70b43 Initial load
duke
parents:
diff changeset
   232
     *             <code>checkConnect</code> method doesn't allow the operation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   233
     * @exception  IllegalArgumentException if the port parameter is outside
90ce3da70b43 Initial load
duke
parents:
diff changeset
   234
     *             the specified range of valid port values, which is between
90ce3da70b43 Initial load
duke
parents:
diff changeset
   235
     *             0 and 65535, inclusive.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   236
     * @exception  NullPointerException if <code>address</code> is null.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   237
     * @see        java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   238
     * @see        java.net.SocketImpl
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
     * @see        java.net.SocketImplFactory#createSocketImpl()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
     * @see        SecurityManager#checkConnect
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   242
    public Socket(InetAddress address, int port) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   243
        this(address != null ? new InetSocketAddress(address, port) : null,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   244
             (SocketAddress) null, true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   245
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   248
     * Creates a socket and connects it to the specified remote host on
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
     * the specified remote port. The Socket will also bind() to the local
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
     * address and port supplied.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   251
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   252
     * If the specified host is <tt>null</tt> it is the equivalent of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   253
     * specifying the address as <tt>{@link java.net.InetAddress#getByName InetAddress.getByName}(null)</tt>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   254
     * In other words, it is equivalent to specifying an address of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   255
     * loopback interface. </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
     * A local port number of <code>zero</code> will let the system pick up a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
     * free port in the <code>bind</code> operation.</p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   259
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   260
     * If there is a security manager, its
90ce3da70b43 Initial load
duke
parents:
diff changeset
   261
     * <code>checkConnect</code> method is called
90ce3da70b43 Initial load
duke
parents:
diff changeset
   262
     * with the host address and <code>port</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   263
     * as its arguments. This could result in a SecurityException.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   264
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   265
     * @param host the name of the remote host, or <code>null</code> for the loopback address.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   266
     * @param port the remote port
475
b8b79ef97ac8 6571950: SSLSocket(raddr, rport, laddr, lport) allows null as laddr that spec doesn't reflect
xuelei
parents: 94
diff changeset
   267
     * @param localAddr the local address the socket is bound to, or
b8b79ef97ac8 6571950: SSLSocket(raddr, rport, laddr, lport) allows null as laddr that spec doesn't reflect
xuelei
parents: 94
diff changeset
   268
     *        <code>null</code> for the <code>anyLocal</code> address.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
     * @param localPort the local port the socket is bound to, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
     *        <code>zero</code> for a system selected free port.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
     * @exception  IOException  if an I/O error occurs when creating the socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
     * @exception  SecurityException  if a security manager exists and its
90ce3da70b43 Initial load
duke
parents:
diff changeset
   273
     *             <code>checkConnect</code> method doesn't allow the operation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   274
     * @exception  IllegalArgumentException if the port parameter or localPort
90ce3da70b43 Initial load
duke
parents:
diff changeset
   275
     *             parameter is outside the specified range of valid port values,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
     *             which is between 0 and 65535, inclusive.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   277
     * @see        SecurityManager#checkConnect
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
     * @since   JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
   279
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
    public Socket(String host, int port, InetAddress localAddr,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
                  int localPort) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
        this(host != null ? new InetSocketAddress(host, port) :
90ce3da70b43 Initial load
duke
parents:
diff changeset
   283
               new InetSocketAddress(InetAddress.getByName(null), port),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   284
             new InetSocketAddress(localAddr, localPort), true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   285
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   286
90ce3da70b43 Initial load
duke
parents:
diff changeset
   287
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   288
     * Creates a socket and connects it to the specified remote address on
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
     * the specified remote port. The Socket will also bind() to the local
90ce3da70b43 Initial load
duke
parents:
diff changeset
   290
     * address and port supplied.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   291
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   292
     * If the specified local address is <tt>null</tt> it is the equivalent of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   293
     * specifying the address as the AnyLocal address (see <tt>{@link java.net.InetAddress#isAnyLocalAddress InetAddress.isAnyLocalAddress}()</tt>).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   294
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   295
     * A local port number of <code>zero</code> will let the system pick up a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
     * free port in the <code>bind</code> operation.</p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
     * If there is a security manager, its
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
     * <code>checkConnect</code> method is called
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
     * with the host address and <code>port</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
     * as its arguments. This could result in a SecurityException.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
     * @param address the remote address
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
     * @param port the remote port
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
     * @param localAddr the local address the socket is bound to, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   306
     *        <code>null</code> for the <code>anyLocal</code> address.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   307
     * @param localPort the local port the socket is bound to or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   308
     *        <code>zero</code> for a system selected free port.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   309
     * @exception  IOException  if an I/O error occurs when creating the socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   310
     * @exception  SecurityException  if a security manager exists and its
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
     *             <code>checkConnect</code> method doesn't allow the operation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   312
     * @exception  IllegalArgumentException if the port parameter or localPort
90ce3da70b43 Initial load
duke
parents:
diff changeset
   313
     *             parameter is outside the specified range of valid port values,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   314
     *             which is between 0 and 65535, inclusive.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   315
     * @exception  NullPointerException if <code>address</code> is null.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   316
     * @see        SecurityManager#checkConnect
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
     * @since   JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
   318
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
    public Socket(InetAddress address, int port, InetAddress localAddr,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   320
                  int localPort) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   321
        this(address != null ? new InetSocketAddress(address, port) : null,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   322
             new InetSocketAddress(localAddr, localPort), true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   323
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   324
90ce3da70b43 Initial load
duke
parents:
diff changeset
   325
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   326
     * Creates a stream socket and connects it to the specified port
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
     * number on the named host.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   329
     * If the specified host is <tt>null</tt> it is the equivalent of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   330
     * specifying the address as <tt>{@link java.net.InetAddress#getByName InetAddress.getByName}(null)</tt>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   331
     * In other words, it is equivalent to specifying an address of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
     * loopback interface. </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   333
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
     * If the stream argument is <code>true</code>, this creates a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
     * stream socket. If the stream argument is <code>false</code>, it
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
     * creates a datagram socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
     * If the application has specified a server socket factory, that
90ce3da70b43 Initial load
duke
parents:
diff changeset
   339
     * factory's <code>createSocketImpl</code> method is called to create
90ce3da70b43 Initial load
duke
parents:
diff changeset
   340
     * the actual socket implementation. Otherwise a "plain" socket is created.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   341
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   342
     * If there is a security manager, its
90ce3da70b43 Initial load
duke
parents:
diff changeset
   343
     * <code>checkConnect</code> method is called
90ce3da70b43 Initial load
duke
parents:
diff changeset
   344
     * with the host address and <code>port</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   345
     * as its arguments. This could result in a SecurityException.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   346
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   347
     * If a UDP socket is used, TCP/IP related socket options will not apply.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   348
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   349
     * @param      host     the host name, or <code>null</code> for the loopback address.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   350
     * @param      port     the port number.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   351
     * @param      stream   a <code>boolean</code> indicating whether this is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   352
     *                      a stream socket or a datagram socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
     * @exception  IOException  if an I/O error occurs when creating the socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
     * @exception  SecurityException  if a security manager exists and its
90ce3da70b43 Initial load
duke
parents:
diff changeset
   355
     *             <code>checkConnect</code> method doesn't allow the operation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   356
     * @exception  IllegalArgumentException if the port parameter is outside
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
     *             the specified range of valid port values, which is between
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
     *             0 and 65535, inclusive.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
     * @see        java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   360
     * @see        java.net.SocketImpl
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
     * @see        java.net.SocketImplFactory#createSocketImpl()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   362
     * @see        SecurityManager#checkConnect
90ce3da70b43 Initial load
duke
parents:
diff changeset
   363
     * @deprecated Use DatagramSocket instead for UDP transport.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   364
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   365
    @Deprecated
90ce3da70b43 Initial load
duke
parents:
diff changeset
   366
    public Socket(String host, int port, boolean stream) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   367
        this(host != null ? new InetSocketAddress(host, port) :
90ce3da70b43 Initial load
duke
parents:
diff changeset
   368
               new InetSocketAddress(InetAddress.getByName(null), port),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   369
             (SocketAddress) null, stream);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   370
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   371
90ce3da70b43 Initial load
duke
parents:
diff changeset
   372
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   373
     * Creates a socket and connects it to the specified port number at
90ce3da70b43 Initial load
duke
parents:
diff changeset
   374
     * the specified IP address.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   375
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   376
     * If the stream argument is <code>true</code>, this creates a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   377
     * stream socket. If the stream argument is <code>false</code>, it
90ce3da70b43 Initial load
duke
parents:
diff changeset
   378
     * creates a datagram socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   379
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   380
     * If the application has specified a server socket factory, that
90ce3da70b43 Initial load
duke
parents:
diff changeset
   381
     * factory's <code>createSocketImpl</code> method is called to create
90ce3da70b43 Initial load
duke
parents:
diff changeset
   382
     * the actual socket implementation. Otherwise a "plain" socket is created.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   383
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   384
     * <p>If there is a security manager, its
90ce3da70b43 Initial load
duke
parents:
diff changeset
   385
     * <code>checkConnect</code> method is called
90ce3da70b43 Initial load
duke
parents:
diff changeset
   386
     * with <code>host.getHostAddress()</code> and <code>port</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   387
     * as its arguments. This could result in a SecurityException.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   388
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   389
     * If UDP socket is used, TCP/IP related socket options will not apply.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   390
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   391
     * @param      host     the IP address.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   392
     * @param      port      the port number.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   393
     * @param      stream    if <code>true</code>, create a stream socket;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   394
     *                       otherwise, create a datagram socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   395
     * @exception  IOException  if an I/O error occurs when creating the socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   396
     * @exception  SecurityException  if a security manager exists and its
90ce3da70b43 Initial load
duke
parents:
diff changeset
   397
     *             <code>checkConnect</code> method doesn't allow the operation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   398
     * @exception  IllegalArgumentException if the port parameter is outside
90ce3da70b43 Initial load
duke
parents:
diff changeset
   399
     *             the specified range of valid port values, which is between
90ce3da70b43 Initial load
duke
parents:
diff changeset
   400
     *             0 and 65535, inclusive.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   401
     * @exception  NullPointerException if <code>host</code> is null.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   402
     * @see        java.net.Socket#setSocketImplFactory(java.net.SocketImplFactory)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   403
     * @see        java.net.SocketImpl
90ce3da70b43 Initial load
duke
parents:
diff changeset
   404
     * @see        java.net.SocketImplFactory#createSocketImpl()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   405
     * @see        SecurityManager#checkConnect
90ce3da70b43 Initial load
duke
parents:
diff changeset
   406
     * @deprecated Use DatagramSocket instead for UDP transport.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   407
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   408
    @Deprecated
90ce3da70b43 Initial load
duke
parents:
diff changeset
   409
    public Socket(InetAddress host, int port, boolean stream) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   410
        this(host != null ? new InetSocketAddress(host, port) : null,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   411
             new InetSocketAddress(0), stream);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   412
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   413
90ce3da70b43 Initial load
duke
parents:
diff changeset
   414
    private Socket(SocketAddress address, SocketAddress localAddr,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   415
                   boolean stream) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   416
        setImpl();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   417
90ce3da70b43 Initial load
duke
parents:
diff changeset
   418
        // backward compatibility
90ce3da70b43 Initial load
duke
parents:
diff changeset
   419
        if (address == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   420
            throw new NullPointerException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   421
90ce3da70b43 Initial load
duke
parents:
diff changeset
   422
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   423
            createImpl(stream);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   424
            if (localAddr != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   425
                bind(localAddr);
10439
b36f86ad26e1 7088747: Use multicatch in Socket constructor
michaelm
parents: 10437
diff changeset
   426
            connect(address);
b36f86ad26e1 7088747: Use multicatch in Socket constructor
michaelm
parents: 10437
diff changeset
   427
        } catch (IOException | IllegalArgumentException | SecurityException e) {
b36f86ad26e1 7088747: Use multicatch in Socket constructor
michaelm
parents: 10437
diff changeset
   428
            try {
b36f86ad26e1 7088747: Use multicatch in Socket constructor
michaelm
parents: 10437
diff changeset
   429
                close();
b36f86ad26e1 7088747: Use multicatch in Socket constructor
michaelm
parents: 10437
diff changeset
   430
            } catch (IOException ce) {
b36f86ad26e1 7088747: Use multicatch in Socket constructor
michaelm
parents: 10437
diff changeset
   431
                e.addSuppressed(ce);
b36f86ad26e1 7088747: Use multicatch in Socket constructor
michaelm
parents: 10437
diff changeset
   432
            }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   433
            throw e;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   434
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   435
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   436
90ce3da70b43 Initial load
duke
parents:
diff changeset
   437
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   438
     * Creates the socket implementation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   439
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   440
     * @param stream a <code>boolean</code> value : <code>true</code> for a TCP socket,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   441
     *               <code>false</code> for UDP.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   442
     * @throws IOException if creation fails
90ce3da70b43 Initial load
duke
parents:
diff changeset
   443
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   444
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   445
     void createImpl(boolean stream) throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   446
        if (impl == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   447
            setImpl();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   448
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   449
            impl.create(stream);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   450
            created = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   451
        } catch (IOException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   452
            throw new SocketException(e.getMessage());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   453
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   454
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   455
90ce3da70b43 Initial load
duke
parents:
diff changeset
   456
    private void checkOldImpl() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   457
        if (impl == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   458
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   459
        // SocketImpl.connect() is a protected method, therefore we need to use
90ce3da70b43 Initial load
duke
parents:
diff changeset
   460
        // getDeclaredMethod, therefore we need permission to access the member
90ce3da70b43 Initial load
duke
parents:
diff changeset
   461
90ce3da70b43 Initial load
duke
parents:
diff changeset
   462
        oldImpl = AccessController.doPrivileged
90ce3da70b43 Initial load
duke
parents:
diff changeset
   463
                                (new PrivilegedAction<Boolean>() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   464
            public Boolean run() {
10596
39b3a979e600 7090158: Networking Libraries don't build with javac -Werror
chegar
parents: 10439
diff changeset
   465
                Class<?> clazz = impl.getClass();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   466
                while (true) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   467
                    try {
10596
39b3a979e600 7090158: Networking Libraries don't build with javac -Werror
chegar
parents: 10439
diff changeset
   468
                        clazz.getDeclaredMethod("connect", SocketAddress.class, int.class);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   469
                        return Boolean.FALSE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   470
                    } catch (NoSuchMethodException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   471
                        clazz = clazz.getSuperclass();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   472
                        // java.net.SocketImpl class will always have this abstract method.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   473
                        // If we have not found it by now in the hierarchy then it does not
90ce3da70b43 Initial load
duke
parents:
diff changeset
   474
                        // exist, we are an old style impl.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   475
                        if (clazz.equals(java.net.SocketImpl.class)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   476
                            return Boolean.TRUE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   477
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   478
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   479
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   480
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   481
        });
90ce3da70b43 Initial load
duke
parents:
diff changeset
   482
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   483
90ce3da70b43 Initial load
duke
parents:
diff changeset
   484
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   485
     * Sets impl to the system-default type of SocketImpl.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   486
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   487
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   488
    void setImpl() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   489
        if (factory != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   490
            impl = factory.createSocketImpl();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   491
            checkOldImpl();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   492
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   493
            // No need to do a checkOldImpl() here, we know it's an up to date
90ce3da70b43 Initial load
duke
parents:
diff changeset
   494
            // SocketImpl!
90ce3da70b43 Initial load
duke
parents:
diff changeset
   495
            impl = new SocksSocketImpl();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   496
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   497
        if (impl != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   498
            impl.setSocket(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   499
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   500
90ce3da70b43 Initial load
duke
parents:
diff changeset
   501
90ce3da70b43 Initial load
duke
parents:
diff changeset
   502
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   503
     * Get the <code>SocketImpl</code> attached to this socket, creating
90ce3da70b43 Initial load
duke
parents:
diff changeset
   504
     * it if necessary.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   505
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   506
     * @return  the <code>SocketImpl</code> attached to that ServerSocket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   507
     * @throws SocketException if creation fails
90ce3da70b43 Initial load
duke
parents:
diff changeset
   508
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   509
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   510
    SocketImpl getImpl() throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   511
        if (!created)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   512
            createImpl(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   513
        return impl;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   514
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   515
90ce3da70b43 Initial load
duke
parents:
diff changeset
   516
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   517
     * Connects this socket to the server.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   518
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   519
     * @param   endpoint the <code>SocketAddress</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   520
     * @throws  IOException if an error occurs during the connection
90ce3da70b43 Initial load
duke
parents:
diff changeset
   521
     * @throws  java.nio.channels.IllegalBlockingModeException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   522
     *          if this socket has an associated channel,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   523
     *          and the channel is in non-blocking mode
90ce3da70b43 Initial load
duke
parents:
diff changeset
   524
     * @throws  IllegalArgumentException if endpoint is null or is a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   525
     *          SocketAddress subclass not supported by this socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
   526
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   527
     * @spec JSR-51
90ce3da70b43 Initial load
duke
parents:
diff changeset
   528
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   529
    public void connect(SocketAddress endpoint) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   530
        connect(endpoint, 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   531
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   532
90ce3da70b43 Initial load
duke
parents:
diff changeset
   533
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   534
     * Connects this socket to the server with a specified timeout value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   535
     * A timeout of zero is interpreted as an infinite timeout. The connection
90ce3da70b43 Initial load
duke
parents:
diff changeset
   536
     * will then block until established or an error occurs.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   537
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   538
     * @param   endpoint the <code>SocketAddress</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   539
     * @param   timeout  the timeout value to be used in milliseconds.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   540
     * @throws  IOException if an error occurs during the connection
90ce3da70b43 Initial load
duke
parents:
diff changeset
   541
     * @throws  SocketTimeoutException if timeout expires before connecting
90ce3da70b43 Initial load
duke
parents:
diff changeset
   542
     * @throws  java.nio.channels.IllegalBlockingModeException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   543
     *          if this socket has an associated channel,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   544
     *          and the channel is in non-blocking mode
90ce3da70b43 Initial load
duke
parents:
diff changeset
   545
     * @throws  IllegalArgumentException if endpoint is null or is a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   546
     *          SocketAddress subclass not supported by this socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
   547
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   548
     * @spec JSR-51
90ce3da70b43 Initial load
duke
parents:
diff changeset
   549
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   550
    public void connect(SocketAddress endpoint, int timeout) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   551
        if (endpoint == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   552
            throw new IllegalArgumentException("connect: The address can't be null");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   553
90ce3da70b43 Initial load
duke
parents:
diff changeset
   554
        if (timeout < 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   555
          throw new IllegalArgumentException("connect: timeout can't be negative");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   556
90ce3da70b43 Initial load
duke
parents:
diff changeset
   557
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   558
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   559
90ce3da70b43 Initial load
duke
parents:
diff changeset
   560
        if (!oldImpl && isConnected())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   561
            throw new SocketException("already connected");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   562
90ce3da70b43 Initial load
duke
parents:
diff changeset
   563
        if (!(endpoint instanceof InetSocketAddress))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   564
            throw new IllegalArgumentException("Unsupported address type");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   565
90ce3da70b43 Initial load
duke
parents:
diff changeset
   566
        InetSocketAddress epoint = (InetSocketAddress) endpoint;
5180
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   567
        InetAddress addr = epoint.getAddress ();
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   568
        int port = epoint.getPort();
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   569
        checkAddress(addr, "connect");
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   570
90ce3da70b43 Initial load
duke
parents:
diff changeset
   571
        SecurityManager security = System.getSecurityManager();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   572
        if (security != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   573
            if (epoint.isUnresolved())
5180
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   574
                security.checkConnect(epoint.getHostName(), port);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   575
            else
5180
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   576
                security.checkConnect(addr.getHostAddress(), port);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   577
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   578
        if (!created)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   579
            createImpl(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   580
        if (!oldImpl)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   581
            impl.connect(epoint, timeout);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   582
        else if (timeout == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   583
            if (epoint.isUnresolved())
5180
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   584
                impl.connect(addr.getHostName(), port);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   585
            else
5180
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   586
                impl.connect(addr, port);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   587
        } else
90ce3da70b43 Initial load
duke
parents:
diff changeset
   588
            throw new UnsupportedOperationException("SocketImpl.connect(addr, timeout)");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   589
        connected = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   590
        /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   591
         * If the socket was not bound before the connect, it is now because
90ce3da70b43 Initial load
duke
parents:
diff changeset
   592
         * the kernel will have picked an ephemeral port & a local address
90ce3da70b43 Initial load
duke
parents:
diff changeset
   593
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   594
        bound = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   595
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   596
90ce3da70b43 Initial load
duke
parents:
diff changeset
   597
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   598
     * Binds the socket to a local address.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   599
     * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   600
     * If the address is <code>null</code>, then the system will pick up
90ce3da70b43 Initial load
duke
parents:
diff changeset
   601
     * an ephemeral port and a valid local address to bind the socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   602
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   603
     * @param   bindpoint the <code>SocketAddress</code> to bind to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   604
     * @throws  IOException if the bind operation fails, or if the socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
   605
     *                     is already bound.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   606
     * @throws  IllegalArgumentException if bindpoint is a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   607
     *          SocketAddress subclass not supported by this socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
   608
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   609
     * @since   1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   610
     * @see #isBound
90ce3da70b43 Initial load
duke
parents:
diff changeset
   611
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   612
    public void bind(SocketAddress bindpoint) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   613
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   614
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   615
        if (!oldImpl && isBound())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   616
            throw new SocketException("Already bound");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   617
90ce3da70b43 Initial load
duke
parents:
diff changeset
   618
        if (bindpoint != null && (!(bindpoint instanceof InetSocketAddress)))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   619
            throw new IllegalArgumentException("Unsupported address type");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   620
        InetSocketAddress epoint = (InetSocketAddress) bindpoint;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   621
        if (epoint != null && epoint.isUnresolved())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   622
            throw new SocketException("Unresolved address");
5180
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   623
        if (epoint == null) {
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   624
            epoint = new InetSocketAddress(0);
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   625
        }
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   626
        InetAddress addr = epoint.getAddress();
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   627
        int port = epoint.getPort();
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   628
        checkAddress (addr, "bind");
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   629
        getImpl().bind (addr, port);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   630
        bound = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   631
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   632
5180
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   633
    private void checkAddress (InetAddress addr, String op) {
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   634
        if (addr == null) {
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   635
            return;
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   636
        }
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   637
        if (!(addr instanceof Inet4Address || addr instanceof Inet6Address)) {
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   638
            throw new IllegalArgumentException(op + ": invalid address type");
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   639
        }
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   640
    }
8161f879d704 6893954: Subclasses of InetAddress may incorrectly interpret network addresses
michaelm
parents: 3450
diff changeset
   641
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   642
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   643
     * set the flags after an accept() call.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   644
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   645
    final void postAccept() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   646
        connected = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   647
        created = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   648
        bound = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   649
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   650
90ce3da70b43 Initial load
duke
parents:
diff changeset
   651
    void setCreated() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   652
        created = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   653
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   654
90ce3da70b43 Initial load
duke
parents:
diff changeset
   655
    void setBound() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   656
        bound = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   657
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   658
90ce3da70b43 Initial load
duke
parents:
diff changeset
   659
    void setConnected() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   660
        connected = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   661
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   662
90ce3da70b43 Initial load
duke
parents:
diff changeset
   663
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   664
     * Returns the address to which the socket is connected.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   665
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   666
     * If the socket was connected prior to being {@link #close closed},
90ce3da70b43 Initial load
duke
parents:
diff changeset
   667
     * then this method will continue to return the connected address
90ce3da70b43 Initial load
duke
parents:
diff changeset
   668
     * after the socket is closed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   669
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   670
     * @return  the remote IP address to which this socket is connected,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   671
     *          or <code>null</code> if the socket is not connected.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   672
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   673
    public InetAddress getInetAddress() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   674
        if (!isConnected())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   675
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   676
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   677
            return getImpl().getInetAddress();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   678
        } catch (SocketException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   679
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   680
        return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   681
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   682
90ce3da70b43 Initial load
duke
parents:
diff changeset
   683
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   684
     * Gets the local address to which the socket is bound.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   685
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   686
     * @return the local address to which the socket is bound, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   687
     *         the {@link InetAddress#isAnyLocalAddress wildcard} address
90ce3da70b43 Initial load
duke
parents:
diff changeset
   688
     *         if the socket is closed or not bound yet.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   689
     * @since   JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
   690
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   691
    public InetAddress getLocalAddress() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   692
        // This is for backward compatibility
90ce3da70b43 Initial load
duke
parents:
diff changeset
   693
        if (!isBound())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   694
            return InetAddress.anyLocalAddress();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   695
        InetAddress in = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   696
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   697
            in = (InetAddress) getImpl().getOption(SocketOptions.SO_BINDADDR);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   698
            if (in.isAnyLocalAddress()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   699
                in = InetAddress.anyLocalAddress();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   700
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   701
        } catch (Exception e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   702
            in = InetAddress.anyLocalAddress(); // "0.0.0.0"
90ce3da70b43 Initial load
duke
parents:
diff changeset
   703
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   704
        return in;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   705
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   706
90ce3da70b43 Initial load
duke
parents:
diff changeset
   707
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   708
     * Returns the remote port number to which this socket is connected.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   709
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   710
     * If the socket was connected prior to being {@link #close closed},
90ce3da70b43 Initial load
duke
parents:
diff changeset
   711
     * then this method will continue to return the connected port number
90ce3da70b43 Initial load
duke
parents:
diff changeset
   712
     * after the socket is closed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   713
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   714
     * @return  the remote port number to which this socket is connected, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   715
     *          0 if the socket is not connected yet.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   716
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   717
    public int getPort() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   718
        if (!isConnected())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   719
            return 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   720
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   721
            return getImpl().getPort();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   722
        } catch (SocketException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   723
            // Shouldn't happen as we're connected
90ce3da70b43 Initial load
duke
parents:
diff changeset
   724
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   725
        return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   726
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   727
90ce3da70b43 Initial load
duke
parents:
diff changeset
   728
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   729
     * Returns the local port number to which this socket is bound.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   730
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   731
     * If the socket was bound prior to being {@link #close closed},
90ce3da70b43 Initial load
duke
parents:
diff changeset
   732
     * then this method will continue to return the local port number
90ce3da70b43 Initial load
duke
parents:
diff changeset
   733
     * after the socket is closed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   734
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   735
     * @return  the local port number to which this socket is bound or -1
90ce3da70b43 Initial load
duke
parents:
diff changeset
   736
     *          if the socket is not bound yet.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   737
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   738
    public int getLocalPort() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   739
        if (!isBound())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   740
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   741
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   742
            return getImpl().getLocalPort();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   743
        } catch(SocketException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   744
            // shouldn't happen as we're bound
90ce3da70b43 Initial load
duke
parents:
diff changeset
   745
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   746
        return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   747
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   748
90ce3da70b43 Initial load
duke
parents:
diff changeset
   749
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   750
     * Returns the address of the endpoint this socket is connected to, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   751
     * <code>null</code> if it is unconnected.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   752
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   753
     * If the socket was connected prior to being {@link #close closed},
90ce3da70b43 Initial load
duke
parents:
diff changeset
   754
     * then this method will continue to return the connected address
90ce3da70b43 Initial load
duke
parents:
diff changeset
   755
     * after the socket is closed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   756
     *
94
wetmore
parents: 81 51
diff changeset
   757
81
c2d2c408d6ed 6667108: typo in javadoc for java.net.Socket.getRemoteSocketAddress()
chegar
parents: 2
diff changeset
   758
     * @return a <code>SocketAddress</code> representing the remote endpoint of this
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   759
     *         socket, or <code>null</code> if it is not connected yet.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   760
     * @see #getInetAddress()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   761
     * @see #getPort()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   762
     * @see #connect(SocketAddress, int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   763
     * @see #connect(SocketAddress)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   764
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   765
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   766
    public SocketAddress getRemoteSocketAddress() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   767
        if (!isConnected())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   768
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   769
        return new InetSocketAddress(getInetAddress(), getPort());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   770
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   771
90ce3da70b43 Initial load
duke
parents:
diff changeset
   772
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   773
     * Returns the address of the endpoint this socket is bound to, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   774
     * <code>null</code> if it is not bound yet.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   775
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   776
     * If a socket bound to an endpoint represented by an
90ce3da70b43 Initial load
duke
parents:
diff changeset
   777
     * <code>InetSocketAddress </code> is {@link #close closed},
90ce3da70b43 Initial load
duke
parents:
diff changeset
   778
     * then this method will continue to return an <code>InetSocketAddress</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   779
     * after the socket is closed. In that case the returned
90ce3da70b43 Initial load
duke
parents:
diff changeset
   780
     * <code>InetSocketAddress</code>'s address is the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   781
     * {@link InetAddress#isAnyLocalAddress wildcard} address
90ce3da70b43 Initial load
duke
parents:
diff changeset
   782
     * and its port is the local port that it was bound to.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   783
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   784
     * @return a <code>SocketAddress</code> representing the local endpoint of this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   785
     *         socket, or <code>null</code> if it is not bound yet.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   786
     * @see #getLocalAddress()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   787
     * @see #getLocalPort()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   788
     * @see #bind(SocketAddress)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   789
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   790
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   791
90ce3da70b43 Initial load
duke
parents:
diff changeset
   792
    public SocketAddress getLocalSocketAddress() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   793
        if (!isBound())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   794
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   795
        return new InetSocketAddress(getLocalAddress(), getLocalPort());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   796
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   797
90ce3da70b43 Initial load
duke
parents:
diff changeset
   798
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   799
     * Returns the unique {@link java.nio.channels.SocketChannel SocketChannel}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   800
     * object associated with this socket, if any.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   801
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   802
     * <p> A socket will have a channel if, and only if, the channel itself was
90ce3da70b43 Initial load
duke
parents:
diff changeset
   803
     * created via the {@link java.nio.channels.SocketChannel#open
90ce3da70b43 Initial load
duke
parents:
diff changeset
   804
     * SocketChannel.open} or {@link
90ce3da70b43 Initial load
duke
parents:
diff changeset
   805
     * java.nio.channels.ServerSocketChannel#accept ServerSocketChannel.accept}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   806
     * methods.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   807
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   808
     * @return  the socket channel associated with this socket,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   809
     *          or <tt>null</tt> if this socket was not created
90ce3da70b43 Initial load
duke
parents:
diff changeset
   810
     *          for a channel
90ce3da70b43 Initial load
duke
parents:
diff changeset
   811
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   812
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   813
     * @spec JSR-51
90ce3da70b43 Initial load
duke
parents:
diff changeset
   814
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   815
    public SocketChannel getChannel() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   816
        return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   817
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   818
90ce3da70b43 Initial load
duke
parents:
diff changeset
   819
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   820
     * Returns an input stream for this socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   821
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   822
     * <p> If this socket has an associated channel then the resulting input
90ce3da70b43 Initial load
duke
parents:
diff changeset
   823
     * stream delegates all of its operations to the channel.  If the channel
90ce3da70b43 Initial load
duke
parents:
diff changeset
   824
     * is in non-blocking mode then the input stream's <tt>read</tt> operations
90ce3da70b43 Initial load
duke
parents:
diff changeset
   825
     * will throw an {@link java.nio.channels.IllegalBlockingModeException}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   826
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   827
     * <p>Under abnormal conditions the underlying connection may be
90ce3da70b43 Initial load
duke
parents:
diff changeset
   828
     * broken by the remote host or the network software (for example
90ce3da70b43 Initial load
duke
parents:
diff changeset
   829
     * a connection reset in the case of TCP connections). When a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   830
     * broken connection is detected by the network software the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   831
     * following applies to the returned input stream :-
90ce3da70b43 Initial load
duke
parents:
diff changeset
   832
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   833
     * <ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   834
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   835
     *   <li><p>The network software may discard bytes that are buffered
90ce3da70b43 Initial load
duke
parents:
diff changeset
   836
     *   by the socket. Bytes that aren't discarded by the network
90ce3da70b43 Initial load
duke
parents:
diff changeset
   837
     *   software can be read using {@link java.io.InputStream#read read}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   838
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   839
     *   <li><p>If there are no bytes buffered on the socket, or all
90ce3da70b43 Initial load
duke
parents:
diff changeset
   840
     *   buffered bytes have been consumed by
90ce3da70b43 Initial load
duke
parents:
diff changeset
   841
     *   {@link java.io.InputStream#read read}, then all subsequent
90ce3da70b43 Initial load
duke
parents:
diff changeset
   842
     *   calls to {@link java.io.InputStream#read read} will throw an
90ce3da70b43 Initial load
duke
parents:
diff changeset
   843
     *   {@link java.io.IOException IOException}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   844
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   845
     *   <li><p>If there are no bytes buffered on the socket, and the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   846
     *   socket has not been closed using {@link #close close}, then
90ce3da70b43 Initial load
duke
parents:
diff changeset
   847
     *   {@link java.io.InputStream#available available} will
90ce3da70b43 Initial load
duke
parents:
diff changeset
   848
     *   return <code>0</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   849
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   850
     * </ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   851
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   852
     * <p> Closing the returned {@link java.io.InputStream InputStream}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   853
     * will close the associated socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   854
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   855
     * @return     an input stream for reading bytes from this socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   856
     * @exception  IOException  if an I/O error occurs when creating the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   857
     *             input stream, the socket is closed, the socket is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   858
     *             not connected, or the socket input has been shutdown
90ce3da70b43 Initial load
duke
parents:
diff changeset
   859
     *             using {@link #shutdownInput()}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   860
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   861
     * @revised 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   862
     * @spec JSR-51
90ce3da70b43 Initial load
duke
parents:
diff changeset
   863
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   864
    public InputStream getInputStream() throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   865
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   866
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   867
        if (!isConnected())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   868
            throw new SocketException("Socket is not connected");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   869
        if (isInputShutdown())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   870
            throw new SocketException("Socket input is shutdown");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   871
        final Socket s = this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   872
        InputStream is = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   873
        try {
51
6fe31bc95bbc 6600143: Remove another 450 unnecessary casts
martin
parents: 2
diff changeset
   874
            is = AccessController.doPrivileged(
6fe31bc95bbc 6600143: Remove another 450 unnecessary casts
martin
parents: 2
diff changeset
   875
                new PrivilegedExceptionAction<InputStream>() {
6fe31bc95bbc 6600143: Remove another 450 unnecessary casts
martin
parents: 2
diff changeset
   876
                    public InputStream run() throws IOException {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   877
                        return impl.getInputStream();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   878
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   879
                });
90ce3da70b43 Initial load
duke
parents:
diff changeset
   880
        } catch (java.security.PrivilegedActionException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   881
            throw (IOException) e.getException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   882
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   883
        return is;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   884
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   885
90ce3da70b43 Initial load
duke
parents:
diff changeset
   886
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   887
     * Returns an output stream for this socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   888
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   889
     * <p> If this socket has an associated channel then the resulting output
90ce3da70b43 Initial load
duke
parents:
diff changeset
   890
     * stream delegates all of its operations to the channel.  If the channel
90ce3da70b43 Initial load
duke
parents:
diff changeset
   891
     * is in non-blocking mode then the output stream's <tt>write</tt>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   892
     * operations will throw an {@link
90ce3da70b43 Initial load
duke
parents:
diff changeset
   893
     * java.nio.channels.IllegalBlockingModeException}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   894
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   895
     * <p> Closing the returned {@link java.io.OutputStream OutputStream}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   896
     * will close the associated socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   897
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   898
     * @return     an output stream for writing bytes to this socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   899
     * @exception  IOException  if an I/O error occurs when creating the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   900
     *               output stream or if the socket is not connected.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   901
     * @revised 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   902
     * @spec JSR-51
90ce3da70b43 Initial load
duke
parents:
diff changeset
   903
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   904
    public OutputStream getOutputStream() throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   905
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   906
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   907
        if (!isConnected())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   908
            throw new SocketException("Socket is not connected");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   909
        if (isOutputShutdown())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   910
            throw new SocketException("Socket output is shutdown");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   911
        final Socket s = this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   912
        OutputStream os = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   913
        try {
51
6fe31bc95bbc 6600143: Remove another 450 unnecessary casts
martin
parents: 2
diff changeset
   914
            os = AccessController.doPrivileged(
6fe31bc95bbc 6600143: Remove another 450 unnecessary casts
martin
parents: 2
diff changeset
   915
                new PrivilegedExceptionAction<OutputStream>() {
6fe31bc95bbc 6600143: Remove another 450 unnecessary casts
martin
parents: 2
diff changeset
   916
                    public OutputStream run() throws IOException {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   917
                        return impl.getOutputStream();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   918
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   919
                });
90ce3da70b43 Initial load
duke
parents:
diff changeset
   920
        } catch (java.security.PrivilegedActionException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   921
            throw (IOException) e.getException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   922
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   923
        return os;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   924
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   925
90ce3da70b43 Initial load
duke
parents:
diff changeset
   926
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
   927
     * Enable/disable {@link SocketOptions#TCP_NODELAY TCP_NODELAY}
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
   928
     * (disable/enable Nagle's algorithm).
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   929
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   930
     * @param on <code>true</code> to enable TCP_NODELAY,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   931
     * <code>false</code> to disable.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   932
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   933
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
   934
     * in the underlying protocol, such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   935
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   936
     * @since   JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
   937
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   938
     * @see #getTcpNoDelay()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   939
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   940
    public void setTcpNoDelay(boolean on) throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   941
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   942
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   943
        getImpl().setOption(SocketOptions.TCP_NODELAY, Boolean.valueOf(on));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   944
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   945
90ce3da70b43 Initial load
duke
parents:
diff changeset
   946
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
   947
     * Tests if {@link SocketOptions#TCP_NODELAY TCP_NODELAY} is enabled.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   948
     *
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
   949
     * @return a <code>boolean</code> indicating whether or not
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
   950
     *         {@link SocketOptions#TCP_NODELAY TCP_NODELAY} is enabled.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   951
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
   952
     * in the underlying protocol, such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   953
     * @since   JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
   954
     * @see #setTcpNoDelay(boolean)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   955
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   956
    public boolean getTcpNoDelay() throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   957
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   958
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   959
        return ((Boolean) getImpl().getOption(SocketOptions.TCP_NODELAY)).booleanValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   960
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   961
90ce3da70b43 Initial load
duke
parents:
diff changeset
   962
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
   963
     * Enable/disable {@link SocketOptions#SO_LINGER SO_LINGER} with the
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
   964
     * specified linger time in seconds. The maximum timeout value is platform
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
   965
     * specific.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   966
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   967
     * The setting only affects socket close.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   968
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   969
     * @param on     whether or not to linger on.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   970
     * @param linger how long to linger for, if on is true.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   971
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
   972
     * in the underlying protocol, such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   973
     * @exception IllegalArgumentException if the linger value is negative.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   974
     * @since JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
   975
     * @see #getSoLinger()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   976
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   977
    public void setSoLinger(boolean on, int linger) throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   978
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   979
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   980
        if (!on) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   981
            getImpl().setOption(SocketOptions.SO_LINGER, new Boolean(on));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   982
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   983
            if (linger < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   984
                throw new IllegalArgumentException("invalid value for SO_LINGER");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   985
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   986
            if (linger > 65535)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   987
                linger = 65535;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   988
            getImpl().setOption(SocketOptions.SO_LINGER, new Integer(linger));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   989
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   990
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   991
90ce3da70b43 Initial load
duke
parents:
diff changeset
   992
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
   993
     * Returns setting for {@link SocketOptions#SO_LINGER SO_LINGER}.
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
   994
     * -1 returns implies that the
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   995
     * option is disabled.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   996
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   997
     * The setting only affects socket close.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   998
     *
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
   999
     * @return the setting for {@link SocketOptions#SO_LINGER SO_LINGER}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1000
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1001
     * in the underlying protocol, such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1002
     * @since   JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1003
     * @see #setSoLinger(boolean, int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1004
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1005
    public int getSoLinger() throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1006
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1007
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1008
        Object o = getImpl().getOption(SocketOptions.SO_LINGER);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1009
        if (o instanceof Integer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1010
            return ((Integer) o).intValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1011
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1012
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1013
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1014
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1015
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1016
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1017
     * Send one byte of urgent data on the socket. The byte to be sent is the lowest eight
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1018
     * bits of the data parameter. The urgent byte is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1019
     * sent after any preceding writes to the socket OutputStream
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1020
     * and before any future writes to the OutputStream.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1021
     * @param data The byte of data to send
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1022
     * @exception IOException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1023
     *  sending the data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1024
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1025
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1026
    public void sendUrgentData (int data) throws IOException  {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1027
        if (!getImpl().supportsUrgentData ()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1028
            throw new SocketException ("Urgent data not supported");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1029
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1030
        getImpl().sendUrgentData (data);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1031
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1032
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1033
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1034
     * Enable/disable {@link SocketOptions#SO_OOBINLINE SO_OOBINLINE}
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1035
     * (receipt of TCP urgent data)
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1036
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1037
     * By default, this option is disabled and TCP urgent data received on a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1038
     * socket is silently discarded. If the user wishes to receive urgent data, then
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1039
     * this option must be enabled. When enabled, urgent data is received
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1040
     * inline with normal data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1041
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1042
     * Note, only limited support is provided for handling incoming urgent
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1043
     * data. In particular, no notification of incoming urgent data is provided
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1044
     * and there is no capability to distinguish between normal data and urgent
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1045
     * data unless provided by a higher level protocol.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1046
     *
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1047
     * @param on <code>true</code> to enable
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1048
     *           {@link SocketOptions#SO_OOBINLINE SO_OOBINLINE},
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1049
     *           <code>false</code> to disable.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1050
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1051
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1052
     * in the underlying protocol, such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1053
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1054
     * @since   1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1055
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1056
     * @see #getOOBInline()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1057
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1058
    public void setOOBInline(boolean on) throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1059
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1060
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1061
        getImpl().setOption(SocketOptions.SO_OOBINLINE, Boolean.valueOf(on));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1062
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1063
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1064
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1065
     * Tests if {@link SocketOptions#SO_OOBINLINE SO_OOBINLINE} is enabled.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1066
     *
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1067
     * @return a <code>boolean</code> indicating whether or not
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1068
     *         {@link SocketOptions#SO_OOBINLINE SO_OOBINLINE}is enabled.
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1069
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1070
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1071
     * in the underlying protocol, such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1072
     * @since   1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1073
     * @see #setOOBInline(boolean)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1074
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1075
    public boolean getOOBInline() throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1076
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1077
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1078
        return ((Boolean) getImpl().getOption(SocketOptions.SO_OOBINLINE)).booleanValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1079
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1080
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1081
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1082
     *  Enable/disable {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT}
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1083
     *  with the specified timeout, in milliseconds. With this option set
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1084
     *  to a non-zero timeout, a read() call on the InputStream associated with
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1085
     *  this Socket will block for only this amount of time.  If the timeout
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1086
     *  expires, a <B>java.net.SocketTimeoutException</B> is raised, though the
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1087
     *  Socket is still valid. The option <B>must</B> be enabled
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1088
     *  prior to entering the blocking operation to have effect. The
18156
edb590d448c5 8016217: More javadoc warnings
alanb
parents: 17469
diff changeset
  1089
     *  timeout must be {@code > 0}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1090
     *  A timeout of zero is interpreted as an infinite timeout.
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1091
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1092
     * @param timeout the specified timeout, in milliseconds.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1093
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1094
     * in the underlying protocol, such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1095
     * @since   JDK 1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1096
     * @see #getSoTimeout()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1097
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1098
    public synchronized void setSoTimeout(int timeout) throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1099
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1100
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1101
        if (timeout < 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1102
          throw new IllegalArgumentException("timeout can't be negative");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1103
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1104
        getImpl().setOption(SocketOptions.SO_TIMEOUT, new Integer(timeout));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1105
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1106
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1107
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1108
     * Returns setting for {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT}.
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1109
     * 0 returns implies that the option is disabled (i.e., timeout of infinity).
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1110
     *
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1111
     * @return the setting for {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT}
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1112
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1113
     * in the underlying protocol, such as a TCP error.
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1114
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1115
     * @since   JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1116
     * @see #setSoTimeout(int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1117
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1118
    public synchronized int getSoTimeout() throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1119
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1120
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1121
        Object o = getImpl().getOption(SocketOptions.SO_TIMEOUT);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1122
        /* extra type safety */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1123
        if (o instanceof Integer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1124
            return ((Integer) o).intValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1125
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1126
            return 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1127
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1128
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1129
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1130
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1131
     * Sets the {@link SocketOptions#SO_SNDBUF SO_SNDBUF} option to the
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1132
     * specified value for this <tt>Socket</tt>.
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1133
     * The {@link SocketOptions#SO_SNDBUF SO_SNDBUF} option is used by the
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1134
     * platform's networking code as a hint for the size to set the underlying
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1135
     * network I/O buffers.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1136
     *
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1137
     * <p>Because {@link SocketOptions#SO_SNDBUF SO_SNDBUF} is a hint,
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1138
     * applications that want to verify what size the buffers were set to
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1139
     * should call {@link #getSendBufferSize()}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1140
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1141
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1142
     * in the underlying protocol, such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1143
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1144
     * @param size the size to which to set the send buffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1145
     * size. This value must be greater than 0.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1146
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1147
     * @exception IllegalArgumentException if the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1148
     * value is 0 or is negative.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1149
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1150
     * @see #getSendBufferSize()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1151
     * @since 1.2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1152
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1153
    public synchronized void setSendBufferSize(int size)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1154
    throws SocketException{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1155
        if (!(size > 0)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1156
            throw new IllegalArgumentException("negative send size");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1157
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1158
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1159
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1160
        getImpl().setOption(SocketOptions.SO_SNDBUF, new Integer(size));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1161
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1162
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1163
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1164
     * Get value of the {@link SocketOptions#SO_SNDBUF SO_SNDBUF} option
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1165
     * for this <tt>Socket</tt>, that is the buffer size used by the platform
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1166
     * for output on this <tt>Socket</tt>.
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1167
     * @return the value of the {@link SocketOptions#SO_SNDBUF SO_SNDBUF}
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1168
     *         option for this <tt>Socket</tt>.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1169
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1170
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1171
     * in the underlying protocol, such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1172
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1173
     * @see #setSendBufferSize(int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1174
     * @since 1.2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1175
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1176
    public synchronized int getSendBufferSize() throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1177
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1178
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1179
        int result = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1180
        Object o = getImpl().getOption(SocketOptions.SO_SNDBUF);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1181
        if (o instanceof Integer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1182
            result = ((Integer)o).intValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1183
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1184
        return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1185
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1186
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1187
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1188
     * Sets the {@link SocketOptions#SO_RCVBUF SO_RCVBUF} option to the
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1189
     * specified value for this <tt>Socket</tt>. The
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1190
     * {@link SocketOptions#SO_RCVBUF SO_RCVBUF} option is
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1191
     * used by the platform's networking code as a hint for the size to set
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1192
     * the underlying network I/O buffers.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1193
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1194
     * <p>Increasing the receive buffer size can increase the performance of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1195
     * network I/O for high-volume connection, while decreasing it can
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1196
     * help reduce the backlog of incoming data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1197
     *
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1198
     * <p>Because {@link SocketOptions#SO_RCVBUF SO_RCVBUF} is a hint,
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1199
     * applications that want to verify what size the buffers were set to
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1200
     * should call {@link #getReceiveBufferSize()}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1201
     *
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1202
     * <p>The value of {@link SocketOptions#SO_RCVBUF SO_RCVBUF} is also used
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1203
     * to set the TCP receive window that is advertized to the remote peer.
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1204
     * Generally, the window size can be modified at any time when a socket is
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1205
     * connected. However, if a receive window larger than 64K is required then
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1206
     * this must be requested <B>before</B> the socket is connected to the
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1207
     * remote peer. There are two cases to be aware of:<p>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1208
     * <ol>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1209
     * <li>For sockets accepted from a ServerSocket, this must be done by calling
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1210
     * {@link ServerSocket#setReceiveBufferSize(int)} before the ServerSocket
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1211
     * is bound to a local address.<p></li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1212
     * <li>For client sockets, setReceiveBufferSize() must be called before
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1213
     * connecting the socket to its remote peer.<p></li></ol>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1214
     * @param size the size to which to set the receive buffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1215
     * size. This value must be greater than 0.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1216
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1217
     * @exception IllegalArgumentException if the value is 0 or is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1218
     * negative.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1219
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1220
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1221
     * in the underlying protocol, such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1222
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1223
     * @see #getReceiveBufferSize()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1224
     * @see ServerSocket#setReceiveBufferSize(int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1225
     * @since 1.2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1226
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1227
    public synchronized void setReceiveBufferSize(int size)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1228
    throws SocketException{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1229
        if (size <= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1230
            throw new IllegalArgumentException("invalid receive size");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1231
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1232
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1233
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1234
        getImpl().setOption(SocketOptions.SO_RCVBUF, new Integer(size));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1235
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1236
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1237
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1238
     * Gets the value of the {@link SocketOptions#SO_RCVBUF SO_RCVBUF} option
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1239
     * for this <tt>Socket</tt>, that is the buffer size used by the platform
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1240
     * for input on this <tt>Socket</tt>.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1241
     *
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1242
     * @return the value of the {@link SocketOptions#SO_RCVBUF SO_RCVBUF}
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1243
     *         option for this <tt>Socket</tt>.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1244
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1245
     * in the underlying protocol, such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1246
     * @see #setReceiveBufferSize(int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1247
     * @since 1.2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1248
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1249
    public synchronized int getReceiveBufferSize()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1250
    throws SocketException{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1251
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1252
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1253
        int result = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1254
        Object o = getImpl().getOption(SocketOptions.SO_RCVBUF);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1255
        if (o instanceof Integer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1256
            result = ((Integer)o).intValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1257
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1258
        return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1259
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1260
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1261
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1262
     * Enable/disable {@link SocketOptions#SO_KEEPALIVE SO_KEEPALIVE}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1263
     *
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1264
     * @param on  whether or not to have socket keep alive turned on.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1265
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1266
     * in the underlying protocol, such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1267
     * @since 1.3
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1268
     * @see #getKeepAlive()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1269
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1270
    public void setKeepAlive(boolean on) throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1271
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1272
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1273
        getImpl().setOption(SocketOptions.SO_KEEPALIVE, Boolean.valueOf(on));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1274
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1275
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1276
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1277
     * Tests if {@link SocketOptions#SO_KEEPALIVE SO_KEEPALIVE} is enabled.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1278
     *
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1279
     * @return a <code>boolean</code> indicating whether or not
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1280
     *         {@link SocketOptions#SO_KEEPALIVE SO_KEEPALIVE} is enabled.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1281
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1282
     * in the underlying protocol, such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1283
     * @since   1.3
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1284
     * @see #setKeepAlive(boolean)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1285
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1286
    public boolean getKeepAlive() throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1287
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1288
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1289
        return ((Boolean) getImpl().getOption(SocketOptions.SO_KEEPALIVE)).booleanValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1290
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1291
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1292
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1293
     * Sets traffic class or type-of-service octet in the IP
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1294
     * header for packets sent from this Socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1295
     * As the underlying network implementation may ignore this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1296
     * value applications should consider it a hint.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1297
     *
18156
edb590d448c5 8016217: More javadoc warnings
alanb
parents: 17469
diff changeset
  1298
     * <P> The tc <B>must</B> be in the range {@code 0 <= tc <=
edb590d448c5 8016217: More javadoc warnings
alanb
parents: 17469
diff changeset
  1299
     * 255} or an IllegalArgumentException will be thrown.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1300
     * <p>Notes:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1301
     * <p>For Internet Protocol v4 the value consists of an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1302
     * <code>integer</code>, the least significant 8 bits of which
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1303
     * represent the value of the TOS octet in IP packets sent by
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1304
     * the socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1305
     * RFC 1349 defines the TOS values as follows:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1306
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1307
     * <UL>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1308
     * <LI><CODE>IPTOS_LOWCOST (0x02)</CODE></LI>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1309
     * <LI><CODE>IPTOS_RELIABILITY (0x04)</CODE></LI>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1310
     * <LI><CODE>IPTOS_THROUGHPUT (0x08)</CODE></LI>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1311
     * <LI><CODE>IPTOS_LOWDELAY (0x10)</CODE></LI>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1312
     * </UL>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1313
     * The last low order bit is always ignored as this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1314
     * corresponds to the MBZ (must be zero) bit.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1315
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1316
     * Setting bits in the precedence field may result in a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1317
     * SocketException indicating that the operation is not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1318
     * permitted.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1319
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1320
     * As RFC 1122 section 4.2.4.2 indicates, a compliant TCP
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1321
     * implementation should, but is not required to, let application
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1322
     * change the TOS field during the lifetime of a connection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1323
     * So whether the type-of-service field can be changed after the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1324
     * TCP connection has been established depends on the implementation
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1325
     * in the underlying platform. Applications should not assume that
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1326
     * they can change the TOS field after the connection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1327
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1328
     * For Internet Protocol v6 <code>tc</code> is the value that
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1329
     * would be placed into the sin6_flowinfo field of the IP header.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1330
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1331
     * @param tc        an <code>int</code> value for the bitset.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1332
     * @throws SocketException if there is an error setting the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1333
     * traffic class or type-of-service
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1334
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1335
     * @see #getTrafficClass
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1336
     * @see SocketOptions#IP_TOS
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1337
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1338
    public void setTrafficClass(int tc) throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1339
        if (tc < 0 || tc > 255)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1340
            throw new IllegalArgumentException("tc is not in range 0 -- 255");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1341
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1342
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1343
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1344
        getImpl().setOption(SocketOptions.IP_TOS, new Integer(tc));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1345
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1346
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1347
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1348
     * Gets traffic class or type-of-service in the IP header
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1349
     * for packets sent from this Socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1350
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1351
     * As the underlying network implementation may ignore the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1352
     * traffic class or type-of-service set using {@link #setTrafficClass(int)}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1353
     * this method may return a different value than was previously
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1354
     * set using the {@link #setTrafficClass(int)} method on this Socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1355
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1356
     * @return the traffic class or type-of-service already set
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1357
     * @throws SocketException if there is an error obtaining the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1358
     * traffic class or type-of-service value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1359
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1360
     * @see #setTrafficClass(int)
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1361
     * @see SocketOptions#IP_TOS
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1362
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1363
    public int getTrafficClass() throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1364
        return ((Integer) (getImpl().getOption(SocketOptions.IP_TOS))).intValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1365
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1366
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1367
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1368
     * Enable/disable the {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR}
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1369
     * socket option.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1370
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1371
     * When a TCP connection is closed the connection may remain
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1372
     * in a timeout state for a period of time after the connection
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1373
     * is closed (typically known as the <tt>TIME_WAIT</tt> state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1374
     * or <tt>2MSL</tt> wait state).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1375
     * For applications using a well known socket address or port
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1376
     * it may not be possible to bind a socket to the required
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1377
     * <tt>SocketAddress</tt> if there is a connection in the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1378
     * timeout state involving the socket address or port.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1379
     * <p>
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1380
     * Enabling {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR}
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1381
     * prior to binding the socket using {@link #bind(SocketAddress)} allows
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1382
     * the socket to be bound even though a previous connection is in a timeout
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1383
     * state.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1384
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1385
     * When a <tt>Socket</tt> is created the initial setting
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1386
     * of {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is disabled.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1387
     * <p>
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1388
     * The behaviour when {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1389
     * enabled or disabled after a socket is bound (See {@link #isBound()})
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1390
     * is not defined.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1391
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1392
     * @param on  whether to enable or disable the socket option
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1393
     * @exception SocketException if an error occurs enabling or
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1394
     *            disabling the {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR}
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1395
     *            socket option, or the socket is closed.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1396
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1397
     * @see #getReuseAddress()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1398
     * @see #bind(SocketAddress)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1399
     * @see #isClosed()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1400
     * @see #isBound()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1401
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1402
    public void setReuseAddress(boolean on) throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1403
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1404
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1405
        getImpl().setOption(SocketOptions.SO_REUSEADDR, Boolean.valueOf(on));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1406
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1407
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1408
    /**
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1409
     * Tests if {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is enabled.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1410
     *
17469
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1411
     * @return a <code>boolean</code> indicating whether or not
e00a02431a8b 6328537: Improve javadocs for Socket class by adding references to SocketOptions
khazra
parents: 16061
diff changeset
  1412
     *         {@link SocketOptions#SO_REUSEADDR SO_REUSEADDR} is enabled.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1413
     * @exception SocketException if there is an error
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1414
     * in the underlying protocol, such as a TCP error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1415
     * @since   1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1416
     * @see #setReuseAddress(boolean)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1417
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1418
    public boolean getReuseAddress() throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1419
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1420
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1421
        return ((Boolean) (getImpl().getOption(SocketOptions.SO_REUSEADDR))).booleanValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1422
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1423
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1424
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1425
     * Closes this socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1426
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1427
     * Any thread currently blocked in an I/O operation upon this socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1428
     * will throw a {@link SocketException}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1429
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1430
     * Once a socket has been closed, it is not available for further networking
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1431
     * use (i.e. can't be reconnected or rebound). A new socket needs to be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1432
     * created.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1433
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1434
     * <p> Closing this socket will also close the socket's
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1435
     * {@link java.io.InputStream InputStream} and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1436
     * {@link java.io.OutputStream OutputStream}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1437
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1438
     * <p> If this socket has an associated channel then the channel is closed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1439
     * as well.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1440
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1441
     * @exception  IOException  if an I/O error occurs when closing this socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1442
     * @revised 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1443
     * @spec JSR-51
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1444
     * @see #isClosed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1445
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1446
    public synchronized void close() throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1447
        synchronized(closeLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1448
            if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1449
                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1450
            if (created)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1451
                impl.close();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1452
            closed = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1453
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1454
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1455
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1456
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1457
     * Places the input stream for this socket at "end of stream".
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1458
     * Any data sent to the input stream side of the socket is acknowledged
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1459
     * and then silently discarded.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1460
     * <p>
10421
2ee16a0f6df5 7014860: Socket.getInputStream().available() not clear for shutdown input
chegar
parents: 9775
diff changeset
  1461
     * If you read from a socket input stream after invoking this method on the
2ee16a0f6df5 7014860: Socket.getInputStream().available() not clear for shutdown input
chegar
parents: 9775
diff changeset
  1462
     * socket, the stream's {@code available} method will return 0, and its
2ee16a0f6df5 7014860: Socket.getInputStream().available() not clear for shutdown input
chegar
parents: 9775
diff changeset
  1463
     * {@code read} methods will return {@code -1} (end of stream).
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1464
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1465
     * @exception IOException if an I/O error occurs when shutting down this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1466
     * socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1467
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1468
     * @since 1.3
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1469
     * @see java.net.Socket#shutdownOutput()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1470
     * @see java.net.Socket#close()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1471
     * @see java.net.Socket#setSoLinger(boolean, int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1472
     * @see #isInputShutdown
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1473
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1474
    public void shutdownInput() throws IOException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1475
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1476
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1477
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1478
        if (!isConnected())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1479
            throw new SocketException("Socket is not connected");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1480
        if (isInputShutdown())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1481
            throw new SocketException("Socket input is already shutdown");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1482
        getImpl().shutdownInput();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1483
        shutIn = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1484
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1485
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1486
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1487
     * Disables the output stream for this socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1488
     * For a TCP socket, any previously written data will be sent
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1489
     * followed by TCP's normal connection termination sequence.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1490
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1491
     * If you write to a socket output stream after invoking
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1492
     * shutdownOutput() on the socket, the stream will throw
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1493
     * an IOException.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1494
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1495
     * @exception IOException if an I/O error occurs when shutting down this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1496
     * socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1497
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1498
     * @since 1.3
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1499
     * @see java.net.Socket#shutdownInput()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1500
     * @see java.net.Socket#close()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1501
     * @see java.net.Socket#setSoLinger(boolean, int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1502
     * @see #isOutputShutdown
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1503
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1504
    public void shutdownOutput() throws IOException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1505
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1506
        if (isClosed())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1507
            throw new SocketException("Socket is closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1508
        if (!isConnected())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1509
            throw new SocketException("Socket is not connected");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1510
        if (isOutputShutdown())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1511
            throw new SocketException("Socket output is already shutdown");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1512
        getImpl().shutdownOutput();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1513
        shutOut = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1514
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1515
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1516
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1517
     * Converts this socket to a <code>String</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1518
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1519
     * @return  a string representation of this socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1520
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1521
    public String toString() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1522
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1523
            if (isConnected())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1524
                return "Socket[addr=" + getImpl().getInetAddress() +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1525
                    ",port=" + getImpl().getPort() +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1526
                    ",localport=" + getImpl().getLocalPort() + "]";
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1527
        } catch (SocketException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1528
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1529
        return "Socket[unconnected]";
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1530
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1531
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1532
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1533
     * Returns the connection state of the socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1534
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1535
     * Note: Closing a socket doesn't clear its connection state, which means
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1536
     * this method will return <code>true</code> for a closed socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1537
     * (see {@link #isClosed()}) if it was successfuly connected prior
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1538
     * to being closed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1539
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1540
     * @return true if the socket was successfuly connected to a server
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1541
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1542
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1543
    public boolean isConnected() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1544
        // Before 1.3 Sockets were always connected during creation
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1545
        return connected || oldImpl;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1546
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1547
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1548
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1549
     * Returns the binding state of the socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1550
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1551
     * Note: Closing a socket doesn't clear its binding state, which means
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1552
     * this method will return <code>true</code> for a closed socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1553
     * (see {@link #isClosed()}) if it was successfuly bound prior
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1554
     * to being closed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1555
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1556
     * @return true if the socket was successfuly bound to an address
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1557
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1558
     * @see #bind
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1559
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1560
    public boolean isBound() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1561
        // Before 1.3 Sockets were always bound during creation
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1562
        return bound || oldImpl;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1563
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1564
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1565
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1566
     * Returns the closed state of the socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1567
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1568
     * @return true if the socket has been closed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1569
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1570
     * @see #close
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1571
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1572
    public boolean isClosed() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1573
        synchronized(closeLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1574
            return closed;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1575
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1576
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1577
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1578
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1579
     * Returns whether the read-half of the socket connection is closed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1580
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1581
     * @return true if the input of the socket has been shutdown
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1582
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1583
     * @see #shutdownInput
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1584
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1585
    public boolean isInputShutdown() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1586
        return shutIn;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1587
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1588
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1589
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1590
     * Returns whether the write-half of the socket connection is closed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1591
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1592
     * @return true if the output of the socket has been shutdown
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1593
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1594
     * @see #shutdownOutput
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1595
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1596
    public boolean isOutputShutdown() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1597
        return shutOut;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1598
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1599
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1600
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1601
     * The factory for all client sockets.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1602
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1603
    private static SocketImplFactory factory = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1604
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1605
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1606
     * Sets the client socket implementation factory for the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1607
     * application. The factory can be specified only once.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1608
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1609
     * When an application creates a new client socket, the socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1610
     * implementation factory's <code>createSocketImpl</code> method is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1611
     * called to create the actual socket implementation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1612
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1613
     * Passing <code>null</code> to the method is a no-op unless the factory
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1614
     * was already set.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1615
     * <p>If there is a security manager, this method first calls
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1616
     * the security manager's <code>checkSetFactory</code> method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1617
     * to ensure the operation is allowed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1618
     * This could result in a SecurityException.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1619
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1620
     * @param      fac   the desired factory.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1621
     * @exception  IOException  if an I/O error occurs when setting the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1622
     *               socket factory.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1623
     * @exception  SocketException  if the factory is already defined.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1624
     * @exception  SecurityException  if a security manager exists and its
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1625
     *             <code>checkSetFactory</code> method doesn't allow the operation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1626
     * @see        java.net.SocketImplFactory#createSocketImpl()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1627
     * @see        SecurityManager#checkSetFactory
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1628
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1629
    public static synchronized void setSocketImplFactory(SocketImplFactory fac)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1630
        throws IOException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1631
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1632
        if (factory != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1633
            throw new SocketException("factory already defined");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1634
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1635
        SecurityManager security = System.getSecurityManager();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1636
        if (security != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1637
            security.checkSetFactory();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1638
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1639
        factory = fac;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1640
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1641
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1642
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1643
     * Sets performance preferences for this socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1644
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1645
     * <p> Sockets use the TCP/IP protocol by default.  Some implementations
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1646
     * may offer alternative protocols which have different performance
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1647
     * characteristics than TCP/IP.  This method allows the application to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1648
     * express its own preferences as to how these tradeoffs should be made
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1649
     * when the implementation chooses from the available protocols.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1650
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1651
     * <p> Performance preferences are described by three integers
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1652
     * whose values indicate the relative importance of short connection time,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1653
     * low latency, and high bandwidth.  The absolute values of the integers
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1654
     * are irrelevant; in order to choose a protocol the values are simply
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1655
     * compared, with larger values indicating stronger preferences. Negative
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1656
     * values represent a lower priority than positive values. If the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1657
     * application prefers short connection time over both low latency and high
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1658
     * bandwidth, for example, then it could invoke this method with the values
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1659
     * <tt>(1, 0, 0)</tt>.  If the application prefers high bandwidth above low
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1660
     * latency, and low latency above short connection time, then it could
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1661
     * invoke this method with the values <tt>(0, 1, 2)</tt>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1662
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1663
     * <p> Invoking this method after this socket has been connected
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1664
     * will have no effect.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1665
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1666
     * @param  connectionTime
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1667
     *         An <tt>int</tt> expressing the relative importance of a short
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1668
     *         connection time
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1669
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1670
     * @param  latency
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1671
     *         An <tt>int</tt> expressing the relative importance of low
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1672
     *         latency
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1673
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1674
     * @param  bandwidth
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1675
     *         An <tt>int</tt> expressing the relative importance of high
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1676
     *         bandwidth
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1677
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1678
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1679
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1680
    public void setPerformancePreferences(int connectionTime,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1681
                                          int latency,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1682
                                          int bandwidth)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1683
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1684
        /* Not implemented yet */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1685
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1686
}