/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
 /* Setup:
  *  - Set environment variables as below for each URL being
  *     tested, along with dns and credentials.
  *  - Copy the server certificates to the data/ directory.
  *     All DER type certificates must have the .der extention.
  *     All BASE64 or PEM certificates must have the .b64
  *     extension.  All certificate files copied to the /data
  *     directory will be added to the ldap certificate store.
  */
   
 /* This test covers the following three types of connections:
  *
  *  - Unsecure ldap://
  *  - Secure ldaps://
  *  - Secure ldap://+Start_TLS
  *  - Unix ldapi://
  *
  * Environment variables:
  *
  * One or more of the following, based on what you have available.
  *
  * - TESTLDAP=ldap://localhost:389
  * - TESTLDAP_TLS=ldap://starttls.server:389
  * - TESTLDAPS=ldaps://ssl.server:636
  * - TESTLDAPI=/tmp/slapd-server.socket
  *
  * Simple bind:
  *
  * - TESTLDAP_DN=cn=Directory Manager
  * - TESTLDAP_PASS=opensesame
  *
  * SASL PLAIN bind:
  *
  * - TESTLDAP_USER=sasluser
  * - TESTLDAP_AUTHNAME=sasluser
  * - TESTLDAP_PASS=opensesame
  *
  * SASL EXTERNAL bind is attempted where supported.
  */

 /*
  * For a working example of an asynchronous LDAP conversation involving a bind,
  * followed by a search, followed by a compare, start at test_ldap_connection()
  * below.
  */

#include "testutil.h"

#include "apr.h"
#include "apr_general.h"
#include "apr_ldap.h"
#include "apr_escape.h"
#include "apr_file_io.h"
#include "apr_file_info.h"
#include "apr_poll.h"
#include "apr_strings.h"
#if APR_HAVE_STDLIB_H
#include <stdlib.h>
#endif
#define APR_WANT_STDIO
#define APR_WANT_STRFUNC
#include "apr_want.h"

#define DIRNAME "data"
#define FILENAME DIRNAME "/host.data"
#define CERTFILEDER DIRNAME "/*.der"
#define CERTFILEB64 DIRNAME "/*.b64"

#if APR_HAS_LDAP

static int add_ldap_certs(abts_case *tc)
{
    apr_status_t status;
    apr_dir_t *thedir;
    apr_finfo_t dirent;
    apu_err_t err;

    if ((status = apr_dir_open(&thedir, DIRNAME, p)) == APR_SUCCESS) {
        apr_ldap_opt_tls_cert_t *cert = (apr_ldap_opt_tls_cert_t *)apr_pcalloc(p, sizeof(apr_ldap_opt_tls_cert_t));

        do {
            status = apr_dir_read(&dirent, APR_FINFO_MIN | APR_FINFO_NAME, thedir);
            if (APR_STATUS_IS_INCOMPLETE(status)) {
                continue; /* ignore un-stat()able files */
            }
            else if (status != APR_SUCCESS) {
                break;
            }

            if (strstr(dirent.name, ".der")) {
                cert->type = APR_LDAP_CA_TYPE_DER;
                cert->path = apr_pstrcat (p, DIRNAME, "/", dirent.name, NULL);
                apr_ldap_option_set(p, NULL, APR_LDAP_OPT_TLS_CERT, (void *)cert, &err);
                ABTS_TRUE(tc, err.rc == APR_SUCCESS);
            }
            if (strstr(dirent.name, ".b64")) {
                cert->type = APR_LDAP_CA_TYPE_BASE64;
                cert->path = apr_pstrcat (p, DIRNAME, "/", dirent.name, NULL);
                apr_ldap_option_set(p, NULL, APR_LDAP_OPT_TLS_CERT, (void *)cert, &err);
                ABTS_TRUE(tc, err.rc == APR_SUCCESS);
            }

        } while (1);

        apr_dir_close(thedir);
    }
    return 0;
}

static apr_status_t bind_interact_simple(apr_ldap_t *ld, unsigned int flags, apr_ldap_bind_interact_t *interact, void *ctx)
{ 

    switch (interact->id) {
    case APR_LDAP_INTERACT_DN: {
        char *dn = getenv("TESTLDAP_DN");
        apr_buffer_str_set(&interact->result, dn ? dn : "", APR_BUFFER_STRING);
        break;
    }
    case APR_LDAP_INTERACT_PASS: {
        char *pass = getenv("TESTLDAP_PASS");
        apr_buffer_str_set(&interact->result, pass ? pass : "opensesame", APR_BUFFER_STRING);
        break;
    }
    default:
        break;
    }

    return APR_SUCCESS;
} 
  
static apr_status_t bind_interact_external(apr_ldap_t *ld, unsigned int flags, apr_ldap_bind_interact_t *interact, void *ctx)
{
    return APR_SUCCESS;
}

static apr_status_t bind_interact_plain(apr_ldap_t *ld, unsigned int flags, apr_ldap_bind_interact_t *interact, void *ctx)
{

    switch (interact->id) {
    case APR_LDAP_INTERACT_USER: {
        char *user = getenv("TESTLDAP_USER");
        apr_buffer_str_set(&interact->result, user ? user : "", APR_BUFFER_STRING);
        break;
    }   
    case APR_LDAP_INTERACT_AUTHNAME: {
        char *authname = getenv("TESTLDAP_AUTHNAME");
        apr_buffer_str_set(&interact->result, authname ? authname : "", APR_BUFFER_STRING);
        break;
    }
    case APR_LDAP_INTERACT_PASS: {
        char *pass = getenv("TESTLDAP_PASS");
        apr_buffer_str_set(&interact->result, pass ? pass : "opensesame", APR_BUFFER_STRING);
        break;
    }    
    default:
        break;
    }   

    return APR_SUCCESS;
}

static apr_status_t bind_interact_abandon(apr_ldap_t *ld, unsigned int flags, apr_ldap_bind_interact_t *interact, void *ctx)
{

    switch (interact->id) {
    case APR_LDAP_INTERACT_USER: {
        apr_buffer_str_set(&interact->result, "cn=notexist", APR_BUFFER_STRING);
        break;
    }
    case APR_LDAP_INTERACT_AUTHNAME: {
        apr_buffer_str_set(&interact->result, "cn=notexist", APR_BUFFER_STRING);
        break;
    }
    case APR_LDAP_INTERACT_PASS: {
        apr_buffer_str_set(&interact->result, "wrongpassword", APR_BUFFER_STRING);
        break;
    }
    default:
        break;
    }

    return APR_SUCCESS;
}

typedef struct test_ldap_connection_t {
    abts_case *tc;
    apr_pool_t *pool;
    apr_ldap_t *ldap;
    apr_pool_t *bind_pool;
    const char *mech;
    apr_ldap_bind_interact_cb *interact;
    apr_pollcb_t *poll;
    apr_pollfd_t socket_read;
    apr_pollfd_t socket_write;
    apu_err_t err;
    int must_bind;
} test_ldap_connection_t;

static apr_status_t test_ldap_compare_cb(apr_ldap_t *ldap,
                                         apr_status_t status,
                                         const char *matcheddn,
                                         apr_ldap_control_t **serverctrls,
                                         void *ctx, apu_err_t *err)
{
    test_ldap_connection_t *test = (test_ldap_connection_t *)ctx;

    /*
     * Step 13: compare result callback triggered, result is complete.
     */

    abts_log_message("comparison matcheddn: \n", matcheddn);

    ABTS_INT_EQUAL(test->tc, APR_COMPARE_TRUE, status);

    return APR_SUCCESS;
}      

static apr_status_t test_ldap_search_entry_cb(apr_ldap_t *ldap,
                                              const char *dn,
                                              int eidx,
                                              int nattrs,
                                              int aidx,
                                              const char *attr,
                                              int nvals,
                                              int vidx,
                                              apr_buffer_t *val,
                                              int binary,
                                              void *ctx, apu_err_t *err)
{
    test_ldap_connection_t *test = (test_ldap_connection_t *)ctx;

    /*
     * Step 8: search entry callback triggered, start processing results.
     */

    if (!nattrs && !vidx && attr) {
        /* first attribute and first value and attr present? output dn */
        abts_log_message("dn: %s", dn);
    }

    if (val) {
        abts_log_message("%s: %s", attr, apr_buffer_pstrdup(test->pool, val));
    }

    return APR_SUCCESS;
}


static apr_status_t test_ldap_search_result_cb(apr_ldap_t *ldap, 
                                               apr_status_t status,
                                               apr_size_t nentries,
                                               const char *matcheddn,
                                               apr_ldap_control_t **serverctrls,
                                               void *ctx, apu_err_t *err)
{
    char errbuf[128];
    test_ldap_connection_t *test = (test_ldap_connection_t *)ctx;

    /*
     * Step 9: search result callback triggered, finish up.
     */

    abts_log_message("\n");

    ABTS_INT_EQUAL(test->tc, APR_SUCCESS, status);

    if (APR_SUCCESS == status) {

        /*
         * Step 10: search successful, it is time to trigger the compare.
         */

        apr_buffer_t val;
        apr_buffer_str_set(&val, "top", APR_BUFFER_STRING);

        /*
         * Step 11: we're writable, trigger a compare, then wait for readable.
         */

        status = apr_ldap_compare(test->pool, test->ldap, "" /* root dn */,
                                 "objectclass" /* attribute */, &val /* value */,
                                 NULL /* serverctls */, NULL /* clientctls */,
                                 apr_time_from_sec(5) /* timeout */,
                                 test_ldap_compare_cb, test, &test->err);

        ABTS_INT_EQUAL(test->tc, APR_WANT_READ, status);

        switch (status) {
        case APR_SUCCESS:
        case APR_WANT_READ:
        case APR_WANT_WRITE:
            break;
        default:
            abts_log_message("apr_ldap_result: %s [%s]\n", test->err.reason,
                              apr_strerror(status, errbuf, sizeof(errbuf)));
        }

    }
    else {
        abts_log_message("apr_ldap_search() failed: %s\n", apr_strerror(status, errbuf, sizeof(errbuf)));
    }

    return status;
}

static apr_status_t test_ldap_bind_cb(apr_ldap_t *ldap, apr_status_t status,
                                         const char *matcheddn,
                                         apr_ldap_control_t **serverctrls,
                                         void *ctx, apu_err_t *err)
{
    char errbuf[128];
    test_ldap_connection_t *test = (test_ldap_connection_t *)ctx;

    if (APR_SUCCESS == status) {

        /*
         * Step 5: bind successful, it is time to trigger the search.
         */

        const char *attrs[2];
        attrs[0] = "+";
        attrs[1] = NULL;

        /*
         * Step 6: we're writable, trigger a search, then wait for readable.
         */

        status = apr_ldap_search(test->pool, test->ldap, "" /* root dn */,
                                 APR_LDAP_SCOPE_BASE, "(objectclass=*)" /* filter */,
                                 attrs /* attrs */, APR_LDAP_OPT_OFF /* attrsonly */,
                                 NULL /* serverctls */, NULL /* clientctls */,
                                 apr_time_from_sec(5) /* timelimit */, 0 /* sizelimit */,
                                 test_ldap_search_result_cb, test_ldap_search_entry_cb, test, &test->err);

        ABTS_INT_EQUAL(test->tc, APR_WANT_READ, status);

        switch (status) {
        case APR_SUCCESS:
        case APR_WANT_READ:
        case APR_WANT_WRITE:
            break;
        default:
            abts_log_message("apr_ldap_result: %s [%s]\n", test->err.reason,
                              apr_strerror(status, errbuf, sizeof(errbuf)));
        }

    }
    else {
        abts_log_message("apr_ldap_bind() failed: %s\n", apr_strerror(status, errbuf, sizeof(errbuf)));
    }

    return status;
}

static apr_status_t test_ldap_initialise_cb(apr_ldap_t *ldap, apr_status_t status,
                                            void *ctx, apu_err_t *err)
{
    char errbuf[128];
    test_ldap_connection_t *test = (test_ldap_connection_t *)ctx;

    if (APR_SUCCESS == status) {

        /*
         * Step 2: we're writable, trigger the initial bind, then wait for readable.
         */

        status = apr_ldap_bind(test->pool, test->ldap, test->mech, test->interact, NULL,
                               apr_time_from_sec(0), test_ldap_bind_cb, test, &test->err);

        ABTS_INT_EQUAL(test->tc, APR_WANT_READ, status);

        switch (status) {
        case APR_SUCCESS:
        case APR_WANT_READ:
        case APR_WANT_WRITE:
            return status;
        default:
            abts_log_message("apr_ldap_result: %s [%s]\n", test->err.reason,
                              apr_strerror(status, errbuf, sizeof(errbuf)));
            return status;
        }

    }
    else {
        abts_log_message("initialise failed: %s\n", apr_strerror(status, errbuf, sizeof(errbuf)));
    }

    return status;
}

static apr_status_t test_ldap_connection_cb(void *baton, apr_pollfd_t *descriptor)
{
    char errbuf[128];
    test_ldap_connection_t *test = (test_ldap_connection_t *) baton;

    apr_status_t status = APR_SUCCESS;

    /* remove our event */
    apr_pollcb_remove(test->poll, descriptor);

    /* are we ready to write? */
    if (descriptor->rtnevents & APR_POLLOUT) {

        /*
         * Step 4: bind callback triggered, continue the bind processing.
         */

        /* handle oustanding tasks */
        status = apr_ldap_process(test->pool, test->ldap, apr_time_from_sec(0), &test->err);

        switch (status) {
        case APR_SUCCESS:
        case APR_WANT_READ:
        case APR_WANT_WRITE:
            break;
        default:
            abts_log_message("apr_ldap_result: %s [%s]\n", test->err.reason,
                              apr_strerror(status, errbuf, sizeof(errbuf)));
        }

    }

    /* are we ready to read? */
    else if (descriptor->rtnevents & APR_POLLIN) {

        /*
         * Step 3: we're readable, fetch the bind result, then request a write to be scheduled.
         */

        /*
         * Step 7: we're readable, fetch the search result, then trigger search callback.
         */

        /*
         * Step 12: we're readable, fetch the compare result, then trigger compare callback.
         */

        status = apr_ldap_result(test->pool, test->ldap, -1, &test->err);

        switch (status) {
        case APR_SUCCESS:
        case APR_WANT_READ:
        case APR_WANT_WRITE:
            break;
        default:
            abts_log_message("apr_ldap_result: %s [%s]\n", test->err.reason,
                              apr_strerror(status, errbuf, sizeof(errbuf)));
        }

    }

    return status;
}

/*
 * Asynchronous test of an LDAP connection.
 *
 * Like all async code, we jump around a lot. In this example we make
 * an attempt to bind, and that that was successful, we make an
 * attempt to search for the root DSE, then if that was successful,
 * we attempt a compare.
 *
 * Start at "Step 1" and follow each step through the callbacks.
 */

static void test_ldap_connection(abts_case *tc, apr_pool_t *pool, apr_ldap_t *ldap,
                                 const char *mech, apr_ldap_bind_interact_cb *interact)
{
    char errbuf[128];
    apu_err_t err;
    test_ldap_connection_t test;
    apr_ldap_opt_t opt;
    apr_status_t status;

    memset(&test, 0, sizeof(test_ldap_connection_t));
 
    test.tc = tc;
    test.pool = pool;
    test.ldap = ldap;
    test.mech = mech;
    test.interact = interact;

    /* always default to LDAP V3 */
    opt.pv = APR_LDAP_VERSION3;
    apr_ldap_option_set(pool, ldap, APR_LDAP_OPT_PROTOCOL_VERSION, &opt, &err);


    /*
     * Step 1: call us back when we're writable.
     */

    /* set the initialise callback */
    apr_ldap_prepare(pool, ldap, test_ldap_initialise_cb, &test);


    apr_ldap_option_get(pool, ldap, APR_LDAP_OPT_HANDLE, &opt, &err);
    ABTS_TRUE(tc, opt.handle != NULL);

    status = apr_ldap_connect(pool, ldap, apr_time_from_sec(5), &err);

    if (APR_SUCCESS != status) {
        abts_log_message("%s - %s (%d)\n", err.reason, err.msg, err.rc);
        return;
    }


    status = apr_ldap_option_get(pool, ldap, APR_LDAP_OPT_DESC, &opt, &err);
    ABTS_TRUE(tc, status == APR_SUCCESS);
    ABTS_ASSERT(tc, "failed to get descriptor", opt.socket != NULL);

    status = apr_pollcb_create(&test.poll, 1, pool, APR_POLLSET_DEFAULT);
    if (APR_ENOTIMPL == status) {
        abts_log_message("apr_pollcb_create() not implemented on this platform, skipping test\n");
        return;
    }
    ABTS_TRUE(tc, status == APR_SUCCESS);
    if (APR_SUCCESS != status) {
        return;
    }

    /* set up read descriptor */
    test.socket_read.desc_type = APR_POLL_SOCKET;
    test.socket_read.reqevents = APR_POLLIN;
    test.socket_read.desc.s = opt.socket;
    test.socket_read.client_data = opt.socket;

    /* set up write descriptor */
    test.socket_write.desc_type = APR_POLL_SOCKET;
    test.socket_write.reqevents = APR_POLLOUT;
    test.socket_write.desc.s = opt.socket;
    test.socket_write.client_data = opt.socket;

    status = APR_WANT_WRITE;

    do {

        if (APR_SUCCESS == status) {
            abts_log_message("apr_pollcb_poll() complete\n");
            break;
        }
        else if (APR_WANT_READ == status) {

            /* wait for socket to be readable, then process another result */
            status = apr_pollcb_add(test.poll, &test.socket_read);
            ABTS_INT_EQUAL(tc, APR_SUCCESS, status);
            if (APR_SUCCESS != status) {
                break;
            }

        }
        else if (APR_WANT_WRITE == status) {

            /* wait for socket to be writeable, then process result */
            status = apr_pollcb_add(test.poll, &test.socket_write);
            ABTS_INT_EQUAL(tc, APR_SUCCESS, status);
            if (APR_SUCCESS != status) {
                break;
            }

        }
        else {
            abts_log_message("apr_ldap_process/apr_ldap_result: %s [%s]\n", test.err.reason,
                              apr_strerror(status, errbuf, sizeof(errbuf)));
            break;
        }

        status = apr_pollcb_poll(test.poll, -1, test_ldap_connection_cb, &test);

    } while (1);


    /*
     * Step 14: bind, search, compare, result is complete, event loop unwound.
     */

    return;
}

/*
 * Synchronous test of an LDAP connection.
 *
 * The code below is identical to the above code, but uses the event loop inside
 * apr_ldap_poll().
 *
 * The initial callback test_ldap_initialise_cb is set, all queries are bootstrapped
 * from this callback.
 */

#if 0
static void test_ldap_connection(abts_case *tc, apr_pool_t *pool, apr_ldap_t *ldap,
                                 const char *mech, apr_ldap_bind_interact_cb *interact)
{
    char errbuf[128];
    apu_err_t err;
    test_ldap_connection_t test;
    apr_ldap_opt_t opt;
    apr_status_t status;

    memset(&test, 0, sizeof(test_ldap_connection_t));

    test.tc = tc;
    test.pool = pool;
    test.ldap = ldap;
    test.mech = mech;
    test.interact = interact;


    /* always default to LDAP V3 */
    opt.pv = APR_LDAP_VERSION3;
    apr_ldap_option_set(pool, ldap, APR_LDAP_OPT_PROTOCOL_VERSION, &opt, &err);


    /* set the initialise callback */
    apr_ldap_prepare(pool, ldap, test_ldap_initialise_cb, &test);


    /* initial connect */
    status = apr_ldap_connect(pool, ldap, apr_time_from_sec(5), &err);

    if (APR_SUCCESS != status) {
        abts_log_message("%s - %s (%d)\n", err.reason, err.msg, err.rc);
        return;
    }


    /* run the callbacks */
    status = apr_ldap_poll(pool, ldap, apr_time_from_sec(5), &err);

    if (APR_SUCCESS == status) {
        abts_log_message("apr_pollcb_poll() complete\n");
    }
    else {
        abts_log_message("apr_ldap_process/apr_ldap_result: %s [%s]\n", test.err.reason,
                              apr_strerror(status, errbuf, sizeof(errbuf)));
    }


    return;
}
#endif


static apr_status_t test_ldap_abandon_cb(void *baton, apr_pollfd_t *descriptor)
{
    char errbuf[128];
    test_ldap_connection_t *test = (test_ldap_connection_t *) baton;

    apr_status_t status = APR_SUCCESS;

    /* remove our event */
    apr_pollcb_remove(test->poll, descriptor);

    /* are we ready to write? */
    if (descriptor->rtnevents & APR_POLLOUT) {

        if (test->must_bind) {

            /*
             * Step B: we're writable, trigger the initial bind from the bind_pool, then wait for readable.
             */

            status = apr_ldap_bind(test->bind_pool, test->ldap, test->mech, test->interact, NULL, apr_time_from_sec(0), test_ldap_bind_cb, test, &test->err);

            test->must_bind = 0;

            ABTS_INT_EQUAL(test->tc, APR_WANT_READ, status);

            if (APR_SUCCESS == status) {
                /* should not have happened */
                return status;
            }
            else if (APR_WANT_READ == status) {

                /*
                 * Step C: spanner in the works - lets abandon the bind.
                 */

                apr_pool_destroy(test->bind_pool);

                test->bind_pool = NULL;

                abts_log_message("bind abandon triggered\n");

                /* and then continue as if nothing had happened */

                return status;

            }
            else {
                return status;
            }

        }

        /*
         * Step E: write callback triggered, send the abandon.
         */

        /* handle oustanding tasks */
        status = apr_ldap_process(test->pool, test->ldap, apr_time_from_sec(0), &test->err);

        ABTS_INT_EQUAL(test->tc, APR_SUCCESS, status);

        switch (status) {
        case APR_SUCCESS:
        case APR_WANT_READ:
        case APR_WANT_WRITE:
            return status;
        default:
            abts_log_message("apr_ldap_result: %s [%s]\n", test->err.reason,
                              apr_strerror(status, errbuf, sizeof(errbuf)));
            return status;
        }

    }

    /* are we ready to read? */
    if (descriptor->rtnevents & APR_POLLIN) {

        /*
         * Step D: we're readable, but our bind has been abandoned.
         */

        status = apr_ldap_result(test->pool, test->ldap, -1, &test->err);

        ABTS_INT_EQUAL(test->tc, APR_WANT_WRITE, status);

        switch (status) {
        case APR_SUCCESS:
        case APR_WANT_READ:
        case APR_WANT_WRITE:
            return status;
        default:
            abts_log_message("apr_ldap_result: %s [%s]\n", test->err.reason,
                              apr_strerror(status, errbuf, sizeof(errbuf)));
            return status;
        }

    }

    return status;
}

static void test_ldap_abandon(abts_case *tc, apr_pool_t *pool, apr_ldap_t *ldap)
{
    char errbuf[128];
    apu_err_t err;
    test_ldap_connection_t test;
    apr_ldap_opt_t opt;
    apr_status_t status;

    memset(&test, 0, sizeof(test_ldap_connection_t));

    test.tc = tc;
    test.pool = pool;
    test.ldap = ldap;
    test.mech = "PLAIN";
    test.interact = bind_interact_abandon;

    test.must_bind = 1;

    apr_pool_create(&test.bind_pool, test.pool);


    /* always default to LDAP V3 */
    opt.pv = APR_LDAP_VERSION3;
    apr_ldap_option_set(pool, ldap, APR_LDAP_OPT_PROTOCOL_VERSION, &opt, &err);

    apr_ldap_option_get(pool, ldap, APR_LDAP_OPT_HANDLE, &opt, &err);
    ABTS_TRUE(tc, opt.handle != NULL);

    status = apr_ldap_connect(pool, ldap, apr_time_from_sec(5), &err);

    if (APR_SUCCESS != status) {
        abts_log_message("%s - %s (%d)\n", err.reason, err.msg, err.rc);
        return;
    }

    status = apr_ldap_option_get(pool, ldap, APR_LDAP_OPT_DESC, &opt, &err);
    ABTS_TRUE(tc, status == APR_SUCCESS);
    ABTS_ASSERT(tc, "failed to get descriptor", opt.socket != NULL);

    status = apr_pollcb_create(&test.poll, 1, pool, APR_POLLSET_DEFAULT);
    if (APR_ENOTIMPL == status) {
        abts_log_message("apr_pollcb_create() not implemented on this platform, skipping test\n");
        return;
    }
    ABTS_TRUE(tc, status == APR_SUCCESS);
    if (APR_SUCCESS != status) {
        return;
    }

    /* set up read descriptor */
    test.socket_read.desc_type = APR_POLL_SOCKET;
    test.socket_read.reqevents = APR_POLLIN;
    test.socket_read.desc.s = opt.socket;
    test.socket_read.client_data = opt.socket;

    /* set up write descriptor */
    test.socket_write.desc_type = APR_POLL_SOCKET;
    test.socket_write.reqevents = APR_POLLOUT;
    test.socket_write.desc.s = opt.socket;
    test.socket_write.client_data = opt.socket;


    /*
     * Step A: call us back when we're writable.
     */

    status = APR_WANT_WRITE;

    do {

        if (APR_SUCCESS == status) {
            abts_log_message("apr_pollcb_poll() complete\n");
            break;
        }
        else if (APR_WANT_READ == status) {

            /* wait for socket to be readable, then process another result */
            status = apr_pollcb_add(test.poll, &test.socket_read);
            ABTS_INT_EQUAL(tc, APR_SUCCESS, status);
            if (APR_SUCCESS != status) {
                break;
            }

        }
        else if (APR_WANT_WRITE == status) {

            /* wait for socket to be writeable, then process result */
            status = apr_pollcb_add(test.poll, &test.socket_write);
            ABTS_INT_EQUAL(tc, APR_SUCCESS, status);
            if (APR_SUCCESS != status) {
                break;
            }

        }
        else {
            abts_log_message("apr_ldap_result: %s [%s]\n", test.err.reason,
                              apr_strerror(status, errbuf, sizeof(errbuf)));
            break;
        }

        status = apr_pollcb_poll(test.poll, -1, test_ldap_abandon_cb, &test);

    } while (1);

    /*
     * Step F: bind, result, abandon is complete, event loop unwound.
     */

    return;
}


static void test_ldap_global_opts(abts_case *tc, void *data)
{
    apr_pool_t *pool;
    apu_err_t err;
    apr_ldap_opt_t opt;
    apr_status_t status;

    char errbuf[128];

    apr_pool_create(&pool, p);

    status = apr_ldap_option_get(pool, NULL, APR_LDAP_OPT_API_INFO, &opt, &err);

    if (status != APR_SUCCESS) {
        abts_log_message("apr_ldap_option_get: %s [%s]\n", err.reason,
                          apr_strerror(status, errbuf, sizeof(errbuf)));
    }

    ABTS_TRUE(tc, status == APR_SUCCESS);
    ABTS_TRUE(tc, err.rc == 0);
    ABTS_TRUE(tc, opt.info.vendor_name != NULL);

    opt.ldfi.name = "THREAD_SAFE";
    status = apr_ldap_option_get(pool, NULL, APR_LDAP_OPT_API_FEATURE_INFO, &opt, &err);
    /* feature may exist, or may not */
    ABTS_TRUE(tc, status == APR_SUCCESS || status == APR_EINVAL);

    status = apr_ldap_option_get(pool, NULL, APR_LDAP_OPT_DEBUG_LEVEL, &opt, &err);
    if (APR_ENOTIMPL == status) {
        abts_log_message("apr_ldap_option_get(APR_LDAP_OPT_DEBUG_LEVEL) not implemented on this platform, skipping test\n");
        return;
    }       
    else {
        ABTS_TRUE(tc, status == APR_SUCCESS);
    }

    apr_pool_destroy(pool);
}

static void test_ldap_opts(abts_case *tc, void *data)
{
    apr_pool_t *pool;
    apr_ldap_t *ldap = NULL;
    apu_err_t err;
    const char *url;

    apr_pool_create(&pool, p);

    url = apr_psprintf(pool, "ldap://%s:%d", "localhost", APR_LDAP_PORT);

    apr_ldap_initialise(pool, &ldap, &(err));

    ABTS_TRUE(tc, ldap != NULL);

    if (ldap) {

        apr_status_t status;
        apr_ldap_opt_t opt;

        opt.uri = url;
        status = apr_ldap_option_set(pool, ldap, APR_LDAP_OPT_URI, &opt, &err);
        ABTS_TRUE(tc, status == APR_SUCCESS); 
        status = apr_ldap_option_get(pool, ldap, APR_LDAP_OPT_URI, &opt, &err);
        ABTS_TRUE(tc, status == APR_SUCCESS);
        ABTS_ASSERT(tc, "failed to set uri", !strcmp(opt.uri, url));

        opt.pv = APR_LDAP_VERSION3;
        status = apr_ldap_option_set(pool, ldap, APR_LDAP_OPT_PROTOCOL_VERSION, &opt, &err);
        ABTS_TRUE(tc, status == APR_SUCCESS);
        status = apr_ldap_option_get(pool, ldap, APR_LDAP_OPT_PROTOCOL_VERSION, &opt, &err);
        ABTS_TRUE(tc, status == APR_SUCCESS);
        ABTS_ASSERT(tc, "failed to set protocol version", opt.pv == APR_LDAP_VERSION3);

        opt.deref = APR_LDAP_DEREF_ALWAYS;
        status = apr_ldap_option_set(pool, ldap, APR_LDAP_OPT_DEREF, &opt, &err);
        ABTS_TRUE(tc, status == APR_SUCCESS);
        status = apr_ldap_option_get(pool, ldap, APR_LDAP_OPT_DEREF, &opt, &err);
        ABTS_TRUE(tc, status == APR_SUCCESS);
        ABTS_ASSERT(tc, "failed to set deref", opt.deref == APR_LDAP_DEREF_ALWAYS);

        opt.refs = APR_LDAP_OPT_ON;
        status = apr_ldap_option_set(pool, ldap, APR_LDAP_OPT_REFERRALS, &opt, &err);
        ABTS_TRUE(tc, status == APR_SUCCESS);
        status = apr_ldap_option_get(pool, ldap, APR_LDAP_OPT_REFERRALS, &opt, &err);
        ABTS_TRUE(tc, status == APR_SUCCESS);
        ABTS_ASSERT(tc, "failed to set referrals", opt.refs == APR_LDAP_OPT_ON);

#if 0
        opt.refhoplimit = 5;
        status = apr_ldap_option_set(pool, ldap, APR_LDAP_OPT_REFHOPLIMIT, &opt, &err);
        if (APR_ENOTIMPL != status) {
            ABTS_TRUE(tc, status == APR_SUCCESS); 
            status = apr_ldap_option_get(pool, ldap, APR_LDAP_OPT_REFHOPLIMIT, &opt, &err);
            ABTS_TRUE(tc, status == APR_SUCCESS); 
            ABTS_ASSERT(tc, "failed to set refhoplimit", opt.refhoplimit == 5);
        }
#endif

    }

    apr_pool_destroy(pool);
}

static void test_ldap(abts_case *tc, void *data)
{
    apr_pool_t *pool;
    apr_ldap_t *ldap;
    apu_err_t err;
    const char *url;
    apr_ldap_opt_t opt;
    apr_status_t status;

    const char *testldap = getenv("TESTLDAP");

    if (!testldap) {
        ABTS_NOT_IMPL(tc, "Environment TESTLDAP unset - skipping");
        return;
    }

    apr_pool_create(&pool, p);

    url = apr_psprintf(pool, "ldap://%s:%d", testldap, APR_LDAP_PORT);
    
    apr_ldap_initialise(pool, &ldap, &(err));

    ABTS_TRUE(tc, ldap != NULL);

    opt.uri = url;
    status = apr_ldap_option_set(pool, ldap, APR_LDAP_OPT_URI, &opt, &err);

    if (status == APR_SUCCESS) {
        test_ldap_connection(tc, pool, ldap, NULL, bind_interact_simple);
    }

    apr_pool_destroy(pool);
}

static void test_ldaps(abts_case *tc, void *data)
{
    apr_pool_t *pool;
    apr_ldap_t *ldap;
    apu_err_t err;
    const char *url; 
    apr_ldap_opt_t opt;
    apr_status_t status;

    const char *testldaps = getenv("TESTLDAPS");

    if (!testldaps) {
        ABTS_NOT_IMPL(tc, "Environment TESTLDAPS unset - skipping");
        return;
    }

    apr_pool_create(&pool, p);

    url = apr_psprintf(pool, "ldaps://%s:%d", testldaps, APR_LDAPS_PORT);

    apr_ldap_initialise(pool, &ldap, &(err));

    ABTS_TRUE(tc, ldap != NULL);

    opt.uri = url;
    status = apr_ldap_option_set(pool, ldap, APR_LDAP_OPT_URI, &opt, &err);

    if (status == APR_SUCCESS) {
        add_ldap_certs(tc);

        test_ldap_connection(tc, pool, ldap, "EXTERNAL", bind_interact_external);
        test_ldap_connection(tc, pool, ldap, "PLAIN", bind_interact_plain);
        test_ldap_connection(tc, pool, ldap, NULL, bind_interact_simple);
    }

    apr_pool_destroy(pool);
}

static void test_ldap_tls(abts_case *tc, void *data)
{
    apr_pool_t *pool;
    apr_ldap_t *ldap;
    apu_err_t err;
    const char *url;
    apr_ldap_opt_t opt;
    apr_status_t status;

    const char *testldap_tls = getenv("TESTLDAP_TLS");

    if (!testldap_tls) {
        ABTS_NOT_IMPL(tc, "Environment TESTLDAP_TLS unset - skipping");
        return;
    }

    apr_pool_create(&pool, p);

    opt.tls = APR_LDAP_TLS_STARTTLS;

    url = apr_psprintf(pool, "ldap://%s:%d", testldap_tls, APR_LDAP_PORT);

    apr_ldap_initialise(pool, &ldap, &(err));

    if (err.rc == APR_SUCCESS) {
        apr_ldap_option_set(pool, ldap, APR_LDAP_OPT_TLS, &opt, &(err));
    }

    ABTS_TRUE(tc, ldap != NULL);

    opt.uri = url;
    status = apr_ldap_option_set(pool, ldap, APR_LDAP_OPT_URI, &opt, &err);

    if (status == APR_SUCCESS) {
        add_ldap_certs(tc);

        test_ldap_connection(tc, pool, ldap, "EXTERNAL", bind_interact_external);
        test_ldap_connection(tc, pool, ldap, "PLAIN", bind_interact_plain);
        test_ldap_connection(tc, pool, ldap, NULL, bind_interact_simple);
    }

    apr_pool_destroy(pool);
}

static void test_ldapi(abts_case *tc, void *data)
{
    apr_pool_t *pool;
    apr_ldap_t *ldap;
    apu_err_t err;
    const char *url;
    apr_ldap_opt_t opt;
    apr_status_t status;

    const char *testldapi = getenv("TESTLDAPI");

    if (!testldapi) {
        ABTS_NOT_IMPL(tc, "Environment TESTLDAPI unset - skipping");
        return;
    }

    apr_pool_create(&pool, p);

    opt.tls = APR_LDAP_TLS_STARTTLS;

    url = apr_psprintf(pool, "ldapi://%s", apr_pescape_urlencoded(pool, testldapi));

    apr_ldap_initialise(pool, &ldap, &(err));

    ABTS_TRUE(tc, ldap != NULL);

    opt.uri = url;
    status = apr_ldap_option_set(pool, ldap, APR_LDAP_OPT_URI, &opt, &err);
    ABTS_TRUE(tc, status == APR_SUCCESS);

    abts_log_message("Initialiased LDAP url [%s]: %s - %s (%d)\n", url, err.reason, err.msg, err.rc);

    if (status == APR_SUCCESS) {
        test_ldap_connection(tc, pool, ldap, "EXTERNAL", bind_interact_external);
        test_ldap_connection(tc, pool, ldap, "PLAIN", bind_interact_plain);
        test_ldap_connection(tc, pool, ldap, NULL, bind_interact_simple);

        test_ldap_abandon(tc, pool, ldap);
    }

    status = apr_ldap_unbind(ldap, NULL, NULL, &err);
    ABTS_TRUE(tc, status == APR_SUCCESS);

    apr_pool_destroy(pool);
}

#endif /* APR_HAS_LDAP */

abts_suite *testldap(abts_suite *suite)
{
#if APR_HAS_LDAP
    suite = ADD_SUITE(suite);

    abts_run_test(suite, test_ldap_global_opts, NULL);
    abts_run_test(suite, test_ldap_opts, NULL);

    abts_run_test(suite, test_ldap, NULL);
    abts_run_test(suite, test_ldaps, NULL);
    abts_run_test(suite, test_ldap_tls, NULL);
    abts_run_test(suite, test_ldapi, NULL);

#endif /* APR_HAS_LDAP */

    return suite;
}