0N/A

0N/A#pragma ident "%Z%%M% %I% %E% SMI"

0N/A

0N/A#include <stdio.h>

0N/A#include <string.h>

0N/A#include <stdlib.h>

0N/A#include <ctype.h>

0N/A#include <fcntl.h>

0N/A#include <unistd.h>

0N/A#include <errno.h>

0N/A#include <locale.h>

0N/A#include <sys/stat.h>

0N/A#include <lber.h>

0N/A#include <ldap.h>

0N/A#include <deflt.h>

0N/A

0N/A#include "ldap_map.h"

0N/A

0N/A#include "ldap_parse.h"

0N/A#include "ldap_glob.h"

0N/A#include "nis_parse_ldap_conf.h"

0N/A

0N/A__nis_ldap_proxy_info proxyInfo =

0N/A {NULL, (auth_method_t)NO_VALUE_SET, (tls_method_t)NO_VALUE_SET, NULL,

0N/A NULL, NULL, NULL, NULL, (follow_referral_t)NO_VALUE_SET};

0N/A__nis_config_t ldapConfig;

0N/A__nisdb_table_mapping_t ldapDBTableMapping;

0N/A__nis_table_mapping_t *ldapTableMapping = NULL;

0N/A__yp_domain_context_t ypDomains;

0N/A

0N/Aparse_error p_error = no_parse_error;

0N/Aint cur_line_num = 0;

0N/Aint start_line_num = 0;

0N/Aint seq_num = 0;

0N/Aconst char *warn_file = NULL;

0N/A

13N/Achar _key_val[38];

13N/Aconst char *command_line_source = NULL;

13N/Aconst char *file_source = NULL;

0N/Aconst char *ldap_source = NULL;

0N/A

0N/Aconst char *const *cmdline_config = NULL;

0N/Astatic bool_t got_config_data = FALSE;

0N/A

0N/Astatic int parse_ldap_cmd_line(const char *const *cmdline_options,

0N/A __nis_ldap_proxy_info *proxy_info, __nis_config_t *nis_config,

0N/A __nis_table_mapping_t **table_mapping, __nis_config_info_t *config_info,

0N/A __nisdb_table_mapping_t *table_info);

0N/Astatic int parse_ldap_default_conf(__nis_ldap_proxy_info *proxy_info,

0N/A __nis_config_t *nis_config, __nis_config_info_t *config_info,

0N/A __nisdb_table_mapping_t *table_info);

0N/Astatic int parse_ldap_config_file(const char *config_file,

0N/A __nis_ldap_proxy_info *proxy_info, __nis_config_t *nis_config,

0N/A __nis_table_mapping_t **table_mapping, __nis_config_info_t *config_info,

0N/A __nisdb_table_mapping_t *table_info);

0N/Astatic int parse_ldap_config_dn_attrs(__nis_ldap_proxy_info *proxy_info,

0N/A __nis_config_t *nis_config, __nis_table_mapping_t **table_mapping,

0N/A __nis_config_info_t *config_info, __nisdb_table_mapping_t *table_info);

0N/Astatic int yp_parse_ldap_default_conf(__nis_ldap_proxy_info *proxy_info,

0N/A __nis_config_t *nis_config, __nis_config_info_t *config_info,

0N/A __nisdb_table_mapping_t *table_info);

0N/A

0N/A

0N/Astatic config_key get_attrib_num_cmdline(const char *s,

0N/A const char **begin_s, const char **end_s);

0N/Astatic config_key get_file_attr_val(int fd, char **attr_val);

0N/Astatic void get_attribute_list(

0N/A const __nis_ldap_proxy_info *proxy_info,

0N/A const __nis_config_t *nis_config,

0N/A const __nis_config_info_t *config_info,

0N/A const __nisdb_table_mapping_t *table_info,

0N/A char **ldap_config_attributes);

13N/A

0N/A

0N/Aparse_ldap_migration(

0N/A const char *const *cmdline_options,

0N/A const char *config_file)

0N/A{

0N/A int rc = 0;

0N/A __nis_config_info_t config_info

0N/A = {NULL, NULL, (auth_method_t)NO_VALUE_SET,

0N/A (tls_method_t)NO_VALUE_SET, NULL,

0N/A NULL, NULL};

0N/A struct stat buf;

0N/A int i = 0;

0N/A

0N/A p_error = no_parse_error;

0N/A

0N/A if (verbose)

0N/A report_info("Getting LDAP configuration", NULL);

0N/A

0N/A initialize_parse_structs(&proxyInfo, &ldapConfig, &ldapDBTableMapping);

0N/A

0N/A if (yp2ldap)

0N/A initialize_yp_parse_structs(&ypDomains);

0N/A

0N/A if (cmdline_options != NULL) {

0N/A got_config_data = TRUE;

0N/A /* NIS to LDAP does not read command line attributes */

0N/A if (!yp2ldap)

0N/A rc = parse_ldap_cmd_line(cmdline_options, &proxyInfo,

0N/A &ldapConfig, &ldapTableMapping, &config_info,

0N/A &ldapDBTableMapping);

0N/A else

0N/A rc = 0;

0N/A }

0N/A

0N/A if (rc == 0) {

0N/A if (yp2ldap)

0N/A rc = yp_parse_ldap_default_conf(&proxyInfo, &ldapConfig,

0N/A &config_info, &ldapDBTableMapping);

0N/A else

0N/A rc = parse_ldap_default_conf(&proxyInfo, &ldapConfig,

0N/A &config_info, &ldapDBTableMapping);

0N/A }

0N/A

0N/A if (config_file == NULL) {

0N/A if (yp2ldap) {

0N/A if (stat(YP_DEFAULT_MAPPING_FILE, &buf) == 0)

0N/A config_file = YP_DEFAULT_MAPPING_FILE;

0N/A } else {

0N/A if (stat(DEFAULT_MAPPING_FILE, &buf) == 0)

0N/A config_file = DEFAULT_MAPPING_FILE;

0N/A }

0N/A }

0N/A

0N/A if (rc == 0 && config_file != NULL) {

0N/A got_config_data = TRUE;

0N/A warn_file = config_file;

0N/A cmdline_config = cmdline_options;

0N/A if (yp2ldap)

0N/A rc = yp_parse_ldap_config_file(config_file, &proxyInfo,

0N/A &ldapConfig, &ldapTableMapping, &config_info,

0N/A &ldapDBTableMapping, &ypDomains);

0N/A else

0N/A rc = parse_ldap_config_file(config_file, &proxyInfo,

0N/A &ldapConfig, &ldapTableMapping, &config_info,

0N/A &ldapDBTableMapping);

0N/A

0N/A warn_file = NULL;

0N/A cmdline_config = NULL;

0N/A }

0N/A if (rc == 0 && (config_info.config_dn != NULL) &&

0N/A (config_info.config_dn[0] != '\0')) {

0N/A rc = parse_ldap_config_dn_attrs(&proxyInfo,

0N/A &ldapConfig, &ldapTableMapping, &config_info,

0N/A &ldapDBTableMapping);

0N/A }

0N/A

0N/A free_config_info(&config_info);

0N/A

0N/A if (rc == 0 && got_config_data == FALSE)

0N/A rc = 1;

0N/A

0N/A set_default_values(&proxyInfo, &ldapConfig, &ldapDBTableMapping);

0N/A

0N/A if (yp2ldap == 1 && rc == 0) {

0N/A rc = second_parser_pass(&ldapTableMapping);

0N/A if (rc == 0)

0N/A rc = final_parser_pass(&ldapTableMapping, &ypDomains);

0N/A if (rc == -2)

0N/A return (-1);

0N/A }

0N/A

0N/A if (rc == 0)

0N/A rc = finish_parse(&proxyInfo, &ldapTableMapping);

0N/A

0N/A if (rc == 0)

0N/A rc = linked2hash(ldapTableMapping);

0N/A

0N/A if ((rc == 0) && yptol_mode)

13N/A rc = map_id_list_init();

0N/A

0N/A if (rc != 0) {

free_parse_structs();

} else if (verbose)

report_info("LDAP configuration complete", NULL);

return (rc);

}

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;

static char *attr_val;

int defflags;

config_key attrib_num;

int i;

int len;

int attr_len;

if (defopen(ETCCONFFILE) == 0) {

file_source = ETCCONFFILE;

if (verbose)

report_info(

"default configuration values: ", NULL);

/* Set defread() to be case insensitive */

defflags = defcntl(DC_GETFLAGS, 0);

TURNOFF(defflags, DC_CASE);

(void) defcntl(DC_SETFLAGS, defflags);

get_attribute_list(proxy_info, nis_config, config_info,

table_info, ldap_config_attributes);

i = 0;

while ((attr = ldap_config_attributes[i++]) != NULL) {

strlcpy(attr_buf, attr, sizeof (attr_buf));

/*

if (strcmp(attr, UPDATE_BATCHING) == 0) {

attr_len = strlen(attr);

attr_buf[attr_len] = '=';

attr_buf[attr_len + 1] = '\0';

attr_val = defread(attr_buf);

if (attr_val == 0) {

attr_buf[attr_len] = ' ';

attr_val = defread(attr_buf);

}

if (attr_val == 0) {

attr_buf[attr_len] = '\t';

attr_val = defread(attr_buf);

}

if (attr_val == 0) {

attr_buf[attr_len] = '\n';

attr_val = defread(attr_buf);

}

} else {

attr_val = defread(attr_buf);

}

if (attr_val == 0)

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;

}

/*

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 */

(void) defopen(0);

}

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;

static char *attr_val;

int defflags;

config_key attrib_num;

int i, len, attr_len;

if ((defopen(YP_ETCCONFFILE)) == 0) {

file_source = YP_ETCCONFFILE;

if (verbose)

report_info("default configuration values: ", NULL);

/* Set defread() to be case insensitive */

defflags = defcntl(DC_GETFLAGS, 0);

TURNOFF(defflags, DC_CASE);

(void) defcntl(DC_SETFLAGS, defflags);

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);

return (-1);

}

if ((attr_val = defread(attr_buf)) == 0)

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;

}

/*

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 */

(void) defopen(0);

}

return (rc);

}

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);

}

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);

}

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;

int numDomains = 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);

}

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;

int found_quote = 0;

*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 =

(char *)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)

{

int rc = 0;

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);

/*

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);

}

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);

}

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);

}

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);

}

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);

}

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);

}

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;