#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 <lber.h>
#include <ldap.h>
#include <syslog.h>
#include "ldap_parse.h"
#include "nis_parse_ldap_conf.h"
extern FILE *cons;
static bool_t get_timeval_t(const char *s, int len, struct timeval *t,
time_t default_val);
static bool_t get_limit(const char *s, int len, int *limit, int default_val);
static bool_t get_time_t(const char *s, time_t *t, time_t default_val);
static bool_t get_uint_val(const char *attrib_val, int *val, int default_val);
static bool_t get_int_val(const char *attrib_val, int *val, int default_val);
static void warn_duplicate_val(config_key attrib_num);
static struct {
const char *key_name;
config_key key_id;
} keyword_lookup[] = {
{CONFIG_DN, key_config_dn},
{YP_CONFIG_DN, key_yp_config_dn},
{CONFIG_SERVER_LIST, key_config_server_list},
{YP_CONFIG_SERVER_LIST, key_yp_config_server_list},
{CONFIG_AUTH_METHOD, key_config_auth_method},
{YP_CONFIG_AUTH_METHOD, key_yp_config_auth_method},
{CONFIG_TLS_OPTION, key_config_tls_option},
{YP_CONFIG_TLS_OPTION, key_yp_config_tls_option},
{CONFIG_TLS_CERT_DB, key_config_tls_certificate_db},
{YP_CONFIG_TLS_CERT_DB, key_yp_config_tls_certificate_db},
{CONFIG_PROXY_USER, key_config_proxy_user},
{YP_CONFIG_PROXY_USER, key_yp_config_proxy_user},
{CONFIG_PROXY_PASSWD, key_config_proxy_passwd},
{YP_CONFIG_PROXY_PASSWD, key_yp_config_proxy_passwd},
{PREFERRED_SERVERS, key_preferred_servers},
{AUTH_METHOD, key_auth_method},
{TLS_OPTION, key_tls_option},
{YP_TLS_OPTION, key_yp_tls_option},
{TLS_CERT_DB, key_tls_certificate_db},
{YP_TLS_CERT_DB, key_yp_tls_certificate_db},
{SEARCH_BASE, key_search_base},
{PROXY_USER, key_proxy_user},
{YP_PROXY_USER, key_yp_proxy_user},
{PROXY_PASSWD, key_proxy_passwd},
{YP_PROXY_PASSWD, key_yp_proxy_passwd},
{LDAP_BASE_DOMAIN, key_ldap_base_domain},
{YP_LDAP_BASE_DOMAIN, key_yp_ldap_base_domain},
{BIND_TIMEOUT, key_bind_timeout},
{YP_BIND_TIMEOUT, key_yp_bind_timeout},
{SEARCH_TIMEOUT, key_search_timeout},
{YP_SEARCH_TIMEOUT, key_yp_search_timeout},
{MODIFY_TIMEOUT, key_modify_timeout},
{YP_MODIFY_TIMEOUT, key_yp_modify_timeout},
{ADD_TIMEOUT, key_add_timeout},
{YP_ADD_TIMEOUT, key_yp_add_timeout},
{DELETE_TIMEOUT, key_delete_timeout},
{YP_DELETE_TIMEOUT, key_yp_delete_timeout},
{SEARCH_TIME_LIMIT, key_search_time_limit},
{YP_SEARCH_TIME_LIMIT, key_yp_search_time_limit},
{SEARCH_SIZE_LIMIT, key_search_size_limit},
{YP_SEARCH_SIZE_LIMIT, key_yp_search_size_limit},
{FOLLOW_REFERRAL, key_follow_referral},
{YP_FOLLOW_REFERRAL, key_yp_follow_referral},
{INITIAL_UPDATE_ACTION, key_initial_update_action},
{INITIAL_UPDATE_ONLY, key_initial_update_only},
{RETRIEVE_ERROR_ACTION, key_retrieve_error_action},
{YP_RETRIEVE_ERROR_ACTION, key_yp_retrieve_error_action},
{RETREIVE_ERROR_ATTEMPTS,
key_retrieve_error_attempts},
{YP_RETREIVE_ERROR_ATTEMPTS,
key_yp_retrieve_error_attempts},
{RETREIVE_ERROR_TIMEOUT,
key_retreive_error_timeout},
{YP_RETREIVE_ERROR_TIMEOUT,
key_yp_retreive_error_timeout},
{STORE_ERROR_ACTION, key_store_error_action},
{YP_STORE_ERROR_ACTION, key_yp_store_error_action},
{STORE_ERROR_ATTEMPTS, key_store_error_attempts},
{YP_STORE_ERROR_ATTEMPTS, key_yp_store_error_attempts},
{STORE_ERROR_TIMEOUT, key_store_error_timeout},
{YP_STORE_ERROR_TIMEOUT, key_yp_store_error_timeout},
{REFRESH_ERROR_ACTION, key_refresh_error_action},
{REFRESH_ERROR_ATTEMPTS,
key_refresh_error_attempts},
{REFRESH_ERROR_TIMEOUT, key_refresh_error_timeout},
{THREAD_CREATE_ERROR_ACTION,
key_thread_create_error_action},
{THREAD_CREATE_ERROR_ATTEMPTS,
key_thread_create_error_attempts},
{THREAD_CREATE_ERROR_TIMEOUT,
key_thread_create_error_timeout},
{DUMP_ERROR_ACTION, key_dump_error_action},
{DUMP_ERROR_ATTEMPTS, key_dump_error_attempts},
{DUMP_ERROR_TIMEOUT, key_dump_error_timeout},
{RESYNC, key_resync},
{UPDATE_BATCHING, key_update_batching},
{UPDATE_BATCHING_TIMEOUT,
key_update_batching_timeout},
{MATCH_FETCH, key_match_fetch},
{YP_MATCH_FETCH, key_yp_match_fetch},
{NUMBER_THEADS, key_number_threads},
{YP_EMULATION, key_yp_emulation},
{MAX_RPC_RECSIZE, key_max_rpc_recsize},
{YP_DOMAIN_CONTEXT, key_yp_domain_context},
{YPPASSWDD_DOMAINS, key_yppasswdd_domains},
{DB_ID_MAP, key_db_id_map},
{YP_DB_ID_MAP, key_yp_db_id_map},
{YP_COMMENT_CHAR, key_yp_comment_char},
{YP_MAP_FLAGS, key_yp_map_flags},
{ENTRY_TTL, key_entry_ttl},
{YP_ENTRY_TTL, key_yp_entry_ttl},
{YP_NAME_FIELDS, key_yp_name_fields},
{YP_SPLIT_FIELD, key_yp_split_field},
{YP_REPEATED_FIELD_SEPARATORS, key_yp_repeated_field_separators},
{LDAP_OBJECT_DN, key_ldap_object_dn},
{YP_LDAP_OBJECT_DN, key_yp_ldap_object_dn},
{LDAP_TO_NISPLUS_MAP, key_ldap_to_nisplus_map},
{LDAP_TO_NIS_MAP, key_ldap_to_nis_map},
{NISPLUS_TO_LDAP_MAP, key_nisplus_to_ldap_map},
{NIS_TO_LDAP_MAP, key_nis_to_ldap_map}
};
int
add_config_attribute(
config_key attrib_num,
const char *attrib_val,
int attrib_len,
__nis_config_info_t *config_info)
{
switch (attrib_num) {
case key_yp_config_dn:
case key_config_dn:
if (config_info->config_dn == NULL) {
if (!validate_dn(attrib_val, attrib_len))
break;
config_info->config_dn =
s_strndup(attrib_val, attrib_len);
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_config_server_list:
case key_config_server_list:
if (config_info->default_servers == NULL) {
config_info->default_servers =
s_strndup(attrib_val, attrib_len);
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_config_auth_method:
case key_config_auth_method:
if (config_info->auth_method ==
(auth_method_t)NO_VALUE_SET) {
if (same_string("none", attrib_val,
attrib_len))
config_info->auth_method = none;
else if (same_string("simple", attrib_val,
attrib_len))
config_info->auth_method = simple;
else if (same_string("sasl/cram-md5",
attrib_val, attrib_len))
config_info->auth_method = cram_md5;
else if (same_string("sasl/digest-md5",
attrib_val, attrib_len))
config_info->auth_method = digest_md5;
else
p_error = parse_bad_auth_method_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_config_tls_option:
case key_config_tls_option:
if (config_info->tls_method ==
(tls_method_t)NO_VALUE_SET) {
if (same_string("none", attrib_val,
attrib_len))
config_info->tls_method = no_tls;
else if (same_string("ssl", attrib_val,
attrib_len))
config_info->tls_method = ssl_tls;
else
p_error = parse_bad_tls_option_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_config_tls_certificate_db:
case key_config_tls_certificate_db:
if (config_info->tls_cert_db == NULL) {
config_info->tls_cert_db =
s_strndup(attrib_val, attrib_len);
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_config_proxy_user:
case key_config_proxy_user:
if (config_info->proxy_dn == NULL) {
config_info->proxy_dn =
s_strndup(attrib_val, attrib_len);
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_config_proxy_passwd:
case key_config_proxy_passwd:
if (config_info->proxy_passwd == NULL) {
config_info->proxy_passwd =
s_strndup_esc(attrib_val, attrib_len);
} else {
warn_duplicate_val(attrib_num);
}
break;
default:
p_error = parse_internal_error;
break;
}
return (p_error == no_parse_error ? 0 : -1);
}
int
add_bind_attribute(
config_key attrib_num,
const char *attrib_val,
int attrib_len,
__nis_ldap_proxy_info *proxy_info)
{
struct timeval t;
int limit;
switch (attrib_num) {
case key_yp_preferred_servers:
case key_preferred_servers:
if (proxy_info->default_servers == NULL) {
proxy_info->default_servers =
s_strndup(attrib_val, attrib_len);
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_auth_method:
case key_auth_method:
if (proxy_info->auth_method ==
(auth_method_t)NO_VALUE_SET) {
if (same_string("none", attrib_val,
attrib_len))
proxy_info->auth_method = none;
else if (same_string("simple", attrib_val,
attrib_len))
proxy_info->auth_method = simple;
else if (same_string("sasl/cram-md5",
attrib_val, attrib_len))
proxy_info->auth_method = cram_md5;
else if (same_string("sasl/digest-md5",
attrib_val, attrib_len))
proxy_info->auth_method = digest_md5;
else
p_error = parse_bad_auth_method_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_tls_option:
case key_tls_option:
if (proxy_info->tls_method ==
(tls_method_t)NO_VALUE_SET) {
if (same_string("none", attrib_val,
attrib_len))
proxy_info->tls_method = no_tls;
else if (same_string("ssl", attrib_val,
attrib_len))
proxy_info->tls_method = ssl_tls;
else
p_error = parse_bad_tls_option_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_tls_certificate_db:
case key_tls_certificate_db:
if (proxy_info->tls_cert_db == NULL) {
proxy_info->tls_cert_db =
s_strndup(attrib_val, attrib_len);
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_search_base:
case key_search_base:
if (proxy_info->default_search_base == NULL) {
if (!validate_dn(attrib_val, attrib_len))
break;
proxy_info->default_search_base =
s_strndup(attrib_val, attrib_len);
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_proxy_user:
case key_proxy_user:
if (proxy_info->proxy_dn == NULL) {
proxy_info->proxy_dn =
s_strndup(attrib_val, attrib_len);
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_proxy_passwd:
case key_proxy_passwd:
if (proxy_info->proxy_passwd == NULL) {
proxy_info->proxy_passwd =
s_strndup_esc(attrib_val, attrib_len);
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_ldap_base_domain:
case key_ldap_base_domain:
if (proxy_info->default_nis_domain == NULL) {
proxy_info->default_nis_domain =
s_strndup_esc(attrib_val, attrib_len);
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_bind_timeout:
case key_bind_timeout:
if (proxy_info->bind_timeout.tv_sec ==
(time_t)NO_VALUE_SET) {
if (!get_timeval_t(attrib_val, attrib_len, &t,
DEFAULT_BIND_TIMEOUT))
break;
proxy_info->bind_timeout = t;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_search_timeout:
if (proxy_info->search_timeout.tv_sec ==
(time_t)NO_VALUE_SET) {
if (!get_timeval_t(attrib_val, attrib_len, &t,
DEFAULT_YP_SEARCH_TIMEOUT))
break;
proxy_info->search_timeout = t;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_search_timeout:
if (proxy_info->search_timeout.tv_sec ==
(time_t)NO_VALUE_SET) {
if (!get_timeval_t(attrib_val, attrib_len, &t,
DEFAULT_SEARCH_TIMEOUT))
break;
proxy_info->search_timeout = t;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_modify_timeout:
case key_modify_timeout:
if (proxy_info->modify_timeout.tv_sec ==
(time_t)NO_VALUE_SET) {
if (!get_timeval_t(attrib_val, attrib_len, &t,
DEFAULT_MODIFY_TIMEOUT))
break;
proxy_info->modify_timeout = t;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_add_timeout:
case key_add_timeout:
if (proxy_info->add_timeout.tv_sec ==
(time_t)NO_VALUE_SET) {
if (!get_timeval_t(attrib_val, attrib_len, &t,
DEFAULT_ADD_TIMEOUT))
break;
proxy_info->add_timeout = t;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_delete_timeout:
case key_delete_timeout:
if (proxy_info->delete_timeout.tv_sec ==
(time_t)NO_VALUE_SET) {
if (!get_timeval_t(attrib_val, attrib_len, &t,
DEFAULT_DELETE_TIMEOUT))
break;
proxy_info->delete_timeout = t;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_search_time_limit:
case key_search_time_limit:
if (proxy_info->search_time_limit ==
(int)NO_VALUE_SET) {
if (!get_limit(attrib_val, attrib_len, &limit,
DEFAULT_SEARCH_TIME_LIMIT))
break;
proxy_info->search_time_limit = limit;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_search_size_limit:
case key_search_size_limit:
if (proxy_info->search_size_limit ==
(int)NO_VALUE_SET) {
if (!get_limit(attrib_val, attrib_len, &limit,
DEFAULT_SEARCH_SIZE_LIMIT))
break;
proxy_info->search_size_limit = limit;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_follow_referral:
case key_follow_referral:
if (proxy_info->follow_referral ==
(follow_referral_t)NO_VALUE_SET) {
if (same_string("yes", attrib_val, attrib_len))
proxy_info->follow_referral = follow;
else if (same_string("no", attrib_val, attrib_len))
proxy_info->follow_referral = no_follow;
else
p_error = parse_yes_or_no_expected_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
default:
p_error = parse_internal_error;
break;
}
return (p_error == no_parse_error ? 0 : -1);
}
int
add_operation_attribute(
config_key attrib_num,
const char *attrib_val,
int attrib_len,
__nis_config_t *config_info,
__nisdb_table_mapping_t *table_info)
{
char buf[1024];
int i;
int len;
time_t timeout;
bool_t last_digit = FALSE;
for (i = 0, len = 0; i < attrib_len; i++) {
if (!last_digit &&
is_whitespace(attrib_val[i]))
continue;
buf[len++] = attrib_val[i];
if (len >= sizeof (buf)) {
p_error = parse_line_too_long;
return (-1);
}
last_digit = isdigit(attrib_val[i]);
}
buf[len] = '\0';
switch (attrib_num) {
case key_initial_update_action:
if (config_info->initialUpdate ==
(__nis_initial_update_t)NO_VALUE_SET) {
if (strcasecmp("none", buf) == 0)
config_info->initialUpdate = ini_none;
else if (strcasecmp("from_ldap", buf) == 0)
config_info->initialUpdate =
(__nis_initial_update_t)FROM_NO_INITIAL_UPDATE;
else if (strcasecmp("to_ldap", buf) == 0)
config_info->initialUpdate =
(__nis_initial_update_t)TO_NO_INITIAL_UPDATE;
else
p_error = parse_initial_update_action_error;
} else if (config_info->initialUpdate ==
(__nis_initial_update_t)INITIAL_UPDATE_NO_ACTION) {
if (strcasecmp("none", buf) == 0)
config_info->initialUpdate = ini_none;
else if (strcasecmp("from_ldap", buf) == 0)
config_info->initialUpdate = from_ldap_update_only;
else if (strcasecmp("to_ldap", buf) == 0)
config_info->initialUpdate = to_ldap_update_only;
else
p_error = parse_initial_update_action_error;
} else if (config_info->initialUpdate ==
(__nis_initial_update_t)NO_INITIAL_UPDATE_NO_ACTION) {
if (strcasecmp("none", buf) == 0)
config_info->initialUpdate = ini_none;
else if (strcasecmp("from_ldap", buf) == 0)
config_info->initialUpdate = from_ldap;
else if (strcasecmp("to_ldap", buf) == 0)
config_info->initialUpdate = to_ldap;
else
p_error = parse_initial_update_action_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_initial_update_only:
if (config_info->initialUpdate ==
(__nis_initial_update_t)NO_VALUE_SET) {
if (strcasecmp("yes", buf) == 0)
config_info->initialUpdate =
(__nis_initial_update_t)
INITIAL_UPDATE_NO_ACTION;
else if (strcasecmp("no", buf) == 0)
config_info->initialUpdate =
(__nis_initial_update_t)
NO_INITIAL_UPDATE_NO_ACTION;
else
p_error = parse_initial_update_only_error;
} else if (config_info->initialUpdate ==
(__nis_initial_update_t)FROM_NO_INITIAL_UPDATE) {
if (strcasecmp("yes", buf) == 0)
config_info->initialUpdate = from_ldap_update_only;
else if (strcasecmp("no", buf) == 0)
config_info->initialUpdate = from_ldap;
else
p_error = parse_initial_update_only_error;
} else if (config_info->initialUpdate ==
(__nis_initial_update_t)TO_NO_INITIAL_UPDATE) {
if (strcasecmp("yes", buf) == 0)
config_info->initialUpdate = to_ldap_update_only;
else if (strcasecmp("no", buf) == 0)
config_info->initialUpdate = to_ldap;
else
p_error = parse_initial_update_only_error;
} else if (config_info->initialUpdate != ini_none) {
warn_duplicate_val(attrib_num);
}
break;
case key_thread_create_error_action:
if (config_info->threadCreationError ==
(__nis_thread_creation_error_t)NO_VALUE_SET) {
if (strcasecmp("pass_error", buf) == 0)
config_info->threadCreationError = pass_error;
else if (strcasecmp("retry", buf) == 0)
config_info->threadCreationError = cre_retry;
else
p_error = parse_thread_create_error_action_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_thread_create_error_attempts:
if (config_info->threadCreationErrorTimeout.attempts ==
NO_VALUE_SET) {
if (get_int_val(buf, &i, DEFAULT_THREAD_ERROR_ATTEMPTS))
config_info->threadCreationErrorTimeout.attempts = i;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_thread_create_error_timeout:
if (config_info->threadCreationErrorTimeout.timeout ==
(time_t)NO_VALUE_SET) {
if (get_time_t(buf, &timeout,
DEFAULT_THREAD_ERROR_TIME_OUT))
config_info->threadCreationErrorTimeout.timeout =
timeout;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_dump_error_action:
if (config_info->dumpError ==
(__nis_dump_error_t)NO_VALUE_SET) {
if (strcasecmp("rollback", buf) == 0)
config_info->dumpError = rollback;
else if (strcasecmp("retry", buf) == 0)
config_info->dumpError = de_retry;
else
p_error = parse_dump_error_action_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_dump_error_attempts:
if (config_info->dumpErrorTimeout.attempts == NO_VALUE_SET) {
if (get_int_val(buf, &i, DEFAULT_DUMP_ERROR_ATTEMPTS))
config_info->dumpErrorTimeout.attempts = i;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_dump_error_timeout:
if (config_info->dumpErrorTimeout.timeout ==
(time_t)NO_VALUE_SET) {
if (get_time_t(buf, &timeout,
DEFAULT_DUMP_ERROR_TIME_OUT))
config_info->dumpErrorTimeout.timeout = timeout;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_resync:
if (config_info->resyncService ==
(__nis_resync_service_t)NO_VALUE_SET) {
if (strcasecmp("directory_locked", buf) == 0)
config_info->resyncService = directory_locked;
else if (strcasecmp("from_copy", buf) == 0)
config_info->resyncService = from_copy;
else if (strcasecmp("from_live", buf) == 0)
config_info->resyncService = from_live;
else
p_error = parse_resync_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_update_batching:
if (config_info->updateBatching ==
(__nis_update_batching_t)NO_VALUE_SET) {
if (strcasecmp("none", buf) == 0)
config_info->updateBatching = upd_none;
else if (strcasecmp("accumulate", buf) == 0) {
config_info->updateBatching = accumulate;
} else if (strcasecmp("bounded_accumulate", buf) == 0) {
config_info->updateBatching = bounded_accumulate;
} else
p_error = parse_update_batching_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_update_batching_timeout:
if (config_info->updateBatchingTimeout.timeout ==
(time_t)NO_VALUE_SET) {
if (get_time_t(buf, &timeout, DEFAULT_BATCHING_TIME_OUT))
config_info->updateBatchingTimeout.timeout = timeout;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_number_threads:
if (config_info->numberOfServiceThreads ==
(int)NO_VALUE_SET) {
if (get_uint_val(buf, &i, DEFAULT_NUMBER_OF_THREADS))
config_info->numberOfServiceThreads = i;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_emulation:
if (config_info->emulate_yp ==
(int)NO_VALUE_SET) {
if (strcasecmp("yes", buf) == 0)
config_info->emulate_yp = TRUE;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_retrieve_error_action:
if (table_info->retrieveError ==
(__nis_retrieve_error_t)NO_VALUE_SET) {
if (strcasecmp("use_cached", buf) == 0)
table_info->retrieveError = use_cached;
else if (strcasecmp("fail", buf) == 0)
table_info->retrieveError = fail;
else
p_error = parse_yp_retrieve_error_action_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_retrieve_error_action:
if (table_info->retrieveError ==
(__nis_retrieve_error_t)NO_VALUE_SET) {
if (strcasecmp("use_cached", buf) == 0)
table_info->retrieveError = use_cached;
else if (strcasecmp("try_again", buf) == 0)
table_info->retrieveError = try_again;
else if (strcasecmp("unavail", buf) == 0)
table_info->retrieveError = ret_unavail;
else if (strcasecmp("no_such_name", buf) == 0)
table_info->retrieveError = no_such_name;
else if (strcasecmp("retry", buf) == 0)
table_info->retrieveError = ret_retry;
else
p_error = parse_retrieve_error_action_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_retrieve_error_attempts:
case key_retrieve_error_attempts:
if (table_info->retrieveErrorRetry.attempts == NO_VALUE_SET) {
if (get_int_val(buf, &i, DEFAULT_RETRIEVE_ERROR_ATTEMPTS))
table_info->retrieveErrorRetry.attempts = i;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_retreive_error_timeout:
case key_retreive_error_timeout:
if (table_info->retrieveErrorRetry.timeout ==
(time_t)NO_VALUE_SET) {
if (get_time_t(buf, &timeout,
DEFAULT_RETRIEVE_ERROR_TIME_OUT))
table_info->retrieveErrorRetry.timeout = timeout;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_store_error_action:
if (table_info->storeError ==
(__nis_store_error_t)NO_VALUE_SET) {
if (strcasecmp("retry", buf) == 0)
table_info->storeError = sto_retry;
else if (strcasecmp("fail", buf) == 0)
table_info->storeError = sto_fail;
else
p_error = parse_yp_store_error_action_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_store_error_action:
if (table_info->storeError ==
(__nis_store_error_t)NO_VALUE_SET) {
if (strcasecmp("system_error", buf) == 0)
table_info->storeError = system_error;
else if (strcasecmp("unavail", buf) == 0)
table_info->storeError = sto_unavail;
else if (strcasecmp("retry", buf) == 0)
table_info->storeError = sto_retry;
else
p_error = parse_store_error_action_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_store_error_attempts:
case key_store_error_attempts:
if (table_info->storeErrorRetry.attempts == NO_VALUE_SET) {
if (get_int_val(buf, &i,
DEFAULT_STORE_ERROR_ATTEMPTS))
table_info->storeErrorRetry.attempts = i;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_store_error_timeout:
case key_store_error_timeout:
if (table_info->storeErrorRetry.timeout ==
(time_t)NO_VALUE_SET) {
if (get_time_t(buf, &timeout,
DEFAULT_STORE_ERROR_TIME_OUT))
table_info->storeErrorRetry.timeout = timeout;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_refresh_error_action:
if (table_info->refreshError ==
(__nis_refresh_error_t)NO_VALUE_SET) {
if (strcasecmp("continue_using", buf) == 0)
table_info->refreshError = continue_using;
else if (strcasecmp("cache_expired", buf) == 0)
table_info->refreshError = cache_expired;
else if (strcasecmp("tryagain", buf) == 0)
table_info->refreshError = tryagain;
else if (strcasecmp("retry", buf) == 0)
table_info->refreshError = ref_retry;
else if (strcasecmp("continue_using,retry", buf) == 0 ||
strcasecmp("retry,continue_using", buf) == 0)
table_info->refreshError = continue_using_retry;
else
p_error = parse_refresh_error_action_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_refresh_error_attempts:
if (table_info->refreshErrorRetry.attempts == NO_VALUE_SET) {
if (get_int_val(buf, &i, DEFAULT_REFRESH_ERROR_ATTEMPTS))
table_info->refreshErrorRetry.attempts = i;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_refresh_error_timeout:
if (table_info->refreshErrorRetry.timeout ==
(time_t)NO_VALUE_SET) {
if (get_time_t(buf, &timeout,
DEFAULT_REFRESH_ERROR_TIME_OUT))
table_info->refreshErrorRetry.timeout = timeout;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_yp_match_fetch:
case key_match_fetch:
if (table_info->matchFetch ==
(__nis_match_fetch_t)NO_VALUE_SET) {
if (strcasecmp("no_match_only", buf) == 0)
table_info->matchFetch = no_match_only;
else if (strcasecmp("always", buf) == 0)
table_info->matchFetch = mat_always;
else if (strcasecmp("never", buf) == 0)
table_info->matchFetch = mat_never;
else
p_error = parse_match_fetch_error;
} else {
warn_duplicate_val(attrib_num);
}
break;
case key_max_rpc_recsize:
if (config_info->maxRPCRecordSize ==
(int)NO_VALUE_SET) {
if (get_uint_val(buf, &i, RPC_MAXDATASIZE))
config_info->maxRPCRecordSize = i;
} else {
warn_duplicate_val(attrib_num);
}
break;
default:
p_error = parse_internal_error;
break;
}
return (p_error == no_parse_error ? 0 : -1);
}
config_key
get_attrib_num(const char *s, int n)
{
int k;
int i;
config_key attrib_num = key_bad;
k = n < sizeof (_key_val) ? n : sizeof (_key_val) - 1;
(void) memcpy(_key_val, s, k);
_key_val[k] = '\0';
for (i = 0; i < sizeof (keyword_lookup) /
sizeof (keyword_lookup[0]); i++) {
if (strncasecmp(s, keyword_lookup[i].key_name, n) == 0 &&
strlen(keyword_lookup[i].key_name) == n) {
attrib_num = keyword_lookup[i].key_id;
break;
}
}
if (attrib_num == key_bad) {
p_error = parse_bad_key;
}
return (attrib_num);
}
static bool_t
get_timeval_t(
const char *s,
int len,
struct timeval *t,
time_t default_val)
{
time_t tv_sec = 0;
time_t tv_usec = 0;
time_t digit;
time_t mult = 100000;
bool_t got_digit = FALSE;
bool_t got_period = FALSE;
const char *s_end = s + len;
while (s < s_end && is_whitespace(*s))
s++;
while (s < s_end && isdigit(*s)) {
digit = (*s++) - '0';
got_digit = TRUE;
if (WILL_OVERFLOW_TIME(tv_sec, digit))
tv_sec = TIME_MAX;
else
tv_sec = tv_sec * 10 + digit;
}
while (s < s_end && is_whitespace(*s))
s++;
if (s < s_end && *s == PERIOD_CHAR) {
s++;
got_period = TRUE;
while (s < s_end && isdigit(*s)) {
got_digit = TRUE;
digit = (*s++) - '0';
tv_usec += digit * mult;
mult /= 10;
}
while (s < s_end && is_whitespace(*s))
s++;
}
if (s == s_end) {
if (!got_digit) {
if (got_period) {
p_error = parse_bad_time_error;
return (FALSE);
}
tv_sec = default_val;
}
t->tv_sec = tv_sec;
t->tv_usec = tv_usec;
} else
p_error = parse_bad_time_error;
return (s == s_end);
}
static bool_t
get_limit(
const char *s,
int len,
int *limit,
int default_val)
{
bool_t got_digit = FALSE;
int l = 0;
time_t digit;
const char *s_end = s + len;
while (s < s_end && is_whitespace(*s))
s++;
while (s < s_end && isdigit(*s)) {
got_digit = TRUE;
digit = (*s++) - '0';
if (WILL_OVERFLOW_LIMIT(l, digit))
l = LIMIT_MAX;
else
l = l * 10 + digit;
}
while (s < s_end && is_whitespace(*s))
s++;
if (s == s_end) {
if (!got_digit)
l = default_val;
*limit = l;
} else
p_error = parse_bad_uint_error;
return (s == s_end);
}
static bool_t
get_time_t(const char *s, time_t *t, time_t default_val)
{
bool_t got_digit = FALSE;
time_t timeout = 0;
for (; is_whitespace(*s); s++)
;
while (isdigit(*s)) {
got_digit = TRUE;
if (WILL_OVERFLOW_TIME(timeout, *s))
timeout = TIME_MAX;
else
timeout = timeout * 10 + *s - '0';
s++;
}
for (; is_whitespace(*s); s++)
;
if (*s != '\0') {
p_error = parse_bad_int_error;
return (FALSE);
}
if (!got_digit)
timeout = default_val;
*t = timeout;
return (TRUE);
}
static bool_t
get_uint_val(const char *s, int *val, int default_val)
{
bool_t got_digit = FALSE;
int v = 0;
for (; is_whitespace(*s); s++)
;
while (isdigit(*s)) {
got_digit = TRUE;
if (WILL_OVERFLOW_INT(v, *s))
v = INT_MAX;
else
v = v * 10 + *s - '0';
s++;
}
for (; is_whitespace(*s); s++)
;
if (*s != '\0') {
p_error = parse_bad_int_error;
return (FALSE);
}
if (!got_digit)
v = default_val;
*val = v;
return (TRUE);
}
static bool_t
get_int_val(const char *s, int *val, int default_val)
{
bool_t got_digit = FALSE;
int v = 0;
bool_t is_neg = FALSE;
for (; is_whitespace(*s); s++)
;
if (*s == '-') {
is_neg = TRUE;
s++;
}
while (isdigit(*s)) {
got_digit = TRUE;
if (WILL_OVERFLOW_INT(v, *s))
v = INT_MAX;
else
v = v * 10 + *s - '0';
s++;
}
for (; is_whitespace(*s); s++)
;
if (*s != '\0') {
p_error = parse_bad_int_error;
return (FALSE);
}
if (!got_digit) {
if (is_neg) {
p_error = parse_bad_int_error;
return (FALSE);
}
v = default_val;
}
if (is_neg)
v = -v;
*val = v;
return (TRUE);
}
static void
warn_duplicate_val(
config_key attrib_num)
{
const char *key_name = "Unknown";
int i;
if (warn_file == NULL || is_cmd_line_option(attrib_num))
return;
for (i = 0; i < sizeof (keyword_lookup) /
sizeof (keyword_lookup[0]); i++) {
if (attrib_num == keyword_lookup[i].key_id) {
key_name = keyword_lookup[i].key_name;
break;
}
}
if (cons != NULL) {
fprintf(cons,
"Warning: Duplicate value for %s in %s at line:%d\n",
key_name, warn_file, start_line_num);
} else {
syslog(LOG_INFO,
"Duplicate value for %s in %s at line:%d",
key_name, warn_file, start_line_num);
}
}
void
warn_duplicate_map(
const char *db_id,
config_key attrib_num)
{
const char *key_name = "Unknown";
int i;
if (warn_file == NULL)
return;
for (i = 0; i < sizeof (keyword_lookup) /
sizeof (keyword_lookup[0]); i++) {
if (attrib_num == keyword_lookup[i].key_id) {
key_name = keyword_lookup[i].key_name;
break;
}
}
if (cons != NULL) {
fprintf(cons,
"Warning: Duplicate value for %s:%s in %s at line:%d\n",
key_name, db_id, warn_file, start_line_num);
} else {
syslog(LOG_INFO,
"Duplicate value for %s:%s in %s at line:%d",
key_name, db_id, warn_file, start_line_num);
}
}
