OpenSolaris_b135/lib/libnisdb/nis_parse_ldap_util.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (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 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#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 <dlfcn.h> /* for dynamic loading only */
#include "ldap_parse.h"
#include "nis_parse_ldap_conf.h"
#include "nis_parse_ldap_err.h"
#include "ldap_util.h"
#include "ldap_util.h"
void append_dot(char **str);
void append_comma(char **str);
bool_t make_full_dn(char **dn, const char *base);
bool_t make_fqdn(__nis_object_dn_t *dn, const char *base);
char *get_default_ldap_base(const char *domain);
bool_t add_domain(char **objName, const char *domain);
bool_t add_column(__nis_table_mapping_t *t, const char *col_name);
__nis_mapping_rule_t **dup_mapping_rules(
__nis_mapping_rule_t **rules, int n_rules);
__nis_mapping_rule_t *dup_mapping_rule(
__nis_mapping_rule_t *in);
void *s_malloc(size_t size);
__nis_mapping_format_t *dup_format_mapping(
__nis_mapping_format_t *in);
bool_t dup_mapping_element(__nis_mapping_element_t *in,
__nis_mapping_element_t *out);
extern FILE *cons;
/*
* FUNCTION: free_parse_structs
*
* Release the resources in parse results
*
*/
void
free_parse_structs()
{
__nis_table_mapping_t *t;
__nis_table_mapping_t *t1;
free_proxy_info(&proxyInfo);
for (t = ldapTableMapping; t != NULL; t = t1) {
t1 = t->next;
free_table_mapping(t);
}
ldapTableMapping = NULL;
}
/*
* FUNCTION: initialize_parse_structs
*
* Initialize fields to unset values
*
* INPUT: __nis_ldap_proxy_info, __nis_config_t
* and __nisdb_table_mapping_t structures
*/
void
initialize_parse_structs(
__nis_ldap_proxy_info *proxy_info,
__nis_config_t *config_info,
__nisdb_table_mapping_t *table_info)
{
proxy_info->default_servers = NULL;
proxy_info->auth_method = (auth_method_t)NO_VALUE_SET;
proxy_info->tls_method = (tls_method_t)NO_VALUE_SET;
proxy_info->tls_cert_db = NULL;
proxy_info->default_search_base = NULL;
proxy_info->proxy_dn = NULL;
proxy_info->proxy_passwd = NULL;
proxy_info->default_nis_domain = NULL;
proxy_info->bind_timeout.tv_sec = (time_t)NO_VALUE_SET;
proxy_info->bind_timeout.tv_usec = 0;
proxy_info->search_timeout.tv_sec = (time_t)NO_VALUE_SET;
proxy_info->search_timeout.tv_usec = 0;
proxy_info->modify_timeout.tv_sec = (time_t)NO_VALUE_SET;
proxy_info->modify_timeout.tv_usec = 0;
proxy_info->add_timeout.tv_sec = (time_t)NO_VALUE_SET;
proxy_info->add_timeout.tv_usec = 0;
proxy_info->delete_timeout.tv_sec = (time_t)NO_VALUE_SET;
proxy_info->delete_timeout.tv_usec = 0;
proxy_info->search_time_limit = (int)NO_VALUE_SET;
proxy_info->search_size_limit = (int)NO_VALUE_SET;
proxy_info->follow_referral = (follow_referral_t)NO_VALUE_SET;
config_info->initialUpdate = (__nis_initial_update_t)NO_VALUE_SET;
config_info->threadCreationError =
(__nis_thread_creation_error_t)NO_VALUE_SET;
config_info->threadCreationErrorTimeout.attempts = NO_VALUE_SET;
config_info->threadCreationErrorTimeout.timeout = (time_t)NO_VALUE_SET;
config_info->dumpError = (__nis_dump_error_t)NO_VALUE_SET;
config_info->dumpErrorTimeout.attempts = NO_VALUE_SET;
config_info->dumpErrorTimeout.timeout = (time_t)NO_VALUE_SET;
config_info->resyncService = (__nis_resync_service_t)NO_VALUE_SET;
config_info->updateBatching = (__nis_update_batching_t)NO_VALUE_SET;
config_info->updateBatchingTimeout.timeout = (time_t)NO_VALUE_SET;
config_info->numberOfServiceThreads = (int)NO_VALUE_SET;
config_info->emulate_yp = (int)NO_VALUE_SET;
config_info->maxRPCRecordSize = (int)NO_VALUE_SET;
table_info->retrieveError = (__nis_retrieve_error_t)NO_VALUE_SET;
table_info->retrieveErrorRetry.attempts = NO_VALUE_SET;
table_info->retrieveErrorRetry.timeout = (time_t)NO_VALUE_SET;
table_info->storeError = (__nis_store_error_t)NO_VALUE_SET;
table_info->storeErrorRetry.attempts = NO_VALUE_SET;
table_info->storeErrorRetry.timeout = (time_t)NO_VALUE_SET;
table_info->refreshError = (__nis_refresh_error_t)NO_VALUE_SET;
table_info->refreshErrorRetry.attempts = NO_VALUE_SET;
table_info->refreshErrorRetry.timeout = (time_t)NO_VALUE_SET;
table_info->matchFetch = (__nis_match_fetch_t)NO_VALUE_SET;
}
/*
* FUNCTION: free_mapping_rule
*
* Frees __nis_mapping_rule_t
*
* INPUT: __nis_mapping_rule_t
*/
void
free_mapping_rule(__nis_mapping_rule_t *rule)
{
int i;
__nis_mapping_rlhs_t *r;
if (rule != NULL) {
r = &rule->lhs;
for (i = 0; i < r->numElements; i++)
free_mapping_element(&r->element[i]);
if (r->element != NULL)
free(r->element);
r = &rule->rhs;
for (i = 0; i < r->numElements; i++)
free_mapping_element(&r->element[i]);
if (r->element != NULL)
free(r->element);
free(rule);
}
}
/*
* FUNCTION: free_mapping_element
*
* Frees __nis_mapping_element_t
*
* INPUT: __nis_mapping_element_t
*/
void
free_mapping_element(__nis_mapping_element_t *e)
{
int i;
if (e == NULL)
return;
switch (e->type) {
case me_item:
free_mapping_item(&e->element.item);
break;
case me_print:
if (e->element.print.fmt != NULL)
free_mapping_format(e->element.print.fmt);
e->element.print.fmt = NULL;
for (i = 0; i < e->element.print.numSubElements; i++)
free_mapping_sub_element(
&e->element.print.subElement[i]);
e->element.print.numSubElements = 0;
if (e->element.print.subElement != NULL)
free(e->element.print.subElement);
e->element.print.subElement = NULL;
break;
case me_split:
free_mapping_item(&e->element.split.item);
break;
case me_match:
if (e->element.match.fmt != NULL)
free_mapping_format(e->element.match.fmt);
e->element.match.fmt = NULL;
for (i = 0; i < e->element.match.numItems; i++)
free_mapping_item(&e->element.match.item[i]);
e->element.match.numItems = 0;
if (e->element.match.item != NULL)
free(e->element.match.item);
e->element.match.item = NULL;
break;
case me_extract:
if (e->element.extract.fmt != NULL)
free_mapping_format(e->element.extract.fmt);
e->element.extract.fmt = NULL;
free_mapping_item(&e->element.extract.item);
break;
}
e = NULL;
}
/*
* FUNCTION: free_table_mapping
*
* Frees __nis_table_mapping_t
*
* INPUT: __nis_table_mapping_t
*/
/*
* free_table_mapping does not remove the table mapping from
* its hashed list
*/
void
free_table_mapping(__nis_table_mapping_t *mapping)
{
int i;
if (mapping == NULL)
return;
if (mapping->dbId != NULL)
free(mapping->dbId);
mapping->dbId = NULL;
if (mapping->objName != NULL)
free(mapping->objName);
mapping->objName = NULL;
for (i = 0; i < mapping->index.numIndexes; i++) {
free(mapping->index.name[i]);
free_mapping_format(mapping->index.value[i]);
}
if (mapping->index.name != NULL)
free(mapping->index.name);
mapping->index.name = NULL;
if (mapping->index.value != NULL)
free(mapping->index.value);
mapping->index.value = NULL;
mapping->index.numIndexes = 0;
if (mapping->column != NULL) {
for (i = 0; i < mapping->numColumns; i++) {
free(mapping->column[i]);
}
mapping->numColumns = 0;
free(mapping->column);
mapping->column = NULL;
}
if (mapping->commentChar != NULL)
mapping->commentChar = NULL;
if (mapping->objectDN != NULL)
free_object_dn(mapping->objectDN);
mapping->objectDN = NULL;
if (mapping->separatorStr != NULL)
mapping->separatorStr = NULL;
for (i = 0; i < mapping->numRulesFromLDAP; i++) {
if (mapping->ruleFromLDAP[i]) /* See Comment below */
free_mapping_rule(mapping->ruleFromLDAP[i]);
}
mapping->numRulesFromLDAP = 0;
if (mapping->ruleFromLDAP != NULL)
free(mapping->ruleFromLDAP);
mapping->ruleFromLDAP = NULL;
for (i = 0; i < mapping->numRulesToLDAP; i++) {
if (mapping->ruleToLDAP[i])
/*
* Normally mapping->ruleToLDAP[i] should
* always be non-null if
* mapping->numRulesToLDAP is > 0.
* However it is possible to have data
* corruption where numRulesToLDAP gets
* some integer value even though no real
* data is present in mapping->ruleToLDAP.
*/
free_mapping_rule(mapping->ruleToLDAP[i]);
}
mapping->numRulesToLDAP = 0;
if (mapping->ruleToLDAP != NULL)
free(mapping->ruleToLDAP);
mapping->ruleToLDAP = NULL;
if (mapping->e != NULL) {
/* Similar logic as in above comment applies. */
for (i = 0; i <= mapping->numSplits; i++) {
free_mapping_element(&mapping->e[i]);
}
free(mapping->e);
}
mapping->e = NULL;
mapping->numSplits = 0;
free(mapping);
}
/*
* FUNCTION: free_config_info
*
* Frees __nis_config_info_t
*
* INPUT: __nis_config_info_t
*/
void
free_config_info(__nis_config_info_t *config_info)
{
if (config_info->config_dn != NULL)
free(config_info->config_dn);
config_info->config_dn = NULL;
if (config_info->default_servers != NULL)
free(config_info->default_servers);
config_info->default_servers = NULL;
if (config_info->proxy_dn != NULL)
free(config_info->proxy_dn);
config_info->proxy_dn = NULL;
if (config_info->proxy_passwd != NULL)
free(config_info->proxy_passwd);
config_info->proxy_passwd = NULL;
if (config_info->tls_cert_db != NULL)
free(config_info->tls_cert_db);
config_info->tls_cert_db = NULL;
}
/*
* FUNCTION: free_proxy_info
*
* Frees __nis_ldap_proxy_info
*
* INPUT: __nis_ldap_proxy_info
*/
void
free_proxy_info(__nis_ldap_proxy_info *proxy_info)
{
if (proxy_info->tls_cert_db != NULL)
free(proxy_info->tls_cert_db);
proxy_info->tls_cert_db = NULL;
if (proxy_info->default_servers != NULL)
free(proxy_info->default_servers);
proxy_info->default_servers = NULL;
if (proxy_info->default_search_base != NULL)
free(proxy_info->default_search_base);
proxy_info->default_search_base = NULL;
if (proxy_info->proxy_dn != NULL)
free(proxy_info->proxy_dn);
proxy_info->proxy_dn = NULL;
if (proxy_info->proxy_passwd != NULL)
free(proxy_info->proxy_passwd);
proxy_info->proxy_passwd = NULL;
if (proxy_info->default_nis_domain != NULL)
free(proxy_info->default_nis_domain);
proxy_info->default_nis_domain = NULL;
}
/*
* FUNCTION: free_object_dn
*
* Frees __nis_object_dn_t
*
* INPUT: __nis_object_dn_t
*/
void
free_object_dn(__nis_object_dn_t *obj_dn)
{
__nis_object_dn_t *t;
int i;
while (obj_dn != NULL) {
if (obj_dn->read.base != NULL)
free(obj_dn->read.base);
obj_dn->read.base = NULL;
if (obj_dn->read.attrs != NULL)
free(obj_dn->read.attrs);
obj_dn->read.attrs = NULL;
if (obj_dn->write.base != NULL)
free(obj_dn->write.base);
obj_dn->write.base = NULL;
if (obj_dn->write.attrs != NULL)
free(obj_dn->write.attrs);
obj_dn->write.attrs = NULL;
if (obj_dn->dbIdName != NULL)
free(obj_dn->dbIdName);
obj_dn->dbIdName = NULL;
for (i = 0; i < obj_dn->numDbIds; i++)
free_mapping_rule(obj_dn->dbId[i]);
obj_dn->numDbIds = 0;
if (obj_dn->dbId != NULL)
free(obj_dn->dbId);
obj_dn->dbId = NULL;
t = obj_dn;
obj_dn = obj_dn->next;
free(t);
}
}
/*
* FUNCTION: free_index
*
* Frees __nis_index_t
*
* INPUT: __nis_index_t
*/
void
free_index(__nis_index_t *index)
{
int i;
for (i = 0; i < index->numIndexes; i++) {
free(index->name[i]);
free_mapping_format(index->value[i]);
}
index->numIndexes = 0;
if (index->name != NULL)
free(index->name);
index->name = NULL;
if (index->value != NULL)
free(index->value);
index->value = NULL;
}
/*
* FUNCTION: free_mapping_item
*
* Frees __nis_mapping_item_t
*
* INPUT: __nis_mapping_item_t
*/
void
free_mapping_item(__nis_mapping_item_t *item)
{
if (item == NULL)
return;
if (item->name != NULL)
free(item->name);
item->name = NULL;
if (item->type == mit_nisplus) {
free_index(&item->searchSpec.obj.index);
if (item->searchSpec.obj.name != NULL)
free(item->searchSpec.obj.name);
item->searchSpec.obj.name = NULL;
} else if (item->type == mit_ldap) {
if (item->searchSpec.triple.base != NULL)
free(item->searchSpec.triple.base);
item->searchSpec.triple.base = NULL;
if (item->searchSpec.triple.attrs != NULL)
free(item->searchSpec.triple.attrs);
item->searchSpec.triple.attrs = NULL;
if (item->searchSpec.triple.element != NULL) {
free_mapping_element(
item->searchSpec.triple.element);
free(item->searchSpec.triple.element);
}
item->searchSpec.triple.element = NULL;
}
if (item->exItem != NULL) {
free_mapping_item(item->exItem);
free(item->exItem);
item->exItem = 0;
}
}
/*
* FUNCTION: free_mapping_format
*
* Frees __nis_mapping_format_t
*
* INPUT: __nis_mapping_format_t
*/
void
free_mapping_format(__nis_mapping_format_t *fmt)
{
__nis_mapping_format_t *f = fmt;
while (fmt->type != mmt_end) {
switch (fmt->type) {
case mmt_item:
break;
case mmt_string:
if (fmt->match.string != NULL)
free(fmt->match.string);
fmt->match.string = NULL;
break;
case mmt_single:
if (fmt->match.single.lo != NULL)
free(fmt->match.single.lo);
fmt->match.single.lo = NULL;
if (fmt->match.single.hi != NULL)
free(fmt->match.single.hi);
fmt->match.single.hi = NULL;
break;
case mmt_limit:
break;
case mmt_any:
break;
case mmt_berstring:
case mmt_berstring_null:
if (fmt->match.berString != NULL)
free(fmt->match.berString);
fmt->match.berString = NULL;
break;
case mmt_begin:
break;
case mmt_end:
break;
}
fmt++;
}
free(f);
}
/*
* FUNCTION: free_mapping_sub_element
*
* Frees __nis_mapping_sub_element_t
*
* INPUT: __nis_mapping_sub_element_t
*/
void
free_mapping_sub_element(__nis_mapping_sub_element_t *sub)
{
int i;
switch (sub->type) {
case me_item:
free_mapping_item(&sub->element.item);
break;
case me_print:
if (sub->element.print.fmt != NULL)
free_mapping_format(sub->element.print.fmt);
sub->element.print.fmt = NULL;
for (i = 0; i < sub->element.print.numItems; i++)
free_mapping_item(&sub->element.print.item[i]);
sub->element.print.numItems = 0;
if (sub->element.print.item != NULL)
free(sub->element.print.item);
sub->element.print.item = NULL;
break;
case me_split:
free_mapping_item(&sub->element.split.item);
break;
case me_extract:
if (sub->element.extract.fmt != NULL)
free_mapping_format(sub->element.extract.fmt);
sub->element.extract.fmt = NULL;
free_mapping_item(&sub->element.extract.item);
break;
}
}
/*
* FUNCTION: read_line
*
* Gets next line in buffer - using '\' at end of line
* to indicate continuation. Lines beginning with # are
* ignored. start_line_num and start_line_num are
* maintained to track the line number currently being
* parsed.
*
* RETURN VALUE: The number of characters read. 0 for
* eof, -1 for error
*
* INPUT: file descriptor, buffer, and buffer size
*/
int
read_line(int fd, char *buffer, int buflen)
{
int linelen;
int rc;
char c;
bool_t skip_line = FALSE;
bool_t begin_line = TRUE;
static bool_t prev_cr = FALSE;
start_line_num = cur_line_num;
(void) memset(buffer, 0, buflen);
for (; p_error == no_parse_error; ) {
linelen = 0;
while (linelen < buflen) {
rc = read(fd, &c, 1);
if (1 == rc) {
if (c == '\n' || c == '\r') {
if (c == '\n') {
if (prev_cr) {
prev_cr = FALSE;
continue;
} else {
if (linelen == 0)
start_line_num =
cur_line_num;
else {
if (
is_string_ok(
buffer,
linelen)) {
(void) memset(
buffer, 0,
linelen);
linelen = 0;
cur_line_num++;
begin_line =
TRUE;
continue;
}
}
cur_line_num++;
}
prev_cr = FALSE;
} else {
prev_cr = TRUE;
if (linelen == 0)
start_line_num =
cur_line_num;
cur_line_num++;
}
if (skip_line) {
skip_line = FALSE;
if (linelen == 0)
start_line_num =
cur_line_num;
} else if (linelen > 0 &&
buffer[linelen - 1]
== ESCAPE_CHAR) {
--linelen;
} else if (linelen > 0) {
buffer[linelen] = '\0';
return (linelen);
}
begin_line = TRUE;
} else {
if (begin_line)
skip_line = c == POUND_SIGN;
begin_line = FALSE;
if (!skip_line)
buffer[linelen++] = c;
}
} else {
if (linelen > 0 &&
buffer[linelen - 1] == ESCAPE_CHAR) {
/* continuation on last line */
p_error = parse_bad_continuation_error;
return (-1);
} else {
buffer[linelen] = '\0';
return (linelen);
}
}
}
p_error = parse_line_too_long;
}
return (-1);
}
/*
* FUNCTION: finish_parse
*
* Adds any elements not configured, fully qualifies
* names
*
* RETURN VALUE: 0 on success, -1 on failure
*/
int
finish_parse(
__nis_ldap_proxy_info *proxy_info,
__nis_table_mapping_t **table_mapping)
{
__nis_table_mapping_t *t;
__nis_table_mapping_t *t1;
__nis_table_mapping_t *t2;
__nis_table_mapping_t *t_del = NULL;
int i;
int j;
int k;
__nis_object_dn_t *objectDN;
__nis_mapping_rlhs_t *lhs;
__nis_mapping_element_t *e;
char *s;
int errnum;
/* set to default those values yet set */
if (proxy_info->auth_method ==
(auth_method_t)NO_VALUE_SET) {
p_error = parse_no_proxy_auth_error;
report_error(NULL, NULL);
return (-1);
}
if (proxy_info->default_servers == NULL) {
p_error = parse_no_ldap_server_error;
report_error(NULL, NULL);
return (-1);
}
if (proxy_info->tls_method == (tls_method_t)NO_VALUE_SET)
proxy_info->tls_method = no_tls;
else if (proxy_info->tls_method == ssl_tls &&
(proxy_info->tls_cert_db == NULL ||
*proxy_info->tls_cert_db == '\0')) {
p_error = parse_no_cert_db;
report_error(NULL, NULL);
return (-1);
}
if (proxy_info->default_nis_domain == NULL)
proxy_info->default_nis_domain =
s_strdup(__nis_rpc_domain());
else if (*proxy_info->default_nis_domain == '\0') {
free(proxy_info->default_nis_domain);
proxy_info->default_nis_domain =
s_strdup(__nis_rpc_domain());
}
if (proxy_info->default_nis_domain != NULL)
append_dot(&proxy_info->default_nis_domain);
if (proxy_info->tls_method == ssl_tls) {
if ((errnum = ldapssl_client_init(
proxy_info->tls_cert_db, NULL)) < 0) {
p_error = parse_ldapssl_client_init_error;
report_error(ldapssl_err2string(errnum), NULL);
return (-1);
}
}
if (proxy_info->default_search_base == NULL)
proxy_info->default_search_base =
get_default_ldap_base(proxy_info->default_nis_domain);
/* convert a relative dn to a fullly qualified dn */
(void) make_full_dn(&proxy_info->proxy_dn,
proxy_info->default_search_base);
if (p_error != no_parse_error) {
report_error(NULL, NULL);
return (-1);
}
/*
* Create a list of potential delete mappings
* those have NULL objectDNs, but badly also rules
* that are missing object dn's will be included.
* We will use the ttl field to determine if the
* delete rule is actually used
*/
t2 = NULL;
for (t = *table_mapping; t != NULL; t = t1) {
t1 = t->next;
if (t->objectDN == NULL) {
if (t2 == NULL)
*table_mapping = t1;
else
t2->next = t1;
t->next = t_del;
t_del = t;
t->ttl = 0;
} else
t2 = t;
}
for (t = *table_mapping; t != NULL; t = t->next) {
objectDN = t->objectDN;
while (objectDN != NULL) {
if (objectDN->dbIdName != NULL) {
s = objectDN->dbIdName;
t1 = find_table_mapping(s, strlen(s), t_del);
if (t1 == NULL) {
p_error = parse_no_db_del_mapping_rule;
report_error2(objectDN->dbIdName, t->dbId);
return (-1);
} else if (t1->objName != NULL ||
t1->numRulesToLDAP == 0 ||
t1->numRulesFromLDAP != 0) {
p_error = parse_invalid_db_del_mapping_rule;
report_error(t1->dbId, NULL);
return (-1);
}
objectDN->dbId =
dup_mapping_rules(t1->ruleToLDAP,
t1->numRulesToLDAP);
if (objectDN->dbId == NULL) {
break;
}
objectDN->numDbIds = t1->numRulesToLDAP;
t1->ttl++;
}
objectDN = objectDN->next;
}
}
for (t = t_del; t != NULL; t = t1) {
t1 = t->next;
if (t->ttl == 0) {
p_error = parse_no_object_dn;
report_error(t->dbId, NULL);
}
free_table_mapping(t);
}
if (p_error != no_parse_error)
return (-1);
/* set to default those table mapping values yet set */
for (t = *table_mapping; t != NULL; t = t->next) {
if (t->objName == 0) {
p_error = parse_no_object_dn;
report_error(t->dbId, NULL);
return (-1);
}
if (!yp2ldap) {
if (!add_domain(&t->objName,
proxy_info->default_nis_domain)) {
report_error(NULL, NULL);
return (-1);
}
}
if (t->initTtlHi == (time_t)NO_VALUE_SET)
t->initTtlHi = DEFAULT_TTL_HIGH;
if (t->initTtlLo == (time_t)NO_VALUE_SET)
t->initTtlLo = DEFAULT_TTL_LOW;
if (t->ttl == (time_t)NO_VALUE_SET)
t->ttl = DEFAULT_TTL;
objectDN = t->objectDN;
/* fixup relative dn's */
while (objectDN != NULL) {
if (!yp2ldap) {
if (!make_full_dn(&objectDN->read.base,
proxy_info->default_search_base))
break;
}
if (objectDN->write.scope != LDAP_SCOPE_UNKNOWN) {
if (objectDN->write.base != NULL &&
!make_full_dn(&objectDN->write.base,
proxy_info->default_search_base))
break;
if (objectDN->write.base == NULL) {
objectDN->write.base =
s_strdup(objectDN->read.base);
if (objectDN->write.base == NULL)
break;
}
}
objectDN = objectDN->next;
}
if (p_error != no_parse_error) {
report_error(NULL, NULL);
return (-1);
}
/* Check for ruleToLDAP with no rhs */
for (i = 0; i < t->numRulesToLDAP; i++) {
if (t->ruleToLDAP[i]->rhs.numElements == 0) {
p_error = parse_unexpected_data_end_rule;
report_error(t->dbId, NULL);
return (-1);
}
}
/* populate cols field */
if (!yp2ldap) {
for (i = 0; i < t->numRulesFromLDAP; i++) {
lhs = &t->ruleFromLDAP[i]->lhs;
for (j = 0; j < lhs->numElements; j++) {
e = &lhs->element[j];
switch (e->type) {
case me_item:
if (!add_column(t,
e->element.item.name)) {
report_error(
NULL, NULL);
return (-1);
}
break;
case me_match:
for (k = 0;
k < e->element.match.numItems;
k++)
if (!add_column(t,
e->element.match.item[k].name)) {
report_error(
NULL, NULL);
return (-1);
}
break;
}
}
}
}
}
return (0);
}
/*
* FUNCTION: set_default_values
*
* Sets unconfigured values to their default value
*/
void
set_default_values(__nis_ldap_proxy_info *proxy_info,
__nis_config_t *config_info, __nisdb_table_mapping_t *table_info)
{
if (proxy_info->bind_timeout.tv_sec == (time_t)NO_VALUE_SET)
proxy_info->bind_timeout.tv_sec = DEFAULT_BIND_TIMEOUT;
if (proxy_info->search_timeout.tv_sec == (time_t)NO_VALUE_SET)
proxy_info->search_timeout.tv_sec =
(yp2ldap)?DEFAULT_YP_SEARCH_TIMEOUT:
DEFAULT_SEARCH_TIMEOUT;
if (proxy_info->modify_timeout.tv_sec == (time_t)NO_VALUE_SET)
proxy_info->modify_timeout.tv_sec = DEFAULT_MODIFY_TIMEOUT;
if (proxy_info->add_timeout.tv_sec == (time_t)NO_VALUE_SET)
proxy_info->add_timeout.tv_sec = DEFAULT_ADD_TIMEOUT;
if (proxy_info->delete_timeout.tv_sec == (time_t)NO_VALUE_SET)
proxy_info->delete_timeout.tv_sec = DEFAULT_DELETE_TIMEOUT;
if (proxy_info->search_time_limit == (int)NO_VALUE_SET)
proxy_info->search_time_limit = DEFAULT_SEARCH_TIME_LIMIT;
if (proxy_info->search_size_limit == (int)NO_VALUE_SET)
proxy_info->search_size_limit = DEFAULT_SEARCH_SIZE_LIMIT;
if (proxy_info->follow_referral == (follow_referral_t)NO_VALUE_SET)
proxy_info->follow_referral = no_follow;
switch (config_info->initialUpdate) {
case (__nis_initial_update_t)NO_VALUE_SET:
case (__nis_initial_update_t)INITIAL_UPDATE_NO_ACTION:
case (__nis_initial_update_t)NO_INITIAL_UPDATE_NO_ACTION:
config_info->initialUpdate = ini_none;
break;
case (__nis_initial_update_t)FROM_NO_INITIAL_UPDATE:
config_info->initialUpdate = from_ldap;
break;
case (__nis_initial_update_t)TO_NO_INITIAL_UPDATE:
config_info->initialUpdate = to_ldap;
break;
}
if (config_info->threadCreationError ==
(__nis_thread_creation_error_t)NO_VALUE_SET)
config_info->threadCreationError = pass_error;
if (config_info->threadCreationErrorTimeout.attempts == NO_VALUE_SET)
config_info->threadCreationErrorTimeout.attempts =
DEFAULT_THREAD_ERROR_ATTEMPTS;
if (config_info->threadCreationErrorTimeout.timeout ==
(time_t)NO_VALUE_SET)
config_info->threadCreationErrorTimeout.timeout =
DEFAULT_THREAD_ERROR_TIME_OUT;
if (config_info->dumpError ==
(__nis_dump_error_t)NO_VALUE_SET)
config_info->dumpError = de_retry;
if (config_info->dumpErrorTimeout.attempts == NO_VALUE_SET)
config_info->dumpErrorTimeout.attempts =
DEFAULT_DUMP_ERROR_ATTEMPTS;
if (config_info->dumpErrorTimeout.timeout == (time_t)NO_VALUE_SET)
config_info->dumpErrorTimeout.timeout =
DEFAULT_DUMP_ERROR_TIME_OUT;
if (config_info->resyncService ==
(__nis_resync_service_t)NO_VALUE_SET)
config_info->resyncService = from_copy;
if (config_info->updateBatching ==
(__nis_update_batching_t)NO_VALUE_SET)
config_info->updateBatching = accumulate;
if (config_info->updateBatchingTimeout.timeout == (time_t)NO_VALUE_SET)
config_info->updateBatchingTimeout.timeout =
DEFAULT_BATCHING_TIME_OUT;
if (config_info->numberOfServiceThreads == (int)NO_VALUE_SET)
config_info->numberOfServiceThreads =
DEFAULT_NUMBER_OF_THREADS;
if (config_info->emulate_yp == (int)NO_VALUE_SET)
config_info->emulate_yp =
DEFAULT_YP_EMULATION;
if (config_info->maxRPCRecordSize == (int)NO_VALUE_SET)
config_info->maxRPCRecordSize = RPC_MAXDATASIZE;
if (table_info->retrieveError ==
(__nis_retrieve_error_t)NO_VALUE_SET)
table_info->retrieveError = use_cached;
if (table_info->retrieveErrorRetry.attempts == NO_VALUE_SET)
table_info->retrieveErrorRetry.attempts =
DEFAULT_RETRIEVE_ERROR_ATTEMPTS;
if (table_info->retrieveErrorRetry.timeout == (time_t)NO_VALUE_SET)
table_info->retrieveErrorRetry.timeout =
DEFAULT_RETRIEVE_ERROR_TIME_OUT;
if (table_info->storeError ==
(__nis_store_error_t)NO_VALUE_SET)
table_info->storeError = sto_retry;
if (table_info->storeErrorRetry.attempts == NO_VALUE_SET)
table_info->storeErrorRetry.attempts =
DEFAULT_STORE_ERROR_ATTEMPTS;
if (table_info->storeErrorRetry.timeout == (time_t)NO_VALUE_SET)
table_info->storeErrorRetry.timeout =
DEFAULT_STORE_ERROR_TIME_OUT;
if (table_info->refreshError ==
(__nis_refresh_error_t)NO_VALUE_SET)
table_info->refreshError = continue_using;
if (table_info->refreshErrorRetry.attempts == NO_VALUE_SET)
table_info->refreshErrorRetry.attempts =
DEFAULT_REFRESH_ERROR_ATTEMPTS;
if (table_info->refreshErrorRetry.timeout == (time_t)NO_VALUE_SET)
table_info->refreshErrorRetry.timeout =
DEFAULT_REFRESH_ERROR_TIME_OUT;
if (table_info->matchFetch ==
(__nis_match_fetch_t)NO_VALUE_SET)
table_info->matchFetch = no_match_only;
}
__nis_table_mapping_t *
find_table_mapping(const char *s, int len, __nis_table_mapping_t *table_mapping)
{
__nis_table_mapping_t *t;
for (t = table_mapping; t != NULL; t = t->next)
if (strlen(t->dbId) == len &&
strncasecmp(t->dbId, s, len) == 0)
break;
return (t);
}
void
append_dot(char **str)
{
char *s = *str;
int len = strlen(s);
if (len == 0 || s[len - 1] != PERIOD_CHAR) {
s = s_realloc(s, len + 2);
if (s != NULL) {
s[len] = PERIOD_CHAR;
s[len+1] = '\0';
*str = s;
}
}
}
void
append_comma(char **str)
{
char *s = *str;
int len = strlen(s);
if (len == 0 || s[len - 1] != COMMA_CHAR) {
s = s_realloc(s, len + 2);
if (s != NULL) {
s[len] = COMMA_CHAR;
s[len+1] = '\0';
*str = s;
}
}
}
/*
* FUNCTION: make_full_dn
*
* Appends the base dn if a relative ldap dn
* (invoked only for LDAP write cycle)
*
* RETURN VALUE: FALSE if error
* TRUE if __nis_index_t returned
*
* INPUT: the relative dn and ldap base
*/
bool_t
make_full_dn(char **dn, const char *base)
{
int len;
int len1;
if (*dn == NULL) {
*dn = s_strdup(base);
} else {
len = strlen(*dn);
if (len > 0 && (*dn)[len-1] == COMMA_CHAR) {
len1 = strlen(base) + 1;
*dn = s_realloc(*dn, len + len1);
if (*dn != NULL)
(void) strcpy(*dn + len, base);
}
}
return (*dn != NULL);
}
/*
* FUNCTION: make_fqdn
*
* Appends the base dn if a relative ldap dn
* (invoked only for LDAP read cycle)
*
* RETURN VALUE: FALSE if error
* TRUE if success
*
* INPUT: the relative dn and ldap base
*/
bool_t
make_fqdn(__nis_object_dn_t *dn, const char *base)
{
int len;
int len1;
if (dn == NULL) {
return (FALSE);
} else {
while (dn != NULL && dn->read.base != NULL) {
len = strlen(dn->read.base);
if (len > 0 && (dn->read.base)[len-1] == COMMA_CHAR) {
len1 = strlen(base) + 1;
dn->read.base =
s_realloc(dn->read.base, len + len1);
if (dn->read.base != NULL)
(void) strlcpy(dn->read.base + len,
base, len1);
else
return (FALSE);
}
dn = dn->next;
}
}
return (TRUE);
}
/*
* FUNCTION: get_default_ldap_base
*
* Gets the default LDAP search base from the
* nis+ default domain
*
* RETURN VALUE: NULL if error
* the default base
*
* INPUT: the nis domain
*/
char *
get_default_ldap_base(const char *domain)
{
int len = strlen(domain);
int i;
int count = len + 4;
char *base;
for (i = 0; i < len - 1; i++)
if (domain[i] == PERIOD_CHAR)
count += 4;
if ((base = malloc(count)) == NULL) {
p_error = parse_no_mem_error;
} else {
(void) strcpy(base, "dc=");
count = 3;
for (i = 0; i < len - 1; i++) {
if (domain[i] == PERIOD_CHAR) {
(void) strcpy(base + count, ",dc=");
count += 4;
} else {
base[count++] = domain[i];
}
}
base[count] = '\0';
}
return (base);
}
/*
* FUNCTION: add_domain
*
* Appends the base domain if a relative object name
*
* RETURN VALUE: FALSE if error
* TRUE if OK
*
* INPUT: the relative object name and base domain
* name
*/
bool_t
add_domain(char **objName, const char *domain)
{
int len;
int len1;
bool_t trailing_dot;
char *obj_name;
if (domain == NULL || *objName == NULL) {
p_error = parse_internal_error;
return (FALSE);
}
len1 = strlen(domain);
trailing_dot = (len1 > 0 && domain[len1 - 1] == PERIOD_CHAR) ?
0 : 1;
len = strlen(*objName);
if (len == 0 || (*objName)[len - 1] != PERIOD_CHAR) {
obj_name = s_realloc(*objName,
len + len1 + 2 + trailing_dot);
if (obj_name != NULL) {
obj_name[len++] = PERIOD_CHAR;
(void) strcpy(obj_name + len, domain);
if (trailing_dot != 0) {
obj_name[len + len1] = PERIOD_CHAR;
obj_name[len + len1 + 1] = '\0';
}
*objName = obj_name;
}
}
return (*objName != NULL);
}
bool_t
dup_index(__nis_index_t *in, __nis_index_t *out)
{
int i;
int j;
out->name = (char **)s_calloc(in->numIndexes, sizeof (char *));
if (out->name == NULL)
return (FALSE);
out->value = (__nis_mapping_format_t **)
s_calloc(in->numIndexes, sizeof (__nis_mapping_format_t *));
if (out->value == NULL) {
free(out->name);
out->name = NULL;
return (FALSE);
}
for (i = 0; i < in->numIndexes; i++) {
out->name[i] = s_strdup(in->name[i]);
if (out->name[i] == NULL)
break;
out->value[i] = dup_format_mapping(in->value[i]);
if (out->value[i] == NULL)
break;
}
if (i < in->numIndexes) {
for (j = 0; j <= i; j++) {
if (out->name[j] != NULL)
free(out->name[j]);
if (out->value[j] != NULL)
free_mapping_format(out->value[j]);
}
free(out->name);
out->name = NULL;
free(out->value);
out->value = NULL;
} else {
out->numIndexes = in->numIndexes;
}
return (i == in->numIndexes);
}
bool_t
dup_mapping_item(__nis_mapping_item_t *in, __nis_mapping_item_t *out)
{
bool_t ret;
if (in->type == mit_nisplus) {
ret = dup_index(&in->searchSpec.obj.index,
&out->searchSpec.obj.index);
if (!ret)
return (ret);
if (in->searchSpec.obj.name != NULL) {
out->searchSpec.obj.name =
s_strdup(in->searchSpec.obj.name);
if (out->searchSpec.obj.name == NULL)
return (FALSE);
} else
out->searchSpec.obj.name = NULL;
} else if (in->type == mit_ldap) {
if (in->searchSpec.triple.base != NULL) {
out->searchSpec.triple.base =
s_strdup(in->searchSpec.triple.base);
if (out->searchSpec.triple.base == NULL)
return (FALSE);
} else
out->searchSpec.triple.base = NULL;
out->searchSpec.triple.scope =
in->searchSpec.triple.scope;
if (in->searchSpec.triple.attrs != NULL) {
out->searchSpec.triple.attrs =
s_strdup(in->searchSpec.triple.attrs);
if (out->searchSpec.triple.attrs == NULL)
return (FALSE);
} else
out->searchSpec.triple.attrs = NULL;
if (in->searchSpec.triple.element != NULL) {
out->searchSpec.triple.element =
(__nis_mapping_element_t *)
s_calloc(1, sizeof (__nis_mapping_element_t));
if (out->searchSpec.triple.element != NULL)
dup_mapping_element(
in->searchSpec.triple.element,
out->searchSpec.triple.element);
if (out->searchSpec.triple.element == NULL)
return (FALSE);
} else
out->searchSpec.triple.element = NULL;
}
if (in->name != NULL) {
out->name = s_strdup(in->name);
if (out->name == NULL)
return (FALSE);
} else
out->name = NULL;
out->type = in->type;
out->repeat = in->repeat;
if (in->exItem) {
out->exItem = (__nis_mapping_item_t *)s_malloc
(sizeof (__nis_mapping_item_t));
if (out->exItem == NULL)
return (FALSE);
else {
(void) memset
(out->exItem, 0, sizeof (out->exItem[0]));
if (!dup_mapping_item
(in->exItem, out->exItem))
p_error = parse_internal_error;
}
} else
out->exItem = NULL;
return (p_error == no_parse_error);
}
__nis_mapping_format_t *
dup_format_mapping(__nis_mapping_format_t *in)
{
int i;
__nis_mapping_format_t *out;
bool_t got_end;
i = 0;
while (in[i].type != mmt_end)
i++;
out = (__nis_mapping_format_t *)s_calloc(
i + 1, sizeof (__nis_mapping_format_t));
if (out != NULL) {
got_end = FALSE;
for (i = 0; !got_end; i++) {
switch (in[i].type) {
case mmt_item:
break;
case mmt_string:
out[i].match.string =
s_strdup(in[i].match.string);
break;
case mmt_single:
out[i].match.single.numRange =
in[i].match.single.numRange;
out[i].match.single.lo =
s_malloc(in[i].match.single.numRange);
if (out[i].match.single.lo == NULL)
break;
out[i].match.single.hi =
s_malloc(in[i].match.single.numRange);
if (out[i].match.single.hi == NULL)
break;
memcpy(out[i].match.single.lo,
in[i].match.single.lo,
in[i].match.single.numRange);
memcpy(out[i].match.single.hi,
in[i].match.single.hi,
in[i].match.single.numRange);
break;
case mmt_limit:
out[i].match.limit = in[i].match.limit;
break;
case mmt_any:
break;
case mmt_berstring:
out[i].match.berString =
s_strdup(in[i].match.berString);
break;
case mmt_begin:
break;
case mmt_end:
got_end = TRUE;
break;
default:
p_error = parse_internal_error;
}
if (p_error != no_parse_error)
break;
out[i].type = in[i].type;
}
if (p_error != no_parse_error) {
free_mapping_format(out);
out = NULL;
}
}
return (out);
}
bool_t
dup_mapping_sub_element(
__nis_mapping_sub_element_t *in,
__nis_mapping_sub_element_t *out)
{
bool_t ret = FALSE;
int i;
switch (in->type) {
case me_item:
ret = dup_mapping_item(&in->element.item,
&out->element.item);
break;
case me_print:
out->element.print.fmt =
dup_format_mapping(in->element.print.fmt);
if (out->element.print.fmt == NULL)
break;
out->element.print.numItems =
in->element.print.numItems;
out->element.print.item = (__nis_mapping_item_t *)
s_calloc(in->element.print.numItems,
sizeof (__nis_mapping_item_t));
if (out->element.print.item == NULL)
break;
for (i = 0; i < in->element.print.numItems; i++)
if (!dup_mapping_item(
&in->element.print.item[i],
&out->element.print.item[i]))
break;
if (i < in->element.print.numItems)
break;
ret = TRUE;
out->element.print.doElide = in->element.print.doElide;
out->element.print.elide = in->element.print.elide;
break;
case me_split:
ret = dup_mapping_item(&in->element.split.item,
&out->element.split.item);
out->element.split.delim = in->element.split.delim;
break;
case me_extract:
out->element.extract.fmt =
dup_format_mapping(in->element.extract.fmt);
if (out->element.extract.fmt == NULL)
break;
ret = dup_mapping_item(&in->element.extract.item,
&out->element.extract.item);
break;
default:
p_error = parse_internal_error;
}
out->type = in->type;
return (ret);
}
bool_t
dup_mapping_element(
__nis_mapping_element_t *in,
__nis_mapping_element_t *out)
{
bool_t ret = FALSE;
int i;
if (in == NULL)
return (ret);
switch (in->type) {
case me_item:
ret = dup_mapping_item(&in->element.item,
&out->element.item);
break;
case me_print:
out->element.print.fmt =
dup_format_mapping(in->element.print.fmt);
if (out->element.print.fmt == NULL)
break;
out->element.print.numSubElements =
in->element.print.numSubElements;
out->element.print.subElement =
(__nis_mapping_sub_element_t *)
s_calloc(in->element.print.numSubElements,
sizeof (__nis_mapping_sub_element_t));
if (out->element.print.subElement == NULL)
break;
for (i = 0; i < in->element.print.numSubElements; i++)
if (!dup_mapping_sub_element(
&in->element.print.subElement[i],
&out->element.print.subElement[i]))
break;
if (i < in->element.print.numSubElements)
break;
ret = TRUE;
out->element.print.doElide = in->element.print.doElide;
out->element.print.elide = in->element.print.elide;
break;
case me_split:
ret = dup_mapping_item(&in->element.split.item,
&out->element.split.item);
out->element.split.delim = in->element.split.delim;
break;
case me_match:
out->element.match.fmt =
dup_format_mapping(in->element.match.fmt);
if (out->element.match.fmt == NULL)
break;
out->element.match.numItems =
in->element.match.numItems;
out->element.match.item = (__nis_mapping_item_t *)
s_calloc(in->element.match.numItems,
sizeof (__nis_mapping_item_t));
if (out->element.match.item == NULL)
break;
for (i = 0; i < in->element.match.numItems; i++)
if (!dup_mapping_item(
&in->element.match.item[i],
&out->element.match.item[i]))
break;
if (i < in->element.match.numItems)
break;
ret = TRUE;
break;
case me_extract:
out->element.extract.fmt =
dup_format_mapping(in->element.extract.fmt);
if (out->element.extract.fmt == NULL)
break;
ret = dup_mapping_item(&in->element.extract.item,
&out->element.extract.item);
break;
default:
p_error = parse_internal_error;
}
out->type = in->type;
return (ret);
}
__nis_mapping_rule_t *
dup_mapping_rule(__nis_mapping_rule_t *in)
{
int i;
__nis_mapping_rlhs_t *r_in;
__nis_mapping_rlhs_t *r_out;
__nis_mapping_rule_t *out;
out = (__nis_mapping_rule_t *)
s_calloc(1, sizeof (__nis_mapping_rule_t));
if (out != NULL) {
r_in = &in->lhs;
r_out = &out->lhs;
r_out->numElements = r_in->numElements;
r_out->element = (__nis_mapping_element_t *)s_calloc
(r_in->numElements, sizeof (__nis_mapping_element_t));
if (r_out->element == NULL) {
free_mapping_rule(out);
return (NULL);
}
for (i = 0; i < r_in->numElements; i++) {
if (!dup_mapping_element(&r_in->element[i],
&r_out->element[i]))
break;
}
if (i < r_in->numElements) {
free_mapping_rule(out);
return (NULL);
}
r_in = &in->rhs;
r_out = &out->rhs;
r_out->numElements = r_in->numElements;
r_out->element = (__nis_mapping_element_t *)s_calloc
(r_in->numElements, sizeof (__nis_mapping_element_t));
if (r_out->element == NULL) {
free_mapping_rule(out);
return (NULL);
}
for (i = 0; i < r_in->numElements; i++) {
if (!dup_mapping_element(&r_in->element[i],
&r_out->element[i]))
break;
}
if (i < r_in->numElements) {
free_mapping_rule(out);
return (NULL);
}
}
return (out);
}
__nis_mapping_rule_t **
dup_mapping_rules(__nis_mapping_rule_t **rules, int n_rules)
{
int i, j;
__nis_mapping_rule_t **r;
r = (__nis_mapping_rule_t **)s_calloc(n_rules,
sizeof (__nis_mapping_rule_t *));
if (r != NULL) {
for (i = 0; i < n_rules; i++) {
r[i] = dup_mapping_rule(rules[i]);
if (r[i] == NULL) {
for (j = 0; j < i; j++)
free_mapping_rule(r[j]);
free(r);
r = NULL;
break;
}
}
}
return (r);
}
/*
* FUNCTION: add_column
*
* Adds a column name to the column list in __nis_table_mapping_t
*
* RETURN VALUE: FALSE if error
* TRUE if __nis_index_t returned
*
* INPUT: the __nis_table_mapping_t and column name
*/
bool_t
add_column(__nis_table_mapping_t *t, const char *col_name)
{
int i;
char **cols = NULL;
if (!yp2ldap) {
for (i = 0; i < t->numColumns; i++) {
if (strcasecmp(col_name, t->column[i]) == 0)
return (TRUE);
}
}
cols = (char **)s_realloc(t->column, (t->numColumns + 1) *
sizeof (char *));
if (cols == NULL)
return (FALSE);
t->column = cols;
cols[t->numColumns] = s_strdup(col_name);
if (cols[t->numColumns] == NULL)
return (FALSE);
t->numColumns++;
return (TRUE);
}
/*
* FUNCTION: add_element
*
* Adds a __nis_mapping_element_t to __nis_mapping_rlhs_t
*
* RETURN VALUE: FALSE if error
* TRUE if __nis_index_t returned
*
* INPUT: the __nis_mapping_element_t and
* __nis_mapping_rlhs_t
*/
bool_t
add_element(
__nis_mapping_element_t *e,
__nis_mapping_rlhs_t *m)
{
__nis_mapping_element_t *e1;
int i;
int n = m->numElements;
e1 = (__nis_mapping_element_t *)s_realloc(m->element,
(n + 1) * sizeof (__nis_mapping_element_t));
if (e1 == NULL) {
e1 = m->element;
for (i = 0; i < n; i++)
free_mapping_element(e1++);
if (m->element != NULL)
free(m->element);
m->element = NULL;
m->numElements = 0;
} else {
e1[m->numElements++] = *e;
free(e);
m->element = (__nis_mapping_element_t *)e1;
}
return (e1 != NULL);
}
/*
* FUNCTION: get_next_object_dn_token
*
* Get the next token in parsing object_dn
*
* RETURN VALUE: NULL if error
* position of beginning next token after
* token
*
* INPUT: the attribute value
*/
const char *
get_next_object_dn_token(
const char **begin_ret,
const char **end_ret,
object_dn_token *token)
{
object_dn_token t = dn_no_token;
const char *s = *begin_ret;
const char *begin;
const char *end = *end_ret;
const char *s1;
bool_t in_quotes;
while (s < end && is_whitespace(*s))
s++;
if (s >= end) {
/* EMPTY */
} else if (*s == SEMI_COLON_CHAR) {
t = dn_semi_token;
s++;
} else if (*s == QUESTION_MARK) {
t = dn_ques_token;
s++;
} else if (*s == COLON_CHAR) {
t = dn_colon_token;
s++;
} else if (*s == OPEN_PAREN_CHAR) {
begin = s;
s = get_ldap_filter(&begin, &end);
if (s != NULL) {
t = dn_text_token;
*begin_ret = begin;
*end_ret = end;
}
} else {
begin = s;
in_quotes = FALSE;
while (s < end) {
if (*s == ESCAPE_CHAR) {
if (s + 2 > end) {
p_error = parse_unmatched_escape;
s = NULL;
break;
}
s++;
} else if (*s == DOUBLE_QUOTE_CHAR) {
in_quotes = ! in_quotes;
} else if (in_quotes)
;
else if (*s == SEMI_COLON_CHAR ||
*s == QUESTION_MARK ||
*s == COLON_CHAR)
break;
s++;
}
if (s != NULL) {
s1 = s - 1;
while (is_whitespace(*s1))
s1--;
s1++;
if (same_string("base", begin, s1 - begin))
t = dn_base_token;
else if (same_string("one", begin, s1 - begin))
t = dn_one_token;
else if (same_string("sub", begin, s1 - begin))
t = dn_sub_token;
else
t = dn_text_token;
*begin_ret = begin;
*end_ret = s1;
}
}
*token = t;
return (s);
}
/*
* FUNCTION: get_next_token
*
* Get the next token in parsing mapping attribute
*
* RETURN VALUE: NULL if error
* position of beginning next token after
* token
*
* INPUT: the attribute value
*/
const char *
get_next_token(const char **begin_token, const char **end_token, token_type *t)
{
const char *s = *begin_token;
const char *end_s = *end_token;
const char *s_begin;
while (s < end_s && is_whitespace(*s))
s++;
if (s == end_s) {
*t = no_token;
return (s);
}
s_begin = s;
if (*s == OPEN_PAREN_CHAR) {
*begin_token = s;
s++;
*end_token = s;
while (s < end_s && is_whitespace(*s))
s++;
*t = open_paren_token;
} else if (*s == DOUBLE_QUOTE_CHAR) {
s++;
while (s < end_s) {
if (*s == ESCAPE_CHAR)
s += 2;
else if (*s == DOUBLE_QUOTE_CHAR)
break;
else
s++;
}
if (s >= end_s) {
p_error = parse_unmatched_escape;
return (NULL);
}
*t = quoted_string_token;
*begin_token = s_begin + 1;
*end_token = s++;
} else if (*s == EQUAL_CHAR || *s == COMMA_CHAR ||
*s == CLOSE_PAREN_CHAR || *s == COLON_CHAR) {
if (*s == EQUAL_CHAR)
*t = equal_token;
else if (*s == COMMA_CHAR)
*t = comma_token;
else if (*s == CLOSE_PAREN_CHAR)
*t = close_paren_token;
else
*t = colon_token;
*begin_token = s;
*end_token = ++s;
} else {
s_begin = s;
while (s < end_s && !is_whitespace(*s)) {
if (*s == ESCAPE_CHAR)
s += 2;
else if (*s == EQUAL_CHAR || *s == CLOSE_PAREN_CHAR ||
*s == OPEN_PAREN_CHAR || *s == COMMA_CHAR ||
*s == COLON_CHAR || *s == OPEN_BRACKET ||
*s == CLOSE_BRACKET)
break;
else
s++;
}
if (s > end_s) {
p_error = parse_unmatched_escape;
return (NULL);
}
*t = string_token;
*end_token = s;
*begin_token = s_begin;
}
if (s) {
while (s < end_s && is_whitespace(*s))
s++;
}
return (s);
}
/*
* FUNCTION: skip_token
*
* Skip over the specified token - An error is set if
* next token does not match expected token
*
* RETURN VALUE: NULL if error
* position of beginning next token after
* token
*
* INPUT: the attribute value
*/
const char *
skip_token(const char *s, const char *end_s, token_type t)
{
bool_t match;
char c = 0;
if (s == NULL)
return (s);
while (s < end_s && is_whitespace(*s))
s++;
c = (s == end_s) ? 0 : *s;
switch (t) {
case equal_token:
match = c == EQUAL_CHAR;
if (!match)
p_error = parse_equal_expected_error;
break;
case comma_token:
match = c == COMMA_CHAR;
if (!match)
p_error = parse_comma_expected_error;
break;
case close_paren_token:
match = c == CLOSE_PAREN_CHAR;
if (!match)
p_error = parse_close_paren_expected_error;
break;
default:
match = FALSE;
break;
}
if (match) {
s++;
while (s < end_s && is_whitespace(*s))
s++;
} else {
s = NULL;
}
return (s);
}
/*
* FUNCTION: get_next_extract_format_item
*
* Get the next format token from the string. Note that
* get_next_extract_format_item may change the input string.
*
* RETURN VALUE: NULL if error
* position of beginning next token after
* token
*
* INPUT: the format string
*/
const char *
get_next_extract_format_item(
const char *begin_fmt,
const char *end_fmt,
__nis_mapping_format_t *fmt)
{
const char *s = begin_fmt;
const char *s_end = end_fmt;
bool_t escape;
bool_t in_range;
bool_t got_char;
bool_t done;
int numRange;
char *lo = NULL;
char *hi = NULL;
bool_t skip_ber;
for (; p_error == no_parse_error; ) {
if (s >= s_end)
break;
if (*s == PERCENT_SIGN) {
s++;
/*
* If the format is %s, it is interpreted
* as a string.
*/
if (s >= s_end) {
p_error = parse_unsupported_format;
break;
}
skip_ber = FALSE;
switch (*s) {
case 's':
fmt->type = mmt_item;
break;
case 'n': /* null */
case 'x': /* skip the next element */
skip_ber = TRUE;
/* FALLTHRU */
case 'b': /* boolean */
case 'e': /* enumerated */
case 'i': /* int */
case 'o': /* octet string */
case 'B': /* bit string */
fmt->match.berString = s_strndup(s, 1);
fmt->type = skip_ber ?
mmt_berstring_null :
mmt_berstring;
break;
case 'a': /* octet string */
if (yp2ldap) {
fmt->match.berString =
s_strndup(s, 1);
fmt->type = skip_ber ?
mmt_berstring_null :
mmt_berstring;
break;
} /* else FALLTHRU */
case '{': /* begin sequence */
case '[': /* begin set */
case '}': /* end sequence */
case ']': /* end set */
case 'l': /* length of next item */
case 'O': /* octet string */
case 't': /* tag of next item */
case 'T': /* skip tag of next item */
case 'v': /* seq of strings */
case 'V': /* seq of strings + lengths */
default:
p_error = parse_bad_ber_format;
break;
}
s++;
} else if (*s == ASTERIX_CHAR) {
fmt->type = mmt_any;
s++;
while (s < s_end && *s == ASTERIX_CHAR)
s++;
} else if (*s == OPEN_BRACKET) {
escape = FALSE;
in_range = FALSE;
got_char = FALSE;
numRange = 0;
done = FALSE;
s++;
for (; s < s_end; s++) {
if (escape) {
escape = FALSE;
} else if (*s == DASH_CHAR) {
if (in_range || !got_char) {
p_error = parse_unexpected_dash;
break;
}
in_range = TRUE;
got_char = FALSE;
continue;
} else if (*s == CLOSE_BRACKET) {
if (in_range) {
p_error = parse_unexpected_dash;
}
done = TRUE;
break;
} else if (*s == ESCAPE_CHAR) {
escape = TRUE;
continue;
}
if (in_range) {
hi[numRange - 1] = *s;
in_range = FALSE;
} else {
lo = s_realloc(lo, numRange + 1);
hi = s_realloc(hi, numRange + 1);
if (lo == NULL || hi == NULL)
break;
lo[numRange] = *s;
hi[numRange] = *s;
numRange++;
got_char = TRUE;
}
}
if (p_error != no_parse_error) {
break;
} else if (!done) {
p_error = parse_mismatched_brackets;
break;
}
s++;
fmt->type = mmt_single;
fmt->match.single.numRange = numRange;
fmt->match.single.lo = (unsigned char *)lo;
fmt->match.single.hi = (unsigned char *)hi;
} else {
/* go to next key symbol - copy escaped key symbols */
escape = FALSE;
done = FALSE;
while (s < s_end) {
if (escape)
escape = FALSE;
else {
switch (*s) {
case OPEN_BRACKET:
case ASTERIX_CHAR:
case PERCENT_SIGN:
done = TRUE;
break;
case ESCAPE_CHAR:
escape = !escape;
break;
default:
break;
}
}
if (done)
break;
s++;
}
if (escape) {
p_error = parse_unmatched_escape;
break;
}
fmt->type = mmt_string;
fmt->match.string =
s_strndup_esc(begin_fmt, s - begin_fmt);
if (fmt->match.string == NULL)
break;
}
if (p_error == no_parse_error)
return (s);
}
if (lo != NULL)
free(lo);
if (hi != NULL)
free(hi);
return (NULL);
}
/*
* FUNCTION: get_next_print_format_item
*
* Get the next format token from the string
*
* RETURN VALUE: NULL if error
* position of beginning next token after
* token
*
* INPUT: the format string
*/
const char *
get_next_print_format_item(
const char *begin_fmt,
const char *end_fmt,
__nis_mapping_format_t *fmt)
{
const char *s = begin_fmt;
const char *s_end = end_fmt;
bool_t skip_ber;
for (; p_error == no_parse_error; ) {
if (s >= s_end) {
p_error = parse_internal_error;
break;
}
if (*s == PERCENT_SIGN) {
s++;
if (s >= s_end) {
p_error = parse_unsupported_format;
break;
}
skip_ber = FALSE;
/*
* If the format is %s, it is interpretted
* as a string.
*/
switch (*s) {
case 's':
fmt->type = mmt_item;
break;
case 'n': /* null */
case 'x': /* skip the next element */
skip_ber = TRUE;
/* FALLTHRU */
case 'b': /* boolean */
case 'e': /* enumerated */
case 'i': /* int */
case 'o': /* octet string */
case 'B': /* bit string */
fmt->match.berString = s_strndup(s, 1);
fmt->type = skip_ber ?
mmt_berstring_null :
mmt_berstring;
break;
case '{': /* begin sequence */
case '[': /* begin set */
case '}': /* end sequence */
case ']': /* end set */
case 'a': /* octet string */
case 'l': /* length of next item */
case 'O': /* octet string */
case 't': /* tag of next item */
case 'T': /* skip tag of next item */
case 'v': /* seq of strings */
case 'V': /* seq of strings + lengths */
default:
p_error = parse_bad_ber_format;
break;
}
s++;
} else {
while (s < s_end) {
if (*s == PERCENT_SIGN)
break;
else if (*s == ESCAPE_CHAR)
s++;
s++;
}
if (s > s_end) {
p_error = parse_unmatched_escape;
break;
}
fmt->match.string =
s_strndup_esc(begin_fmt, s - begin_fmt);
if (fmt->match.string == NULL)
break;
fmt->type = mmt_string;
}
if (p_error == no_parse_error)
return (s);
}
return (NULL);
}
/*
* FUNCTION: get_ldap_filter
*
* Gets an LDAP filter - see RFC 2254. Note that this does not
* determine if the ldap filter is valid. This only determines
* that the parentheses are balanced.
*
* RETURN VALUE: NULL if error
* position of beginning next token after
* filter
*
* INPUT: the begin and end of string
*
* OUTPUT: the begin and end of LDAP filter
*
*/
const char *
get_ldap_filter(const char **begin, const char **end)
{
const char *s = *begin;
const char *s_begin;
const char *s_end = *end;
int nParen;
for (; p_error == no_parse_error; ) {
while (s < s_end && is_whitespace(*s))
s++;
if (s == s_end) {
s = NULL;
break;
}
s_begin = s;
if (*s == OPEN_PAREN_CHAR) {
nParen = 1;
s++;
while (s < s_end && nParen > 0) {
if (*s == ESCAPE_CHAR)
s++;
else if (*s == OPEN_PAREN_CHAR)
nParen++;
else if (*s == CLOSE_PAREN_CHAR)
nParen--;
s++;
}
if (nParen == 0) {
*begin = s_begin;
*end = s;
while (s < s_end && is_whitespace(*s))
s++;
} else
s = NULL;
} else
s = NULL;
if (p_error == no_parse_error)
break;
}
if (s == NULL)
p_error = parse_invalid_ldap_search_filter;
return (s);
}
/*
* FUNCTION: get_ava_list
*
* Gets an attribute value assertion list
*
* RETURN VALUE: NULL if error
* position of beginning next token after
* after attribute assertion
*
* INPUT: the begin and end of string
* Indicator if ava list is part of a nisplus
* item
*
* OUTPUT: the begin and end of LDAP filter
*
*/
const char *
get_ava_list(const char **begin, const char **end, bool_t end_nisplus)
{
const char *s = *begin;
const char *s_begin;
const char *s_end = *end;
bool_t in_quote;
bool_t got_equal;
bool_t got_data;
for (; p_error == no_parse_error; ) {
while (s < s_end && is_whitespace(*s))
s++;
if (s == s_end) {
s = NULL;
break;
}
in_quote = FALSE;
got_equal = FALSE;
got_data = FALSE;
s_begin = s;
while (s < s_end) {
if (*s == ESCAPE_CHAR) {
s++;
got_data = TRUE;
} else if (*s == DOUBLE_QUOTE_CHAR) {
in_quote = !in_quote;
got_data = TRUE;
} else if (in_quote)
;
else if (*s == EQUAL_CHAR) {
if (end_nisplus && got_data && got_equal)
break;
if (!got_data || got_equal) {
got_equal = FALSE;
break;
}
got_equal = TRUE;
got_data = FALSE;
} else if (*s == COMMA_CHAR) {
if (!got_data || !got_equal)
break;
got_data = FALSE;
got_equal = FALSE;
} else if (is_whitespace(*s))
;
else
got_data = TRUE;
s++;
}
if (!got_data || !got_equal || in_quote)
s = NULL;
else {
*begin = s_begin;
*end = s;
while (s < s_end && is_whitespace(*s))
s++;
}
if (p_error == no_parse_error)
break;
}
if (s == NULL)
p_error = parse_invalid_ldap_search_filter;
return (s);
}
/* Utility functions */
bool_t
validate_dn(const char *s, int len)
{
const char *end = s + len;
bool_t valid;
valid = skip_get_dn(s, end) == end;
if (!valid)
p_error = parse_bad_dn;
return (valid);
}
bool_t
validate_ldap_filter(const char *s, const char *end)
{
const char *s_begin;
const char *s_end;
s_begin = s;
s_end = end;
if (*s == OPEN_PAREN_CHAR) {
s = get_ldap_filter(&s_begin, &s_end);
} else {
/* Assume an attribute value list */
s = get_ava_list(&s_begin, &s_end, FALSE);
}
if (s == NULL || s_end != end)
p_error = parse_invalid_ldap_search_filter;
return (p_error == no_parse_error);
}
char *
s_strndup(const char *s, int n)
{
char *d = (char *)malloc(n + 1);
if (d != NULL) {
(void) memcpy(d, s, n);
d[n] = '\0';
} else {
p_error = parse_no_mem_error;
}
return (d);
}
char *
s_strndup_esc(const char *s, int n)
{
char *d = (char *)malloc(n + 1);
int i;
int j;
if (d != NULL) {
for (i = 0, j = 0; i < n; i++) {
if (s[i] == ESCAPE_CHAR)
i++;
d[j++] = s[i];
}
d[j] = '\0';
} else {
p_error = parse_no_mem_error;
}
return (d);
}
void *
s_calloc(size_t n, size_t size)
{
void *d = (char *)calloc(n, size);
if (d == NULL) {
p_error = parse_no_mem_error;
}
return (d);
}
void *
s_malloc(size_t size)
{
void *d = malloc(size);
if (d == NULL)
p_error = parse_no_mem_error;
return (d);
}
void *
s_realloc(void *s, size_t size)
{
s = realloc(s, size);
if (s == NULL)
p_error = parse_no_mem_error;
return (s);
}
char *
s_strdup(const char *s)
{
return (s != NULL ? s_strndup(s, strlen(s)) : NULL);
}
bool_t
is_whitespace(int c)
{
return (c == ' ' || c == '\t');
}
bool_t
is_string_ok(char *buffer, int buflen)
{
int i;
if (buffer == NULL)
return (FALSE);
for (i = 0; i < buflen; i++) {
if (!is_whitespace(buffer[i])) {
if (buffer[i] == POUND_SIGN)
return (TRUE);
else
return (FALSE);
}
}
return (TRUE);
}
/*
* Returns true if the first string is contained at the beginning of the
* second string. Otherwise returns false.
*/
bool_t
contains_string(const char *s1, const char *s2)
{
return (strncasecmp(s1, s2, strlen(s1)) == 0);
}
/*
* Returns the next character position in the second string, if the first
* string is contained at the beginning of the second string. Otherwise
* returns NULL.
*/
const char *
skip_string(const char *s1, const char *s2, int len)
{
int len1 = strlen(s1);
if (len >= len1 && strncasecmp(s1, s2, strlen(s1)) == 0)
return (s2 + len1);
else
return (NULL);
}
/*
* The second string is not necessarily null terminated.
* same_string returns true if the second string matches the first.
* Otherwise returns false.
*/
bool_t
same_string(const char *s1, const char *s2, int len)
{
int len1 = strlen(s1);
return (len1 == len && strncasecmp(s1, s2, len1) == 0);
}
void
report_error(const char *str, const char *attr)
{
char fmt_buf[1024];
int pos = 0;
if (command_line_source != NULL) {
snprintf(fmt_buf, sizeof (fmt_buf), "Error parsing %s: ",
command_line_source);
pos = strlen(fmt_buf);
} else if (file_source != NULL) {
snprintf(fmt_buf, sizeof (fmt_buf), "Error parsing file '%s': ",
file_source);
pos = strlen(fmt_buf);
} else if (ldap_source != NULL) {
snprintf(fmt_buf, sizeof (fmt_buf), "Error for LDAP dn '%s': ",
ldap_source);
pos = strlen(fmt_buf);
}
if (start_line_num != 0) {
snprintf(fmt_buf + pos, sizeof (fmt_buf) - pos, "at line %d: ",
start_line_num);
pos += strlen(fmt_buf + pos);
}
if (attr != NULL) {
snprintf(fmt_buf + pos, sizeof (fmt_buf) - pos,
"for attribute %s: ", attr);
pos += strlen(fmt_buf + pos);
}
if (cons != NULL) {
snprintf(fmt_buf + pos, sizeof (fmt_buf) - pos, "%s\n",
parse_error_msg[p_error]);
fprintf(cons, fmt_buf, str == NULL ? "" : str);
} else {
snprintf(fmt_buf + pos, sizeof (fmt_buf) - pos, "%s",
parse_error_msg[p_error]);
syslog(LOG_ERR, fmt_buf, str == NULL ? "" : str);
}
}
void
report_error2(
const char *str1,
const char *str2)
{
char fmt_buf[1024];
if (cons != NULL) {
snprintf(fmt_buf, sizeof (fmt_buf),
"%s\n", parse_error_msg[p_error]);
fprintf(cons, fmt_buf, str1, str2);
} else {
syslog(LOG_ERR, parse_error_msg[p_error], str1, str2);
}
}
void
report_conn_error(
conn_error e,
const char *str1,
const char *str2)
{
char fmt_buf[1024];
if (cons != NULL) {
snprintf(fmt_buf, sizeof (fmt_buf),
"%s\n", conn_error_msg[e]);
fprintf(cons, fmt_buf,
str1 == NULL ? "" : str1,
str2 == NULL ? "" : str2);
} else {
syslog(LOG_ERR,
conn_error_msg[e],
str1 == NULL ? "" : str1,
str2 == NULL ? "" : str2);
}
}
void
report_info(
const char *str,
const char *arg)
{
if (cons != NULL) {
fputs(str, cons);
if (arg != NULL)
fputs(arg, cons);
fputs("\n", cons);
} else
syslog(LOG_INFO, str, arg);
}