lib/libnisdb/nis_parse_ldap_conf.c

/*
 * 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
 */
/*
 * Copyright 2015 Gary Mills
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <locale.h>
#include <sys/stat.h>
#include <lber.h>
#include <ldap.h>
#include <deflt.h>

#include "ldap_map.h"

#include "ldap_parse.h"
#include "ldap_glob.h"
#include "nis_parse_ldap_conf.h"

__nis_ldap_proxy_info   proxyInfo       =
    {NULL, (auth_method_t)NO_VALUE_SET, (tls_method_t)NO_VALUE_SET, NULL,
        NULL, NULL, NULL, NULL, (follow_referral_t)NO_VALUE_SET};
__nis_config_t      ldapConfig;
__nisdb_table_mapping_t ldapDBTableMapping;
__nis_table_mapping_t   *ldapTableMapping   = NULL;
__yp_domain_context_t   ypDomains;

parse_error     p_error         = no_parse_error;
int         cur_line_num        = 0;
int         start_line_num      = 0;
int         seq_num         = 0;
const char      *warn_file      = NULL;

char            _key_val[38];
const char      *command_line_source    = NULL;
const char      *file_source        = NULL;
const char      *ldap_source        = NULL;

static
const char *const   *cmdline_config     = NULL;
static bool_t       got_config_data     = FALSE;

/* high level parsing functions functions */
static int parse_ldap_cmd_line(const char *const *cmdline_options,
    __nis_ldap_proxy_info *proxy_info, __nis_config_t *nis_config,
    __nis_table_mapping_t **table_mapping, __nis_config_info_t *config_info,
    __nisdb_table_mapping_t *table_info);
static int parse_ldap_default_conf(__nis_ldap_proxy_info *proxy_info,
    __nis_config_t *nis_config, __nis_config_info_t *config_info,
    __nisdb_table_mapping_t *table_info);
static int parse_ldap_config_file(const char *config_file,
    __nis_ldap_proxy_info *proxy_info, __nis_config_t *nis_config,
    __nis_table_mapping_t **table_mapping, __nis_config_info_t *config_info,
    __nisdb_table_mapping_t *table_info);
static int parse_ldap_config_dn_attrs(__nis_ldap_proxy_info *proxy_info,
    __nis_config_t *nis_config, __nis_table_mapping_t **table_mapping,
    __nis_config_info_t *config_info, __nisdb_table_mapping_t *table_info);
static int yp_parse_ldap_default_conf(__nis_ldap_proxy_info *proxy_info,
    __nis_config_t *nis_config, __nis_config_info_t *config_info,
    __nisdb_table_mapping_t *table_info);

/* Forward declarations */
int yp_parse_ldap_config_file(const char *, __nis_ldap_proxy_info *,
    __nis_config_t *, __nis_table_mapping_t **, __nis_config_info_t *,
    __nisdb_table_mapping_t *,  __yp_domain_context_t *);


/* helper functions */
static config_key get_attrib_num_cmdline(const char *s,
    const char **begin_s, const char **end_s);
static config_key get_file_attr_val(int fd, char **attr_val);
static void get_attribute_list(
    const __nis_ldap_proxy_info *proxy_info,
    const __nis_config_t *nis_config,
    const __nis_config_info_t *config_info,
    const __nisdb_table_mapping_t *table_info,
    char **ldap_config_attributes);

/*
 * FUNCTION:    parse_ldap_migration
 *
 *  Parses the information for LDAP. The values are first
 *  obtained from the command line, secondly from the preference
 *  file, and finally from an LDAP profile (if so configured in
 *  the command line or preference file). Any unset values will
 *  be set to their default values.
 *
 *  If no command line options, no settings in the /etc/default
 *  configuration file, and no mapping file, then no mapping
 *  should be used.
 *
 * RETURN VALUE:
 *          0   Success
 *          -1  Config file stat/open or parse error
 *          1   No mapping should be used.
 *
 * INPUT:       command line parameters, configuration file
 */

int
parse_ldap_migration(
    const char *const   *cmdline_options,
    const char      *config_file)
{
    int         rc  = 0;
    __nis_config_info_t config_info
                = {NULL, NULL, (auth_method_t)NO_VALUE_SET,
                    (tls_method_t)NO_VALUE_SET, NULL,
                    NULL, NULL};
    struct stat     buf;

    p_error = no_parse_error;

    if (verbose)
        report_info("Getting LDAP configuration", NULL);

    initialize_parse_structs(&proxyInfo, &ldapConfig, &ldapDBTableMapping);

    if (yp2ldap)
        initialize_yp_parse_structs(&ypDomains);

    if (cmdline_options != NULL) {
        got_config_data = TRUE;
        /* NIS to LDAP does not read command line attributes */
        if (!yp2ldap)
            rc = parse_ldap_cmd_line(cmdline_options, &proxyInfo,
                &ldapConfig, &ldapTableMapping, &config_info,
                &ldapDBTableMapping);
        else
            rc = 0;
    }

    if (rc == 0) {
        if (yp2ldap)
            rc = yp_parse_ldap_default_conf(&proxyInfo, &ldapConfig,
                &config_info, &ldapDBTableMapping);
        else
            rc = parse_ldap_default_conf(&proxyInfo, &ldapConfig,
                &config_info, &ldapDBTableMapping);
    }

    if (config_file == NULL) {
        if (yp2ldap) {
            if (stat(YP_DEFAULT_MAPPING_FILE, &buf) == 0)
                config_file = YP_DEFAULT_MAPPING_FILE;
        } else {
            if (stat(DEFAULT_MAPPING_FILE, &buf) == 0)
                config_file = DEFAULT_MAPPING_FILE;
        }
    }

    if (rc == 0 && config_file != NULL) {
        got_config_data = TRUE;
        warn_file = config_file;
        cmdline_config = cmdline_options;
        if (yp2ldap)
            rc = yp_parse_ldap_config_file(config_file, &proxyInfo,
                &ldapConfig, &ldapTableMapping, &config_info,
                &ldapDBTableMapping, &ypDomains);
        else
            rc = parse_ldap_config_file(config_file, &proxyInfo,
                &ldapConfig, &ldapTableMapping, &config_info,
                &ldapDBTableMapping);

        warn_file = NULL;
        cmdline_config = NULL;
    }
    if (rc == 0 && (config_info.config_dn != NULL) &&
        (config_info.config_dn[0] != '\0')) {
        rc = parse_ldap_config_dn_attrs(&proxyInfo,
            &ldapConfig, &ldapTableMapping, &config_info,
            &ldapDBTableMapping);
    }

    free_config_info(&config_info);

    if (rc == 0 && got_config_data == FALSE)
        rc = 1;

    set_default_values(&proxyInfo, &ldapConfig, &ldapDBTableMapping);

    if (yp2ldap == 1 && rc == 0) {
        rc = second_parser_pass(&ldapTableMapping);
        if (rc == 0)
            rc = final_parser_pass(&ldapTableMapping, &ypDomains);
        if (rc == -2)
            return (-1);
    }

    if (rc == 0)
        rc = finish_parse(&proxyInfo, &ldapTableMapping);

    if (rc == 0)
        rc = linked2hash(ldapTableMapping);

    if ((rc == 0) && yptol_mode)
        rc = map_id_list_init();

    if (rc != 0) {
        free_parse_structs();
    } else if (verbose)
        report_info("LDAP configuration complete", NULL);
    return (rc);
}

/*
 * FUNCTION:    parse_ldap_cmd_line
 *
 *  Parses the information for LDAP from the command line
 *
 * RETURN VALUE:    0 on success, -1 on failure
 *
 * INPUT:       command line values
 */

static int
parse_ldap_cmd_line(
    const char *const   *cmdline_options,
    __nis_ldap_proxy_info   *proxy_info,
    __nis_config_t      *nis_config,
    __nis_table_mapping_t   **table_mapping,
    __nis_config_info_t *config_info,
    __nisdb_table_mapping_t *table_info)
{
    int     rc = 0;
    config_key  attrib_num;
    const char  *begin_s;
    const char  *end_s;

    if (verbose)
        report_info("Command line values: ", NULL);
    while (*cmdline_options != NULL) {
        if (verbose)
            report_info("\t", *cmdline_options);

        attrib_num = get_attrib_num_cmdline(
            *cmdline_options, &begin_s, &end_s);
        if (attrib_num == key_bad) {
            command_line_source = "command line";
            report_error(*cmdline_options, NULL);
            command_line_source = NULL;
            rc = -1;
            break;
        } else if (IS_CONFIG_KEYWORD(attrib_num)) {
            rc = add_config_attribute(attrib_num,
                begin_s, end_s - begin_s, config_info);
        } else if (IS_BIND_INFO(attrib_num)) {
            rc = add_bind_attribute(attrib_num,
                begin_s, end_s - begin_s, proxy_info);
        } else if (IS_OPER_INFO(attrib_num)) {
            rc = add_operation_attribute(attrib_num,
                begin_s, end_s - begin_s, nis_config,
                table_info);
        } else {
            rc = add_mapping_attribute(attrib_num,
                begin_s, end_s - begin_s, table_mapping);
        }

        if (rc < 0) {
            command_line_source = "command line";
            report_error(begin_s, _key_val);
            command_line_source = NULL;
            break;
        }
        cmdline_options++;
    }
    return (rc);
}

static int
parse_ldap_default_conf(
    __nis_ldap_proxy_info *proxy_info,
    __nis_config_t *nis_config,
    __nis_config_info_t *config_info,
    __nisdb_table_mapping_t *table_info)
{
    int     rc = 0;
    char        *ldap_config_attributes[n_config_keys];
    char        attr_buf[128];
    char        *attr;
    char        *attr_val;
    int     defflags;
    config_key  attrib_num;
    int     i;
    int     len;
    int     attr_len;
    void        *defp;

    if ((defp = defopen_r(ETCCONFFILE)) != NULL) {
        file_source = ETCCONFFILE;
        if (verbose)
            report_info("default configuration values: ", NULL);
        /* Set defread_r() to be case insensitive */
        defflags = defcntl_r(DC_GETFLAGS, 0, defp);
        TURNOFF(defflags, DC_CASE);
        (void) defcntl_r(DC_SETFLAGS, defflags, defp);

        get_attribute_list(proxy_info, nis_config, config_info,
            table_info, ldap_config_attributes);
        i = 0;
        while ((attr = ldap_config_attributes[i++]) != NULL) {
            (void) strlcpy(attr_buf, attr, sizeof (attr_buf));
            /*
             * if nisplusUpdateBatching, make sure
             * we don't match nisplusUpdateBatchingTimeout
             */
            if (strcmp(attr, UPDATE_BATCHING) == 0) {
                attr_len = strlen(attr);
                attr_buf[attr_len] = '=';
                attr_buf[attr_len + 1] = '\0';
                attr_val = defread_r(attr_buf, defp);

                if (attr_val == 0) {
                    attr_buf[attr_len] = ' ';
                    attr_val = defread_r(attr_buf, defp);
                }
                if (attr_val == 0) {
                    attr_buf[attr_len] = '\t';
                    attr_val = defread_r(attr_buf, defp);
                }
                if (attr_val == 0) {
                    attr_buf[attr_len] = '\n';
                    attr_val = defread_r(attr_buf, defp);
                }
            } else {
                attr_val = defread_r(attr_buf, defp);
            }
            if (attr_val == NULL)
                continue;

            got_config_data = TRUE;
            attrib_num = get_attrib_num(attr, strlen(attr));
            if (attrib_num == key_bad) {
                report_error(attr, NULL);
                rc = -1;
                break;
            }

            /*
             * Allow either entries of the form
             *  attr val
             *     or
             *  attr = val
             */
            while (is_whitespace(*attr_val))
                attr_val++;
            if (*attr_val == '=')
                attr_val++;
            while (is_whitespace(*attr_val))
                attr_val++;
            len = strlen(attr_val);
            while (len > 0 && is_whitespace(attr_val[len - 1]))
                len--;

            if (verbose) {
                report_info("\t", attr);
                report_info("\t\t", attr_val);
            }
            if (IS_BIND_INFO(attrib_num)) {
                rc = add_bind_attribute(attrib_num,
                    attr_val, len, proxy_info);
            } else if (IS_OPER_INFO(attrib_num)) {
                rc = add_operation_attribute(attrib_num,
                    attr_val, len, nis_config,
                    table_info);
            }
            if (p_error != no_parse_error) {
                report_error(attr_val, attr);
                rc = -1;
                break;
            }
        }
        file_source = NULL;
        /* Close the /etc/default file */
        defclose_r(defp);
    }
    return (rc);
}

static int
yp_parse_ldap_default_conf(
    __nis_ldap_proxy_info *proxy_info,
    __nis_config_t  *nis_config,
    __nis_config_info_t *config_info,
    __nisdb_table_mapping_t *table_info)
{
    int rc = 0;
    char        *ldap_config_attributes[n_config_keys];
    char        attr_buf[128];
    char        *attr;
    char        *attr_val;
    int     defflags;
    config_key  attrib_num;
    int         i, len;
    void        *defp;

    if ((defp = defopen_r(YP_ETCCONFFILE)) != NULL) {
        file_source = YP_ETCCONFFILE;
        if (verbose)
            report_info("default configuration values: ", NULL);
        /* Set defread_r() to be case insensitive */
        defflags = defcntl_r(DC_GETFLAGS, 0, defp);
        TURNOFF(defflags, DC_CASE);
        (void) defcntl_r(DC_SETFLAGS, defflags, defp);

        get_attribute_list(proxy_info, nis_config, config_info,
            table_info, ldap_config_attributes);
        i = 0;
        while ((attr = ldap_config_attributes[i++]) != NULL) {
            if ((strlcpy(attr_buf, attr, sizeof (attr_buf))) >=
                sizeof (attr_buf)) {
                report_error(
                    "Static buffer attr_buf overflow", NULL);
                defclose_r(defp);
                return (-1);
            }

            if ((attr_val = defread_r(attr_buf, defp)) == NULL)
                continue;

            got_config_data = TRUE;
            attrib_num = get_attrib_num(attr, strlen(attr));
            if (attrib_num == key_bad) {
                report_error(attr, NULL);
                rc = -1;
                break;
            }

            /*
             * Allow either entries of the form
             * attr val
             * or
             * attr = val
             */
            while (is_whitespace(*attr_val))
                attr_val++;
            if (*attr_val == '=')
                attr_val++;
            while (is_whitespace(*attr_val))
                attr_val++;
            len = strlen(attr_val);
            while (len > 0 && is_whitespace(attr_val[len - 1]))
                len--;

            if (verbose) {
                report_info("\t", attr);
                report_info("\t\t", attr_val);
            }
            if (IS_YP_BIND_INFO(attrib_num)) {
                rc = add_bind_attribute(attrib_num,
                    attr_val, len, proxy_info);
            } else if (IS_YP_OPER_INFO(attrib_num)) {
                rc = add_operation_attribute(attrib_num,
                    attr_val, len, nis_config,
                    table_info);
            }
            if (p_error != no_parse_error) {
                report_error(attr_val, attr);
                rc = -1;
                break;
            }
        }
        file_source = NULL;
        /* Close the /etc/default file */
        defclose_r(defp);
    }
    return (rc);
}

/*
 * FUNCTION:    get_attrib_num_cmdline
 *
 *  Parses the information for LDAP from the command line
 *  The form of the command line request is
 *      -x attribute=value
 *
 * RETURN VALUE:    0 on success, -1 on failure
 *
 * INPUT:       command line values
 */

static config_key
get_attrib_num_cmdline(
    const char  *s,
    const char  **begin_s,
    const char  **end_s)
{
    const char  *s_end      = s + strlen(s);
    const char  *equal_s;
    const char  *s1;
    config_key  attrib_num;

    while (s < s_end && is_whitespace(*s))
        s++;

    for (equal_s = s; equal_s < s_end; equal_s++)
        if (*equal_s == EQUAL_CHAR)
            break;

    if (equal_s == s_end) {
        p_error = parse_bad_command_line_attribute_format;
        return (key_bad);
    }

    for (s1 = equal_s; s1 > s && is_whitespace(s1[-1]); s1--)
        ;

    if (s1 == s) {
        p_error = parse_bad_command_line_attribute_format;
        return (key_bad);
    }

    attrib_num = get_attrib_num(s, s1 - s);

    if (attrib_num != key_bad) {
        s1 = equal_s + 1;
        while (s1 < s_end && is_whitespace(*s1))
            s1++;
        *begin_s = s1;
        while (s_end > s1 && is_whitespace(s_end[-1]))
            s_end--;
        *end_s = s_end;
    }

    return (attrib_num);
}

/*
 * FUNCTION:    parse_ldap_config_file
 *
 *  Parses the information for LDAP from a configuration
 *  file. If no file is specified, /var/nis/NIS+LDAPmapping
 *  is used
 *
 * RETURN VALUE:    0 on success, -1 on failure
 *
 * INPUT:       configuration file name
 */

static int
parse_ldap_config_file(
    const char      *config_file,
    __nis_ldap_proxy_info   *proxy_info,
    __nis_config_t      *nis_config,
    __nis_table_mapping_t   **table_mapping,
    __nis_config_info_t *config_info,
    __nisdb_table_mapping_t *table_info)
{
    int     rc = 0;
    config_key  attrib_num;
    int     fd;
    char        *attr_val;
    int     len;

    if ((fd = open(config_file, O_RDONLY)) == -1) {
        p_error = parse_open_file_error;
        report_error(config_file, NULL);
        return (-1);
    }

    start_line_num = 1;
    cur_line_num = 1;

    if (verbose)
        report_info("Reading configuration from ", config_file);

    file_source = config_file;
    while ((attrib_num = get_file_attr_val(fd, &attr_val)) > 0) {
        len = attr_val == NULL ? 0 : strlen(attr_val);
        if (IS_CONFIG_KEYWORD(attrib_num)) {
            rc = add_config_attribute(attrib_num,
                attr_val, len, config_info);
        } else if (IS_BIND_INFO(attrib_num)) {
            rc = add_bind_attribute(attrib_num,
                attr_val, len, proxy_info);
        } else if (IS_OPER_INFO(attrib_num)) {
            rc = add_operation_attribute(attrib_num,
                attr_val, len, nis_config, table_info);
        } else {
            rc = add_mapping_attribute(attrib_num,
                attr_val, len, table_mapping);
        }

        if (rc < 0) {
            report_error(attr_val == NULL ?
                "<no attribute>" : attr_val, _key_val);
            if (attr_val)
                free(attr_val);
            break;
        }
        if (attr_val)
            free(attr_val);
    }

    (void) close(fd);
    if (attrib_num == key_bad) {
        report_error(_key_val, NULL);
        rc = -1;
    }
    start_line_num = 0;
    file_source = NULL;
    return (rc);
}

/*
 * FUNCTION:    yp_parse_ldap_config_file
 *
 * Parses the information for LDAP from a configuration
 * file. If no file is specified, /var/yp/NISLDAPmapping
 * is used
 *
 * RETURN VALUE:    0 on success, -1 on failure
 *
 * INPUT:       configuration file name
 */

int
yp_parse_ldap_config_file(
    const char  *config_file,
    __nis_ldap_proxy_info   *proxy_info,
    __nis_config_t          *nis_config,
    __nis_table_mapping_t   **table_mapping,
    __nis_config_info_t     *config_info,
    __nisdb_table_mapping_t *table_info,
    __yp_domain_context_t   *ypDomains)
{
    int rc = 0;
    config_key  attrib_num;
    int fd;
    char    *attr_val = NULL;
    int     len;

    if ((fd = open(config_file, O_RDONLY)) == -1) {
        p_error = parse_open_file_error;
        report_error(config_file, NULL);
        return (-1);
    }

    start_line_num = 1;
    cur_line_num = 1;

    if (verbose)
        report_info("Reading configuration from ", config_file);

    file_source = config_file;
    while ((attrib_num = get_file_attr_val(fd, &attr_val)) > 0) {
        len = attr_val == NULL ? 0 : strlen(attr_val);
        if (IS_YP_CONFIG_KEYWORD(attrib_num)) {
            rc = add_config_attribute(attrib_num,
                attr_val, len, config_info);
        } else if (IS_YP_BIND_INFO(attrib_num)) {
            rc = add_bind_attribute(attrib_num,
                attr_val, len, proxy_info);
        } else if (IS_YP_OPER_INFO(attrib_num)) {
            rc = add_operation_attribute(attrib_num,
                attr_val, len, nis_config, table_info);
        } else if (IS_YP_DOMAIN_INFO(attrib_num)) {
            rc = add_ypdomains_attribute(attrib_num,
                attr_val, len, ypDomains);
        } else if (IS_YP_MAP_ATTR(attrib_num)) {
            rc = add_mapping_attribute(attrib_num,
                attr_val, len, table_mapping);
        } else {
            rc = -1;
            p_error = parse_unsupported_format;
        }

        if (rc < 0) {
            report_error(attr_val == NULL ?
                "<no attribute>" : attr_val, _key_val);
            if (attr_val)
                free(attr_val);
            break;
        }
        if (attr_val) {
            free(attr_val);
            attr_val = NULL;
        }
    }

    (void) close(fd);
    if (attrib_num == key_bad) {
        report_error(_key_val, NULL);
        rc = -1;
    }
    start_line_num = 0;
    file_source = NULL;
    return (rc);
}

/*
 * FUNCTION:    get_file_attr_val
 *
 *  Gets the next attribute from the configuration file.
 *
 * RETURN VALUE:    The config key if more attributes
 *          no_more_keys if eof
 *          key_bad if error
 */

static config_key
get_file_attr_val(int fd, char **attr_val)
{
    char        buf[BUFSIZE];
    char        *start_tag;
    char        *start_val;
    char        *end_val;
    char        *cut_here;
    char        *s;
    char        *a;
    char        *attribute_value;
    int     ret;
    config_key  attrib_num = no_more_keys;

    *attr_val = NULL;

    if ((ret = read_line(fd, buf, sizeof (buf))) > 0) {
        for (s = buf; is_whitespace(*s); s++)
            ;

        start_tag = s;
        while (*s != '\0' && !is_whitespace(*s))
            s++;

        if (verbose)
            report_info("\t", start_tag);
        attrib_num = get_attrib_num(start_tag, s - start_tag);
        if (attrib_num == key_bad)
            return (key_bad);

        while (is_whitespace(*s))
            s++;
        if (*s == '\0')
            return (attrib_num);
        start_val = s;

        /* note that read_line will not return a line ending with \ */
        for (; *s != '\0'; s++) {
            if (*s == ESCAPE_CHAR)
                s++;
        }
        while (s > start_val && is_whitespace(s[-1]))
            s--;

        attribute_value =
            calloc(1, (size_t)(s - start_val) + 1);
        if (attribute_value == NULL) {
            p_error = parse_no_mem_error;
            return (key_bad);
        }
        attr_val[0] = attribute_value;

        a = *attr_val;
        end_val = s;
        cut_here = 0;
        for (s = start_val; s < end_val; s++) {
            if (*s == POUND_SIGN) {
                    cut_here = s;
                    while (s < end_val) {
                        if (*s == DOUBLE_QUOTE_CHAR ||
                            *s == SINGLE_QUOTE_CHAR) {
                            cut_here = 0;
                            break;
                        }
                        s++;
                    }
            }
        }
        if (cut_here != 0)
            end_val = cut_here;

        for (s = start_val; s < end_val; s++)
            *a++ = *s;
        *a++ = '\0';
    }
    if (ret == -1)
        return (key_bad);

    return (attrib_num);
}

static LDAP *
connect_to_ldap_config_server(
    char            *sever_name,
    int         server_port,
    __nis_config_info_t *config_info)
{
    LDAP        *ld     = NULL;
    int     ldapVersion = LDAP_VERSION3;
    int     derefOption = LDAP_DEREF_ALWAYS;
    int     timelimit   = LDAP_NO_LIMIT;
    int     sizelimit   = LDAP_NO_LIMIT;
    int     errnum;
    bool_t      retrying    = FALSE;
    int     sleep_seconds   = 1;
    struct berval   cred;

    if (config_info->tls_method == no_tls) {
        ld = ldap_init(sever_name, server_port);
        if (ld == NULL) {
            p_error = parse_ldap_init_error;
            report_error(strerror(errno), NULL);
            return (NULL);
        }
    } else {
        if ((errnum = ldapssl_client_init(
            config_info->tls_cert_db, NULL)) < 0) {
            p_error = parse_ldapssl_client_init_error;
            report_error(ldapssl_err2string(errnum), NULL);
            return (NULL);
        }
        ld = ldapssl_init(sever_name, server_port, 1);
        if (ld == NULL) {
            p_error = parse_ldapssl_init_error;
            report_error(strerror(errno), NULL);
            return (NULL);
        }
    }

    (void) ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION,
        &ldapVersion);
    (void) ldap_set_option(ld, LDAP_OPT_DEREF, &derefOption);
    (void) ldap_set_option(ld, LDAP_OPT_REFERRALS, LDAP_OPT_OFF);
    (void) ldap_set_option(ld, LDAP_OPT_TIMELIMIT, &timelimit);
    (void) ldap_set_option(ld, LDAP_OPT_SIZELIMIT, &sizelimit);

    /*
     * Attempt to bind to the LDAP server.
     * We will loop until success or until an error other
     * than LDAP_CONNECT_ERROR or LDAP_SERVER_DOWN
     */
    if (verbose)
        report_info("Connecting to ", sever_name);

    for (;;) {
        if (config_info->auth_method == simple) {
            errnum = ldap_simple_bind_s(ld, config_info->proxy_dn,
                config_info->proxy_passwd);
        } else if (config_info->auth_method == cram_md5) {
            cred.bv_len = strlen(config_info->proxy_passwd);
            cred.bv_val = config_info->proxy_passwd;
            errnum = ldap_sasl_cram_md5_bind_s(ld,
                config_info->proxy_dn, &cred, NULL, NULL);
        } else if (config_info->auth_method == digest_md5) {
            cred.bv_len = strlen(config_info->proxy_passwd);
            cred.bv_val = config_info->proxy_passwd;
            errnum = ldap_x_sasl_digest_md5_bind_s(ld,
                config_info->proxy_dn, &cred, NULL, NULL);
        } else {
            errnum = ldap_simple_bind_s(ld, NULL, NULL);
        }

        if (errnum == LDAP_SUCCESS)
            break;

        if (errnum == LDAP_CONNECT_ERROR ||
            errnum == LDAP_SERVER_DOWN) {
            if (!retrying) {
                if (verbose)
                    report_info(
                    "LDAP server unavailable. Retrying...",
                        NULL);
                retrying = TRUE;
            }
            (void) sleep(sleep_seconds);
            sleep_seconds *= 2;
            if (sleep_seconds > MAX_LDAP_CONFIG_RETRY_TIME)
                sleep_seconds = MAX_LDAP_CONFIG_RETRY_TIME;
            p_error = no_parse_error;
            continue;
        }
        p_error = parse_ldap_bind_error;
        report_error2(config_info->proxy_dn, ldap_err2string(errnum));
        (void) ldap_unbind(ld);
        return (NULL);
    }

    if (verbose)
        report_info("Reading values from ", config_info->config_dn);

    return (ld);
}

/*
 * FUNCTION:    process_ldap_config_result
 *
 *  Extracts the LDAPMessage containing the nis+/LDAP
 *  configuration
 *
 * RETURN VALUE:    0 on success, -1 on failure
 *
 * INPUT:       LDAP        the LDAP connection
 *          LDAPMessage the LDAP message
 */

static int
process_ldap_config_result(
    LDAP            *ld,
    LDAPMessage     *resultMsg,
    __nis_ldap_proxy_info   *proxy_info,
    __nis_config_t      *nis_config,
    __nis_table_mapping_t   **table_mapping,
    __nisdb_table_mapping_t *table_info)
{
    LDAPMessage *e;
    int     errnum;
    char        *attr;
    BerElement  *ber        = NULL;
    config_key  attrib_num;
    char        **vals;
    int     n;
    int     i;
    char        *attr_val;
    int     len;
    int     rc = 0;
    bool_t      error_reported  = FALSE;

    e = ldap_first_entry(ld, resultMsg);

    if (e != NULL) {
        for (attr = ldap_first_attribute(ld, e, &ber); attr != NULL;
            attr = ldap_next_attribute(ld, e, ber)) {
            if (verbose)
                report_info("\t", attr);
            attrib_num = get_attrib_num(attr, strlen(attr));
            if (attrib_num == key_bad) {
                report_error(attr, NULL);
                break;
            }
            if ((vals = ldap_get_values(ld, e, attr)) != NULL) {
                n = ldap_count_values(vals);
                /* parse the attribute values */
                for (i = 0; i < n; i++) {
                    attr_val = vals[i];
                    while (is_whitespace(*attr_val))
                        attr_val++;
                    if (verbose)
                        report_info("\t\t", attr_val);
                    len = strlen(attr_val);
                    while (len > 0 &&
                        is_whitespace(attr_val[len - 1]))
                        len--;
        if (yp2ldap) {
            if (IS_YP_BIND_INFO(attrib_num)) {
                rc = add_bind_attribute(attrib_num, attr_val,
                    len, proxy_info);
            } else if (IS_YP_OPER_INFO(attrib_num)) {
                rc = add_operation_attribute(attrib_num,
                    attr_val, len, nis_config, table_info);
            } else if (IS_YP_MAP_ATTR(attrib_num)) {
                rc = add_mapping_attribute(attrib_num, attr_val,
                    len, table_mapping);
            } else {
                p_error = parse_unsupported_format;
            }
        } else {
            if (IS_BIND_INFO(attrib_num)) {
                rc = add_bind_attribute(attrib_num, attr_val,
                    len, proxy_info);
            } else if (IS_OPER_INFO(attrib_num)) {
                rc = add_operation_attribute(attrib_num,
                    attr_val, len, nis_config, table_info);
            } else {
                rc = add_mapping_attribute(attrib_num, attr_val,
                    len, table_mapping);
            }
        }
                    if (p_error != no_parse_error) {
                        report_error(attr_val, attr);
                        error_reported = TRUE;
                        break;
                    }
                }
                ldap_value_free(vals);
            } else {
                (void) ldap_get_option(ld,
                    LDAP_OPT_ERROR_NUMBER, &errnum);
                if (errnum != LDAP_SUCCESS)
                    p_error = parse_ldap_get_values_error;
            }
            ldap_memfree(attr);
            if (p_error != no_parse_error)
                break;
        }
    } else {
        errnum = ldap_result2error(ld, resultMsg, FALSE);
        if (errnum != LDAP_SUCCESS)
            p_error = parse_ldap_search_error;
    }
    if (ber != NULL)
        ber_free(ber, 0);

    if (!error_reported && p_error != no_parse_error) {
        report_error(ldap_err2string(errnum), 0);
    }

    if (p_error != no_parse_error)
        rc = -1;
    return (rc);
}

/*
 * FUNCTION:    process_ldap_referral
 *
 *  Retrieves the configuration for a referral url
 *
 * RETURN VALUE:    0 on success, -1 on failure, 1 on skip
 *
 * INPUT:       url     the ldap url
 *          __nis_ldap_proxy_info
 */

static int
process_ldap_referral(
    char            *url,
    char            **attrs,
    __nis_ldap_proxy_info   *proxy_info,
    __nis_config_t      *nis_config,
    __nis_table_mapping_t   **table_mapping,
    __nis_config_info_t *config_info,
    __nisdb_table_mapping_t *table_info)
{
    LDAPURLDesc *ludpp      = NULL;
    int     rc;
    LDAP        *ld     = NULL;
    int     errnum;
    LDAPMessage *resultMsg  = NULL;

    if ((rc = ldap_url_parse(url, &ludpp)) != LDAP_SUCCESS)
        return (1);

#ifdef LDAP_URL_OPT_SECURE
    if (ludpp->lud_options & LDAP_URL_OPT_SECURE) {
        if (config_info->tls_method != ssl_tls) {
            ldap_free_urldesc(ludpp);
            return (1);
        }
    } else {
        if (config_info->tls_method != no_tls) {
            ldap_free_urldesc(ludpp);
            return (1);
        }
    }
#endif

    if ((ld = connect_to_ldap_config_server(ludpp->lud_host,
        ludpp->lud_port, config_info)) == NULL) {
        ldap_free_urldesc(ludpp);
        return (-1);
    }

    errnum = ldap_search_s(ld, config_info->config_dn, LDAP_SCOPE_BASE,
        "objectclass=nisplusLDAPconfig", attrs, 0, &resultMsg);

    ldap_source = config_info->config_dn;

    if (errnum != LDAP_SUCCESS) {
        p_error = parse_ldap_search_error;
        report_error(ldap_err2string(errnum), 0);
        rc = -1;
    } else {
        rc = process_ldap_config_result(ld, resultMsg, proxy_info,
            nis_config, table_mapping, table_info);
    }

    ldap_source = NULL;
    (void) ldap_unbind(ld);
    if (resultMsg != NULL)
        (void) ldap_msgfree(resultMsg);

    return (rc);
}

/*
 * FUNCTION:    process_ldap_referral_msg
 *
 *  Retrieves the configuration from referred servers
 *
 * RETURN VALUE:    0 on success, -1 on failure
 *
 * INPUT:       LDAP        the LDAP connection
 *          LDAPMessage the LDAP message
 *          __nis_ldap_proxy_info
 */

static int
process_ldap_referral_msg(
    LDAP            *ld,
    LDAPMessage     *resultMsg,
    char            **attrs,
    __nis_ldap_proxy_info   *proxy_info,
    __nis_config_t      *nis_config,
    __nis_table_mapping_t   **table_mapping,
    __nis_config_info_t *config_info,
    __nisdb_table_mapping_t *table_info)
{
    int errCode;
    char    **referralsp    = NULL;
    int i;
    int rc;

    rc = ldap_parse_result(ld, resultMsg, &errCode, NULL, NULL, &referralsp,
        NULL, 0);

    if (rc != LDAP_SUCCESS || errCode != LDAP_REFERRAL) {
        p_error = parse_ldap_get_values_error;
        report_error(ldap_err2string(errCode), 0);
        rc = -1;
    } else {
        for (i = 0; referralsp[i] != NULL; i++) {
            rc = process_ldap_referral(referralsp[i], attrs,
                proxy_info, nis_config, table_mapping,
                config_info, table_info);
            if (rc <= 0)
                break;
            else
                report_info("Cannot use referral \n",
                    referralsp[i]);

        }
        if (rc > 0) {
            p_error = parse_no_available_referrals_error;
            report_error(0, 0);
        }
    }

    if (referralsp)
        ldap_value_free(referralsp);

    return (rc);
}

/*
 * FUNCTION:    parse_ldap_config_dn_attrs
 *
 *  Parses the information for LDAP from the LDAP profile
 *  - the profile object name, the LDAP server, and the
 *  authentication method must be specified.
 *
 * RETURN VALUE:    0 on success, -1 on failure
 *
 * INPUT:       __nis_ldap_proxy_info
 */

static int
parse_ldap_config_dn_attrs(
    __nis_ldap_proxy_info   *proxy_info,
    __nis_config_t      *nis_config,
    __nis_table_mapping_t   **table_mapping,
    __nis_config_info_t *config_info,
    __nisdb_table_mapping_t *table_info)
{
    int     rc      = 0;
    LDAP        *ld     = NULL;
    int     errnum;
    char        *ldap_config_attributes[n_config_keys];
    LDAPMessage *resultMsg  = NULL;

    /* Determine if properly configured for LDAP lookup */
    if (config_info->auth_method == simple &&
        config_info->proxy_dn == NULL)
        p_error = parse_no_proxy_dn_error;
    else if (config_info->auth_method ==
        (auth_method_t)NO_VALUE_SET)
        p_error = parse_no_config_auth_error;
    else if ((config_info->default_servers == NULL) ||
        (config_info->default_servers[0] == '\0'))
        p_error = parse_no_config_server_addr;
    if (p_error != no_parse_error) {
        report_error(NULL, NULL);
        return (-1);
    }

    if (config_info->tls_method == (tls_method_t)NO_VALUE_SET)
        config_info->tls_method = no_tls;
    else if (config_info->tls_method == ssl_tls &&
        (config_info->tls_cert_db == NULL ||
        *config_info->tls_cert_db == '\0')) {
        p_error = parse_no_config_cert_db;
        report_error(NULL, NULL);
        return (-1);
    }

    if (verbose)
        report_info(
            "Getting configuration from LDAP server(s): ",
            config_info->default_servers);

    /* Determine which attributes should be retrieved */
    get_attribute_list(proxy_info, nis_config, NULL, table_info,
        ldap_config_attributes);

    if ((ld = connect_to_ldap_config_server(config_info->default_servers, 0,
        config_info)) == NULL)
        return (-1);

    /* Get the attribute values */
    errnum = ldap_search_s(ld, config_info->config_dn, LDAP_SCOPE_BASE,
        "objectclass=nisplusLDAPconfig",
        ldap_config_attributes, 0, &resultMsg);
    ldap_source = config_info->config_dn;

    if (errnum == LDAP_REFERRAL) {
        rc = process_ldap_referral_msg(ld, resultMsg,
            ldap_config_attributes, proxy_info, nis_config,
            table_mapping, config_info, table_info);
    } else if (errnum != LDAP_SUCCESS) {
        p_error = parse_ldap_search_error;
        report_error(ldap_err2string(errnum), 0);
        rc = -1;
    } else {
        rc = process_ldap_config_result(ld, resultMsg, proxy_info,
            nis_config, table_mapping, table_info);
    }

    ldap_source = NULL;
    (void) ldap_unbind(ld);
    if (resultMsg != NULL)
        (void) ldap_msgfree(resultMsg);

    return (rc);
}

bool_t
is_cmd_line_option(config_key a_num)
{
    const char *const   *cmdline_options = cmdline_config;
    config_key      attrib_num;
    const char      *begin_s;
    const char      *end_s;

    if (cmdline_options == NULL)
        return (FALSE);

    while (*cmdline_options != NULL) {
        attrib_num = get_attrib_num_cmdline(
            *cmdline_options, &begin_s, &end_s);
        if (attrib_num == a_num)
            break;
        cmdline_options++;
    }
    return (*cmdline_options != NULL);
}

/*
 * FUNCTION:    get_attribute_list
 *
 *  Get a list of attributes from the LDAP server that have not yet
 *  been gotten. If config_info is NULL, the associated parameters
 *  are not needed.
 *
 * RETURN VALUE:    none
 *
 * INPUT:       Returns a list of parameters in attributes
 *          which is assumed to be of sufficient size.
 */

static void
get_attribute_list(
    const __nis_ldap_proxy_info *proxy_info,
    const __nis_config_t        *nis_config,
    const __nis_config_info_t   *config_info,
    const __nisdb_table_mapping_t   *table_info,
    char                **attributes)
{
    int     n_attrs;

    /* Determine which attributes should be retrieved */
    n_attrs = 0;

    if (config_info != NULL) {
        if (yp2ldap) {
            if (config_info->config_dn == NULL)
                attributes[n_attrs++] = YP_CONFIG_DN;
            if (config_info->default_servers == NULL)
                attributes[n_attrs++] = YP_CONFIG_SERVER_LIST;
            if (config_info->auth_method ==
                (auth_method_t)NO_VALUE_SET)
                attributes[n_attrs++] = YP_CONFIG_AUTH_METHOD;
            if (config_info->tls_method ==
                (tls_method_t)NO_VALUE_SET)
                attributes[n_attrs++] = YP_CONFIG_TLS_OPTION;
            if (config_info->proxy_dn == NULL)
                attributes[n_attrs++] = YP_CONFIG_PROXY_USER;
            if (config_info->proxy_passwd == NULL)
                attributes[n_attrs++] = YP_CONFIG_PROXY_PASSWD;
            if (config_info->tls_cert_db == NULL)
                attributes[n_attrs++] = YP_CONFIG_TLS_CERT_DB;
        } else {
            if (config_info->config_dn == NULL)
                attributes[n_attrs++] = CONFIG_DN;
            if (config_info->default_servers == NULL)
                attributes[n_attrs++] = CONFIG_SERVER_LIST;
            if (config_info->auth_method ==
                (auth_method_t)NO_VALUE_SET)
                attributes[n_attrs++] = CONFIG_AUTH_METHOD;
            if (config_info->tls_method ==
                (tls_method_t)NO_VALUE_SET)
                attributes[n_attrs++] = CONFIG_TLS_OPTION;
            if (config_info->proxy_dn == NULL)
                attributes[n_attrs++] = CONFIG_PROXY_USER;
            if (config_info->proxy_passwd == NULL)
                attributes[n_attrs++] = CONFIG_PROXY_PASSWD;
            if (config_info->tls_cert_db == NULL)
                attributes[n_attrs++] = CONFIG_TLS_CERT_DB;
        }
    } else {
        if (yp2ldap) {
            attributes[n_attrs++] = YP_DOMAIN_CONTEXT;
            attributes[n_attrs++] = YPPASSWDD_DOMAINS;
            attributes[n_attrs++] = YP_DB_ID_MAP;
            attributes[n_attrs++] = YP_COMMENT_CHAR;
            attributes[n_attrs++] = YP_MAP_FLAGS;
            attributes[n_attrs++] = YP_ENTRY_TTL;
            attributes[n_attrs++] = YP_NAME_FIELDS;
            attributes[n_attrs++] = YP_SPLIT_FIELD;
            attributes[n_attrs++] = YP_REPEATED_FIELD_SEPARATORS;
            attributes[n_attrs++] = YP_LDAP_OBJECT_DN;
            attributes[n_attrs++] = NIS_TO_LDAP_MAP;
            attributes[n_attrs++] = LDAP_TO_NIS_MAP;
        } else {
            attributes[n_attrs++] = DB_ID_MAP;
            attributes[n_attrs++] = ENTRY_TTL;
            attributes[n_attrs++] = LDAP_OBJECT_DN;
            attributes[n_attrs++] = NISPLUS_TO_LDAP_MAP;
            attributes[n_attrs++] = LDAP_TO_NISPLUS_MAP;
        }
    }

    if (yp2ldap) {
        if (proxy_info->default_servers == NULL)
            attributes[n_attrs++] = PREFERRED_SERVERS;
        if (proxy_info->auth_method == (auth_method_t)NO_VALUE_SET)
            attributes[n_attrs++] = AUTH_METHOD;
        if (proxy_info->tls_method == (tls_method_t)NO_VALUE_SET)
            attributes[n_attrs++] = YP_TLS_OPTION;
        if (proxy_info->tls_cert_db == NULL)
            attributes[n_attrs++] = YP_TLS_CERT_DB;
        if (proxy_info->default_search_base == NULL)
            attributes[n_attrs++] = SEARCH_BASE;
        if (proxy_info->proxy_dn == NULL)
            attributes[n_attrs++] = YP_PROXY_USER;
        if (proxy_info->proxy_passwd == NULL)
            attributes[n_attrs++] = YP_PROXY_PASSWD;
        if (proxy_info->default_nis_domain == NULL)
            attributes[n_attrs++] = YP_LDAP_BASE_DOMAIN;
        if (proxy_info->bind_timeout.tv_sec ==
            (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = YP_BIND_TIMEOUT;
        if (proxy_info->search_timeout.tv_sec ==
            (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = YP_SEARCH_TIMEOUT;
        if (proxy_info->modify_timeout.tv_sec ==
            (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = YP_MODIFY_TIMEOUT;
        if (proxy_info->add_timeout.tv_sec == (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = YP_ADD_TIMEOUT;
        if (proxy_info->delete_timeout.tv_sec ==
            (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = YP_DELETE_TIMEOUT;
        if (proxy_info->search_time_limit == (int)NO_VALUE_SET)
            attributes[n_attrs++] = YP_SEARCH_TIME_LIMIT;
        if (proxy_info->search_size_limit == (int)NO_VALUE_SET)
            attributes[n_attrs++] = YP_SEARCH_SIZE_LIMIT;
        if (proxy_info->follow_referral ==
            (follow_referral_t)NO_VALUE_SET)
            attributes[n_attrs++] = YP_FOLLOW_REFERRAL;

        if (table_info->retrieveError ==
            (__nis_retrieve_error_t)NO_VALUE_SET)
            attributes[n_attrs++] = YP_RETRIEVE_ERROR_ACTION;
        if (table_info->retrieveErrorRetry.attempts == NO_VALUE_SET)
            attributes[n_attrs++] = YP_RETREIVE_ERROR_ATTEMPTS;
        if (table_info->retrieveErrorRetry.timeout ==
            (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = YP_RETREIVE_ERROR_TIMEOUT;
        if (table_info->storeError ==
            (__nis_store_error_t)NO_VALUE_SET)
            attributes[n_attrs++] = YP_STORE_ERROR_ACTION;
        if (table_info->storeErrorRetry.attempts == NO_VALUE_SET)
            attributes[n_attrs++] = YP_STORE_ERROR_ATTEMPTS;
        if (table_info->storeErrorRetry.timeout ==
            (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = YP_STORE_ERROR_TIMEOUT;
        if (table_info->refreshError ==
            (__nis_refresh_error_t)NO_VALUE_SET)
            attributes[n_attrs++] = REFRESH_ERROR_ACTION;
        if (table_info->refreshErrorRetry.attempts == NO_VALUE_SET)
            attributes[n_attrs++] = REFRESH_ERROR_ATTEMPTS;
        if (table_info->refreshErrorRetry.timeout ==
            (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = REFRESH_ERROR_TIMEOUT;
        if (table_info->matchFetch ==
            (__nis_match_fetch_t)NO_VALUE_SET)
            attributes[n_attrs++] = YP_MATCH_FETCH;
    } else {
        if (proxy_info->default_servers == NULL)
            attributes[n_attrs++] = PREFERRED_SERVERS;
        if (proxy_info->auth_method == (auth_method_t)NO_VALUE_SET)
            attributes[n_attrs++] = AUTH_METHOD;
        if (proxy_info->tls_method == (tls_method_t)NO_VALUE_SET)
            attributes[n_attrs++] = TLS_OPTION;
        if (proxy_info->tls_cert_db == NULL)
            attributes[n_attrs++] = TLS_CERT_DB;
        if (proxy_info->default_search_base == NULL)
            attributes[n_attrs++] = SEARCH_BASE;
        if (proxy_info->proxy_dn == NULL)
            attributes[n_attrs++] = PROXY_USER;
        if (proxy_info->proxy_passwd == NULL)
            attributes[n_attrs++] = PROXY_PASSWD;
        if (proxy_info->default_nis_domain == NULL)
            attributes[n_attrs++] = LDAP_BASE_DOMAIN;
        if (proxy_info->bind_timeout.tv_sec ==
            (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = BIND_TIMEOUT;
        if (proxy_info->search_timeout.tv_sec ==
            (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = SEARCH_TIMEOUT;
        if (proxy_info->modify_timeout.tv_sec ==
            (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = MODIFY_TIMEOUT;
        if (proxy_info->add_timeout.tv_sec == (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = ADD_TIMEOUT;
        if (proxy_info->delete_timeout.tv_sec ==
            (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = DELETE_TIMEOUT;
        if (proxy_info->search_time_limit == (int)NO_VALUE_SET)
            attributes[n_attrs++] = SEARCH_TIME_LIMIT;
        if (proxy_info->search_size_limit == (int)NO_VALUE_SET)
            attributes[n_attrs++] = SEARCH_SIZE_LIMIT;
        if (proxy_info->follow_referral ==
            (follow_referral_t)NO_VALUE_SET)
            attributes[n_attrs++] = FOLLOW_REFERRAL;

        if (table_info->retrieveError ==
            (__nis_retrieve_error_t)NO_VALUE_SET)
            attributes[n_attrs++] = RETRIEVE_ERROR_ACTION;
        if (table_info->retrieveErrorRetry.attempts == NO_VALUE_SET)
            attributes[n_attrs++] = RETREIVE_ERROR_ATTEMPTS;
        if (table_info->retrieveErrorRetry.timeout ==
            (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = RETREIVE_ERROR_TIMEOUT;
        if (table_info->storeError ==
            (__nis_store_error_t)NO_VALUE_SET)
            attributes[n_attrs++] = STORE_ERROR_ACTION;
        if (table_info->storeErrorRetry.attempts == NO_VALUE_SET)
            attributes[n_attrs++] = STORE_ERROR_ATTEMPTS;
        if (table_info->storeErrorRetry.timeout ==
            (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = STORE_ERROR_TIMEOUT;
        if (table_info->refreshError ==
            (__nis_refresh_error_t)NO_VALUE_SET)
            attributes[n_attrs++] = REFRESH_ERROR_ACTION;
        if (table_info->refreshErrorRetry.attempts == NO_VALUE_SET)
            attributes[n_attrs++] = REFRESH_ERROR_ATTEMPTS;
        if (table_info->refreshErrorRetry.timeout ==
            (time_t)NO_VALUE_SET)
            attributes[n_attrs++] = REFRESH_ERROR_TIMEOUT;
        if (table_info->matchFetch ==
            (__nis_match_fetch_t)NO_VALUE_SET)
            attributes[n_attrs++] = MATCH_FETCH;
    }

    switch (nis_config->initialUpdate) {
    case (__nis_initial_update_t)NO_VALUE_SET:
        attributes[n_attrs++] = INITIAL_UPDATE_ACTION;
        attributes[n_attrs++] = INITIAL_UPDATE_ONLY;
        break;
    case (__nis_initial_update_t)INITIAL_UPDATE_NO_ACTION:
    case (__nis_initial_update_t)NO_INITIAL_UPDATE_NO_ACTION:
        attributes[n_attrs++] = INITIAL_UPDATE_ACTION;
        break;
    case (__nis_initial_update_t)FROM_NO_INITIAL_UPDATE:
    case (__nis_initial_update_t)TO_NO_INITIAL_UPDATE:
        attributes[n_attrs++] = INITIAL_UPDATE_ONLY;
        break;
    }

    if (nis_config->threadCreationError ==
        (__nis_thread_creation_error_t)NO_VALUE_SET)
        attributes[n_attrs++] = THREAD_CREATE_ERROR_ACTION;
    if (nis_config->threadCreationErrorTimeout.attempts == NO_VALUE_SET)
        attributes[n_attrs++] = THREAD_CREATE_ERROR_ATTEMPTS;
    if (nis_config->threadCreationErrorTimeout.timeout ==
        (time_t)NO_VALUE_SET)
        attributes[n_attrs++] = THREAD_CREATE_ERROR_TIMEOUT;
    if (nis_config->dumpError == (__nis_dump_error_t)NO_VALUE_SET)
        attributes[n_attrs++] = DUMP_ERROR_ACTION;
    if (nis_config->dumpErrorTimeout.attempts == NO_VALUE_SET)
        attributes[n_attrs++] = DUMP_ERROR_ATTEMPTS;
    if (nis_config->dumpErrorTimeout.timeout == (time_t)NO_VALUE_SET)
        attributes[n_attrs++] = DUMP_ERROR_TIMEOUT;
    if (nis_config->resyncService == (__nis_resync_service_t)NO_VALUE_SET)
        attributes[n_attrs++] = RESYNC;
    if (nis_config->updateBatching ==
        (__nis_update_batching_t)NO_VALUE_SET)
        attributes[n_attrs++] = UPDATE_BATCHING;
    if (nis_config->updateBatchingTimeout.timeout == (time_t)NO_VALUE_SET)
        attributes[n_attrs++] = UPDATE_BATCHING_TIMEOUT;
    if (nis_config->numberOfServiceThreads == (int)NO_VALUE_SET)
        attributes[n_attrs++] = NUMBER_THEADS;
    if (nis_config->emulate_yp == (int)NO_VALUE_SET)
        attributes[n_attrs++] = YP_EMULATION;

    /* maxRPCRecordSize is not configurable through LDAP profiles */
    if (nis_config->maxRPCRecordSize == (int)NO_VALUE_SET)
        attributes[n_attrs++] = MAX_RPC_RECSIZE;

    attributes[n_attrs++] = NULL;
}

/*
 *  Notes on adding new attributes
 *  1. Determine where the attribute value will be saved
 *      Currently, the following structures are defined:
 *      __nis_config_info_t config_info
 *      __nis_ldap_proxy_info   proxyInfo
 *      __nis_config_t      ldapConfig
 *      __nisdb_table_mapping_t ldapDBTableMapping
 *      __nis_table_mapping_t   ldapTableMapping
 *      or add a new structure or variable - this will require
 *      more code.
 *  2. Initialize the value to a known unconfigured value.
 *      This can be done in initialize_parse_structs or
 *      parse_ldap_migration.
 *  3. In the header file nis_parse_ldap_conf.h, add the name
 *      of the attribute. (Currently, the attribute name is assumed
 *      to be the same for the command line, the preference file,
 *      and LDAP.) The names are grouped logically. Add a corresponding
 *      config_key to the enum. Note that position in this file is
 *      essential because the macros such as IS_BIND_INFO depend on
 *      the sequence. The corresponding macro (IS_CONFIG_KEYWORD,
 *      IS_BIND_INFO, or IS_OPER_INFO) may need to be adjusted. These
 *      are used to partition the attributes into smaller chunks.
 *  4. Add the correspond entry to the keyword_lookup array in
 *      nis_parse_ldap_attr.c, which is used to determine the config_key
 *      from the corresponding key word.
 *  5. Add the attribute to the list of attributes to retrieve from
 *      the LDAP server if no value has been set in the function
 *      parse_ldap_config_dn_attrs. (This assumes that the attribute
 *      is not used to get the configuration from the LDAP server.)
 *  6. Add logic to parse the individual attribute in
 *      add_config_attribute, add_bind_attribute,
 *      add_operation_attribute, or add_mapping_attribute depending
 *      which group of attributes the added attribute belongs to.
 *  7. In set_default_values, if the attribute value has not been set, set
 *      the default value. If any additional fixup is needed depending
 *      on other configuration values, it should be done here.
 *  8. If an attribute name is a subset of another, parse_ldap_default_conf
 *          should be modified.
 */