/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 *      ns_ldap.c
 *
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <syslog.h>
#include <string.h>
#include <ctype.h>
#include <nsswitch.h>
#include <sys/param.h>
#include <sys/types.h>
#include <rpc/rpc.h>
#include <rpcsvc/nfs_prot.h>
#include <sys/errno.h>
#include <libintl.h>
#include "automount.h"
#include "../../../lib/libsldap/common/ns_sldap.h"

/*
 * LDAP schema used for automounter:
 *
 * automountMapName: mapname i.e. auto_home, etc.
 * automountKey: contains the key i.e. the mount point
 * automountInformation: contains the mount options and remote mount location
 * description: an optional description (not used by automounter)
 *
 * For example, if auto_direct has the following line of data:
 *
 *              /work -rw,intr,nosuid,noquota hosta:/export/work
 *
 * Then this would map to the the following LDAP entry:
 *
 *      dn: automountKey=/work,automountMapName=auto_direct,...
 *      automountKey: /work
 *      automountInformation: -rw,intr,nosuid,noquota hosta:/export/work
 *      objectclass: top
 *      objectclass: automount
 *
 * In this container:
 *
 *      dn: automountMapName=auto_direct,...
 *      automountMapName: auto_direct
 *      objectClass: top
 *      objectClass: automountMap
 *
 * Note that the schema can be mapped and SSD's can be used to relocate
 * the default location of these entries.
 *
 */

#define CAPCHAR '%'
#define MAXERROR 4000

static char *automountKey = NULL;
static char *automountInformation = NULL;
static char *defaultFilter = NULL;
static int encode = 0;

static int mastermap_callback_ldap();
static int directmap_callback();
static int ldap_err(int);
static int ldap_match();
static int readdir_callback();

struct loadmaster_cbdata {
        char *ptr1;
        char **ptr2;
        char ***ptr3;
};

struct loaddirect_cbdata {
        char *ptr1;
        char *ptr2;
        char **ptr3;
        char ***ptr4;
};

struct dir_cbdata {
        struct dir_entry **list;
        struct dir_entry *last;
        int error;
};

static char *tosunds_str(char *);
static char *tounix_str(char *);

static int
isAttrMapped(char *orig, char *mapped)
{
        char **s;
        char **mappedschema = NULL;

        mappedschema = __ns_ldap_getMappedAttributes("automount", orig);
        if (mappedschema == NULL)
                return (0);
        if (strcasecmp(mappedschema[0], mapped) != 0) {
                for (s = mappedschema; *s != NULL; s++)
                        free(*s);
                free(mappedschema);
                return (0);
        }
        for (s = mappedschema; *s != NULL; s++)
                free(*s);
        free(mappedschema);
        return (1);
}

static int
isObjectMapped(char *orig, char *mapped)
{
        char **s;
        char **mappedschema = NULL;

        mappedschema = __ns_ldap_getMappedObjectClass("automount", orig);
        if (mappedschema == NULL)
                return (0);
        if (strcasecmp(mappedschema[0], mapped) != 0) {
                for (s = mappedschema; *s != NULL; s++)
                        free(*s);
                free(mappedschema);
                return (0);
        }
        for (s = mappedschema; *s != NULL; s++)
                free(*s);
        free(mappedschema);
        return (1);
}

void
init_ldap(char **stack, char ***stkptr)
{
        /*
         * Check for version of the profile the client is using
         *
         * For version 1 profiles we do encoding of attributes
         * and use nisMap and nisObject schema for backward compatibility.
         *
         * For version 2 profiles we don't do encoding and use
         * automountMap and automount as default attributes (which can
         * then be overridden in libsldap if schema mapping is configured
         * in the profile).
         *
         * If profile version is not available, use version 2 as default
         * and syslog message.
         */
        int rc, v2 = 1;
        void **paramVal = NULL;
        ns_ldap_error_t *errorp = NULL;
        struct __nsw_switchconfig *conf = NULL;
        struct __nsw_lookup *lkp = NULL;
        enum __nsw_parse_err pserr;
        int     ldap_configured = 0;

#ifdef lint
        stack = stack;
        stkptr = stkptr;
#endif /* lint */

        /* get nsswitch info of "automount */
        conf = __nsw_getconfig("automount", &pserr);

        /* find out if LDAP backend is configured */
        if (conf != NULL) {
                for (lkp = conf->lookups; lkp != NULL; lkp = lkp->next) {
                        if (strcmp(lkp->service_name, "ldap") == 0) {
                                ldap_configured = 1;
                                break;
                        }
                }
                /* free conf at the end of "if"  bracket */
                (void) __nsw_freeconfig(conf);
        }

        /* if ldap is not configured, init_ldap is a no op */
        if (!ldap_configured)
                return;

        rc = __ns_ldap_getParam(NS_LDAP_FILE_VERSION_P, &paramVal, &errorp);
        if (rc != NS_LDAP_SUCCESS || !paramVal || !*paramVal) {
                syslog(LOG_ERR, "Can not determine version of LDAP profile"
                    " that is used (%d, %s).  Using version 2 profile"
                    " defaults", rc, (errorp && errorp->message ?
                    errorp->message : ""));
                (void) __ns_ldap_freeError(&errorp);
        } else {
                if (strcasecmp(*paramVal, NS_LDAP_VERSION_1) == 0)
                        v2 = 0;
                (void) __ns_ldap_freeParam(&paramVal);
        }

        if (v2) {
                if (trace > 1)
                        trace_prt(1, "init_ldap: setting up for version 2\n");
                automountKey = "automountKey";
                automountInformation = "automountInformation";
                defaultFilter = "(&(objectClass=automount)(automountKey=%s))";

                /* check for automountMapName mapped to nisMapName */
                if (!isAttrMapped("automountMapName", "nisMapName"))
                        return;

                /* check for automountKey mapped to cn */
                if (!isAttrMapped("automountKey", "cn"))
                        return;

                /* check for automountInformation mapped to nisMapEntry */
                if (!isAttrMapped("automountInformation", "nisMapEntry"))
                        return;

                /* check for automountMap mapped to nisMap */
                if (!isObjectMapped("automountMap", "nisMap"))
                        return;

                /* check for automount mapped to nisObject */
                if (!isObjectMapped("automount", "nisObject"))
                        return;

                if (trace > 1)
                        trace_prt(1, "init_ldap: encode = TRUE\n");
                encode = 1;
        } else {
                if (trace > 1) {
                        trace_prt(1, "init_ldap: setting up for version 1\n");
                        trace_prt(1, "init_ldap: encode = TRUE\n");
                }
                encode = 1;
                automountKey = "cn";
                automountInformation = "nisMapEntry";
                defaultFilter = "(&(objectClass=nisObject)(cn=%s))";
        }
}

/*ARGSUSED*/
int
getmapent_ldap(char *key, char *map, struct mapline *ml,
char **stack, char ***stkptr, bool_t *iswildcard, bool_t isrestricted)
{
        char *ldap_line = NULL;
        char *lp;
        int ldap_len, len;
        int nserr;

        if (trace > 1)
                trace_prt(1, "getmapent_ldap called\n");

        if (trace > 1) {
                trace_prt(1, "getmapent_ldap: key=[ %s ]\n", key);
        }

        if (iswildcard)
                *iswildcard = FALSE;
        nserr = ldap_match(map, key, &ldap_line, &ldap_len);
        if (nserr) {
                if (nserr == __NSW_NOTFOUND) {
                        /* Try the default entry "*" */
                        if ((nserr = ldap_match(map, "\\2a", &ldap_line,
                            &ldap_len)))
                                goto done;
                        else {
                                if (iswildcard)
                                        *iswildcard = TRUE;
                        }
                } else
                        goto done;
        }

        /*
         * at this point we are sure that ldap_match
         * succeeded so massage the entry by
         * 1. ignoring # and beyond
         * 2. trim the trailing whitespace
         */
        if (lp = strchr(ldap_line, '#'))
                *lp = '\0';
        len = strlen(ldap_line);
        if (len == 0) {
                nserr = __NSW_NOTFOUND;
                goto done;
        }
        lp = &ldap_line[len - 1];
        while (lp > ldap_line && isspace(*lp))
                *lp-- = '\0';
        if (lp == ldap_line) {
                nserr = __NSW_NOTFOUND;
                goto done;
        }
        (void) strncpy(ml->linebuf, ldap_line, LINESZ);
        unquote(ml->linebuf, ml->lineqbuf);
        nserr = __NSW_SUCCESS;
done:
        if (ldap_line)
                free((char *)ldap_line);

        if (trace > 1)
                trace_prt(1, "getmapent_ldap: exiting ...\n");

        return (nserr);
}

static int
ldap_match(char *map, char *key, char **ldap_line, int *ldap_len)
{
        char searchfilter[LDAP_FILT_MAXSIZ];
        int res, attr_found;
        ns_ldap_result_t *result = NULL;
        ns_ldap_error_t *errp = NULL;
        ns_ldap_entry_t *entry = NULL;
        char *ldapkey;
        int i;

        if (trace > 1) {
                trace_prt(1, "ldap_match called\n");
                trace_prt(1, "ldap_match: key =[ %s ]\n", key);
        }

        /*
         * need to handle uppercase characters in the key because LDAP
         * searches are case insensitive.  Note, key = attribute automountKey.
         */
        if (encode)
                ldapkey = tosunds_str(key);
        else
                ldapkey = key;

        if (trace > 1) {
                trace_prt(1, "ldap_match: ldapkey =[ %s ]\n", ldapkey);
        }

        (void) sprintf(searchfilter, defaultFilter, ldapkey);

        if (trace > 1)
                trace_prt(1, "  ldap_match: Requesting list for %s in %s\n",
                    searchfilter, map);

        res = __ns_ldap_list(map, searchfilter, NULL,
            NULL, NULL, 0, &result, &errp, NULL, NULL);

        if (trace > 1) {
                if (res != NS_LDAP_SUCCESS)
                        trace_prt(1,
                            "  ldap_match: __ns_ldap_list FAILED (%d)\n", res);
                else
                        trace_prt(1, "  ldap_match: __ns_ldap_list OK\n");
        }

        if (res != NS_LDAP_SUCCESS && res != NS_LDAP_NOTFOUND) {
                if (errp) {
                        if (verbose) {
                                char errstr[MAXERROR];
                                (void) sprintf(errstr,
                                    gettext("ldap server can't list map,"
                                    " '%s': '%s' - '%d'."),
                                    map, errp->message, errp->status);
                                syslog(LOG_ERR, errstr);
                        }
                        __ns_ldap_freeError(&errp);
                } else {
                        if (verbose) {
                                char *errmsg;
                                __ns_ldap_err2str(res, &errmsg);
                                syslog(LOG_ERR, errmsg);
                        }
                }
                if (result)
                        __ns_ldap_freeResult(&result);
                return (ldap_err(res));
        }

        if (res == NS_LDAP_NOTFOUND || result == NULL ||
            result->entries_count == 0 || result->entry->attr_count == 0) {
                if (trace > 1)
                        trace_prt(1, "  ldap_match: no entries found\n");
                if (errp)
                        __ns_ldap_freeError(&errp);
                if (result)
                        __ns_ldap_freeResult(&result);
                return (__NSW_NOTFOUND);
        }

        /*
         * get value of attribute nisMapEntry.  This attribute contains a
         * list of mount options AND mount location for a particular mount
         * point (key).
         * For example:
         *
         * key: /work
         *      ^^^^^
         *      (mount point)
         *
         * nisMapEntry: -rw,intr,nosuid,noquota hosta:/export/work
         *              ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
         *              (    mount options    ) (remote mount location)
         *
         */
        attr_found = 0;
        entry = result->entry;
        for (i = 0; i < entry->attr_count; i++) {
                ns_ldap_attr_t *attr;

                attr = entry->attr_pair[i];
                if (strcasecmp(attr->attrname, automountInformation) == 0) {
                        char *attrval;

                        attr_found = 1;
                        if (encode)
                                attrval = tounix_str(attr->attrvalue[0]);
                        else
                                attrval = attr->attrvalue[0];
                        *ldap_len = strlen(key) + strlen(attrval);

                        /*
                         * so check for the length; it should be less than
                         * LINESZ
                         */
                        if ((*ldap_len + 2) > LINESZ) {
                                syslog(LOG_ERR,
                                    "ldap server map %s, entry for %s"
                                    " is too long %d chars (max %d)",
                                    map, key, (*ldap_len + 2), LINESZ);
                                __ns_ldap_freeResult(&result);
                                return (__NSW_UNAVAIL);
                        }
                        *ldap_line = (char *)malloc(*ldap_len + 2);
                        if (*ldap_line == NULL) {
                                syslog(LOG_ERR, "ldap_match: malloc failed");
                                __ns_ldap_freeResult(&result);
                                return (__NSW_UNAVAIL);
                        }

                        (void) sprintf(*ldap_line, "%s", attrval);

                        break;
                }
        }

        __ns_ldap_freeError(&errp);
        __ns_ldap_freeResult(&result);

        if (!attr_found)
                return (__NSW_NOTFOUND);

        if (trace > 1)
                trace_prt(1, "  ldap_match: found: %s\n", *ldap_line);

        return (__NSW_SUCCESS);
}

int
loadmaster_ldap(char *mapname, char *defopts, char **stack, char ***stkptr)
{
        char searchfilter[LDAP_FILT_MAXSIZ];
        int res;
        ns_ldap_result_t *result = NULL;
        ns_ldap_error_t *errp = NULL;
        struct loadmaster_cbdata master_cbdata;

        if (trace > 1)
                trace_prt(1, "loadmaster_ldap called\n");

        master_cbdata.ptr1 = defopts;
        master_cbdata.ptr2 = stack;
        master_cbdata.ptr3 = stkptr;

        /* filter gets all the entries for the specified mapname */
        (void) sprintf(searchfilter, defaultFilter, "*");

        if (trace > 1)
                trace_prt(1, "loadmaster_ldap: Requesting list for %s in %s\n",
                    searchfilter, mapname);

        res = __ns_ldap_list(mapname, searchfilter, NULL, NULL, NULL,
            0, &result, &errp, mastermap_callback_ldap,
            (void *) &master_cbdata);

        if (trace > 1)
                trace_prt(1,
                    "loadmaster_ldap: __ns_ldap_list just returned: %d\n",
                    res);

        if (res != NS_LDAP_SUCCESS) {
                if (errp) {
                        char errstr[MAXERROR];
                        if (verbose) {
                                (void) sprintf(errstr, gettext(
                                    "ldap server can't list map,"
                                    "'%s': '%s' - '%d'."),
                                    mapname, errp->message, errp->status);
                                syslog(LOG_ERR, errstr);
                        }
                        __ns_ldap_freeError(&errp);
                } else {
                        if (verbose) {
                                char *errmsg;
                                __ns_ldap_err2str(res, &errmsg);
                                syslog(LOG_ERR, errmsg);
                        }
                }
                if (result)
                        __ns_ldap_freeResult(&result);
                return (ldap_err(res));
        }

        if (trace > 1)
                trace_prt(1,
                    "loadmaster_ldap: calling __ns_ldap_freeResult...\n");

        __ns_ldap_freeResult(&result);

        if (trace > 1)
                trace_prt(1,
                    "loadmaster_ldap: about to return __NSW_SUCCESS...\n");

        return (__NSW_SUCCESS);
}

int
loaddirect_ldap(char *nsmap, char *localmap, char *opts,
char **stack, char ***stkptr)
{
        char searchfilter[LDAP_FILT_MAXSIZ];
        int res;
        ns_ldap_result_t *result = NULL;
        ns_ldap_error_t *errp = NULL;
        struct loaddirect_cbdata direct_cbdata;

        if (trace > 1) {
                trace_prt(1, "loaddirect_ldap called\n");
        }

        direct_cbdata.ptr1 = opts;
        direct_cbdata.ptr2 = localmap;
        direct_cbdata.ptr3 = stack;
        direct_cbdata.ptr4 = stkptr;

        /* filter gets all the entries for the specified mapname */
        (void) sprintf(searchfilter, defaultFilter, "*");

        if (trace > 1)
                trace_prt(1, "loaddirect_ldap: Requesting list for %s in %s\n",
                    searchfilter, nsmap);

        res = __ns_ldap_list(nsmap, searchfilter, NULL, NULL,
            NULL, 0, &result, &errp,
            directmap_callback, (void *) &direct_cbdata);


        if (res != NS_LDAP_SUCCESS) {
                if (errp) {
                        char errstr[MAXERROR];
                        if (verbose) {
                                (void) sprintf(errstr,
                                    gettext("ldap server can't list map,"
                                    " '%s': '%s' - '%d'."),
                                    nsmap, errp->message, errp->status);
                                syslog(LOG_ERR, errstr);
                        }
                        __ns_ldap_freeError(&errp);
                } else {
                        if (verbose) {
                                char *errmsg;
                                __ns_ldap_err2str(res, &errmsg);
                                syslog(LOG_ERR, errmsg);
                        }
                }
                if (result)
                        __ns_ldap_freeResult(&result);
                return (ldap_err(res));
        }

        __ns_ldap_freeResult(&result);
        return (__NSW_SUCCESS);
}

static int
ldap_err(int err)
{
        if (trace > 1)
                trace_prt(1, "ldap_err called\n");

        switch (err) {

        case NS_LDAP_SUCCESS:
                return (__NSW_SUCCESS);

        case NS_LDAP_NOTFOUND:
                return (__NSW_NOTFOUND);

        case NS_LDAP_PARTIAL:
                return (__NSW_TRYAGAIN);

        default:
                return (__NSW_UNAVAIL);
        }
}

static int
mastermap_callback_ldap(ns_ldap_entry_t *entry, void *udata)
{
        char *key, *contents, *pmap, *opts;
        char dir[LINESZ], map[LINESZ], qbuff[LINESZ];
        char cont_temp[LINESZ], key_temp[LINESZ];
        int  key_len, contents_len;
        struct loadmaster_cbdata *temp = (struct loadmaster_cbdata *)udata;
        char *defopts = temp->ptr1;
        char **stack = temp->ptr2;
        char ***stkptr = temp->ptr3;
        int i;

        if (trace > 1) {
                trace_prt(1, "mastermap_callback_ldap called\n");
                trace_prt(1, "mastermap_callback_ldap: entry=%x\n", entry);
                if (entry) {
                        trace_prt(1,
                        "mastermap_callback_ldap: entry->attr_count=[ %d ]\n",
                            entry->attr_count);
                }
        }

        /*
         * For the current entry, obtain the values of the cn and the
         * nisMapEntry attributes and the length of each value (cn=key,
         * nisMapEntry=contents).
         * We skip the description.  Even though LDAP allows for multiple
         * values per attribute, we take only the 1st value for each
         * attribute because the automount data is organized as such.
         */
        key_len = 0;
        contents_len = 0;
        key = NULL;
        contents = NULL;
        for (i = 0; i < entry->attr_count; i++) {
                ns_ldap_attr_t *attr;

                attr = entry->attr_pair[i];
                if (trace > 1) {
                        trace_prt(1,
                        "mastermap_callback_ldap: attr[%d]: %s=%s\n",
                            i, attr->attrname, attr->attrvalue[0]);
                }
                if (strcasecmp(attr->attrname, automountInformation) == 0) {
                        if (encode)
                                (void) strncpy(cont_temp,
                                    tounix_str(attr->attrvalue[0]), LINESZ);
                        else
                                (void) strncpy(cont_temp, attr->attrvalue[0],
                                    LINESZ);
                        contents = cont_temp;
                        contents_len = strlen(contents);
                        if (trace > 1) {
                                trace_prt(1,
                                    "mastermap_callback_ldap: contents=[ %s ],"
                                    " contents_len=[ %d ]\n",
                                    contents, contents_len);
                        }
                }
                if (strcasecmp(attr->attrname, automountKey) == 0) {
                        if (encode)
                                (void) strncpy(key_temp,
                                    tounix_str(attr->attrvalue[0]), LINESZ);
                        else
                                (void) strncpy(key_temp, attr->attrvalue[0],
                                    LINESZ);
                        key = key_temp;
                        key_len = strlen(key);
                        if (trace > 1) {
                                trace_prt(1,
                                    "mastermap_callback_ldap: key=[ %s ],"
                                    " key_len=[ %d ]\n",
                                    key, key_len);
                        }
                }
        }

        if (key_len >= LINESZ || contents_len >= LINESZ)
                return (0);
        if (key_len < 2 || contents_len < 2)
                return (0);

        while (isspace(*contents))
                contents++;
        if (contents == NULL)
                return (0);
        if (isspace(*key) || *key == '#')
                return (0);

        (void) strncpy(dir, key, key_len);
        dir[key_len] = '\0';
        if (trace > 1)
                trace_prt(1, "mastermap_callback_ldap: dir= [ %s ]\n", dir);
        for (i = 0; i < LINESZ; i++)
                qbuff[i] = ' ';
        if (macro_expand("", dir, qbuff, sizeof (dir))) {
                syslog(LOG_ERR,
                    "%s in ldap server map: entry too long (max %d chars)",
                    dir, sizeof (dir) - 1);
                return (0);
        }
        (void) strncpy(map, contents, contents_len);
        map[contents_len] = '\0';
        if (trace > 1)
                trace_prt(1, "mastermap_callback_ldap: map= [ %s ]\n", map);
        if (macro_expand("", map, qbuff, sizeof (map))) {
                syslog(LOG_ERR,
                    "%s in ldap server map: entry too long (max %d chars)",
                    map, sizeof (map) - 1);
                return (0);
        }
        pmap = map;
        while (*pmap && isspace(*pmap))
                pmap++;         /* skip blanks in front of map */
        opts = pmap;
        while (*opts && !isspace(*opts))
                opts++;
        if (*opts) {
                *opts++ = '\0';
                while (*opts && isspace(*opts))
                        opts++;
                if (*opts == '-')
                        opts++;
                        else
                        opts = defopts;
        }
        /*
         * Check for no embedded blanks.
         */
        if (strcspn(opts, "     ") == strlen(opts)) {
                if (trace > 1)
                        trace_prt(1,
                        "mastermap_callback_ldap: dir=[ %s ], pmap=[ %s ]\n",
                            dir, pmap);
                dirinit(dir, pmap, opts, 0, stack, stkptr);
        } else {
                char *dn = NULL;

                /* get the value for the dn */
                for (i = 0; i < entry->attr_count; i++) {
                        ns_ldap_attr_t *attr;

                        attr = entry->attr_pair[i];
                        if (strcasecmp(attr->attrname, "dn")
                            == 0) {
                                dn = attr->attrvalue[0];
                                break;
                        }
                }
                pr_msg(
                    "Warning: invalid entry for %s in ldap server"
                    " dn: %s ignored.\n",
                    dir, dn);
        }
        if (trace > 1)
                trace_prt(1, "mastermap_callback_ldap exiting...\n");
        return (0);
}

static int
directmap_callback(ns_ldap_entry_t *entry, void *udata)
{
        char *key;
        char dir[256];
        int  key_len;
        struct loaddirect_cbdata *temp = (struct loaddirect_cbdata *)udata;
        char *opts = temp->ptr1;
        char *localmap = temp->ptr2;
        char **stack = temp->ptr3;
        char ***stkptr = temp->ptr4;
        int i;

        /*
         * For the current entry, obtain the value and length of the cn i.e.
         * the contents of key and its key length.
         */
        key_len = 0;
        key = NULL;
        for (i = 0; i < entry->attr_count; i++) {
                ns_ldap_attr_t *attr;

                attr = entry->attr_pair[i];
                if (strcasecmp(attr->attrname, automountKey) == 0) {
                        if (encode)
                                key = tounix_str(attr->attrvalue[0]);
                        else
                                key = attr->attrvalue[0];
                        key_len = strlen(key);
                        break;
                }
        }

        if (key_len >= 100 || key_len < 2)
                return (0);

        if (isspace(*key) || *key == '#')
                return (0);
        (void) strncpy(dir, key, key_len);
        dir[key_len] = '\0';

        dirinit(dir, localmap, opts, 1, stack, stkptr);

        return (0);
}

int
getmapkeys_ldap(char *nsmap, struct dir_entry **list, int *error,
int *cache_time, char **stack, char ***stkptr)
{
        char searchfilter[LDAP_FILT_MAXSIZ];
        int res;
        ns_ldap_result_t *result = NULL;
        ns_ldap_error_t *errp = NULL;
        struct dir_cbdata readdir_cbdata;

#ifdef lint
        stack = stack;
        stkptr = stkptr;
#endif /* lint */

        if (trace > 1)
                trace_prt(1, "getmapkeys_ldap called\n");

        *cache_time = RDDIR_CACHE_TIME;
        *error = 0;
        readdir_cbdata.list = list;
        readdir_cbdata.last = NULL;

        /* filter gets all the entries for the specified mapname */
        (void) sprintf(searchfilter, defaultFilter, "*");

        if (trace > 1)
                trace_prt(1, "getmapkeys_ldap: Requesting list for %s in %s\n",
                    searchfilter, nsmap);

        res = __ns_ldap_list(nsmap, searchfilter, NULL, NULL, NULL, 0,
            &result, &errp, readdir_callback, (void *) &readdir_cbdata);

        if (trace > 1)
                trace_prt(1, "  getmapkeys_ldap: __ns_ldap_list returned %d\n",
                    res);

        if (readdir_cbdata.error)
                *error = readdir_cbdata.error;

        if (res != NS_LDAP_SUCCESS && res != NS_LDAP_NOTFOUND) {
                if (errp) {
                        if (verbose) {
                                char errstr[MAXERROR];
                                (void) sprintf(errstr, gettext(
                                    "ldap server can't list map,"
                                    " '%s': '%s' - '%d'."),
                                    nsmap, errp->message, errp->status);
                                syslog(LOG_ERR, errstr);
                        }
                        __ns_ldap_freeError(&errp);
                } else {
                        if (verbose) {
                                char *errmsg;
                                __ns_ldap_err2str(res, &errmsg);
                                syslog(LOG_ERR, errmsg);
                        }
                }
                if (result)
                        __ns_ldap_freeResult(&result);
                if (*error == 0)
                        *error = ECOMM;
                return (ldap_err(res));
        }
        if (result)
                __ns_ldap_freeResult(&result);

        return (__NSW_SUCCESS);
}

static int
readdir_callback(const ns_ldap_entry_t *entry, const void *udata)
{
        char *key;
        int  key_len;
        struct dir_cbdata *temp = (struct dir_cbdata *)udata;
        struct dir_entry **list = temp->list;
        struct dir_entry *last = temp->last;
        int i;

        if (trace > 1)
                trace_prt(1, "readdir_callback called\n");
        /*
         * For the current entry, obtain the value and length of the cn i.e. the
         * contents of key and its key length.
         */
        key_len = 0;
        key = NULL;

        if (trace > 1)
                trace_prt(1, "readdir_callback: entry->attr_count=[ %d ]\n",
                    entry->attr_count);

        for (i = 0; i < entry->attr_count; i++) {
                ns_ldap_attr_t *attr;

                attr = entry->attr_pair[i];

                if (trace > 1)
                        trace_prt(1,
                        "readdir_callback: attr->attrname=[ %s ]\n",
                            attr->attrname);

                if (strcasecmp(attr->attrname, automountKey) == 0) {
                        if (encode)
                                key = tounix_str(attr->attrvalue[0]);
                        else
                                key = attr->attrvalue[0];
                        key_len = strlen(key);

                        if (trace > 1)
                                trace_prt(1,
                        "readdir_callback: key=[ %s ], key_len=[ %d ]\n",
                                    key, key_len);

                        break;
                }
        }

        if (key_len >= 100 || key_len < 2)
                return (0);

        if (isspace(*key) || *key == '#')
                return (0);

        /*
         * Wildcard entry should be ignored - following entries should continue
         * to be read to corroborate with the way we search for entries in
         * LDAP, i.e., first for an exact key match and then a wildcard
         * if there's no exact key match.
         */
        if (key[0] == '*' && key[1] == '\0')
                return (0);

        if (add_dir_entry(key, list, &last)) {
                temp->error = ENOMEM;
                return (1);
        }

        temp->last = last;
        temp->error = 0;

        if (trace > 1)
                trace_prt(1, "readdir_callback returning 0...\n");

        return (0);
}

/*
 * Puts CAPCHAR in front of uppercase characters or surrounds a set of
 * contiguous uppercase characters with CAPCHARS and square brackets.
 *
 * For example (assuming CAPCHAR = '%'):
 *
 * if str = Abc, it returns %Abc
 * if str = ABc, it returns %[AB]c
 * if str = AbC, it returns %Ab%C
 *
 */
static char *
tosunds_str(char *str)
{
        static char buf[BUFSIZ];
        int i, j, er = FALSE;
#ifdef NEWCAP
        int openBracket = FALSE, closeBracket = FALSE;
#endif

        (void) memset(buf, 0, BUFSIZ);

        j = 0;
        for (i = 0; i < strlen(str); i++) {
                /* Check the current element */
                if (isupper(str[i])) {
#ifdef NEWCAP
                        /* check the next element */
                        if (isupper(str[i+1])) {
                                if (openBracket == FALSE) {
                                        openBracket = TRUE;
                                        buf[j] = CAPCHAR;
                                        buf[j+1] = '[';
                                        j += 2;
                                }
                        } else {
                                if (openBracket == FALSE) {
                                        buf[j] = CAPCHAR;
                                        j++;
                                } else {
                                        openBracket = FALSE;
                                        closeBracket = TRUE;
                                }
                        }
#else
                        buf[j++] = CAPCHAR;
#endif
                }
                buf[j] = str[i];
                j++;

#ifdef NEWCAP
                if (closeBracket == TRUE) {
                        closeBracket = FALSE;
                        buf[j] = ']';
                        j++;
                }
#endif
                if (j >= BUFSIZ) {
                        er = TRUE;
                        break;
                }
        }

        if (er) {
                syslog(LOG_ERR, "Buffer size exceeded.");
                (void) memset(buf, 0, BUFSIZ);
        } else
                buf[j] = '\0';

        return (buf);

}

/*
 * Reverses what tosunds_str() did
 */
static char *
tounix_str(char *str)
{
        static char buf[BUFSIZ];
        int i, j;
        int openBracket = FALSE;

        (void) memset(buf, 0, BUFSIZ);
        j = 0;

        for (i = 0; i < strlen(str); i++) {
                if (str[i] == '%') {
                        if (isupper(str[i+1])) {
                                i += 1;
                        } else if ((str[i+1] == '[') && (isupper(str[i+2]))) {
                                i += 2;
                                openBracket = TRUE;
                        }
                } else if (str[i] == ']') {
                        if ((isupper(str[i-1])) && (openBracket == TRUE))
                                i += 1;
                        openBracket = FALSE;
                }
                buf[j] = str[i];
                j++;
        }
        return (buf);
}