/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package com.sun.jndi.ldap;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.InterruptedIOException;

import java.io.IOException;

import java.io.OutputStream;

import java.io.InputStream;

import java.net.Socket;

import javax.naming.CommunicationException;

import javax.naming.ServiceUnavailableException;

import javax.naming.NamingException;

import javax.naming.InterruptedNamingException;

import javax.naming.ldap.Control;

import java.lang.reflect.Method;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

//import javax.net.SocketFactory;

/**

  * A thread that creates a connection to an LDAP server.

  * After the connection, the thread reads from the connection.

  * A caller can invoke methods on the instance to read LDAP responses

  * and to send LDAP requests.

  * <p>

  * There is a one-to-one correspondence between an LdapClient and

  * a Connection. Access to Connection and its methods is only via

  * LdapClient with two exceptions: SASL authentication and StartTLS.

  * SASL needs to access Connection's socket IO streams (in order to do encryption

  * of the security layer). StartTLS needs to do replace IO streams

  * and close the IO  streams on nonfatal close. The code for SASL

  * authentication can be treated as being the same as from LdapClient

  * because the SASL code is only ever called from LdapClient, from

  * inside LdapClient's synchronized authenticate() method. StartTLS is called

  * directly by the application but should only occur when the underlying

  * connection is quiet.

  * <p>

  * In terms of synchronization, worry about data structures

  * used by the Connection thread because that usage might contend

  * with calls by the main threads (i.e., those that call LdapClient).

  * Main threads need to worry about contention with each other.

  * Fields that Connection thread uses:

  *     inStream - synced access and update; initialized in constructor;

  *           referenced outside class unsync'ed (by LdapSasl) only

  *           when connection is quiet

  *     traceFile, traceTagIn, traceTagOut - no sync; debugging only

  *     parent - no sync; initialized in constructor; no updates

  *     pendingRequests - sync

  *     pauseLock - per-instance lock;

  *     paused - sync via pauseLock (pauseReader())

  * Members used by main threads (LdapClient):

  *     host, port - unsync; read-only access for StartTLS and debug messages

  *     setBound(), setV3() - no sync; called only by LdapClient.authenticate(),

  *             which is a sync method called only when connection is "quiet"

  *     getMsgId() - sync

  *     writeRequest(), removeRequest(),findRequest(), abandonOutstandingReqs() -

  *             access to shared pendingRequests is sync

  *     writeRequest(),  abandonRequest(), ldapUnbind() - access to outStream sync

  *     cleanup() - sync

  *     readReply() - access to sock sync

  *     unpauseReader() - (indirectly via writeRequest) sync on pauseLock

  * Members used by SASL auth (main thread):

  *     inStream, outStream - no sync; used to construct new stream; accessed

  *             only when conn is "quiet" and not shared

  *     replaceStreams() - sync method

  * Members used by StartTLS:

  *     inStream, outStream - no sync; used to record the existing streams;

  *             accessed only when conn is "quiet" and not shared

  *     replaceStreams() - sync method

  * <p>

  * Handles anonymous, simple, and SASL bind for v3; anonymous and simple

  * for v2.

  * %%% made public for access by LdapSasl %%%

  *

  * @author Vincent Ryan

  * @author Rosanna Lee

  * @author Jagane Sundar

  */

public final class Connection implements Runnable {

    private static final boolean debug = false;

    private static final int dump = 0; // > 0 r, > 1 rw

    final private Thread worker;    // Initialized in constructor

    private boolean v3 = true;       // Set in setV3()

    final public String host;  // used by LdapClient for generating exception messages

                         // used by StartTlsResponse when creating an SSL socket

    final public int port;     // used by LdapClient for generating exception messages

                         // used by StartTlsResponse when creating an SSL socket

    private boolean bound = false;   // Set in setBound()

    // All three are initialized in constructor and read-only afterwards

    private OutputStream traceFile = null;

    private String traceTagIn = null;

    private String traceTagOut = null;

    // Initialized in constructor; read and used externally (LdapSasl);

    // Updated in replaceStreams() during "quiet", unshared, period

    public InputStream inStream;   // must be public; used by LdapSasl

    // Initialized in constructor; read and used externally (LdapSasl);

    // Updated in replaceOutputStream() during "quiet", unshared, period

    public OutputStream outStream; // must be public; used by LdapSasl

    // Initialized in constructor; read and used externally (TLS) to

    // get new IO streams; closed during cleanup

    public Socket sock;            // for TLS

    // For processing "disconnect" unsolicited notification

    // Initialized in constructor

    final private LdapClient parent;

    // Incremented and returned in sync getMsgId()

    private int outMsgId = 0;

    //

    // The list of ldapRequests pending on this binding

    //

    // Accessed only within sync methods

    private LdapRequest pendingRequests = null;

    volatile IOException closureReason = null;

    volatile boolean useable = true;  // is Connection still useable

    private int readTimeout;

    // true means v3; false means v2

    // Called in LdapClient.authenticate() (which is synchronized)

    // when connection is "quiet" and not shared; no need to synchronize

    void setV3(boolean v) {

        v3 = v;

    }

    // A BIND request has been successfully made on this connection

    // When cleaning up, remember to do an UNBIND

    // Called in LdapClient.authenticate() (which is synchronized)

    // when connection is "quiet" and not shared; no need to synchronize

    void setBound() {

        bound = true;

    }

    ////////////////////////////////////////////////////////////////////////////

    //

    // Create an LDAP Binding object and bind to a particular server

    //

    ////////////////////////////////////////////////////////////////////////////

    Connection(LdapClient parent, String host, int port, String socketFactory,

        int connectTimeout, int readTimeout, OutputStream trace) throws NamingException {

        this.host = host;

        this.port = port;

        this.parent = parent;

        this.readTimeout = readTimeout;

        if (trace != null) {

            traceFile = trace;

            traceTagIn = "<- " + host + ":" + port + "\n\n";

            traceTagOut = "-> " + host + ":" + port + "\n\n";

        }

        //

        // Connect to server

        //

        try {

            sock = createSocket(host, port, socketFactory, connectTimeout);

            if (debug) {

                System.err.println("Connection: opening socket: " + host + "," + port);

            }

            inStream = new BufferedInputStream(sock.getInputStream());

            outStream = new BufferedOutputStream(sock.getOutputStream());

        } catch (InvocationTargetException e) {

            Throwable realException = e.getTargetException();

            // realException.printStackTrace();

            CommunicationException ce =

                new CommunicationException(host + ":" + port);

            ce.setRootCause(realException);

            throw ce;

        } catch (Exception e) {

            // Class.forName() seems to do more error checking

            // and will throw IllegalArgumentException and such.

            // That's why we need to have a catch all here and

            // ignore generic exceptions.

            // Also catches all IO errors generated by socket creation.

            CommunicationException ce =

                new CommunicationException(host + ":" + port);

            ce.setRootCause(e);

            throw ce;

        }

        worker = Obj.helper.createThread(this);

        worker.setDaemon(true);

        worker.start();

    }

    /*

     * Create an InetSocketAddress using the specified hostname and port number.

     */

    private Object createInetSocketAddress(String host, int port)

            throws NoSuchMethodException {

        try {

            Class inetSocketAddressClass =

                Class.forName("java.net.InetSocketAddress");

            Constructor inetSocketAddressCons =

                inetSocketAddressClass.getConstructor(new Class[]{

                String.class, int.class});

            return inetSocketAddressCons.newInstance(new Object[]{

                host, new Integer(port)});

        } catch (ClassNotFoundException e) {

            throw new NoSuchMethodException();

        } catch (InstantiationException e) {

            throw new NoSuchMethodException();

        } catch (InvocationTargetException e) {

            throw new NoSuchMethodException();

        } catch (IllegalAccessException e) {

            throw new NoSuchMethodException();

        }

    }

    /*

     * Create a Socket object using the specified socket factory and time limit.

     *

     * If a timeout is supplied and unconnected sockets are supported then

     * an unconnected socket is created and the timeout is applied when

     * connecting the socket. If a timeout is supplied but unconnected sockets

     * are not supported then the timeout is ignored and a connected socket

     * is created.

     */

    private Socket createSocket(String host, int port, String socketFactory,

            int connectTimeout) throws Exception {

        Socket socket = null;

        if (socketFactory != null) {

            // create the factory

            Class socketFactoryClass = Obj.helper.loadClass(socketFactory);

            Method getDefault =

                socketFactoryClass.getMethod("getDefault", new Class[]{});

            Object factory = getDefault.invoke(null, new Object[]{});

            // create the socket

            Method createSocket = null;

            if (connectTimeout > 0) {

                try {

                    createSocket = socketFactoryClass.getMethod("createSocket",

                        new Class[]{});

                    Method connect = Socket.class.getMethod("connect",

                        new Class[]{Class.forName("java.net.SocketAddress"),

                        int.class});

                    Object endpoint = createInetSocketAddress(host, port);

                    // unconnected socket

                    socket =

                        (Socket)createSocket.invoke(factory, new Object[]{});

                    if (debug) {

                        System.err.println("Connection: creating socket with " +

                            "a timeout using supplied socket factory");

                    }

                    // connected socket

                    connect.invoke(socket, new Object[]{

                        endpoint, new Integer(connectTimeout)});

                } catch (NoSuchMethodException e) {

                    // continue (but ignore connectTimeout)

                }

            }

            if (socket == null) {

                createSocket = socketFactoryClass.getMethod("createSocket",

                    new Class[]{String.class, int.class});

                if (debug) {

                    System.err.println("Connection: creating socket using " +

                        "supplied socket factory");

                }

                // connected socket

                socket = (Socket) createSocket.invoke(factory,

                    new Object[]{host, new Integer(port)});

            }

        } else {

            if (connectTimeout > 0) {

                try {

                    Constructor socketCons =

                        Socket.class.getConstructor(new Class[]{});

                    Method connect = Socket.class.getMethod("connect",

                        new Class[]{Class.forName("java.net.SocketAddress"),

                        int.class});

                    Object endpoint = createInetSocketAddress(host, port);

                    socket = (Socket) socketCons.newInstance(new Object[]{});

                    if (debug) {

                        System.err.println("Connection: creating socket with " +

                            "a timeout");

                    }

                    connect.invoke(socket, new Object[]{

                        endpoint, new Integer(connectTimeout)});

                } catch (NoSuchMethodException e) {

                    // continue (but ignore connectTimeout)

                }

            }

            if (socket == null) {

                if (debug) {

                    System.err.println("Connection: creating socket");

                }

                // connected socket

                socket = new Socket(host, port);

            }

        }

        return socket;

    }

    ////////////////////////////////////////////////////////////////////////////

    //

    // Methods to IO to the LDAP server

    //

    ////////////////////////////////////////////////////////////////////////////

    synchronized int getMsgId() {

        return ++outMsgId;

    }

    LdapRequest writeRequest(BerEncoder ber, int msgId) throws IOException {

        return writeRequest(ber, msgId, false /* pauseAfterReceipt */);

    }

    LdapRequest writeRequest(BerEncoder ber, int msgId, boolean pauseAfterReceipt)

        throws IOException {

        LdapRequest req = new LdapRequest(msgId, pauseAfterReceipt);

        addRequest(req);

        if (traceFile != null) {

            Ber.dumpBER(traceFile, traceTagOut, ber.getBuf(), 0, ber.getDataLen());

        }

        // unpause reader so that it can get response

        // NOTE: Must do this before writing request, otherwise might

        // create a race condition where the writer unblocks its own response

        unpauseReader();

        if (debug) {

            System.err.println("Writing request to: " + outStream);

        }

        try {

            synchronized (this) {

                outStream.write(ber.getBuf(), 0, ber.getDataLen());

                outStream.flush();

            }

        } catch (IOException e) {

            cleanup(null, true);

            throw (closureReason = e); // rethrow

        }

        return req;

    }

    /**

     * Reads a reply; waits until one is ready.

     */

    BerDecoder readReply(LdapRequest ldr)

            throws IOException, NamingException {

        BerDecoder rber;

        boolean waited = false;

        while (((rber = ldr.getReplyBer()) == null) && !waited) {

            try {

                // If socket closed, don't even try

                synchronized (this) {

                    if (sock == null) {

                        throw new ServiceUnavailableException(host + ":" + port +

                            "; socket closed");

                    }

                }

                synchronized (ldr) {

                    // check if condition has changed since our last check

                    rber = ldr.getReplyBer();

                    if (rber == null) {

                        if (readTimeout > 0) {  // Socket read timeout is specified

                            // will be woken up before readTimeout only if reply is

                            // available

                            ldr.wait(readTimeout);

                            waited = true;

                        } else {

                            ldr.wait(15 * 1000); // 15 second timeout

                        }

                    } else {

                        break;

                    }

                }

            } catch (InterruptedException ex) {

                throw new InterruptedNamingException(

                    "Interrupted during LDAP operation");

            }

        }

        if ((rber == null) && waited) {

            removeRequest(ldr);

            throw new NamingException("LDAP response read timed out, timeout used:"

                            + readTimeout + "ms." );

        }

        return rber;

    }

    ////////////////////////////////////////////////////////////////////////////

    //

    // Methods to add, find, delete, and abandon requests made to server

    //

    ////////////////////////////////////////////////////////////////////////////

    private synchronized void addRequest(LdapRequest ldapRequest) {

        LdapRequest ldr = pendingRequests;

        if (ldr == null) {

            pendingRequests = ldapRequest;

            ldapRequest.next = null;

        } else {

            ldapRequest.next = pendingRequests;

            pendingRequests = ldapRequest;

        }

    }

    synchronized LdapRequest findRequest(int msgId) {

        LdapRequest ldr = pendingRequests;

        while (ldr != null) {

            if (ldr.msgId == msgId) {

                return ldr;

            }

            ldr = ldr.next;

        }

        return null;

    }

    synchronized void removeRequest(LdapRequest req) {

        LdapRequest ldr = pendingRequests;

        LdapRequest ldrprev = null;

        while (ldr != null) {

            if (ldr == req) {

                ldr.cancel();

                if (ldrprev != null) {

                    ldrprev.next = ldr.next;

                } else {

                    pendingRequests = ldr.next;

                }

                ldr.next = null;

            }

            ldrprev = ldr;

            ldr = ldr.next;

        }

    }

    void abandonRequest(LdapRequest ldr, Control[] reqCtls) {

        // Remove from queue

        removeRequest(ldr);

        BerEncoder ber = new BerEncoder(256);

        int abandonMsgId = getMsgId();

        //

        // build the abandon request.