src/java.base/share/classes/java/net/AbstractPlainSocketImpl.java
author rriggs
Fri, 02 Feb 2018 14:17:07 -0500
changeset 48737 7c12219870fd
parent 47216 71c04702a3d5
child 49249 92cca24c8807
permissions -rw-r--r--
8195059: Update java.net Socket and DatagramSocket implementations to use Cleaner Reviewed-by: chegar, plevart
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
48737
7c12219870fd 8195059: Update java.net Socket and DatagramSocket implementations to use Cleaner
rriggs
parents: 47216
diff changeset
     2
 * Copyright (c) 1995, 2018, 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: 2446
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: 2446
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: 2446
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2446
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2446
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
48737
7c12219870fd 8195059: Update java.net Socket and DatagramSocket implementations to use Cleaner
rriggs
parents: 47216
diff changeset
    28
import java.io.FileDescriptor;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    29
import java.io.IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    30
import java.io.InputStream;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
import java.io.OutputStream;
48737
7c12219870fd 8195059: Update java.net Socket and DatagramSocket implementations to use Cleaner
rriggs
parents: 47216
diff changeset
    32
7c12219870fd 8195059: Update java.net Socket and DatagramSocket implementations to use Cleaner
rriggs
parents: 47216
diff changeset
    33
import java.util.Collections;
7c12219870fd 8195059: Update java.net Socket and DatagramSocket implementations to use Cleaner
rriggs
parents: 47216
diff changeset
    34
import java.util.HashSet;
7c12219870fd 8195059: Update java.net Socket and DatagramSocket implementations to use Cleaner
rriggs
parents: 47216
diff changeset
    35
import java.util.Set;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
90ce3da70b43 Initial load
duke
parents:
diff changeset
    37
import sun.net.ConnectionResetException;
2446
07047237e4d4 4890703: Support SDP (sol)
alanb
parents: 1335
diff changeset
    38
import sun.net.NetHooks;
8817
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
    39
import sun.net.ResourceManager;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
/**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
 * Default Socket Implementation. This implementation does
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
 * not implement any security checks.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
 * Note this class should <b>NOT</b> be public.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
 * @author  Steven B. Byrne
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    48
abstract class AbstractPlainSocketImpl extends SocketImpl
90ce3da70b43 Initial load
duke
parents:
diff changeset
    49
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
    /* instance variable for SO_TIMEOUT */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
    int timeout;   // timeout in millisec
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
    // traffic class
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
    private int trafficClass;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
    private boolean shut_rd = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
    private boolean shut_wr = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
    private SocketInputStream socketInputStream = null;
14173
8a94baea7747 7181793: Socket getOutputStream create streams that cannot be GC'ed until Socket is closed
coffeys
parents: 14014
diff changeset
    59
    private SocketOutputStream socketOutputStream = null;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
    /* number of threads using the FileDescriptor */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
    protected int fdUseCount = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
    /* lock when increment/decrementing fdUseCount */
7027
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
    65
    protected final Object fdLock = new Object();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
    /* indicates a close is pending on the file descriptor */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
    protected boolean closePending = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
    /* indicates connection reset state */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
    private int CONNECTION_NOT_RESET = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
    private int CONNECTION_RESET_PENDING = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
    private int CONNECTION_RESET = 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
    private int resetState;
7027
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
    75
    private final Object resetLock = new Object();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    76
8817
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
    77
   /* whether this Socket is a stream (TCP) socket or not (UDP)
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
    78
    */
10708
f255532bf336 7099488: TwoStacksPlainSocketImpl should invoke super.create(stream), typo in fix for 7098719
chegar
parents: 10704
diff changeset
    79
    protected boolean stream;
8817
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
    80
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
     * Load net library into runtime.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
    static {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
        java.security.AccessController.doPrivileged(
29986
97167d851fc4 8078467: Update core libraries to use diamond with anonymous classes
darcy
parents: 25859
diff changeset
    86
            new java.security.PrivilegedAction<>() {
12559
9456ceada8b1 7164376: Replace use of sun.security.action.LoadLibraryAction with System.loadLibrary
mchung
parents: 10708
diff changeset
    87
                public Void run() {
9456ceada8b1 7164376: Replace use of sun.security.action.LoadLibraryAction with System.loadLibrary
mchung
parents: 10708
diff changeset
    88
                    System.loadLibrary("net");
9456ceada8b1 7164376: Replace use of sun.security.action.LoadLibraryAction with System.loadLibrary
mchung
parents: 10708
diff changeset
    89
                    return null;
9456ceada8b1 7164376: Replace use of sun.security.action.LoadLibraryAction with System.loadLibrary
mchung
parents: 10708
diff changeset
    90
                }
9456ceada8b1 7164376: Replace use of sun.security.action.LoadLibraryAction with System.loadLibrary
mchung
parents: 10708
diff changeset
    91
            });
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
36115
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
    94
    private static volatile boolean checkedReusePort;
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
    95
    private static volatile boolean isReusePortAvailable;
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
    96
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
    97
    /**
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
    98
     * Tells whether SO_REUSEPORT is supported.
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
    99
     */
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   100
    static boolean isReusePortAvailable() {
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   101
        if (!checkedReusePort) {
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   102
            isReusePortAvailable = isReusePortAvailable0();
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   103
            checkedReusePort = true;
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   104
        }
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   105
        return isReusePortAvailable;
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   106
    }
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   107
38477
f462865d453d 8143923: java.net socket supportedOptions set depends on call order
vtewari
parents: 36115
diff changeset
   108
    /**
f462865d453d 8143923: java.net socket supportedOptions set depends on call order
vtewari
parents: 36115
diff changeset
   109
     * Returns a set of SocketOptions supported by this impl and by this impl's
f462865d453d 8143923: java.net socket supportedOptions set depends on call order
vtewari
parents: 36115
diff changeset
   110
     * socket (Socket or ServerSocket)
f462865d453d 8143923: java.net socket supportedOptions set depends on call order
vtewari
parents: 36115
diff changeset
   111
     *
f462865d453d 8143923: java.net socket supportedOptions set depends on call order
vtewari
parents: 36115
diff changeset
   112
     * @return a Set of SocketOptions
f462865d453d 8143923: java.net socket supportedOptions set depends on call order
vtewari
parents: 36115
diff changeset
   113
     */
36115
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   114
    @Override
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   115
    protected Set<SocketOption<?>> supportedOptions() {
38477
f462865d453d 8143923: java.net socket supportedOptions set depends on call order
vtewari
parents: 36115
diff changeset
   116
        Set<SocketOption<?>> options;
f462865d453d 8143923: java.net socket supportedOptions set depends on call order
vtewari
parents: 36115
diff changeset
   117
        if (isReusePortAvailable()) {
f462865d453d 8143923: java.net socket supportedOptions set depends on call order
vtewari
parents: 36115
diff changeset
   118
            options = new HashSet<>();
f462865d453d 8143923: java.net socket supportedOptions set depends on call order
vtewari
parents: 36115
diff changeset
   119
            options.addAll(super.supportedOptions());
f462865d453d 8143923: java.net socket supportedOptions set depends on call order
vtewari
parents: 36115
diff changeset
   120
            options.add(StandardSocketOptions.SO_REUSEPORT);
f462865d453d 8143923: java.net socket supportedOptions set depends on call order
vtewari
parents: 36115
diff changeset
   121
            options = Collections.unmodifiableSet(options);
f462865d453d 8143923: java.net socket supportedOptions set depends on call order
vtewari
parents: 36115
diff changeset
   122
        } else {
f462865d453d 8143923: java.net socket supportedOptions set depends on call order
vtewari
parents: 36115
diff changeset
   123
            options = super.supportedOptions();
36115
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   124
        }
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   125
        return options;
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   126
    }
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   127
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
     * Creates a socket with a boolean that specifies whether this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   130
     * is a stream socket (true) or an unconnected UDP socket (false).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   131
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   132
    protected synchronized void create(boolean stream) throws IOException {
8817
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   133
        this.stream = stream;
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   134
        if (!stream) {
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   135
            ResourceManager.beforeUdpCreate();
10704
db5816a6e8c7 7098719: -Dsun.net.maxDatagramSockets and Socket constructor does not work correctly with System.gc()
chegar
parents: 10421
diff changeset
   136
            // only create the fd after we know we will be able to create the socket
db5816a6e8c7 7098719: -Dsun.net.maxDatagramSockets and Socket constructor does not work correctly with System.gc()
chegar
parents: 10421
diff changeset
   137
            fd = new FileDescriptor();
8817
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   138
            try {
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   139
                socketCreate(false);
48737
7c12219870fd 8195059: Update java.net Socket and DatagramSocket implementations to use Cleaner
rriggs
parents: 47216
diff changeset
   140
                SocketCleanable.register(fd);
8817
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   141
            } catch (IOException ioe) {
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   142
                ResourceManager.afterUdpClose();
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   143
                fd = null;
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   144
                throw ioe;
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   145
            }
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   146
        } else {
10704
db5816a6e8c7 7098719: -Dsun.net.maxDatagramSockets and Socket constructor does not work correctly with System.gc()
chegar
parents: 10421
diff changeset
   147
            fd = new FileDescriptor();
8817
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   148
            socketCreate(true);
48737
7c12219870fd 8195059: Update java.net Socket and DatagramSocket implementations to use Cleaner
rriggs
parents: 47216
diff changeset
   149
            SocketCleanable.register(fd);
8817
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   150
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
        if (socket != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
            socket.setCreated();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
        if (serverSocket != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
            serverSocket.setCreated();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
     * Creates a socket and connects it to the specified port on
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
     * the specified host.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
     * @param host the specified host
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
     * @param port the specified port
90ce3da70b43 Initial load
duke
parents:
diff changeset
   162
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
    protected void connect(String host, int port)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
        throws UnknownHostException, IOException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   165
    {
7027
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   166
        boolean connected = false;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   167
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   168
            InetAddress address = InetAddress.getByName(host);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   169
            this.port = port;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   170
            this.address = address;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   171
7027
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   172
            connectToAddress(address, port, timeout);
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   173
            connected = true;
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   174
        } finally {
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   175
            if (!connected) {
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   176
                try {
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   177
                    close();
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   178
                } catch (IOException ioe) {
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   179
                    /* Do nothing. If connect threw an exception then
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   180
                       it will be passed up the call stack */
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   181
                }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   187
     * Creates a socket and connects it to the specified address on
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
     * the specified port.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
     * @param address the address
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
     * @param port the specified port
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
    protected void connect(InetAddress address, int port) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
        this.port = port;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
        this.address = address;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   195
90ce3da70b43 Initial load
duke
parents:
diff changeset
   196
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
            connectToAddress(address, port, timeout);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
        } catch (IOException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   200
            // everything failed
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
            close();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
            throw e;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   204
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   205
90ce3da70b43 Initial load
duke
parents:
diff changeset
   206
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
     * Creates a socket and connects it to the specified address on
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
     * the specified port.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
     * @param address the address
90ce3da70b43 Initial load
duke
parents:
diff changeset
   210
     * @param timeout the timeout value in milliseconds, or zero for no timeout.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   211
     * @throws IOException if connection fails
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
     * @throws  IllegalArgumentException if address is null or is a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   213
     *          SocketAddress subclass not supported by this socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
   214
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
     */
7027
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   216
    protected void connect(SocketAddress address, int timeout)
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   217
            throws IOException {
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   218
        boolean connected = false;
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   219
        try {
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   220
            if (address == null || !(address instanceof InetSocketAddress))
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   221
                throw new IllegalArgumentException("unsupported address type");
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   222
            InetSocketAddress addr = (InetSocketAddress) address;
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   223
            if (addr.isUnresolved())
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   224
                throw new UnknownHostException(addr.getHostName());
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   225
            this.port = addr.getPort();
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   226
            this.address = addr.getAddress();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
90ce3da70b43 Initial load
duke
parents:
diff changeset
   228
            connectToAddress(this.address, port, timeout);
7027
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   229
            connected = true;
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   230
        } finally {
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   231
            if (!connected) {
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   232
                try {
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   233
                    close();
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   234
                } catch (IOException ioe) {
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   235
                    /* Do nothing. If connect threw an exception then
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   236
                       it will be passed up the call stack */
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   237
                }
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   238
            }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
90ce3da70b43 Initial load
duke
parents:
diff changeset
   242
    private void connectToAddress(InetAddress address, int port, int timeout) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   243
        if (address.isAnyLocalAddress()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   244
            doConnect(InetAddress.getLocalHost(), port, timeout);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   245
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
            doConnect(address, port, timeout);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   248
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
    public void setOption(int opt, Object val) throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   251
        if (isClosedOrPending()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   252
            throw new SocketException("Socket Closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   253
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   254
        boolean on = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   255
        switch (opt) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
            /* check type safety b4 going native.  These should never
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
             * fail, since only java.Socket* has access to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
             * PlainSocketImpl.setOption().
90ce3da70b43 Initial load
duke
parents:
diff changeset
   259
             */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   260
        case SO_LINGER:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   261
            if (val == null || (!(val instanceof Integer) && !(val instanceof Boolean)))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   262
                throw new SocketException("Bad parameter for option");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   263
            if (val instanceof Boolean) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   264
                /* true only if disabling - enabling should be Integer */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   265
                on = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   266
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   267
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   268
        case SO_TIMEOUT:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
            if (val == null || (!(val instanceof Integer)))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
                throw new SocketException("Bad parameter for SO_TIMEOUT");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
            int tmp = ((Integer) val).intValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
            if (tmp < 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   273
                throw new IllegalArgumentException("timeout < 0");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   274
            timeout = tmp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   275
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
        case IP_TOS:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   277
             if (val == null || !(val instanceof Integer)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
                 throw new SocketException("bad argument for IP_TOS");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   279
             }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
             trafficClass = ((Integer)val).intValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
             break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
        case SO_BINDADDR:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   283
            throw new SocketException("Cannot re-bind socket");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   284
        case TCP_NODELAY:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   285
            if (val == null || !(val instanceof Boolean))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   286
                throw new SocketException("bad parameter for TCP_NODELAY");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   287
            on = ((Boolean)val).booleanValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   288
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
        case SO_SNDBUF:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   290
        case SO_RCVBUF:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   291
            if (val == null || !(val instanceof Integer) ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
   292
                !(((Integer)val).intValue() > 0)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   293
                throw new SocketException("bad parameter for SO_SNDBUF " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   294
                                          "or SO_RCVBUF");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   295
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
        case SO_KEEPALIVE:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
            if (val == null || !(val instanceof Boolean))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
                throw new SocketException("bad parameter for SO_KEEPALIVE");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
            on = ((Boolean)val).booleanValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
        case SO_OOBINLINE:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
            if (val == null || !(val instanceof Boolean))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
                throw new SocketException("bad parameter for SO_OOBINLINE");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
            on = ((Boolean)val).booleanValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   306
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   307
        case SO_REUSEADDR:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   308
            if (val == null || !(val instanceof Boolean))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   309
                throw new SocketException("bad parameter for SO_REUSEADDR");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   310
            on = ((Boolean)val).booleanValue();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
            break;
36115
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   312
        case SO_REUSEPORT:
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   313
            if (val == null || !(val instanceof Boolean))
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   314
                throw new SocketException("bad parameter for SO_REUSEPORT");
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   315
            if (!supportedOptions().contains(StandardSocketOptions.SO_REUSEPORT))
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   316
                throw new UnsupportedOperationException("unsupported option");
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   317
            on = ((Boolean)val).booleanValue();
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   318
            break;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
        default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   320
            throw new SocketException("unrecognized TCP option: " + opt);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   321
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   322
        socketSetOption(opt, on, val);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   323
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   324
    public Object getOption(int opt) throws SocketException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   325
        if (isClosedOrPending()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   326
            throw new SocketException("Socket Closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
        if (opt == SO_TIMEOUT) {
25522
10d789df41bb 8049892: Replace uses of 'new Integer()' with appropriate alternative across core classes
prr
parents: 23010
diff changeset
   329
            return timeout;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   330
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   331
        int ret = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
        /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   333
         * The native socketGetOption() knows about 3 options.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
         * The 32 bit value it returns will be interpreted according
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
         * to what we're asking.  A return of -1 means it understands
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
         * the option but its turned off.  It will raise a SocketException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
         * if "opt" isn't one it understands.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   339
90ce3da70b43 Initial load
duke
parents:
diff changeset
   340
        switch (opt) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   341
        case TCP_NODELAY:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   342
            ret = socketGetOption(opt, null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   343
            return Boolean.valueOf(ret != -1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   344
        case SO_OOBINLINE:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   345
            ret = socketGetOption(opt, null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   346
            return Boolean.valueOf(ret != -1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   347
        case SO_LINGER:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   348
            ret = socketGetOption(opt, null);
25522
10d789df41bb 8049892: Replace uses of 'new Integer()' with appropriate alternative across core classes
prr
parents: 23010
diff changeset
   349
            return (ret == -1) ? Boolean.FALSE: (Object)(ret);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   350
        case SO_REUSEADDR:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   351
            ret = socketGetOption(opt, null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   352
            return Boolean.valueOf(ret != -1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
        case SO_BINDADDR:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
            InetAddressContainer in = new InetAddressContainer();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   355
            ret = socketGetOption(opt, in);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   356
            return in.addr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
        case SO_SNDBUF:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
        case SO_RCVBUF:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
            ret = socketGetOption(opt, null);
25522
10d789df41bb 8049892: Replace uses of 'new Integer()' with appropriate alternative across core classes
prr
parents: 23010
diff changeset
   360
            return ret;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
        case IP_TOS:
30963
88469d06e03f 8072384: Setting IP_TOS on java.net sockets not working on unix
coffeys
parents: 29986
diff changeset
   362
            try {
88469d06e03f 8072384: Setting IP_TOS on java.net sockets not working on unix
coffeys
parents: 29986
diff changeset
   363
                ret = socketGetOption(opt, null);
88469d06e03f 8072384: Setting IP_TOS on java.net sockets not working on unix
coffeys
parents: 29986
diff changeset
   364
                if (ret == -1) { // ipv6 tos
88469d06e03f 8072384: Setting IP_TOS on java.net sockets not working on unix
coffeys
parents: 29986
diff changeset
   365
                    return trafficClass;
88469d06e03f 8072384: Setting IP_TOS on java.net sockets not working on unix
coffeys
parents: 29986
diff changeset
   366
                } else {
88469d06e03f 8072384: Setting IP_TOS on java.net sockets not working on unix
coffeys
parents: 29986
diff changeset
   367
                    return ret;
88469d06e03f 8072384: Setting IP_TOS on java.net sockets not working on unix
coffeys
parents: 29986
diff changeset
   368
                }
88469d06e03f 8072384: Setting IP_TOS on java.net sockets not working on unix
coffeys
parents: 29986
diff changeset
   369
            } catch (SocketException se) {
88469d06e03f 8072384: Setting IP_TOS on java.net sockets not working on unix
coffeys
parents: 29986
diff changeset
   370
                    // TODO - should make better effort to read TOS or TCLASS
88469d06e03f 8072384: Setting IP_TOS on java.net sockets not working on unix
coffeys
parents: 29986
diff changeset
   371
                    return trafficClass; // ipv6 tos
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   372
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   373
        case SO_KEEPALIVE:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   374
            ret = socketGetOption(opt, null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   375
            return Boolean.valueOf(ret != -1);
36115
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   376
        case SO_REUSEPORT:
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   377
            if (!supportedOptions().contains(StandardSocketOptions.SO_REUSEPORT)) {
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   378
                throw new UnsupportedOperationException("unsupported option");
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   379
            }
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   380
            ret = socketGetOption(opt, null);
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   381
            return Boolean.valueOf(ret != -1);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   382
        // should never get here
90ce3da70b43 Initial load
duke
parents:
diff changeset
   383
        default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   384
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   385
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   386
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   387
90ce3da70b43 Initial load
duke
parents:
diff changeset
   388
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   389
     * The workhorse of the connection operation.  Tries several times to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   390
     * establish a connection to the given <host, port>.  If unsuccessful,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   391
     * throws an IOException indicating what went wrong.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   392
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   393
90ce3da70b43 Initial load
duke
parents:
diff changeset
   394
    synchronized void doConnect(InetAddress address, int port, int timeout) throws IOException {
2446
07047237e4d4 4890703: Support SDP (sol)
alanb
parents: 1335
diff changeset
   395
        synchronized (fdLock) {
07047237e4d4 4890703: Support SDP (sol)
alanb
parents: 1335
diff changeset
   396
            if (!closePending && (socket == null || !socket.isBound())) {
07047237e4d4 4890703: Support SDP (sol)
alanb
parents: 1335
diff changeset
   397
                NetHooks.beforeTcpConnect(fd, address, port);
07047237e4d4 4890703: Support SDP (sol)
alanb
parents: 1335
diff changeset
   398
            }
07047237e4d4 4890703: Support SDP (sol)
alanb
parents: 1335
diff changeset
   399
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   400
        try {
7027
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   401
            acquireFD();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   402
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   403
                socketConnect(address, port, timeout);
1335
79ed7fd4bb49 6739920: java 6u4~ use larger C heap if there are many threads
michaelm
parents: 715
diff changeset
   404
                /* socket may have been closed during poll/select */
79ed7fd4bb49 6739920: java 6u4~ use larger C heap if there are many threads
michaelm
parents: 715
diff changeset
   405
                synchronized (fdLock) {
79ed7fd4bb49 6739920: java 6u4~ use larger C heap if there are many threads
michaelm
parents: 715
diff changeset
   406
                    if (closePending) {
79ed7fd4bb49 6739920: java 6u4~ use larger C heap if there are many threads
michaelm
parents: 715
diff changeset
   407
                        throw new SocketException ("Socket closed");
79ed7fd4bb49 6739920: java 6u4~ use larger C heap if there are many threads
michaelm
parents: 715
diff changeset
   408
                    }
79ed7fd4bb49 6739920: java 6u4~ use larger C heap if there are many threads
michaelm
parents: 715
diff changeset
   409
                }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   410
                // If we have a ref. to the Socket, then sets the flags
90ce3da70b43 Initial load
duke
parents:
diff changeset
   411
                // created, bound & connected to true.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   412
                // This is normally done in Socket.connect() but some
90ce3da70b43 Initial load
duke
parents:
diff changeset
   413
                // subclasses of Socket may call impl.connect() directly!
90ce3da70b43 Initial load
duke
parents:
diff changeset
   414
                if (socket != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   415
                    socket.setBound();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   416
                    socket.setConnected();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   417
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   418
            } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   419
                releaseFD();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   420
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   421
        } catch (IOException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   422
            close();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   423
            throw e;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   424
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   425
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   426
90ce3da70b43 Initial load
duke
parents:
diff changeset
   427
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   428
     * Binds the socket to the specified address of the specified local port.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   429
     * @param address the address
14014
da3648e13e67 8000269: Cleanup javadoc warnings
alanb
parents: 12559
diff changeset
   430
     * @param lport the port
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   431
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   432
    protected synchronized void bind(InetAddress address, int lport)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   433
        throws IOException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   434
    {
2446
07047237e4d4 4890703: Support SDP (sol)
alanb
parents: 1335
diff changeset
   435
       synchronized (fdLock) {
07047237e4d4 4890703: Support SDP (sol)
alanb
parents: 1335
diff changeset
   436
            if (!closePending && (socket == null || !socket.isBound())) {
07047237e4d4 4890703: Support SDP (sol)
alanb
parents: 1335
diff changeset
   437
                NetHooks.beforeTcpBind(fd, address, lport);
07047237e4d4 4890703: Support SDP (sol)
alanb
parents: 1335
diff changeset
   438
            }
07047237e4d4 4890703: Support SDP (sol)
alanb
parents: 1335
diff changeset
   439
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   440
        socketBind(address, lport);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   441
        if (socket != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   442
            socket.setBound();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   443
        if (serverSocket != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   444
            serverSocket.setBound();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   445
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   446
90ce3da70b43 Initial load
duke
parents:
diff changeset
   447
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   448
     * Listens, for a specified amount of time, for connections.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   449
     * @param count the amount of time to listen for connections
90ce3da70b43 Initial load
duke
parents:
diff changeset
   450
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   451
    protected synchronized void listen(int count) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   452
        socketListen(count);
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
     * Accepts connections.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   457
     * @param s the connection
90ce3da70b43 Initial load
duke
parents:
diff changeset
   458
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   459
    protected void accept(SocketImpl s) throws IOException {
7027
d3404b1406d5 6994079: PlainSocketImpl should close the socket if it fails
chegar
parents: 5506
diff changeset
   460
        acquireFD();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   461
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   462
            socketAccept(s);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   463
        } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   464
            releaseFD();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   465
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   466
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   467
90ce3da70b43 Initial load
duke
parents:
diff changeset
   468
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   469
     * Gets an InputStream for this socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   470
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   471
    protected synchronized InputStream getInputStream() throws IOException {
14671
22fad096737b 8003833: Spurious NPE from Socket.getIn/OutputStream
chegar
parents: 14342
diff changeset
   472
        synchronized (fdLock) {
22fad096737b 8003833: Spurious NPE from Socket.getIn/OutputStream
chegar
parents: 14342
diff changeset
   473
            if (isClosedOrPending())
22fad096737b 8003833: Spurious NPE from Socket.getIn/OutputStream
chegar
parents: 14342
diff changeset
   474
                throw new IOException("Socket Closed");
22fad096737b 8003833: Spurious NPE from Socket.getIn/OutputStream
chegar
parents: 14342
diff changeset
   475
            if (shut_rd)
22fad096737b 8003833: Spurious NPE from Socket.getIn/OutputStream
chegar
parents: 14342
diff changeset
   476
                throw new IOException("Socket input is shutdown");
22fad096737b 8003833: Spurious NPE from Socket.getIn/OutputStream
chegar
parents: 14342
diff changeset
   477
            if (socketInputStream == null)
22fad096737b 8003833: Spurious NPE from Socket.getIn/OutputStream
chegar
parents: 14342
diff changeset
   478
                socketInputStream = new SocketInputStream(this);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   479
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   480
        return socketInputStream;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   481
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   482
90ce3da70b43 Initial load
duke
parents:
diff changeset
   483
    void setInputStream(SocketInputStream in) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   484
        socketInputStream = in;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   485
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   486
90ce3da70b43 Initial load
duke
parents:
diff changeset
   487
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   488
     * Gets an OutputStream for this socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   489
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   490
    protected synchronized OutputStream getOutputStream() throws IOException {
14671
22fad096737b 8003833: Spurious NPE from Socket.getIn/OutputStream
chegar
parents: 14342
diff changeset
   491
        synchronized (fdLock) {
22fad096737b 8003833: Spurious NPE from Socket.getIn/OutputStream
chegar
parents: 14342
diff changeset
   492
            if (isClosedOrPending())
22fad096737b 8003833: Spurious NPE from Socket.getIn/OutputStream
chegar
parents: 14342
diff changeset
   493
                throw new IOException("Socket Closed");
22fad096737b 8003833: Spurious NPE from Socket.getIn/OutputStream
chegar
parents: 14342
diff changeset
   494
            if (shut_wr)
22fad096737b 8003833: Spurious NPE from Socket.getIn/OutputStream
chegar
parents: 14342
diff changeset
   495
                throw new IOException("Socket output is shutdown");
22fad096737b 8003833: Spurious NPE from Socket.getIn/OutputStream
chegar
parents: 14342
diff changeset
   496
            if (socketOutputStream == null)
22fad096737b 8003833: Spurious NPE from Socket.getIn/OutputStream
chegar
parents: 14342
diff changeset
   497
                socketOutputStream = new SocketOutputStream(this);
14173
8a94baea7747 7181793: Socket getOutputStream create streams that cannot be GC'ed until Socket is closed
coffeys
parents: 14014
diff changeset
   498
        }
8a94baea7747 7181793: Socket getOutputStream create streams that cannot be GC'ed until Socket is closed
coffeys
parents: 14014
diff changeset
   499
        return socketOutputStream;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   500
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   501
90ce3da70b43 Initial load
duke
parents:
diff changeset
   502
    void setFileDescriptor(FileDescriptor fd) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   503
        this.fd = fd;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   504
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   505
90ce3da70b43 Initial load
duke
parents:
diff changeset
   506
    void setAddress(InetAddress address) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   507
        this.address = address;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   508
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   509
90ce3da70b43 Initial load
duke
parents:
diff changeset
   510
    void setPort(int port) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   511
        this.port = port;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   512
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   513
90ce3da70b43 Initial load
duke
parents:
diff changeset
   514
    void setLocalPort(int localport) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   515
        this.localport = localport;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   516
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   517
90ce3da70b43 Initial load
duke
parents:
diff changeset
   518
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   519
     * Returns the number of bytes that can be read without blocking.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   520
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   521
    protected synchronized int available() throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   522
        if (isClosedOrPending()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   523
            throw new IOException("Stream closed.");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   524
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   525
90ce3da70b43 Initial load
duke
parents:
diff changeset
   526
        /*
10421
2ee16a0f6df5 7014860: Socket.getInputStream().available() not clear for shutdown input
chegar
parents: 9035
diff changeset
   527
         * If connection has been reset or shut down for input, then return 0
2ee16a0f6df5 7014860: Socket.getInputStream().available() not clear for shutdown input
chegar
parents: 9035
diff changeset
   528
         * to indicate there are no buffered bytes.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   529
         */
10421
2ee16a0f6df5 7014860: Socket.getInputStream().available() not clear for shutdown input
chegar
parents: 9035
diff changeset
   530
        if (isConnectionReset() || shut_rd) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   531
            return 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   532
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   533
90ce3da70b43 Initial load
duke
parents:
diff changeset
   534
        /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   535
         * If no bytes available and we were previously notified
90ce3da70b43 Initial load
duke
parents:
diff changeset
   536
         * of a connection reset then we move to the reset state.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   537
         *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   538
         * If are notified of a connection reset then check
90ce3da70b43 Initial load
duke
parents:
diff changeset
   539
         * again if there are bytes buffered on the socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   540
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   541
        int n = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   542
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   543
            n = socketAvailable();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   544
            if (n == 0 && isConnectionResetPending()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   545
                setConnectionReset();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   546
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   547
        } catch (ConnectionResetException exc1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   548
            setConnectionResetPending();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   549
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   550
                n = socketAvailable();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   551
                if (n == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   552
                    setConnectionReset();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   553
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   554
            } catch (ConnectionResetException exc2) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   555
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   556
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   557
        return n;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   558
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   559
90ce3da70b43 Initial load
duke
parents:
diff changeset
   560
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   561
     * Closes the socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   562
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   563
    protected void close() throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   564
        synchronized(fdLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   565
            if (fd != null) {
8817
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   566
                if (!stream) {
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   567
                    ResourceManager.afterUdpClose();
5351579c46a9 6981922: DNS cache poisoning by untrusted applets
michaelm
parents: 7668
diff changeset
   568
                }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   569
                if (fdUseCount == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   570
                    if (closePending) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   571
                        return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   572
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   573
                    closePending = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   574
                    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   575
                     * We close the FileDescriptor in two-steps - first the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   576
                     * "pre-close" which closes the socket but doesn't
90ce3da70b43 Initial load
duke
parents:
diff changeset
   577
                     * release the underlying file descriptor. This operation
90ce3da70b43 Initial load
duke
parents:
diff changeset
   578
                     * may be lengthy due to untransmitted data and a long
90ce3da70b43 Initial load
duke
parents:
diff changeset
   579
                     * linger interval. Once the pre-close is done we do the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   580
                     * actual socket to release the fd.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   581
                     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   582
                    try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   583
                        socketPreClose();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   584
                    } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   585
                        socketClose();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   586
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   587
                    fd = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   588
                    return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   589
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   590
                    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   591
                     * If a thread has acquired the fd and a close
90ce3da70b43 Initial load
duke
parents:
diff changeset
   592
                     * isn't pending then use a deferred close.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   593
                     * Also decrement fdUseCount to signal the last
90ce3da70b43 Initial load
duke
parents:
diff changeset
   594
                     * thread that releases the fd to close it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   595
                     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   596
                    if (!closePending) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   597
                        closePending = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   598
                        fdUseCount--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   599
                        socketPreClose();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   600
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   601
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   602
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   603
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   604
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   605
90ce3da70b43 Initial load
duke
parents:
diff changeset
   606
    void reset() throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   607
        if (fd != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   608
            socketClose();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   609
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   610
        fd = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   611
        super.reset();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   612
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   613
90ce3da70b43 Initial load
duke
parents:
diff changeset
   614
90ce3da70b43 Initial load
duke
parents:
diff changeset
   615
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   616
     * Shutdown read-half of the socket connection;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   617
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   618
    protected void shutdownInput() throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   619
      if (fd != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   620
          socketShutdown(SHUT_RD);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   621
          if (socketInputStream != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   622
              socketInputStream.setEOF(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   623
          }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   624
          shut_rd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   625
      }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   626
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   627
90ce3da70b43 Initial load
duke
parents:
diff changeset
   628
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   629
     * Shutdown write-half of the socket connection;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   630
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   631
    protected void shutdownOutput() throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   632
      if (fd != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   633
          socketShutdown(SHUT_WR);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   634
          shut_wr = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   635
      }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   636
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   637
90ce3da70b43 Initial load
duke
parents:
diff changeset
   638
    protected boolean supportsUrgentData () {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   639
        return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   640
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   641
90ce3da70b43 Initial load
duke
parents:
diff changeset
   642
    protected void sendUrgentData (int data) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   643
        if (fd == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   644
            throw new IOException("Socket Closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   645
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   646
        socketSendUrgentData (data);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   647
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   648
90ce3da70b43 Initial load
duke
parents:
diff changeset
   649
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   650
     * "Acquires" and returns the FileDescriptor for this impl
90ce3da70b43 Initial load
duke
parents:
diff changeset
   651
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   652
     * A corresponding releaseFD is required to "release" the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   653
     * FileDescriptor.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   654
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   655
    FileDescriptor acquireFD() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   656
        synchronized (fdLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   657
            fdUseCount++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   658
            return fd;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   659
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   660
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   661
90ce3da70b43 Initial load
duke
parents:
diff changeset
   662
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   663
     * "Release" the FileDescriptor for this impl.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   664
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   665
     * If the use count goes to -1 then the socket is closed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   666
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   667
    void releaseFD() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   668
        synchronized (fdLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   669
            fdUseCount--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   670
            if (fdUseCount == -1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   671
                if (fd != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   672
                    try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   673
                        socketClose();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   674
                    } catch (IOException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   675
                    } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   676
                        fd = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   677
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   678
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   679
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   680
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   681
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   682
90ce3da70b43 Initial load
duke
parents:
diff changeset
   683
    public boolean isConnectionReset() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   684
        synchronized (resetLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   685
            return (resetState == CONNECTION_RESET);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   686
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   687
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   688
90ce3da70b43 Initial load
duke
parents:
diff changeset
   689
    public boolean isConnectionResetPending() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   690
        synchronized (resetLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   691
            return (resetState == CONNECTION_RESET_PENDING);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   692
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   693
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   694
90ce3da70b43 Initial load
duke
parents:
diff changeset
   695
    public void setConnectionReset() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   696
        synchronized (resetLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   697
            resetState = CONNECTION_RESET;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   698
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   699
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   700
90ce3da70b43 Initial load
duke
parents:
diff changeset
   701
    public void setConnectionResetPending() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   702
        synchronized (resetLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   703
            if (resetState == CONNECTION_NOT_RESET) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   704
                resetState = CONNECTION_RESET_PENDING;
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
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   709
90ce3da70b43 Initial load
duke
parents:
diff changeset
   710
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   711
     * Return true if already closed or close is pending
90ce3da70b43 Initial load
duke
parents:
diff changeset
   712
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   713
    public boolean isClosedOrPending() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   714
        /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   715
         * Lock on fdLock to ensure that we wait if a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   716
         * close is in progress.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   717
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   718
        synchronized (fdLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   719
            if (closePending || (fd == null)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   720
                return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   721
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   722
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   723
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   724
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   725
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   726
90ce3da70b43 Initial load
duke
parents:
diff changeset
   727
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   728
     * Return the current value of SO_TIMEOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
   729
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   730
    public int getTimeout() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   731
        return timeout;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   732
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   733
90ce3da70b43 Initial load
duke
parents:
diff changeset
   734
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   735
     * "Pre-close" a socket by dup'ing the file descriptor - this enables
90ce3da70b43 Initial load
duke
parents:
diff changeset
   736
     * the socket to be closed without releasing the file descriptor.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   737
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   738
    private void socketPreClose() throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   739
        socketClose0(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   740
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   741
90ce3da70b43 Initial load
duke
parents:
diff changeset
   742
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   743
     * Close the socket (and release the file descriptor).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   744
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   745
    protected void socketClose() throws IOException {
48737
7c12219870fd 8195059: Update java.net Socket and DatagramSocket implementations to use Cleaner
rriggs
parents: 47216
diff changeset
   746
        SocketCleanable.unregister(fd);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   747
        socketClose0(false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   748
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   749
90ce3da70b43 Initial load
duke
parents:
diff changeset
   750
    abstract void socketCreate(boolean isServer) throws IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   751
    abstract void socketConnect(InetAddress address, int port, int timeout)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   752
        throws IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   753
    abstract void socketBind(InetAddress address, int port)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   754
        throws IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   755
    abstract void socketListen(int count)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   756
        throws IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   757
    abstract void socketAccept(SocketImpl s)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   758
        throws IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   759
    abstract int socketAvailable()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   760
        throws IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   761
    abstract void socketClose0(boolean useDeferredClose)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   762
        throws IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   763
    abstract void socketShutdown(int howto)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   764
        throws IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   765
    abstract void socketSetOption(int cmd, boolean on, Object value)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   766
        throws SocketException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   767
    abstract int socketGetOption(int opt, Object iaContainerObj) throws SocketException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   768
    abstract void socketSendUrgentData(int data)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   769
        throws IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   770
32649
2ee9017c7597 8136583: Core libraries should use blessed modifier order
martin
parents: 30963
diff changeset
   771
    public static final int SHUT_RD = 0;
2ee9017c7597 8136583: Core libraries should use blessed modifier order
martin
parents: 30963
diff changeset
   772
    public static final int SHUT_WR = 1;
36115
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   773
0676e37a0b9c 6432031: Add support for SO_REUSEPORT
alanb
parents: 32649
diff changeset
   774
    private static native boolean isReusePortAvailable0();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   775
}