src/java.naming/share/classes/com/sun/jndi/ldap/Connection.java
author pkoppula
Tue, 02 Oct 2018 21:38:54 +0530
changeset 51993 c0d05cf1d19d
parent 51157 e9bbd853944d
child 54622 a8dcacf95bff
permissions -rw-r--r--
8211107: LDAPS communication failure with jdk 1.8.0_181 Reviewed-by: chegar, coffeys, vtewari
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
51157
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
     2
 * Copyright (c) 1999, 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: 4188
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: 4188
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: 4188
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 4188
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 4188
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 com.sun.jndi.ldap;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
90ce3da70b43 Initial load
duke
parents:
diff changeset
    28
import java.io.BufferedInputStream;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    29
import java.io.BufferedOutputStream;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    30
import java.io.InterruptedIOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
import java.io.IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    32
import java.io.OutputStream;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    33
import java.io.InputStream;
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
    34
import java.net.InetSocketAddress;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    35
import java.net.Socket;
10703
5e4b04df89ec 7094377: Com.sun.jndi.ldap.read.timeout doesn't work with ldaps.
vinnie
parents: 10324
diff changeset
    36
import javax.net.ssl.SSLSocket;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    37
90ce3da70b43 Initial load
duke
parents:
diff changeset
    38
import javax.naming.CommunicationException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
import javax.naming.ServiceUnavailableException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
import javax.naming.NamingException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
import javax.naming.InterruptedNamingException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
import javax.naming.ldap.Control;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
import java.lang.reflect.Method;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
import java.lang.reflect.InvocationTargetException;
51157
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
    47
import java.security.AccessController;
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
    48
import java.security.PrivilegedAction;
4188
f67abce80f05 6864911: ASN.1/DER input stream parser needs more work
weijun
parents: 2
diff changeset
    49
import java.util.Arrays;
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
    50
import javax.net.SocketFactory;
51157
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
    51
import javax.net.ssl.SSLParameters;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
/**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
  * A thread that creates a connection to an LDAP server.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
  * After the connection, the thread reads from the connection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
  * A caller can invoke methods on the instance to read LDAP responses
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
  * and to send LDAP requests.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
  * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
  * There is a one-to-one correspondence between an LdapClient and
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
  * a Connection. Access to Connection and its methods is only via
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
  * LdapClient with two exceptions: SASL authentication and StartTLS.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
  * SASL needs to access Connection's socket IO streams (in order to do encryption
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
  * of the security layer). StartTLS needs to do replace IO streams
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
  * and close the IO  streams on nonfatal close. The code for SASL
90ce3da70b43 Initial load
duke
parents:
diff changeset
    65
  * authentication can be treated as being the same as from LdapClient
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
  * because the SASL code is only ever called from LdapClient, from
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
  * inside LdapClient's synchronized authenticate() method. StartTLS is called
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
  * directly by the application but should only occur when the underlying
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
  * connection is quiet.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
  * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
  * In terms of synchronization, worry about data structures
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
  * used by the Connection thread because that usage might contend
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
  * with calls by the main threads (i.e., those that call LdapClient).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
  * Main threads need to worry about contention with each other.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
  * Fields that Connection thread uses:
90ce3da70b43 Initial load
duke
parents:
diff changeset
    76
  *     inStream - synced access and update; initialized in constructor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
  *           referenced outside class unsync'ed (by LdapSasl) only
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
  *           when connection is quiet
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
  *     traceFile, traceTagIn, traceTagOut - no sync; debugging only
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
  *     parent - no sync; initialized in constructor; no updates
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
  *     pendingRequests - sync
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
  *     pauseLock - per-instance lock;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
  *     paused - sync via pauseLock (pauseReader())
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
  * Members used by main threads (LdapClient):
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
  *     host, port - unsync; read-only access for StartTLS and debug messages
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
  *     setBound(), setV3() - no sync; called only by LdapClient.authenticate(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
  *             which is a sync method called only when connection is "quiet"
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
  *     getMsgId() - sync
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
  *     writeRequest(), removeRequest(),findRequest(), abandonOutstandingReqs() -
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
  *             access to shared pendingRequests is sync
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
  *     writeRequest(),  abandonRequest(), ldapUnbind() - access to outStream sync
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
  *     cleanup() - sync
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
  *     readReply() - access to sock sync
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
  *     unpauseReader() - (indirectly via writeRequest) sync on pauseLock
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
  * Members used by SASL auth (main thread):
90ce3da70b43 Initial load
duke
parents:
diff changeset
    96
  *     inStream, outStream - no sync; used to construct new stream; accessed
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
  *             only when conn is "quiet" and not shared
90ce3da70b43 Initial load
duke
parents:
diff changeset
    98
  *     replaceStreams() - sync method
90ce3da70b43 Initial load
duke
parents:
diff changeset
    99
  * Members used by StartTLS:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   100
  *     inStream, outStream - no sync; used to record the existing streams;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   101
  *             accessed only when conn is "quiet" and not shared
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
  *     replaceStreams() - sync method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   103
  * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   104
  * Handles anonymous, simple, and SASL bind for v3; anonymous and simple
90ce3da70b43 Initial load
duke
parents:
diff changeset
   105
  * for v2.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   106
  * %%% made public for access by LdapSasl %%%
90ce3da70b43 Initial load
duke
parents:
diff changeset
   107
  *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   108
  * @author Vincent Ryan
90ce3da70b43 Initial load
duke
parents:
diff changeset
   109
  * @author Rosanna Lee
90ce3da70b43 Initial load
duke
parents:
diff changeset
   110
  * @author Jagane Sundar
90ce3da70b43 Initial load
duke
parents:
diff changeset
   111
  */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
public final class Connection implements Runnable {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
    private static final boolean debug = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
    private static final int dump = 0; // > 0 r, > 1 rw
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
90ce3da70b43 Initial load
duke
parents:
diff changeset
   117
90ce3da70b43 Initial load
duke
parents:
diff changeset
   118
    final private Thread worker;    // Initialized in constructor
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
    private boolean v3 = true;       // Set in setV3()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   121
90ce3da70b43 Initial load
duke
parents:
diff changeset
   122
    final public String host;  // used by LdapClient for generating exception messages
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
                         // used by StartTlsResponse when creating an SSL socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
    final public int port;     // used by LdapClient for generating exception messages
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
                         // used by StartTlsResponse when creating an SSL socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
90ce3da70b43 Initial load
duke
parents:
diff changeset
   127
    private boolean bound = false;   // Set in setBound()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
    // All three are initialized in constructor and read-only afterwards
90ce3da70b43 Initial load
duke
parents:
diff changeset
   130
    private OutputStream traceFile = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   131
    private String traceTagIn = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   132
    private String traceTagOut = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   133
90ce3da70b43 Initial load
duke
parents:
diff changeset
   134
    // Initialized in constructor; read and used externally (LdapSasl);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   135
    // Updated in replaceStreams() during "quiet", unshared, period
90ce3da70b43 Initial load
duke
parents:
diff changeset
   136
    public InputStream inStream;   // must be public; used by LdapSasl
90ce3da70b43 Initial load
duke
parents:
diff changeset
   137
90ce3da70b43 Initial load
duke
parents:
diff changeset
   138
    // Initialized in constructor; read and used externally (LdapSasl);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   139
    // Updated in replaceOutputStream() during "quiet", unshared, period
90ce3da70b43 Initial load
duke
parents:
diff changeset
   140
    public OutputStream outStream; // must be public; used by LdapSasl
90ce3da70b43 Initial load
duke
parents:
diff changeset
   141
90ce3da70b43 Initial load
duke
parents:
diff changeset
   142
    // Initialized in constructor; read and used externally (TLS) to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   143
    // get new IO streams; closed during cleanup
90ce3da70b43 Initial load
duke
parents:
diff changeset
   144
    public Socket sock;            // for TLS
90ce3da70b43 Initial load
duke
parents:
diff changeset
   145
90ce3da70b43 Initial load
duke
parents:
diff changeset
   146
    // For processing "disconnect" unsolicited notification
90ce3da70b43 Initial load
duke
parents:
diff changeset
   147
    // Initialized in constructor
90ce3da70b43 Initial load
duke
parents:
diff changeset
   148
    final private LdapClient parent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   149
90ce3da70b43 Initial load
duke
parents:
diff changeset
   150
    // Incremented and returned in sync getMsgId()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
    private int outMsgId = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
    // The list of ldapRequests pending on this binding
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
    // Accessed only within sync methods
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
    private LdapRequest pendingRequests = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
    volatile IOException closureReason = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
    volatile boolean useable = true;  // is Connection still useable
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
14184
5553422ece67 8000487: Java JNDI connection library on ldap conn is not honoring configured timeout
robm
parents: 13157
diff changeset
   162
    int readTimeout;
5553422ece67 8000487: Java JNDI connection library on ldap conn is not honoring configured timeout
robm
parents: 13157
diff changeset
   163
    int connectTimeout;
51157
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   164
    private static final boolean IS_HOSTNAME_VERIFICATION_DISABLED
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   165
            = hostnameVerificationDisabledValue();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
51157
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   167
    private static boolean hostnameVerificationDisabledValue() {
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   168
        PrivilegedAction<String> act = () -> System.getProperty(
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   169
                "com.sun.jndi.ldap.object.disableEndpointIdentification");
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   170
        String prop = AccessController.doPrivileged(act);
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   171
        if (prop == null) {
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   172
            return false;
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   173
        }
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   174
        return prop.isEmpty() ? true : Boolean.parseBoolean(prop);
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   175
    }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
    // true means v3; false means v2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   177
    // Called in LdapClient.authenticate() (which is synchronized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
    // when connection is "quiet" and not shared; no need to synchronize
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
    void setV3(boolean v) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
        v3 = v;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
    // A BIND request has been successfully made on this connection
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
    // When cleaning up, remember to do an UNBIND
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
    // Called in LdapClient.authenticate() (which is synchronized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
    // when connection is "quiet" and not shared; no need to synchronize
90ce3da70b43 Initial load
duke
parents:
diff changeset
   187
    void setBound() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
        bound = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
    ////////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
    // Create an LDAP Binding object and bind to a particular server
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   195
    ////////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
   196
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
    Connection(LdapClient parent, String host, int port, String socketFactory,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
        int connectTimeout, int readTimeout, OutputStream trace) throws NamingException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
90ce3da70b43 Initial load
duke
parents:
diff changeset
   200
        this.host = host;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
        this.port = port;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
        this.parent = parent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
        this.readTimeout = readTimeout;
14184
5553422ece67 8000487: Java JNDI connection library on ldap conn is not honoring configured timeout
robm
parents: 13157
diff changeset
   204
        this.connectTimeout = connectTimeout;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   205
90ce3da70b43 Initial load
duke
parents:
diff changeset
   206
        if (trace != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
            traceFile = trace;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
            traceTagIn = "<- " + host + ":" + port + "\n\n";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
            traceTagOut = "-> " + host + ":" + port + "\n\n";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   210
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   211
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
        //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   213
        // Connect to server
90ce3da70b43 Initial load
duke
parents:
diff changeset
   214
        //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   216
            sock = createSocket(host, port, socketFactory, connectTimeout);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   217
90ce3da70b43 Initial load
duke
parents:
diff changeset
   218
            if (debug) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   219
                System.err.println("Connection: opening socket: " + host + "," + port);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   220
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   221
90ce3da70b43 Initial load
duke
parents:
diff changeset
   222
            inStream = new BufferedInputStream(sock.getInputStream());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   223
            outStream = new BufferedOutputStream(sock.getOutputStream());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   224
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
        } catch (InvocationTargetException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
            Throwable realException = e.getTargetException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
            // realException.printStackTrace();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   228
90ce3da70b43 Initial load
duke
parents:
diff changeset
   229
            CommunicationException ce =
90ce3da70b43 Initial load
duke
parents:
diff changeset
   230
                new CommunicationException(host + ":" + port);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   231
            ce.setRootCause(realException);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   232
            throw ce;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   233
        } catch (Exception e) {
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   234
            // We need to have a catch all here and
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   235
            // ignore generic exceptions.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   236
            // Also catches all IO errors generated by socket creation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   237
            CommunicationException ce =
90ce3da70b43 Initial load
duke
parents:
diff changeset
   238
                new CommunicationException(host + ":" + port);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
            ce.setRootCause(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
            throw ce;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   242
90ce3da70b43 Initial load
duke
parents:
diff changeset
   243
        worker = Obj.helper.createThread(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   244
        worker.setDaemon(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   245
        worker.start();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
90ce3da70b43 Initial load
duke
parents:
diff changeset
   248
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
     * Create an InetSocketAddress using the specified hostname and port number.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
     */
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   251
    private InetSocketAddress createInetSocketAddress(String host, int port) {
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   252
            return new InetSocketAddress(host, port);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   253
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   254
90ce3da70b43 Initial load
duke
parents:
diff changeset
   255
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
     * Create a Socket object using the specified socket factory and time limit.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
     * If a timeout is supplied and unconnected sockets are supported then
90ce3da70b43 Initial load
duke
parents:
diff changeset
   259
     * an unconnected socket is created and the timeout is applied when
90ce3da70b43 Initial load
duke
parents:
diff changeset
   260
     * connecting the socket. If a timeout is supplied but unconnected sockets
90ce3da70b43 Initial load
duke
parents:
diff changeset
   261
     * are not supported then the timeout is ignored and a connected socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
   262
     * is created.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   263
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   264
    private Socket createSocket(String host, int port, String socketFactory,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   265
            int connectTimeout) throws Exception {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   266
90ce3da70b43 Initial load
duke
parents:
diff changeset
   267
        Socket socket = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   268
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
        if (socketFactory != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
            // create the factory
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
25577
1d036fa8c9c4 8050798: New unchecked warning introduced in com.sun.jndi.ldap.Connection
darcy
parents: 25514
diff changeset
   273
            @SuppressWarnings("unchecked")
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   274
            Class<? extends SocketFactory> socketFactoryClass =
25577
1d036fa8c9c4 8050798: New unchecked warning introduced in com.sun.jndi.ldap.Connection
darcy
parents: 25514
diff changeset
   275
                (Class<? extends SocketFactory>)Obj.helper.loadClass(socketFactory);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
            Method getDefault =
10324
e28265130e4f 7072353: JNDI libraries do not build with javac -Xlint:all -Werror
jjg
parents: 8564
diff changeset
   277
                socketFactoryClass.getMethod("getDefault", new Class<?>[]{});
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   278
            SocketFactory factory = (SocketFactory) getDefault.invoke(null, new Object[]{});
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   279
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
            // create the socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
            if (connectTimeout > 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   283
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   284
                InetSocketAddress endpoint =
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   285
                        createInetSocketAddress(host, port);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   286
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   287
                // unconnected socket
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   288
                socket = factory.createSocket();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   290
                if (debug) {
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   291
                    System.err.println("Connection: creating socket with " +
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   292
                            "a timeout using supplied socket factory");
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   293
                }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   294
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   295
                // connected socket
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   296
                socket.connect(endpoint, connectTimeout);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   299
            // continue (but ignore connectTimeout)
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
            if (socket == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
                if (debug) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
                    System.err.println("Connection: creating socket using " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
                        "supplied socket factory");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
                // connected socket
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   306
                socket = factory.createSocket(host, port);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   307
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   308
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   309
90ce3da70b43 Initial load
duke
parents:
diff changeset
   310
            if (connectTimeout > 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   312
                    InetSocketAddress endpoint = createInetSocketAddress(host, port);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   313
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   314
                    socket = new Socket();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   315
90ce3da70b43 Initial load
duke
parents:
diff changeset
   316
                    if (debug) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
                        System.err.println("Connection: creating socket with " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   318
                            "a timeout");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
                    }
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   320
                    socket.connect(endpoint, connectTimeout);
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   321
            }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   322
25514
3cc6665bb6f4 8048175: Remove redundant use of reflection on core classes from JNDI
prappo
parents: 25406
diff changeset
   323
            // continue (but ignore connectTimeout)
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   324
90ce3da70b43 Initial load
duke
parents:
diff changeset
   325
            if (socket == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   326
                if (debug) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
                    System.err.println("Connection: creating socket");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   329
                // connected socket
90ce3da70b43 Initial load
duke
parents:
diff changeset
   330
                socket = new Socket(host, port);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   331
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   333
10703
5e4b04df89ec 7094377: Com.sun.jndi.ldap.read.timeout doesn't work with ldaps.
vinnie
parents: 10324
diff changeset
   334
        // For LDAP connect timeouts on LDAP over SSL connections must treat
5e4b04df89ec 7094377: Com.sun.jndi.ldap.read.timeout doesn't work with ldaps.
vinnie
parents: 10324
diff changeset
   335
        // the SSL handshake following socket connection as part of the timeout.
5e4b04df89ec 7094377: Com.sun.jndi.ldap.read.timeout doesn't work with ldaps.
vinnie
parents: 10324
diff changeset
   336
        // So explicitly set a socket read timeout, trigger the SSL handshake,
5e4b04df89ec 7094377: Com.sun.jndi.ldap.read.timeout doesn't work with ldaps.
vinnie
parents: 10324
diff changeset
   337
        // then reset the timeout.
51157
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   338
        if (socket instanceof SSLSocket) {
10703
5e4b04df89ec 7094377: Com.sun.jndi.ldap.read.timeout doesn't work with ldaps.
vinnie
parents: 10324
diff changeset
   339
            SSLSocket sslSocket = (SSLSocket) socket;
51157
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   340
            if (!IS_HOSTNAME_VERIFICATION_DISABLED) {
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   341
                SSLParameters param = sslSocket.getSSLParameters();
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   342
                param.setEndpointIdentificationAlgorithm("LDAPS");
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   343
                sslSocket.setSSLParameters(param);
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   344
            }
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   345
            if (connectTimeout > 0) {
51993
c0d05cf1d19d 8211107: LDAPS communication failure with jdk 1.8.0_181
pkoppula
parents: 51157
diff changeset
   346
                int socketTimeout = sslSocket.getSoTimeout();
51157
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   347
                sslSocket.setSoTimeout(connectTimeout); // reuse full timeout value
51993
c0d05cf1d19d 8211107: LDAPS communication failure with jdk 1.8.0_181
pkoppula
parents: 51157
diff changeset
   348
                sslSocket.startHandshake();
c0d05cf1d19d 8211107: LDAPS communication failure with jdk 1.8.0_181
pkoppula
parents: 51157
diff changeset
   349
                sslSocket.setSoTimeout(socketTimeout);
51157
e9bbd853944d 8200666: Improve LDAP support
vtewari
parents: 47216
diff changeset
   350
            }
10703
5e4b04df89ec 7094377: Com.sun.jndi.ldap.read.timeout doesn't work with ldaps.
vinnie
parents: 10324
diff changeset
   351
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   352
        return socket;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
90ce3da70b43 Initial load
duke
parents:
diff changeset
   355
    ////////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
   356
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
    // Methods to IO to the LDAP server
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
    ////////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
   360
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
    synchronized int getMsgId() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   362
        return ++outMsgId;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   363
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   364
90ce3da70b43 Initial load
duke
parents:
diff changeset
   365
    LdapRequest writeRequest(BerEncoder ber, int msgId) throws IOException {
8564
d99f879a35ab 6750362: Very large LDAP requests throw a OOM on LDAP servers which aren't aware of Paged Results Controls
coffeys
parents: 8182
diff changeset
   366
        return writeRequest(ber, msgId, false /* pauseAfterReceipt */, -1);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   367
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   368
8564
d99f879a35ab 6750362: Very large LDAP requests throw a OOM on LDAP servers which aren't aware of Paged Results Controls
coffeys
parents: 8182
diff changeset
   369
    LdapRequest writeRequest(BerEncoder ber, int msgId,
d99f879a35ab 6750362: Very large LDAP requests throw a OOM on LDAP servers which aren't aware of Paged Results Controls
coffeys
parents: 8182
diff changeset
   370
        boolean pauseAfterReceipt) throws IOException {
d99f879a35ab 6750362: Very large LDAP requests throw a OOM on LDAP servers which aren't aware of Paged Results Controls
coffeys
parents: 8182
diff changeset
   371
        return writeRequest(ber, msgId, pauseAfterReceipt, -1);
d99f879a35ab 6750362: Very large LDAP requests throw a OOM on LDAP servers which aren't aware of Paged Results Controls
coffeys
parents: 8182
diff changeset
   372
    }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   373
8564
d99f879a35ab 6750362: Very large LDAP requests throw a OOM on LDAP servers which aren't aware of Paged Results Controls
coffeys
parents: 8182
diff changeset
   374
    LdapRequest writeRequest(BerEncoder ber, int msgId,
d99f879a35ab 6750362: Very large LDAP requests throw a OOM on LDAP servers which aren't aware of Paged Results Controls
coffeys
parents: 8182
diff changeset
   375
        boolean pauseAfterReceipt, int replyQueueCapacity) throws IOException {
d99f879a35ab 6750362: Very large LDAP requests throw a OOM on LDAP servers which aren't aware of Paged Results Controls
coffeys
parents: 8182
diff changeset
   376
d99f879a35ab 6750362: Very large LDAP requests throw a OOM on LDAP servers which aren't aware of Paged Results Controls
coffeys
parents: 8182
diff changeset
   377
        LdapRequest req =
d99f879a35ab 6750362: Very large LDAP requests throw a OOM on LDAP servers which aren't aware of Paged Results Controls
coffeys
parents: 8182
diff changeset
   378
            new LdapRequest(msgId, pauseAfterReceipt, replyQueueCapacity);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   379
        addRequest(req);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   380
90ce3da70b43 Initial load
duke
parents:
diff changeset
   381
        if (traceFile != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   382
            Ber.dumpBER(traceFile, traceTagOut, ber.getBuf(), 0, ber.getDataLen());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   383
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   384
90ce3da70b43 Initial load
duke
parents:
diff changeset
   385
90ce3da70b43 Initial load
duke
parents:
diff changeset
   386
        // unpause reader so that it can get response
90ce3da70b43 Initial load
duke
parents:
diff changeset
   387
        // NOTE: Must do this before writing request, otherwise might
90ce3da70b43 Initial load
duke
parents:
diff changeset
   388
        // create a race condition where the writer unblocks its own response
90ce3da70b43 Initial load
duke
parents:
diff changeset
   389
        unpauseReader();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   390
90ce3da70b43 Initial load
duke
parents:
diff changeset
   391
        if (debug) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   392
            System.err.println("Writing request to: " + outStream);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   393
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   394
90ce3da70b43 Initial load
duke
parents:
diff changeset
   395
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   396
            synchronized (this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   397
                outStream.write(ber.getBuf(), 0, ber.getDataLen());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   398
                outStream.flush();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   399
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   400
        } catch (IOException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   401
            cleanup(null, true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   402
            throw (closureReason = e); // rethrow
90ce3da70b43 Initial load
duke
parents:
diff changeset
   403
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   404
90ce3da70b43 Initial load
duke
parents:
diff changeset
   405
        return req;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   406
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   407
90ce3da70b43 Initial load
duke
parents:
diff changeset
   408
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   409
     * Reads a reply; waits until one is ready.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   410
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   411
    BerDecoder readReply(LdapRequest ldr)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   412
            throws IOException, NamingException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   413
        BerDecoder rber;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   414
30901
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   415
        // Track down elapsed time to workaround spurious wakeups
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   416
        long elapsedMilli = 0;
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   417
        long elapsedNano = 0;
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   418
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   419
        while (((rber = ldr.getReplyBer()) == null) &&
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   420
                (readTimeout <= 0 || elapsedMilli < readTimeout))
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   421
        {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   422
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   423
                // If socket closed, don't even try
90ce3da70b43 Initial load
duke
parents:
diff changeset
   424
                synchronized (this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   425
                    if (sock == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   426
                        throw new ServiceUnavailableException(host + ":" + port +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   427
                            "; socket closed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   428
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   429
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   430
                synchronized (ldr) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   431
                    // check if condition has changed since our last check
90ce3da70b43 Initial load
duke
parents:
diff changeset
   432
                    rber = ldr.getReplyBer();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   433
                    if (rber == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   434
                        if (readTimeout > 0) {  // Socket read timeout is specified
30901
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   435
                            long beginNano = System.nanoTime();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   436
30901
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   437
                            // will be woken up before readTimeout if reply is
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   438
                            // available
30901
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   439
                            ldr.wait(readTimeout - elapsedMilli);
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   440
                            elapsedNano += (System.nanoTime() - beginNano);
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   441
                            elapsedMilli += elapsedNano / 1000_000;
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   442
                            elapsedNano %= 1000_000;
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   443
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   444
                        } else {
27935
80c148fb46c5 8065238: javax.naming.NamingException after upgrade to JDK 8
robm
parents: 25859
diff changeset
   445
                            // no timeout is set so we wait infinitely until
80c148fb46c5 8065238: javax.naming.NamingException after upgrade to JDK 8
robm
parents: 25859
diff changeset
   446
                            // a response is received
80c148fb46c5 8065238: javax.naming.NamingException after upgrade to JDK 8
robm
parents: 25859
diff changeset
   447
                            // http://docs.oracle.com/javase/8/docs/technotes/guides/jndi/jndi-ldap.html#PROP
80c148fb46c5 8065238: javax.naming.NamingException after upgrade to JDK 8
robm
parents: 25859
diff changeset
   448
                            ldr.wait();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   449
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   450
                    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   451
                        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   452
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   453
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   454
            } catch (InterruptedException ex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   455
                throw new InterruptedNamingException(
90ce3da70b43 Initial load
duke
parents:
diff changeset
   456
                    "Interrupted during LDAP operation");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   457
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   458
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   459
30901
3a319ea18158 7011441: jndi/ldap/Connection.java needs to avoid spurious wakeup
igerasim
parents: 27935
diff changeset
   460
        if ((rber == null) && (elapsedMilli >= readTimeout)) {
24568
0a6c919b3b31 8041451: com.sun.jndi.ldap.Connection:ReadTimeout should abandon ldap request
robm
parents: 24519
diff changeset
   461
            abandonRequest(ldr, null);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   462
            throw new NamingException("LDAP response read timed out, timeout used:"
90ce3da70b43 Initial load
duke
parents:
diff changeset
   463
                            + readTimeout + "ms." );
90ce3da70b43 Initial load
duke
parents:
diff changeset
   464
90ce3da70b43 Initial load
duke
parents:
diff changeset
   465
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   466
        return rber;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   467
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   468
90ce3da70b43 Initial load
duke
parents:
diff changeset
   469
90ce3da70b43 Initial load
duke
parents:
diff changeset
   470
    ////////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
   471
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   472
    // Methods to add, find, delete, and abandon requests made to server
90ce3da70b43 Initial load
duke
parents:
diff changeset
   473
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   474
    ////////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
   475
90ce3da70b43 Initial load
duke
parents:
diff changeset
   476
    private synchronized void addRequest(LdapRequest ldapRequest) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   477
90ce3da70b43 Initial load
duke
parents:
diff changeset
   478
        LdapRequest ldr = pendingRequests;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   479
        if (ldr == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   480
            pendingRequests = ldapRequest;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   481
            ldapRequest.next = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   482
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   483
            ldapRequest.next = pendingRequests;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   484
            pendingRequests = ldapRequest;
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
    synchronized LdapRequest findRequest(int msgId) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   489
90ce3da70b43 Initial load
duke
parents:
diff changeset
   490
        LdapRequest ldr = pendingRequests;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   491
        while (ldr != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   492
            if (ldr.msgId == msgId) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   493
                return ldr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   494
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   495
            ldr = ldr.next;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   496
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   497
        return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   498
90ce3da70b43 Initial load
duke
parents:
diff changeset
   499
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   500
90ce3da70b43 Initial load
duke
parents:
diff changeset
   501
    synchronized void removeRequest(LdapRequest req) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   502
        LdapRequest ldr = pendingRequests;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   503
        LdapRequest ldrprev = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   504
90ce3da70b43 Initial load
duke
parents:
diff changeset
   505
        while (ldr != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   506
            if (ldr == req) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   507
                ldr.cancel();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   508
90ce3da70b43 Initial load
duke
parents:
diff changeset
   509
                if (ldrprev != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   510
                    ldrprev.next = ldr.next;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   511
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   512
                    pendingRequests = ldr.next;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   513
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   514
                ldr.next = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   515
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   516
            ldrprev = ldr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   517
            ldr = ldr.next;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   518
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   519
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   520
90ce3da70b43 Initial load
duke
parents:
diff changeset
   521
    void abandonRequest(LdapRequest ldr, Control[] reqCtls) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   522
        // Remove from queue
90ce3da70b43 Initial load
duke
parents:
diff changeset
   523
        removeRequest(ldr);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   524
90ce3da70b43 Initial load
duke
parents:
diff changeset
   525
        BerEncoder ber = new BerEncoder(256);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   526
        int abandonMsgId = getMsgId();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   527
90ce3da70b43 Initial load
duke
parents:
diff changeset
   528
        //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   529
        // build the abandon request.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   530
        //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   531
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   532
            ber.beginSeq(Ber.ASN_SEQUENCE | Ber.ASN_CONSTRUCTOR);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   533
                ber.encodeInt(abandonMsgId);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   534
                ber.encodeInt(ldr.msgId, LdapClient.LDAP_REQ_ABANDON);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   535
90ce3da70b43 Initial load
duke
parents:
diff changeset
   536
                if (v3) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   537
                    LdapClient.encodeControls(ber, reqCtls);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   538
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   539
            ber.endSeq();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   540
90ce3da70b43 Initial load
duke
parents:
diff changeset
   541
            if (traceFile != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   542
                Ber.dumpBER(traceFile, traceTagOut, ber.getBuf(), 0,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   543
                    ber.getDataLen());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   544
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   545
90ce3da70b43 Initial load
duke
parents:
diff changeset
   546
            synchronized (this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   547
                outStream.write(ber.getBuf(), 0, ber.getDataLen());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   548
                outStream.flush();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   549
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   550
90ce3da70b43 Initial load
duke
parents:
diff changeset
   551
        } catch (IOException ex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   552
            //System.err.println("ldap.abandon: " + ex);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   553
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   554
21278
ef8a3a2a72f2 8022746: List of spelling errors in API doc
malenkov
parents: 14184
diff changeset
   555
        // Don't expect any response for the abandon request.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   556
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   557
90ce3da70b43 Initial load
duke
parents:
diff changeset
   558
    synchronized void abandonOutstandingReqs(Control[] reqCtls) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   559
        LdapRequest ldr = pendingRequests;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   560
90ce3da70b43 Initial load
duke
parents:
diff changeset
   561
        while (ldr != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   562
            abandonRequest(ldr, reqCtls);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   563
            pendingRequests = ldr = ldr.next;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   564
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   565
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   566
90ce3da70b43 Initial load
duke
parents:
diff changeset
   567
    ////////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
   568
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   569
    // Methods to unbind from server and clear up resources when object is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   570
    // destroyed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   571
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   572
    ////////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
   573
90ce3da70b43 Initial load
duke
parents:
diff changeset
   574
    private void ldapUnbind(Control[] reqCtls) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   575
90ce3da70b43 Initial load
duke
parents:
diff changeset
   576
        BerEncoder ber = new BerEncoder(256);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   577
        int unbindMsgId = getMsgId();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   578
90ce3da70b43 Initial load
duke
parents:
diff changeset
   579
        //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   580
        // build the unbind request.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   581
        //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   582
90ce3da70b43 Initial load
duke
parents:
diff changeset
   583
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   584
90ce3da70b43 Initial load
duke
parents:
diff changeset
   585
            ber.beginSeq(Ber.ASN_SEQUENCE | Ber.ASN_CONSTRUCTOR);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   586
                ber.encodeInt(unbindMsgId);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   587
                // IMPLICIT TAGS
90ce3da70b43 Initial load
duke
parents:
diff changeset
   588
                ber.encodeByte(LdapClient.LDAP_REQ_UNBIND);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   589
                ber.encodeByte(0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   590
90ce3da70b43 Initial load
duke
parents:
diff changeset
   591
                if (v3) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   592
                    LdapClient.encodeControls(ber, reqCtls);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   593
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   594
            ber.endSeq();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   595
90ce3da70b43 Initial load
duke
parents:
diff changeset
   596
            if (traceFile != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   597
                Ber.dumpBER(traceFile, traceTagOut, ber.getBuf(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   598
                    0, ber.getDataLen());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   599
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   600
90ce3da70b43 Initial load
duke
parents:
diff changeset
   601
            synchronized (this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   602
                outStream.write(ber.getBuf(), 0, ber.getDataLen());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   603
                outStream.flush();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   604
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   605
90ce3da70b43 Initial load
duke
parents:
diff changeset
   606
        } catch (IOException ex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   607
            //System.err.println("ldap.unbind: " + ex);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   608
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   609
21278
ef8a3a2a72f2 8022746: List of spelling errors in API doc
malenkov
parents: 14184
diff changeset
   610
        // Don't expect any response for the unbind request.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   611
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   612
90ce3da70b43 Initial load
duke
parents:
diff changeset
   613
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   614
     * @param reqCtls Possibly null request controls that accompanies the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   615
     *    abandon and unbind LDAP request.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   616
     * @param notifyParent true means to call parent LdapClient back, notifying
90ce3da70b43 Initial load
duke
parents:
diff changeset
   617
     *    it that the connection has been closed; false means not to notify
90ce3da70b43 Initial load
duke
parents:
diff changeset
   618
     *    parent. If LdapClient invokes cleanup(), notifyParent should be set to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   619
     *    false because LdapClient already knows that it is closing
90ce3da70b43 Initial load
duke
parents:
diff changeset
   620
     *    the connection. If Connection invokes cleanup(), notifyParent should be
90ce3da70b43 Initial load
duke
parents:
diff changeset
   621
     *    set to true because LdapClient needs to know about the closure.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   622
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   623
    void cleanup(Control[] reqCtls, boolean notifyParent) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   624
        boolean nparent = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   625
90ce3da70b43 Initial load
duke
parents:
diff changeset
   626
        synchronized (this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   627
            useable = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   628
90ce3da70b43 Initial load
duke
parents:
diff changeset
   629
            if (sock != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   630
                if (debug) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   631
                    System.err.println("Connection: closing socket: " + host + "," + port);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   632
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   633
                try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   634
                    if (!notifyParent) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   635
                        abandonOutstandingReqs(reqCtls);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   636
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   637
                    if (bound) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   638
                        ldapUnbind(reqCtls);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   639
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   640
                } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   641
                    try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   642
                        outStream.flush();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   643
                        sock.close();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   644
                        unpauseReader();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   645
                    } catch (IOException ie) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   646
                        if (debug)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   647
                            System.err.println("Connection: problem closing socket: " + ie);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   648
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   649
                    if (!notifyParent) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   650
                        LdapRequest ldr = pendingRequests;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   651
                        while (ldr != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   652
                            ldr.cancel();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   653
                            ldr = ldr.next;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   654
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   655
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   656
                    sock = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   657
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   658
                nparent = notifyParent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   659
            }
8182
1afdfa9621b6 7017486: Need synchronized access when flushing the LDAP request queue
vinnie
parents: 6312
diff changeset
   660
            if (nparent) {
1afdfa9621b6 7017486: Need synchronized access when flushing the LDAP request queue
vinnie
parents: 6312
diff changeset
   661
                LdapRequest ldr = pendingRequests;
1afdfa9621b6 7017486: Need synchronized access when flushing the LDAP request queue
vinnie
parents: 6312
diff changeset
   662
                while (ldr != null) {
1afdfa9621b6 7017486: Need synchronized access when flushing the LDAP request queue
vinnie
parents: 6312
diff changeset
   663
1afdfa9621b6 7017486: Need synchronized access when flushing the LDAP request queue
vinnie
parents: 6312
diff changeset
   664
                    synchronized (ldr) {
1afdfa9621b6 7017486: Need synchronized access when flushing the LDAP request queue
vinnie
parents: 6312
diff changeset
   665
                        ldr.notify();
1afdfa9621b6 7017486: Need synchronized access when flushing the LDAP request queue
vinnie
parents: 6312
diff changeset
   666
                        ldr = ldr.next;
1afdfa9621b6 7017486: Need synchronized access when flushing the LDAP request queue
vinnie
parents: 6312
diff changeset
   667
                    }
1afdfa9621b6 7017486: Need synchronized access when flushing the LDAP request queue
vinnie
parents: 6312
diff changeset
   668
                }
6126
bf66999384ac 6870947: 15 sec delay detecting "socket closed" condition when a TCP connection is reset by an LDAP server
xuelei
parents: 5506
diff changeset
   669
            }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   670
        }
13157
2141a68fb2a7 7174887: Deadlock in jndi ldap connection cleanup
robm
parents: 10703
diff changeset
   671
        if (nparent) {
2141a68fb2a7 7174887: Deadlock in jndi ldap connection cleanup
robm
parents: 10703
diff changeset
   672
            parent.processConnectionClosure();
2141a68fb2a7 7174887: Deadlock in jndi ldap connection cleanup
robm
parents: 10703
diff changeset
   673
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   674
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   675
90ce3da70b43 Initial load
duke
parents:
diff changeset
   676
90ce3da70b43 Initial load
duke
parents:
diff changeset
   677
    // Assume everything is "quiet"
90ce3da70b43 Initial load
duke
parents:
diff changeset
   678
    // "synchronize" might lead to deadlock so don't synchronize method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   679
    // Use streamLock instead for synchronizing update to stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   680
90ce3da70b43 Initial load
duke
parents:
diff changeset
   681
    synchronized public void replaceStreams(InputStream newIn, OutputStream newOut) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   682
        if (debug) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   683
            System.err.println("Replacing " + inStream + " with: " + newIn);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   684
            System.err.println("Replacing " + outStream + " with: " + newOut);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   685
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   686
90ce3da70b43 Initial load
duke
parents:
diff changeset
   687
        inStream = newIn;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   688
90ce3da70b43 Initial load
duke
parents:
diff changeset
   689
        // Cleanup old stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   690
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   691
            outStream.flush();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   692
        } catch (IOException ie) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   693
            if (debug)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   694
                System.err.println("Connection: cannot flush outstream: " + ie);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   695
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   696
90ce3da70b43 Initial load
duke
parents:
diff changeset
   697
        // Replace stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   698
        outStream = newOut;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   699
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   700
90ce3da70b43 Initial load
duke
parents:
diff changeset
   701
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   702
     * Used by Connection thread to read inStream into a local variable.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   703
     * This ensures that there is no contention between the main thread
90ce3da70b43 Initial load
duke
parents:
diff changeset
   704
     * and the Connection thread when the main thread updates inStream.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   705
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   706
    synchronized private InputStream getInputStream() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   707
        return inStream;
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
    ////////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
   712
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   713
    // Code for pausing/unpausing the reader thread ('worker')
90ce3da70b43 Initial load
duke
parents:
diff changeset
   714
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   715
    ////////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
   716
90ce3da70b43 Initial load
duke
parents:
diff changeset
   717
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   718
     * The main idea is to mark requests that need the reader thread to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   719
     * pause after getting the response. When the reader thread gets the response,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   720
     * it waits on a lock instead of returning to the read(). The next time a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   721
     * request is sent, the reader is automatically unblocked if necessary.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   722
     * Note that the reader must be unblocked BEFORE the request is sent.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   723
     * Otherwise, there is a race condition where the request is sent and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   724
     * the reader thread might read the response and be unblocked
90ce3da70b43 Initial load
duke
parents:
diff changeset
   725
     * by writeRequest().
90ce3da70b43 Initial load
duke
parents:
diff changeset
   726
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   727
     * This pause gives the main thread (StartTLS or SASL) an opportunity to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   728
     * update the reader's state (e.g., its streams) if necessary.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   729
     * The assumption is that the connection will remain quiet during this pause
90ce3da70b43 Initial load
duke
parents:
diff changeset
   730
     * (i.e., no intervening requests being sent).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   731
     *<p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   732
     * For dealing with StartTLS close,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   733
     * when the read() exits either due to EOF or an exception,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   734
     * the reader thread checks whether there is a new stream to read from.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   735
     * If so, then it reattempts the read. Otherwise, the EOF or exception
90ce3da70b43 Initial load
duke
parents:
diff changeset
   736
     * is processed and the reader thread terminates.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   737
     * In a StartTLS close, the client first replaces the SSL IO streams with
90ce3da70b43 Initial load
duke
parents:
diff changeset
   738
     * plain ones and then closes the SSL socket.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   739
     * If the reader thread attempts to read, or was reading, from
90ce3da70b43 Initial load
duke
parents:
diff changeset
   740
     * the SSL socket (that is, it got to the read BEFORE replaceStreams()),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   741
     * the SSL socket close will cause the reader thread to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   742
     * get an EOF/exception and reexamine the input stream.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   743
     * If the reader thread sees a new stream, it reattempts the read.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   744
     * If the underlying socket is still alive, then the new read will succeed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   745
     * If the underlying socket has been closed also, then the new read will
90ce3da70b43 Initial load
duke
parents:
diff changeset
   746
     * fail and the reader thread exits.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   747
     * If the reader thread attempts to read, or was reading, from the plain
90ce3da70b43 Initial load
duke
parents:
diff changeset
   748
     * socket (that is, it got to the read AFTER replaceStreams()), the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   749
     * SSL socket close will have no effect on the reader thread.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   750
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   751
     * The check for new stream is made only
90ce3da70b43 Initial load
duke
parents:
diff changeset
   752
     * in the first attempt at reading a BER buffer; the reader should
90ce3da70b43 Initial load
duke
parents:
diff changeset
   753
     * never be in midst of reading a buffer when a nonfatal close occurs.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   754
     * If this occurs, then the connection is in an inconsistent state and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   755
     * the safest thing to do is to shut it down.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   756
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   757
90ce3da70b43 Initial load
duke
parents:
diff changeset
   758
    private Object pauseLock = new Object();  // lock for reader to wait on while paused
90ce3da70b43 Initial load
duke
parents:
diff changeset
   759
    private boolean paused = false;           // paused state of reader
90ce3da70b43 Initial load
duke
parents:
diff changeset
   760
90ce3da70b43 Initial load
duke
parents:
diff changeset
   761
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   762
     * Unpauses reader thread if it was paused
90ce3da70b43 Initial load
duke
parents:
diff changeset
   763
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   764
    private void unpauseReader() throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   765
        synchronized (pauseLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   766
            if (paused) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   767
                if (debug) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   768
                    System.err.println("Unpausing reader; read from: " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   769
                                        inStream);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   770
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   771
                paused = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   772
                pauseLock.notify();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   773
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   774
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   775
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   776
90ce3da70b43 Initial load
duke
parents:
diff changeset
   777
     /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   778
     * Pauses reader so that it stops reading from the input stream.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   779
     * Reader blocks on pauseLock instead of read().
90ce3da70b43 Initial load
duke
parents:
diff changeset
   780
     * MUST be called from within synchronized (pauseLock) clause.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   781
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   782
    private void pauseReader() throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   783
        if (debug) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   784
            System.err.println("Pausing reader;  was reading from: " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   785
                                inStream);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   786
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   787
        paused = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   788
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   789
            while (paused) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   790
                pauseLock.wait(); // notified by unpauseReader
90ce3da70b43 Initial load
duke
parents:
diff changeset
   791
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   792
        } catch (InterruptedException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   793
            throw new InterruptedIOException(
90ce3da70b43 Initial load
duke
parents:
diff changeset
   794
                    "Pause/unpause reader has problems.");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   795
        }
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
    ////////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
   800
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   801
    // The LDAP Binding thread. It does the mux/demux of multiple requests
90ce3da70b43 Initial load
duke
parents:
diff changeset
   802
    // on the same TCP connection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   803
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
   804
    ////////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
   805
90ce3da70b43 Initial load
duke
parents:
diff changeset
   806
90ce3da70b43 Initial load
duke
parents:
diff changeset
   807
    public void run() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   808
        byte inbuf[];   // Buffer for reading incoming bytes
90ce3da70b43 Initial load
duke
parents:
diff changeset
   809
        int inMsgId;    // Message id of incoming response
90ce3da70b43 Initial load
duke
parents:
diff changeset
   810
        int bytesread;  // Number of bytes in inbuf
90ce3da70b43 Initial load
duke
parents:
diff changeset
   811
        int br;         // Temp; number of bytes read from stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   812
        int offset;     // Offset of where to store bytes in inbuf
90ce3da70b43 Initial load
duke
parents:
diff changeset
   813
        int seqlen;     // Length of ASN sequence
90ce3da70b43 Initial load
duke
parents:
diff changeset
   814
        int seqlenlen;  // Number of sequence length bytes
90ce3da70b43 Initial load
duke
parents:
diff changeset
   815
        boolean eos;    // End of stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   816
        BerDecoder retBer;    // Decoder for ASN.1 BER data from inbuf
90ce3da70b43 Initial load
duke
parents:
diff changeset
   817
        InputStream in = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   818
90ce3da70b43 Initial load
duke
parents:
diff changeset
   819
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   820
            while (true) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   821
                try {
6312
ec857430700d 6921610: 1.6 update 17 and 18 throw java.lang.IndexOutOfBoundsException
weijun
parents: 6126
diff changeset
   822
                    // type and length (at most 128 octets for long form)
ec857430700d 6921610: 1.6 update 17 and 18 throw java.lang.IndexOutOfBoundsException
weijun
parents: 6126
diff changeset
   823
                    inbuf = new byte[129];
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   824
90ce3da70b43 Initial load
duke
parents:
diff changeset
   825
                    offset = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   826
                    seqlen = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   827
                    seqlenlen = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   828
90ce3da70b43 Initial load
duke
parents:
diff changeset
   829
                    in = getInputStream();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   830
90ce3da70b43 Initial load
duke
parents:
diff changeset
   831
                    // check that it is the beginning of a sequence
90ce3da70b43 Initial load
duke
parents:
diff changeset
   832
                    bytesread = in.read(inbuf, offset, 1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   833
                    if (bytesread < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   834
                        if (in != getInputStream()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   835
                            continue;   // a new stream to try
90ce3da70b43 Initial load
duke
parents:
diff changeset
   836
                        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   837
                            break; // EOF
90ce3da70b43 Initial load
duke
parents:
diff changeset
   838
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   839
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   840
90ce3da70b43 Initial load
duke
parents:
diff changeset
   841
                    if (inbuf[offset++] != (Ber.ASN_SEQUENCE | Ber.ASN_CONSTRUCTOR))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   842
                        continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   843
90ce3da70b43 Initial load
duke
parents:
diff changeset
   844
                    // get length of sequence
90ce3da70b43 Initial load
duke
parents:
diff changeset
   845
                    bytesread = in.read(inbuf, offset, 1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   846
                    if (bytesread < 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   847
                        break; // EOF
90ce3da70b43 Initial load
duke
parents:
diff changeset
   848
                    seqlen = inbuf[offset++];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   849
90ce3da70b43 Initial load
duke
parents:
diff changeset
   850
                    // if high bit is on, length is encoded in the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   851
                    // subsequent length bytes and the number of length bytes
90ce3da70b43 Initial load
duke
parents:
diff changeset
   852
                    // is equal to & 0x80 (i.e. length byte with high bit off).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   853
                    if ((seqlen & 0x80) == 0x80) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   854
                        seqlenlen = seqlen & 0x7f;  // number of length bytes
90ce3da70b43 Initial load
duke
parents:
diff changeset
   855
90ce3da70b43 Initial load
duke
parents:
diff changeset
   856
                        bytesread = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   857
                        eos = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   858
90ce3da70b43 Initial load
duke
parents:
diff changeset
   859
                        // Read all length bytes
90ce3da70b43 Initial load
duke
parents:
diff changeset
   860
                        while (bytesread < seqlenlen) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   861
                            br = in.read(inbuf, offset+bytesread,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   862
                                seqlenlen-bytesread);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   863
                            if (br < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   864
                                eos = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   865
                                break; // EOF
90ce3da70b43 Initial load
duke
parents:
diff changeset
   866
                            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   867
                            bytesread += br;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   868
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   869
90ce3da70b43 Initial load
duke
parents:
diff changeset
   870
                        // end-of-stream reached before length bytes are read
90ce3da70b43 Initial load
duke
parents:
diff changeset
   871
                        if (eos)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   872
                            break;  // EOF
90ce3da70b43 Initial load
duke
parents:
diff changeset
   873
90ce3da70b43 Initial load
duke
parents:
diff changeset
   874
                        // Add contents of length bytes to determine length
90ce3da70b43 Initial load
duke
parents:
diff changeset
   875
                        seqlen = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   876
                        for( int i = 0; i < seqlenlen; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   877
                            seqlen = (seqlen << 8) + (inbuf[offset+i] & 0xff);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   878
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   879
                        offset += bytesread;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   880
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   881
90ce3da70b43 Initial load
duke
parents:
diff changeset
   882
                    // read in seqlen bytes
32933
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   883
                    byte[] left = readFully(in, seqlen);
4188
f67abce80f05 6864911: ASN.1/DER input stream parser needs more work
weijun
parents: 2
diff changeset
   884
                    inbuf = Arrays.copyOf(inbuf, offset + left.length);
f67abce80f05 6864911: ASN.1/DER input stream parser needs more work
weijun
parents: 2
diff changeset
   885
                    System.arraycopy(left, 0, inbuf, offset, left.length);
f67abce80f05 6864911: ASN.1/DER input stream parser needs more work
weijun
parents: 2
diff changeset
   886
                    offset += left.length;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   887
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   888
if (dump > 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   889
System.err.println("seqlen: " + seqlen);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   890
System.err.println("bufsize: " + offset);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   891
System.err.println("bytesleft: " + bytesleft);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   892
System.err.println("bytesread: " + bytesread);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   893
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   894
*/
90ce3da70b43 Initial load
duke
parents:
diff changeset
   895
90ce3da70b43 Initial load
duke
parents:
diff changeset
   896
90ce3da70b43 Initial load
duke
parents:
diff changeset
   897
                    try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   898
                        retBer = new BerDecoder(inbuf, 0, offset);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   899
90ce3da70b43 Initial load
duke
parents:
diff changeset
   900
                        if (traceFile != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   901
                            Ber.dumpBER(traceFile, traceTagIn, inbuf, 0, offset);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   902
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   903
90ce3da70b43 Initial load
duke
parents:
diff changeset
   904
                        retBer.parseSeq(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   905
                        inMsgId = retBer.parseInt();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   906
                        retBer.reset(); // reset offset
90ce3da70b43 Initial load
duke
parents:
diff changeset
   907
90ce3da70b43 Initial load
duke
parents:
diff changeset
   908
                        boolean needPause = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   909
90ce3da70b43 Initial load
duke
parents:
diff changeset
   910
                        if (inMsgId == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   911
                            // Unsolicited Notification
90ce3da70b43 Initial load
duke
parents:
diff changeset
   912
                            parent.processUnsolicited(retBer);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   913
                        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   914
                            LdapRequest ldr = findRequest(inMsgId);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   915
90ce3da70b43 Initial load
duke
parents:
diff changeset
   916
                            if (ldr != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   917
90ce3da70b43 Initial load
duke
parents:
diff changeset
   918
                                /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   919
                                 * Grab pauseLock before making reply available
90ce3da70b43 Initial load
duke
parents:
diff changeset
   920
                                 * to ensure that reader goes into paused state
90ce3da70b43 Initial load
duke
parents:
diff changeset
   921
                                 * before writer can attempt to unpause reader
90ce3da70b43 Initial load
duke
parents:
diff changeset
   922
                                 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   923
                                synchronized (pauseLock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   924
                                    needPause = ldr.addReplyBer(retBer);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   925
                                    if (needPause) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   926
                                        /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   927
                                         * Go into paused state; release
90ce3da70b43 Initial load
duke
parents:
diff changeset
   928
                                         * pauseLock
90ce3da70b43 Initial load
duke
parents:
diff changeset
   929
                                         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   930
                                        pauseReader();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   931
                                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   932
90ce3da70b43 Initial load
duke
parents:
diff changeset
   933
                                    // else release pauseLock
90ce3da70b43 Initial load
duke
parents:
diff changeset
   934
                                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   935
                            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   936
                                // System.err.println("Cannot find" +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   937
                                //              "LdapRequest for " + inMsgId);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   938
                            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   939
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   940
                    } catch (Ber.DecodeException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   941
                        //System.err.println("Cannot parse Ber");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   942
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   943
                } catch (IOException ie) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   944
                    if (debug) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   945
                        System.err.println("Connection: Inside Caught " + ie);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   946
                        ie.printStackTrace();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   947
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   948
90ce3da70b43 Initial load
duke
parents:
diff changeset
   949
                    if (in != getInputStream()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   950
                        // A new stream to try
90ce3da70b43 Initial load
duke
parents:
diff changeset
   951
                        // Go to top of loop and continue
90ce3da70b43 Initial load
duke
parents:
diff changeset
   952
                    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   953
                        if (debug) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   954
                            System.err.println("Connection: rethrowing " + ie);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   955
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   956
                        throw ie;  // rethrow exception
90ce3da70b43 Initial load
duke
parents:
diff changeset
   957
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   958
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   959
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   960
90ce3da70b43 Initial load
duke
parents:
diff changeset
   961
            if (debug) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   962
                System.err.println("Connection: end-of-stream detected: "
90ce3da70b43 Initial load
duke
parents:
diff changeset
   963
                    + in);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   964
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   965
        } catch (IOException ex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   966
            if (debug) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   967
                System.err.println("Connection: Caught " + ex);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   968
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   969
            closureReason = ex;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   970
        } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   971
            cleanup(null, true); // cleanup
90ce3da70b43 Initial load
duke
parents:
diff changeset
   972
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   973
        if (debug) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   974
            System.err.println("Connection: Thread Exiting");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   975
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   976
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   977
32933
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   978
    private static byte[] readFully(InputStream is, int length)
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   979
        throws IOException
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   980
    {
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   981
        byte[] buf = new byte[Math.min(length, 8192)];
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   982
        int nread = 0;
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   983
        while (nread < length) {
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   984
            int bytesToRead;
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   985
            if (nread >= buf.length) {  // need to allocate a larger buffer
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   986
                bytesToRead = Math.min(length - nread, buf.length + 8192);
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   987
                if (buf.length < nread + bytesToRead) {
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   988
                    buf = Arrays.copyOf(buf, nread + bytesToRead);
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   989
                }
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   990
            } else {
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   991
                bytesToRead = buf.length - nread;
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   992
            }
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   993
            int count = is.read(buf, nread, bytesToRead);
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   994
            if (count < 0) {
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   995
                if (buf.length != nread)
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   996
                    buf = Arrays.copyOf(buf, nread);
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   997
                break;
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   998
            }
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
   999
            nread += count;
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
  1000
        }
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
  1001
        return buf;
83d50f1247bb 8138978: Examine usages of sun.misc.IOUtils
chegar
parents: 30901
diff changeset
  1002
    }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1003
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1004
    // This code must be uncommented to run the LdapAbandonTest.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1005
    /*public void sendSearchReqs(String dn, int numReqs) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1006
        int i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1007
        String attrs[] = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1008
        for(i = 1; i <= numReqs; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1009
            BerEncoder ber = new BerEncoder(2048);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1010
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1011
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1012
            ber.beginSeq(Ber.ASN_SEQUENCE | Ber.ASN_CONSTRUCTOR);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1013
                ber.encodeInt(i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1014
                ber.beginSeq(LdapClient.LDAP_REQ_SEARCH);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1015
                    ber.encodeString(dn == null ? "" : dn);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1016
                    ber.encodeInt(0, LdapClient.LBER_ENUMERATED);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1017
                    ber.encodeInt(3, LdapClient.LBER_ENUMERATED);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1018
                    ber.encodeInt(0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1019
                    ber.encodeInt(0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1020
                    ber.encodeBoolean(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1021
                    LdapClient.encodeFilter(ber, "");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1022
                    ber.beginSeq(Ber.ASN_SEQUENCE | Ber.ASN_CONSTRUCTOR);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1023
                        ber.encodeStringArray(attrs);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1024
                    ber.endSeq();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1025
                ber.endSeq();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1026
            ber.endSeq();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1027
            writeRequest(ber, i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1028
            //System.err.println("wrote request " + i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1029
            } catch (Exception ex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1030
            //System.err.println("ldap.search: Caught " + ex + " building req");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1031
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1032
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1033
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1034
    } */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1035
}