xref: /titanic_51/usr/src/lib/libnisdb/nis_parse_ldap_map.c (revision a87701e9837f8a9ee9e4c4d3186295c0e29f743f)

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

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <fcntl.h>
#include <unistd.h>
#include <locale.h>

#include "ldap_parse.h"
#include "nis_parse_ldap_conf.h"
#include "nis_parse_ldap_yp_util.h"
#include "nis_parse_ldap_util.h"

/* other attribute functions */
static char *getIndex(const char **s_cur, const char *end_s);
static bool_t get_ttls(const char *s, const char *s_end,
    __nis_table_mapping_t *t_mapping);
static __nis_object_dn_t *parse_object_dn(const char *s, const char *end);
static int	parse_name_fields(const char *name_s, const char *name_s_end,
	__nis_table_mapping_t *t_mapping);
static void get_mapping_rule(const char *s, int len,
    __nis_table_mapping_t *tbl, bool_t to_ldap);
static bool_t get_deleteDisp(const char *s_begin, const char *s_end,
    __nis_object_dn_t *obj_dn);

/* mapping rule functions */
static const char *get_lhs(const char *s, const char *end_s,
    __nis_mapping_rlhs_t *lhs, __nis_mapping_item_type_t item_type);
static const char *get_lhs_match(const char *s, const char *end_s,
    __nis_mapping_rlhs_t *lhs, __nis_mapping_item_type_t item_type);
static const char *get_lhs_paren_item(const char *s, const char *end_s,
    __nis_mapping_rlhs_t *lhs, __nis_mapping_item_type_t item_type);
static const char *get_rhs(const char *s, const char *end_s,
    __nis_mapping_rlhs_t *lhs, __nis_mapping_item_type_t item_type);
static const char *get_mapping_item(const char *s, const char *end_s,
    __nis_mapping_item_t *item, __nis_mapping_item_type_t type);
static const char *get_print_mapping_element(const char *s,
    const char *end_s, char *fmt_string, __nis_mapping_element_t *e,
    __nis_mapping_item_type_t item_type);
static const char *get_subElement(const char *s, const char *end_s,
    __nis_mapping_sub_element_t *subelement,
    __nis_mapping_item_type_t type);
static bool_t get_mapping_format(const char *fmt_string,
    __nis_mapping_format_t **fmt, int *nfmt, int *numItems,
    bool_t print_mapping);
extern __yp_domain_context_t ypDomains;

/*
 * FUNCTION:	add_mapping_attribute
 *
 *	Adds the attribute value to __nis_table_mapping_t
 *	if the value is not yet set for the given database.
 *
 * RETURN VALUE:	0 on success, -1 on failure
 *
 * INPUT:		attribute number and value
 */

int
add_mapping_attribute(
	config_key		attrib_num,
	const char		*attrib_val,
	int			attrib_len,
	__nis_table_mapping_t	**table_mapping)
{
	const char		*s;
	const char		*attrib_end;
	const char		*db_id_end;
	const char		*begin_token;
	char			*index_string;
	__nis_object_dn_t	*objectDN;
	__nis_table_mapping_t	*t_mapping;
	__nis_table_mapping_t	*t;

	bool_t			new_mapping	= FALSE;
	int				nm;
	char			*tmp_dbId;

	attrib_end = attrib_val + attrib_len;
	for (s = attrib_val; s < attrib_end; s++)
		if (*s == COLON_CHAR)
			break;

	if (s == attrib_end || *attrib_val == COLON_CHAR) {
		p_error = parse_unexpected_data_end_rule;
		return (-1);
	}

	db_id_end = s;
	while (s > attrib_val && is_whitespace(s[-1]))
		s--;

	if (s == attrib_val) {
		p_error = parse_unexpected_data_end_rule;
		return (-1);
	}

	if (yp2ldap) {
		tmp_dbId = s_strndup(attrib_val, s - attrib_val);
		if (tmp_dbId == NULL) {
			p_error = parse_no_mem_error;
			return (-1);
		}
		if (strchr(tmp_dbId, COMMA_CHAR)) {
			/* domain explicitly specified */
			nm = check_domain_specific_order(tmp_dbId,
				attrib_num, *table_mapping, &ypDomains);
			/*
			 * No logging is needed here, as
			 * check_domain_specific_order
			 * will log any appropriate errors.
			 */
			if (nm != 0) {
				free(tmp_dbId);
				return (-1);
			}
		}
		free(tmp_dbId);
	}

	if ((t_mapping = find_table_mapping(attrib_val,
			s - attrib_val, *table_mapping)) == NULL) {
		/* No mapping with this id, create one */
		t_mapping = (__nis_table_mapping_t *)
			s_calloc(1, sizeof (__nis_table_mapping_t));

		if (t_mapping == NULL) {
			p_error = parse_no_mem_error;
			return (-1);
		}
		(void) initialize_table_mapping(t_mapping);

		/* dbId is the label before the colon */
		t_mapping->dbId = s_strndup(attrib_val, s - attrib_val);
		if (t_mapping->dbId == NULL) {
			p_error = parse_no_mem_error;
			free(t_mapping);
			return (-1);
		}
		new_mapping = TRUE;
	} else {
		/* a table mapping already exists, use it */
		new_mapping = FALSE;
	}

	s = db_id_end + 1;
	while (s < attrib_end && is_whitespace(*s))
		s++;

	switch (attrib_num) {
		case key_yp_map_flags:
			if (t_mapping->usedns_flag != 0 ||
				t_mapping->securemap_flag != 0) {
				warn_duplicate_map(t_mapping->dbId,
					attrib_num);
				break;
			}
			while (is_whitespace(*s) && s < attrib_end)
				s++;
			while (s < attrib_end) {
				if (s < attrib_end && *s == 'b')
					t_mapping->usedns_flag = 1;
				if (s < attrib_end && *s == 's')
					t_mapping->securemap_flag = 1;
				s++;
			}
			break;
		case key_yp_comment_char:
			if (t_mapping->commentChar !=
				DEFAULT_COMMENT_CHAR) {
				warn_duplicate_map(t_mapping->dbId, attrib_num);
				break;
			}
			while (is_whitespace(*s) && s < attrib_end)
				s++;
			if (s < attrib_end && (s+1) < attrib_end &&
				(s+2) <= attrib_end) {
				while (is_whitespace(attrib_end[-1]))
					attrib_end--;
				while (*s != SINGLE_QUOTE_CHAR)
					s++;
				if (*s == SINGLE_QUOTE_CHAR &&
					*(s+2) == SINGLE_QUOTE_CHAR) {
					t_mapping->commentChar = *(s+1);
				} else if (*s == SINGLE_QUOTE_CHAR &&
					*(s+1) == SINGLE_QUOTE_CHAR) {
					t_mapping->commentChar = NULL;
				} else {
					/* anything else is an error */
					p_error = parse_bad_yp_comment_error;
				}
				break;
			} else {
				p_error = parse_bad_yp_comment_error;
				break;
			}
		case key_yp_repeated_field_separators:
			while (s < attrib_end && is_whitespace(*s))
				s++;
			if (s < attrib_end) {
				while (is_whitespace(attrib_end[-1]))
					attrib_end--;
				while (s < attrib_end &&
						*s != DOUBLE_QUOTE_CHAR)
					s++;
				s++;
				begin_token = s;
				while (s < attrib_end &&
						*s != DOUBLE_QUOTE_CHAR) {
					if (*s == ESCAPE_CHAR)
						s++;
					s++;
				}
				t_mapping->separatorStr =
					s_strndup(begin_token, s - begin_token);
				if (t_mapping->separatorStr == NULL)
					break;
			} else {
				p_error = parse_bad_field_separator_error;
			}
			break;
		case key_yp_name_fields:
		case key_yp_split_field:
			if (t_mapping->e || t_mapping->numSplits > 0) {
				warn_duplicate_map(t_mapping->dbId,
					attrib_num);
				break;
			}
			if (parse_name_fields(s, attrib_end, t_mapping)) {
				p_error = parse_bad_name_field;
			}
			break;
		case key_yp_db_id_map:
		case key_db_id_map:
			if (t_mapping->objName != NULL) {
				warn_duplicate_map(t_mapping->dbId, attrib_num);
				break;
			}

			if (s < attrib_end && *s == OPEN_BRACKET) {
				index_string = getIndex(&s, attrib_end);
				if (index_string == NULL)
					break;
				(void) parse_index(index_string,
					index_string + strlen(index_string),
					&t_mapping->index);
				free(index_string);
				if (p_error != no_parse_error)
					break;
			}
			while (is_whitespace(*s) && s < attrib_end)
				s++;
			if (s < attrib_end) {
				while (is_whitespace(attrib_end[-1]))
					attrib_end--;
				t_mapping->objName =
					s_strndup_esc(s, attrib_end - s);
			} else {
				if (yp2ldap) {
					p_error = parse_bad_map_error;
				} else {
					t_mapping->objName = s_strndup(s, 0);
				}
			}
			break;

		case key_yp_entry_ttl:
		case key_entry_ttl:
			if (t_mapping->initTtlLo != (time_t)NO_VALUE_SET) {
				warn_duplicate_map(t_mapping->dbId, attrib_num);
				break;
			}

			if (!get_ttls(s, attrib_end, t_mapping))
				p_error = parse_bad_ttl_format_error;
			break;

		case key_yp_ldap_object_dn:
		case key_ldap_object_dn:
			if (t_mapping->objectDN != NULL) {
				warn_duplicate_map(t_mapping->dbId, attrib_num);
				break;
			}
			objectDN = parse_object_dn(s, attrib_end);
			if (objectDN == NULL)
				break;
			t_mapping->objectDN = objectDN;
			t_mapping->seq_num = seq_num++;
			break;

		case key_nis_to_ldap_map:
		case key_nisplus_to_ldap_map:
			if (t_mapping->ruleToLDAP != 0) {
				warn_duplicate_map(t_mapping->dbId, attrib_num);
				break;
			}

			get_mapping_rule(s, attrib_end - s, t_mapping, TRUE);
			break;

		case key_ldap_to_nis_map:
		case key_ldap_to_nisplus_map:
			if (t_mapping->ruleFromLDAP != NULL) {
				warn_duplicate_map(t_mapping->dbId, attrib_num);
				break;
			}

			get_mapping_rule(s, attrib_end - s, t_mapping, FALSE);
			break;

		default:
			p_error = parse_internal_error;
			break;
	}
	if (p_error == no_parse_error) {
		if (new_mapping) {
			if (*table_mapping == NULL)
				*table_mapping = t_mapping;
			else {
				for (t = *table_mapping; t->next != NULL;
				    t = t->next)
					;
				t->next = t_mapping;
			}
		}
	} else {
		if (new_mapping)
			free_table_mapping(t_mapping);
	}
	return (p_error == no_parse_error ? 0 : -1);
}

/*
 * FUNCTION:	add_ypdomains_attribute
 *
 * Adds the yp domains information to the __yp_domain_context_t
 * structure.
 *
 * RETURN:		0 on success, -1 on failure
 *
 * INPUT:		attribute number and value
 */

int
add_ypdomains_attribute(
	config_key		attrib_num,
	const char		*attrib_val,
	int				attrib_len,
	__yp_domain_context_t	*ypDomains)
{
	const char 		*s;
	const char		*attrib_end;
	int				numDomains = 0;

	attrib_end = attrib_val + attrib_len;
	for (s = attrib_val; s < attrib_end; s++) {
		if (*s == COLON_CHAR) {
			break;
		}
	}
	while (s > attrib_val && is_whitespace(s[-1]))
		s--;

	if (s == attrib_val) {
		p_error = parse_unexpected_data_end_rule;
		return (-1);
	}

	if (ypDomains == NULL) {
		/*
		 * No point allocating. We cant return the resulting structure,
		 * so just return failure. Should not ever happen because we
		 * are always called with a pointer to the global ypDomains
		 * structure.
		 */
		return (-1);
	}

	switch (attrib_num) {
		case key_yp_domain_context:
			numDomains = ypDomains->numDomains;
			ypDomains->domainLabels =
				(char **)s_realloc(ypDomains->domainLabels,
				(numDomains + 1) *
				sizeof (ypDomains->domainLabels[0]));
			if (ypDomains->domainLabels == NULL) {
				p_error = parse_no_mem_error;
				free_yp_domain_context(ypDomains);
				break;
			}
			ypDomains->domainLabels[numDomains] =
				s_strndup(attrib_val, s - attrib_val);
			if (ypDomains->domainLabels[numDomains] == NULL) {
				p_error = parse_no_mem_error;
				free_yp_domain_context(ypDomains);
				break;
			}
			ypDomains->numDomains = numDomains + 1;
			while (s < attrib_end && is_whitespace(*s))
				s++;
			if (*s == COLON_CHAR)
				s++;
			while (s < attrib_end && is_whitespace(*s))
				s++;
			ypDomains->domains =
				(char **)s_realloc(ypDomains->domains,
				(numDomains + 1) *
				sizeof (ypDomains->domains[0]));
			if (ypDomains->domains == NULL) {
				p_error = parse_no_mem_error;
				free_yp_domain_context(ypDomains);
				break;
			}

			if (s < attrib_end) {
				while (is_whitespace(attrib_end[-1]))
					attrib_end--;
				ypDomains->domains[numDomains] =
					s_strndup_esc(s, attrib_end - s);
				if (ypDomains->domains[numDomains] == NULL) {
					p_error = parse_no_mem_error;
					free_yp_domain_context(ypDomains);
					break;
				}
			} else {
				p_error = parse_unexpected_yp_domain_end_error;
				free(ypDomains->domainLabels[numDomains]);
				ypDomains->domainLabels[numDomains] = NULL;
				ypDomains->numDomains--;
				free_yp_domain_context(ypDomains);
			}
			break;
		case key_yppasswdd_domains:
			ypDomains->yppasswddDomainLabels =
				(char **)s_realloc(
				ypDomains->yppasswddDomainLabels,
				(ypDomains->numYppasswdd + 1) *
				sizeof (ypDomains->yppasswddDomainLabels[0]));
			if (ypDomains->yppasswddDomainLabels == NULL) {
				p_error = parse_no_mem_error;
				break;
			}
			ypDomains->yppasswddDomainLabels
				[ypDomains->numYppasswdd] =
				s_strndup(attrib_val, s - attrib_val);
			if (ypDomains->yppasswddDomainLabels
				[ypDomains->numYppasswdd] == NULL) {
				p_error = parse_no_mem_error;
			}
			ypDomains->numYppasswdd++;
			break;
	}

	return (p_error == no_parse_error ? 0 : -1);
}

/*
 * FUNCTION:	get_ttls
 *
 *	Parse time to live attribute
 *
 * RETURN VALUE:	TRUE on success, FALSE on failure
 *
 * INPUT:		the attribute value
 */

static bool_t
get_ttls(
	const char		*s,
	const char		*s_end,
	__nis_table_mapping_t	*t_mapping)
{
	time_t		initTtlHi	= 0;
	time_t		initTtlLo	= 0;
	time_t		ttl		= 0;
	time_t		digit;

	/*
	 * attribute should be of the form
	 * initialTTLlo ":" initialTTLhi ":" runningTTL
	 */

	if (s == s_end) {
		p_error = parse_bad_ttl_format_error;
		return (FALSE);
	}

	if (isdigit(*s)) {
		while (s < s_end && isdigit(*s)) {
			digit = (*s++) - '0';
			if (WILL_OVERFLOW_TIME(initTtlLo, digit))
				initTtlLo = TIME_MAX;
			else
				initTtlLo = initTtlLo * 10 + digit;
		}
	} else {
		initTtlLo = ONE_HOUR;
	}

	while (s < s_end && is_whitespace(*s))
		s++;
	if (s + 1 >= s_end || *s++ != COLON_CHAR) {
		p_error = parse_bad_ttl_format_error;
		return (FALSE);
	}

	while (s < s_end && is_whitespace(*s))
		s++;
	if (isdigit(*s)) {
		while (s < s_end && isdigit(*s)) {
			digit = (*s++) - '0';
			if (WILL_OVERFLOW_TIME(initTtlHi, digit))
				initTtlHi = TIME_MAX;
			else
				initTtlHi = initTtlHi * 10 + digit;
		}
	} else {
		initTtlHi = initTtlLo;
	}

	while (s < s_end && is_whitespace(*s))
		s++;
	if (s >= s_end || *s++ != COLON_CHAR) {
		p_error = parse_bad_ttl_format_error;
		return (FALSE);
	}

	while (s < s_end && is_whitespace(*s))
		s++;
	if (isdigit(*s)) {
		while (s < s_end && isdigit(*s)) {
			digit = (*s++) - '0';
			if (WILL_OVERFLOW_TIME(ttl, digit))
				ttl = TIME_MAX;
			else
				ttl = ttl * 10 + digit;
		}
	} else {
		ttl = ONE_HOUR;
	}
	while (s < s_end && is_whitespace(*s))
		s++;
	if (s != s_end) {
		p_error = parse_bad_ttl_format_error;
		return (FALSE);
	}

	t_mapping->initTtlLo = initTtlLo;
	t_mapping->initTtlHi = initTtlHi;
	t_mapping->ttl = ttl;
	return (TRUE);
}

/*
 * FUNCTION:	parse_name_fields
 *
 * Parse yp name fields
 *
 * RETURN VALUE:	0 on success, non-zero on failure
 *
 * INPUTS:		attrib_value and attribute_end pointers.
 */

static int
parse_name_fields(const char *name_s,
	const char *name_s_end,
	__nis_table_mapping_t   *t_map)
{
	int	i, n = 0;
	int nElements = 0;
	int numSplits = 0;
	int parse_next_line = 1;
	int itm_count = 0;
	const char	*begin_fmt;
	const char	*end_fmt;
	const char	*begin_token;
	const char	*end_token;
	char	*fmt_string = NULL;
	__nis_mapping_format_t  *base = NULL;
	__nis_mapping_item_t    *item = NULL;
	__nis_mapping_element_t *elmnt = NULL;
	__nis_mapping_item_type_t   item_type = mit_nisplus;
	token_type	token;

	t_map->numColumns = 0;

	for (; parse_next_line > 0; parse_next_line--) {
		nElements = 0;
		item = NULL;
		base = NULL;
		while (name_s < name_s_end && *name_s != OPEN_PAREN_CHAR)
			name_s++;
		if (name_s == name_s_end) {
			p_error = parse_unexpected_data_end_rule;
			return (1);
		}
		while (name_s < name_s_end && *name_s != DOUBLE_QUOTE_CHAR)
			name_s++;
		if (name_s == name_s_end) {
			p_error = parse_unexpected_data_end_rule;
			return (1);
		}
		begin_fmt = ++name_s; /* start of format string */
		while (name_s < name_s_end && *name_s != DOUBLE_QUOTE_CHAR)
			name_s++;
		if (name_s == name_s_end) {
			p_error = parse_unexpected_data_end_rule;
			return (1);
		}
		end_fmt = name_s;
		fmt_string = s_strndup(begin_fmt, end_fmt - begin_fmt);
		if (fmt_string == NULL) {
			p_error = parse_no_mem_error;
			return (2);
		}
		if (!get_mapping_format(fmt_string, &base, &n, NULL, FALSE)) {
			p_error = parse_internal_error;
			free(fmt_string);
			fmt_string = NULL;
			return (3);
		}
		free(fmt_string);
		fmt_string = NULL;
		for (n = 0; base[n].type != mmt_end; n++) {
			if (base[n].type != mmt_item && base[n].type
				!= mmt_berstring) {
				if (base[n].type == mmt_berstring_null)
					base[n].type = mmt_berstring;
				continue;
			}
			while (name_s < name_s_end && *name_s != COMMA_CHAR)
				name_s++;
			name_s++;    /* now at comma char */
			while (name_s < name_s_end && is_whitespace(*name_s))
				name_s++;
			begin_token = name_s++;
			end_token = name_s_end;
			name_s = get_next_token(
				&begin_token, &end_token, &token);
			if (name_s == NULL) {
				p_error = parse_item_expected_error;
				return (4);
			}
			if (token != string_token) {
				p_error = parse_item_expected_error;
				return (5);
			}
			item = (__nis_mapping_item_t *)s_realloc(item,
				(nElements + 1) *
				sizeof (__nis_mapping_item_t));
			if (item == NULL) {
				p_error = parse_no_mem_error;
				return (2);
			}
			name_s = get_mapping_item(begin_token, name_s_end,
				&item[nElements], item_type);
			if (name_s == NULL) {
				p_error = parse_unmatched_escape;
				for (n = 0; n < (nElements + 1); n++)
					free_mapping_item(&item[n]);
				free_mapping_format(base);
				return (4);
			}
			nElements++;
		}
		if (p_error != no_parse_error) {
			for (n = 0; n < (nElements + 1); n++)
				free_mapping_item(&item[n]);
			free_mapping_format(base);
			return (6);
		}
		name_s = skip_token(name_s, name_s_end, close_paren_token);
		if (name_s == NULL) {
			p_error = parse_close_paren_expected_error;
			for (n = 0; n < (nElements + 1); n++)
				free_mapping_item(&item[n]);
			free_mapping_format(base);
			return (4);
		}
		while (name_s < name_s_end && is_whitespace(*name_s))
			name_s++;
		if (*name_s == COMMA_CHAR)
			parse_next_line++;

		if (nElements == 0) {
			p_error = parse_no_match_item;
			for (n = 0; n < (nElements + 1); n++)
				free_mapping_item(&item[n]);
			free_mapping_format(base);
			return (7);
		}
		elmnt = (__nis_mapping_element_t *)s_realloc(elmnt,
			(numSplits + 1) *
			sizeof (__nis_mapping_element_t));
		if (elmnt == NULL) {
			for (n = 0; n < (nElements + 1); n++)
				free_mapping_item(&item[n]);
			free_mapping_format(base);
			p_error = parse_no_mem_error;
			return (2);
		}
		elmnt[numSplits].type = me_match;
		elmnt[numSplits].element.match.numItems = nElements;
		elmnt[numSplits].element.match.item = item;
		elmnt[numSplits].element.match.fmt = base;
		item = NULL;
		base = NULL;

		t_map->e = elmnt;
		t_map->numSplits = numSplits;
		n = t_map->numColumns;

		for (i = n, itm_count = 0; i < n + nElements; i++) {
			if (t_map->e[numSplits].element.
				match.item[itm_count].name) {
				if (!add_column(t_map,
					t_map->e[numSplits].element.
					match.item[itm_count].name))
					return (1);
				itm_count++;
			} else {
				p_error = parse_internal_error;
				for (n = 0; n < (nElements + 1); n++)
					free_mapping_item(&item[n]);
				free_mapping_format(base);
				free_mapping_element(elmnt);
				return (1);
			}
		}
		numSplits++;
	}
	elmnt = NULL;

	if (item != NULL) {
		for (n = 0; n < t_map->numColumns; n++) {
			free_mapping_item(&item[n]);
		}
		free(item);
	}
	if (elmnt != NULL)
		free_mapping_element(elmnt);
	if (base != NULL)
		free_mapping_format(base);

	return (p_error == no_parse_error ? 0 : -1);
}

/*
 * FUNCTION:	parse_object_dn
 *
 *	Parse object dn attribute
 *
 * RETURN VALUE:	__nis_object_dn_t on success
 *			NULL on failure
 *
 * INPUT:		the attribute value
 */

static __nis_object_dn_t *
parse_object_dn(const char *s, const char *end)
{
	const char		*s_begin;
	const char		*s_end;
	object_dn_token		token;
	parse_object_dn_state	dn_state	= dn_begin_parse;
	__nis_object_dn_t	*obj_dn		= NULL;
	__nis_object_dn_t	*next		= NULL;
	__nis_object_dn_t	*last		= NULL;

	/*
	 * The attribute should be of form
	 * objectDN *( ";" objectDN )
	 * objectDN = readObjectSpec [":"[writeObjectSpec]]
	 * readObjectSpec = [baseAndScope [filterAttrValList]]
	 * writeObjectSpec = [baseAndScope [attrValList [":" deleteDisp]]]
	 */

	while (s < end) {
		s_begin = s;
		s_end = end;
		s = get_next_object_dn_token(&s_begin, &s_end, &token);
		if (s == NULL)
			break;

		if (token == dn_no_token || token == dn_semi_token) {
			if (obj_dn == NULL)
				obj_dn = next;
			else
				last->next = next;
			last = next;
			next = NULL;
			if (token == dn_no_token)
				break;
			dn_state = dn_begin_parse;
		}
		if (next == NULL) {
			next = (__nis_object_dn_t *)
				s_calloc(1, sizeof (__nis_object_dn_t));
			if (next == NULL)
				break;
			next->read.scope = LDAP_SCOPE_ONELEVEL;
			next->write.scope = LDAP_SCOPE_UNKNOWN;
			next->delDisp = dd_always;
		}
		if (token == dn_semi_token)
			continue;

		switch (dn_state) {
		    case dn_begin_parse:
			if (token == dn_ques_token)
				dn_state = dn_got_read_q_scope;
			else if (token == dn_colon_token) {
				dn_state = dn_got_write_colon;
				next->write.scope = LDAP_SCOPE_ONELEVEL;
			} else {
				if (!validate_dn(s_begin, s_end - s_begin))
					break;
				next->read.base =
					s_strndup_esc(s_begin, s_end - s_begin);
				dn_state = dn_got_read_dn;
			}
			break;
		    case dn_got_read_dn:
			if (token == dn_ques_token)
				dn_state = dn_got_read_q_scope;
			else if (token == dn_colon_token) {
				dn_state = dn_got_write_colon;
				next->write.scope = LDAP_SCOPE_ONELEVEL;
			} else
				p_error = parse_object_dn_syntax_error;
			break;
		    case dn_got_read_q_scope:
			if (token == dn_ques_token)
				dn_state = dn_got_read_q_filter;
			else if (token == dn_colon_token) {
				dn_state = dn_got_write_colon;
				next->write.scope = LDAP_SCOPE_ONELEVEL;
			} else if (token == dn_base_token) {
				next->read.scope = LDAP_SCOPE_BASE;
				dn_state = dn_got_read_scope;
			} else if (token == dn_one_token) {
				next->read.scope = LDAP_SCOPE_ONELEVEL;
				dn_state = dn_got_read_scope;
			} else if (token == dn_sub_token) {
				next->read.scope = LDAP_SCOPE_SUBTREE;
				dn_state = dn_got_read_scope;
			} else {
				p_error = parse_invalid_scope;
			}
			break;
		    case dn_got_read_scope:
			if (token == dn_ques_token)
				dn_state = dn_got_read_q_filter;
			else if (token == dn_colon_token) {
				dn_state = dn_got_write_colon;
				next->write.scope = LDAP_SCOPE_ONELEVEL;
			} else
				p_error = parse_object_dn_syntax_error;
			break;
		    case dn_got_read_q_filter:
			if (token == dn_ques_token) {
				p_error = parse_object_dn_syntax_error;
			} else if (token == dn_colon_token) {
				dn_state = dn_got_write_colon;
				next->write.scope = LDAP_SCOPE_ONELEVEL;
			} else {
				if (!validate_ldap_filter(s_begin, s_end))
					break;
				next->read.attrs =
					s_strndup_esc(s_begin, s_end - s_begin);
				dn_state = dn_got_read_filter;
			}
			break;
		    case dn_got_read_filter:
			if (token == dn_ques_token) {
				p_error = parse_object_dn_syntax_error;
			} else if (token == dn_colon_token) {
				dn_state = dn_got_write_colon;
				next->write.scope = LDAP_SCOPE_ONELEVEL;
			} else
				p_error = parse_object_dn_syntax_error;
			break;
		    case dn_got_write_colon:
			if (token == dn_ques_token)
				dn_state = dn_got_write_q_scope;
			else if (token == dn_colon_token) {
				dn_state = dn_got_delete_colon;
			} else {
				if (!validate_dn(s_begin, s_end - s_begin))
					break;
				next->write.base =
					s_strndup_esc(s_begin, s_end - s_begin);
				dn_state = dn_got_write_dn;
			}
			break;
		    case dn_got_write_dn:
			if (token == dn_ques_token)
				dn_state = dn_got_write_q_scope;
			else if (token == dn_colon_token) {
				dn_state = dn_got_delete_colon;
			} else
				p_error = parse_object_dn_syntax_error;
			break;
		    case dn_got_write_q_scope:
			if (token == dn_ques_token)
				dn_state = dn_got_write_q_filter;
			else if (token == dn_colon_token) {
				dn_state = dn_got_delete_colon;
			} else if (token == dn_base_token) {
				next->write.scope = LDAP_SCOPE_BASE;
				dn_state = dn_got_write_scope;
			} else if (token == dn_one_token) {
				next->write.scope = LDAP_SCOPE_ONELEVEL;
				dn_state = dn_got_write_scope;
			} else if (token == dn_sub_token) {
				next->write.scope = LDAP_SCOPE_SUBTREE;
				dn_state = dn_got_write_scope;
			} else {
				p_error = parse_invalid_scope;
			}
			break;
		    case dn_got_write_scope:
			if (token == dn_ques_token)
				dn_state = dn_got_write_q_filter;
			else if (token == dn_colon_token) {
				dn_state = dn_got_delete_colon;
			} else
				p_error = parse_object_dn_syntax_error;
			break;
		    case dn_got_write_q_filter:
			if (token == dn_ques_token) {
				p_error = parse_object_dn_syntax_error;
			} else if (token == dn_colon_token) {
				dn_state = dn_got_delete_colon;
			} else {
				if (!validate_ldap_filter(s_begin, s_end))
					break;
				next->write.attrs =
					s_strndup_esc(s_begin, s_end - s_begin);
				dn_state = dn_got_write_filter;
			}
			break;
		    case dn_got_write_filter:
			if (token == dn_ques_token) {
				p_error = parse_object_dn_syntax_error;
			} else if (token == dn_colon_token) {
				dn_state = dn_got_delete_colon;

			} else
				p_error = parse_semi_expected_error;
			break;
		    case dn_got_delete_colon:
			if (token == dn_ques_token) {
				p_error = parse_object_dn_syntax_error;
			} else if (token == dn_colon_token) {
				p_error = parse_object_dn_syntax_error;
			} else {
				if (!get_deleteDisp(s_begin, s_end, next))
					break;
				dn_state = dn_got_delete_dsp;
			}
			break;
		    case dn_got_delete_dsp:
			p_error = parse_object_dn_syntax_error;
			break;
		}

		if (p_error != no_parse_error)
			break;
	}
	if (p_error != no_parse_error) {
		if (obj_dn != NULL)
			free_object_dn(obj_dn);
		if (next != NULL)
			free_object_dn(next);
		obj_dn = NULL;
	} else if (next != NULL) {
		if (obj_dn == NULL)
			obj_dn = next;
		else
			last->next = next;
	} else if (obj_dn == NULL)
		obj_dn = (__nis_object_dn_t *)
			s_calloc(1, sizeof (__nis_object_dn_t));

	return (obj_dn);
}

/*
 * FUNCTION:	get_mapping_rule
 *
 *	Parse mapping rule attributes
 *
 * RETURN VALUE:	None. Errors determined by p_error
 *
 * INPUT:		the attribute value and mapping rule type
 */

static void
get_mapping_rule(
	const char		*s,
	int			len,
	__nis_table_mapping_t	*tbl,
	bool_t			to_ldap)
{
	const char		*end_s			= s + len;
	const char		*begin_token;
	const char		*end_token;
	__nis_mapping_rule_t	**rule			= NULL;
	__nis_mapping_rule_t	*next			= NULL;
	/* __nis_mapping_rule_t	**r; */
	token_type		t;
	int			nRules			= 0;
	const char		*s1;
	int			i;

	/*
	 * The attribute value is of the form
	 * colattrspec *("," colattrspec)
	 * colattrspec	= lhs "=" rhs
	 * lhs		= lval | namespeclist
	 * rhs		= rval | [namespec]
	 */

	for (;;) {
		if ((next = (__nis_mapping_rule_t *)
		    s_calloc(1, sizeof (__nis_mapping_rule_t))) == NULL)
			break;

		s = get_lhs(s, end_s, &next->lhs,
			to_ldap ? mit_ldap : mit_nisplus);
		if (s == NULL)
			break;

		begin_token = s;
		end_token = end_s;
		s1 = get_next_token(&begin_token, &end_token, &t);
		if (s1 == NULL)
			break;
		if (!(to_ldap && (t == comma_token || t == no_token))) {
			s = get_rhs(s, end_s, &next->rhs,
				to_ldap ? mit_nisplus : mit_ldap);
			if (s == NULL)
				break;
		}

		if (next->lhs.numElements > 1 &&
		    (next->rhs.numElements != 1 ||
		    next->rhs.element[0].type != me_split)) {
			p_error = parse_lhs_rhs_type_mismatch;
			break;
		}
		if (rule == NULL) {
			rule = (__nis_mapping_rule_t **)
				malloc(sizeof (__nis_mapping_rule_t *));
			if (rule == NULL)
				break;
		} else {
			rule = (__nis_mapping_rule_t **)s_realloc(rule,
				(nRules + 1) *
				sizeof (__nis_mapping_rule_t *));
			if (rule == NULL)
				break;
		}

		rule[nRules++] = next;
		next = NULL;

		begin_token = s;
		end_token = end_s;
		s = get_next_token(&begin_token, &end_token, &t);
		if (s == NULL)
			break;
		if (t == comma_token)
			continue;
		if (t != no_token) {
			p_error = parse_unexpected_data_end_rule;
			break;
		}
		if (to_ldap) {
			tbl->numRulesToLDAP = nRules;
			tbl->ruleToLDAP = rule;
		} else {
			tbl->numRulesFromLDAP = nRules;
			tbl->ruleFromLDAP = rule;
		}
		return;
	}

	if (rule) {
		for (i = 0; i < nRules; i++)
			free_mapping_rule(rule[i]);
		free(rule);
	}
	if (next)
		free_mapping_rule(next);
}

/*
 * FUNCTION:	get_lhs
 *
 *	Parse left hand side of mapping rule attribute
 *
 * RETURN VALUE:	NULL if error
 *			position of beginning rhs
 *
 * INPUT:		the attribute value and mapping rule type
 */

static const char *
get_lhs(const char			*s,
	const char			*end_s,
	__nis_mapping_rlhs_t		*lhs,
	__nis_mapping_item_type_t	item_type)
{
	token_type		t;
	const char		*begin_token;
	const char		*end_token;
	const char		*sav_s;
	__nis_mapping_element_t	*e		= NULL;

	/*
	 *	lhs can be expressed as:
	 *		item
	 *		(item)
	 *		(item list)
	 *		(fmt, item list)
	 *
	 * lhs = lval | namespeclist
	 * lval = "(" formatspec "," namespec *("," namespec) ")"
	 * namespeclist = namespec | "(" namespec *("," namespec) ")"
	 */

	for (; p_error == no_parse_error; ) {
		begin_token = s;
		end_token = end_s;
		s = get_next_token(&begin_token, &end_token, &t);
		if (s == NULL)
			break;
		if (t == no_token) {
			p_error = parse_unexpected_data_end_rule;
			break;
		}

		e = (__nis_mapping_element_t *)
			s_calloc(1, sizeof (__nis_mapping_element_t));
		if (e == NULL)
			break;

		if (t == open_paren_token) {
			free(e);
			e = NULL;

			begin_token = s;
			end_token = end_s;
			sav_s = s;
			s = get_next_token(&begin_token, &end_token, &t);
			if (s == NULL)
				break;

			if (t == quoted_string_token) {
				s = get_lhs_match(sav_s, end_s, lhs, item_type);
				if (s == NULL)
					break;
			} else if (t == string_token) {
				s = get_lhs_paren_item(sav_s, end_s, lhs,
					item_type);
				if (s == NULL)
					break;
			} else {
				p_error = parse_bad_lhs_format_error;
				break;
			}
		} else if (t == string_token) {
			s = get_mapping_item(begin_token, end_s,
				&e->element.item, item_type);
			if (s == NULL)
				break;
			e->type = me_item;
			if (!add_element(e, lhs))
				break;
			e = NULL;
		} else {
			p_error = parse_bad_lhs_format_error;
			break;
		}

		s = skip_token(s, end_s, equal_token);
		if (s == NULL)
			break;
		if (p_error == no_parse_error)
			return (s);
	}
	if (e != NULL)
		free_mapping_element(e);

	return (NULL);
}

/*
 * FUNCTION:	get_lhs_match
 *
 *	Parse left hand side of mapping rule attribute in case of
 *	matching rule
 *
 * RETURN VALUE:	NULL if error
 *			position of beginning rhs
 *
 * INPUT:		the attribute value and mapping rule type
 */

static const char *
get_lhs_match(
	const char			*s,
	const char			*end_s,
	__nis_mapping_rlhs_t		*lhs,
	__nis_mapping_item_type_t	item_type)
{
	token_type			t;
	const char			*begin_token;
	const char			*end_token;
	int				n		= 0;
	int				nElements	= 0;
	char				*fmt_string	= NULL;
	__nis_mapping_format_t		*base		= NULL;
	__nis_mapping_item_t		*item		= NULL;
	__nis_mapping_item_t		*itm;
	__nis_mapping_element_t		*e;

	/*
	 *  lval = "(" formatspec "," namespec *("," namespec) ")"
	 */

	for (; p_error == no_parse_error; ) {
		begin_token = s;
		end_token = end_s;
		s = get_next_token(&begin_token, &end_token, &t);
		if (s == NULL || t != quoted_string_token) {
			p_error = parse_internal_error;
			break;
		}


		fmt_string = s_strndup(begin_token, end_token - begin_token);
		if (fmt_string == NULL)
			break;

		if (!get_mapping_format(fmt_string, &base, &n, NULL, FALSE))
			break;

		for (n = 0; base[n].type != mmt_end; n++) {
			if (base[n].type != mmt_item &&
			    base[n].type != mmt_berstring) {
				if (base[n].type == mmt_berstring_null)
					base[n].type = mmt_berstring;
				continue;
			}
			s = skip_token(s, end_s, comma_token);
			if (s == NULL) {
				p_error = parse_not_enough_extract_items;
				break;
			}
			begin_token = s;
			end_token = end_s;
			s = get_next_token(&begin_token, &end_token, &t);
			if (s == NULL)
				break;
			if (t != string_token) {
				p_error = parse_item_expected_error;
				break;
			}
			itm = (__nis_mapping_item_t *)
				s_realloc(item, (nElements + 1) *
				sizeof (__nis_mapping_item_t));
			if (itm == NULL)
				break;
			item = itm;

			s = get_mapping_item(begin_token, end_s,
				&item[nElements], item_type);
			if (s == NULL)
				break;
			nElements++;
		}
		if (p_error != no_parse_error)
			break;

		s = skip_token(s, end_s, close_paren_token);
		if (s == NULL)
			break;
		free(fmt_string);
		fmt_string = NULL;

		if (nElements == 0) {
			p_error = parse_no_match_item;
			break;
		}
		e = (__nis_mapping_element_t *)s_calloc(1,
			sizeof (__nis_mapping_element_t));
		if (e == NULL)
			break;
		e->type = me_match;
		e->element.match.numItems = nElements;
		e->element.match.item = item;
		e->element.match.fmt = base;
		lhs->numElements = 1;
		lhs->element = e;

		if (p_error == no_parse_error)
			return (s);
	}
	if (item == NULL) {
		for (n = 0; n < nElements; n++)
			free_mapping_item(&item[n]);
		free(item);
	}
	if (fmt_string != NULL)
		free(fmt_string);
	if (base != NULL)
		free_mapping_format(base);

	return (NULL);
}

/*
 * FUNCTION:	get_lhs_paren_item
 *
 *	Parse left hand side of mapping rule attribute in case of
 *	(item1, ..., item-n)
 *
 * RETURN VALUE:	NULL if error
 *			position of beginning rhs
 *
 * INPUT:		the attribute value and mapping rule type
 */

static const char *
get_lhs_paren_item(
	const char			*s,
	const char			*end_s,
	__nis_mapping_rlhs_t		*lhs,
	__nis_mapping_item_type_t	item_type)
{
	token_type		t;
	const char		*begin_token;
	const char		*end_token;
	__nis_mapping_element_t	*e		= NULL;
	int			n		= 0;
	int			i;

	/*
	 * "(" namespec *("," namespec) ")"
	 */

	for (;;) {
		e = (__nis_mapping_element_t *)s_realloc(e, (n + 1) *
			sizeof (__nis_mapping_element_t));
		if (e == NULL)
			break;

		s = get_mapping_item(s, end_s, &e[n].element.item,
			item_type);
		if (s == NULL)
			break;
		e[n].type = me_item;
		n++;

		begin_token = s;
		end_token = end_s;
		s = get_next_token(&begin_token, &end_token, &t);
		if (s != NULL && t == close_paren_token) {
			lhs->numElements = n;
			if (n == 1)
				e[0].element.item.repeat = TRUE;
			lhs->element = e;
			return (s);
		}
		if (s == NULL || t != comma_token) {
			p_error = parse_comma_expected_error;
			break;
		}
	}
	for (i = 0; i < n; i++)
		free_mapping_element(&e[i]);
	if (e != NULL)
		free(e);
	return (NULL);
}

/*
 * FUNCTION:	get_rhs
 *
 *	Parse right hand side of mapping rule attribute
 *
 * RETURN VALUE:	NULL if error
 *			position of beginning next mapping rule
 *
 * INPUT:		the attribute value and mapping rule type
 */

static const char *
get_rhs(
	const char			*s,
	const char			*end_s,
	__nis_mapping_rlhs_t		*rhs,
	__nis_mapping_item_type_t	item_type)
{
	/*
	 * This handles the following cases:
	 *	name				me_item
	 *	(name)				me_item
	 *	(fmt, name-list)		me_print
	 *	(item, fmt)			me_extract
	 */

	token_type		t;
	const char		*begin_token;
	const char		*end_token;
	char			*str		= NULL;
	__nis_mapping_format_t	*fmt		= NULL;
	__nis_mapping_element_t	*e		= NULL;
	__nis_mapping_item_t	item;
	int			n;

	(void) memset(&item, 0, sizeof (item));

	for (; p_error == no_parse_error; ) {
		begin_token = s;
		end_token = end_s;
		s = get_next_token(&begin_token, &end_token, &t);
		if (s == NULL)
			break;

		e = (__nis_mapping_element_t *)
			s_calloc(1, sizeof (__nis_mapping_element_t));
		if (e == NULL)
			break;

		if (t == string_token) {
			s = get_mapping_item(begin_token, end_s,
				&e->element.item, item_type);
		} else if (t == open_paren_token) {
			begin_token = s;
			end_token = end_s;
			s = get_next_token(&begin_token, &end_token, &t);
			if (s == NULL)
				break;
			if (t == string_token) {
				/* (item, fmt) - me_extract */
				/* (item, "c") - me_split */
				s = get_mapping_item(begin_token, end_s,
					&item, item_type);
				if (s == NULL)
					break;
				begin_token = s;
				end_token = end_s;
				s = get_next_token(&begin_token, &end_token,
					&t);
				if (s == NULL)
					break;
				else if (t == close_paren_token) {
					item.repeat = TRUE;
					e->element.item = item;
					e->type = me_item;
					rhs->numElements = 1;
					rhs->element = e;
					return (s);
				} else if (t != comma_token) {
					p_error = parse_comma_expected_error;
					break;
				}

				begin_token = s;
				end_token = end_s;
				s = get_next_token(&begin_token, &end_token,
					&t);
				if (s == NULL || t != quoted_string_token) {
				    p_error =
					parse_format_string_expected_error;
				    break;
				}

				if (end_token == begin_token + 1 ||
				    (*begin_token == ESCAPE_CHAR &&
				    end_token == begin_token + 2)) {
					e->type = me_split;
					e->element.split.item = item;
					e->element.split.delim = *begin_token;
				} else {
					str = s_strndup(begin_token,
						end_token - begin_token);
					if (str == NULL)
						break;
					if (!get_mapping_format(str, &fmt,
					    NULL, &n, FALSE))
						break;
					free(str);
					str = NULL;
					if (n != 1) {
					    p_error =
						parse_bad_extract_format_spec;
					    break;
					}
					e->type = me_extract;
					e->element.extract.item = item;
					e->element.extract.fmt = fmt;
				}
				s = skip_token(s, end_s, close_paren_token);
			} else if (t == quoted_string_token) {
				/* (fmt, name-list) - me_print */
				str = s_strndup(begin_token,
					end_token - begin_token);
				if (str == NULL)
					break;

				s = get_print_mapping_element(s, end_s,
					str, e, item_type);
				free(str);
				str = NULL;
			} else {
				p_error = parse_start_rhs_unrecognized;
				break;
			}
		} else {
			p_error = parse_start_rhs_unrecognized;
			break;
		}
		if (s == NULL)
			break;
		rhs->numElements = 1;
		rhs->element = e;
		if (p_error == no_parse_error)
			return (s);
	}
	if (str)
		free(str);
	if (fmt != NULL)
		free_mapping_format(fmt);
	if (e != NULL)
		free_mapping_element(e);
	free_mapping_item(&item);

	return (NULL);
}

/*
 * FUNCTION:	get_print_mapping_element
 *
 *	Parse a print mapping rule attribute in case of the form
 *	(fmt, name-list)
 *
 * RETURN VALUE:	NULL if error
 *			position of beginning next mapping rule
 *
 * INPUT:		the attribute value and mapping rule type
 */

static const char *
get_print_mapping_element(
	const char			*s,
	const char			*end_s,
	char				*fmt_string,
	__nis_mapping_element_t		*e,
	__nis_mapping_item_type_t	item_type)
{
	token_type			t;
	const char			*begin_token;
	const char			*end_token;
	char				elide;
	bool_t				doElide;
	__nis_mapping_format_t		*base		= NULL;
	__nis_mapping_sub_element_t	*subElement	= NULL;
	int				n		= 0;
	int				nSub		= 0;
	int				numSubElements;

	for (; p_error == no_parse_error; ) {
		if (!get_mapping_format(fmt_string, &base, &n,
		    &numSubElements, TRUE))
			break;
		subElement = (__nis_mapping_sub_element_t *)
			s_calloc(numSubElements,
			sizeof (__nis_mapping_sub_element_t));
		if (subElement == NULL)
			break;
		for (n = 0; base[n].type != mmt_end; n++) {
			if (base[n].type != mmt_item &&
				base[n].type != mmt_berstring) {
			    if (base[n].type == mmt_berstring_null)
				base[n].type = mmt_berstring;
			    continue;
			}
			if (nSub < numSubElements) {
				s = skip_token(s, end_s, comma_token);
				if (s == NULL) {
					p_error = parse_bad_print_format;
					break;
				}
			}

			/* namelist may have parens around it */
			s = get_subElement(s, end_s, &subElement[nSub],
				item_type);
			if (s == NULL)
				break;
			nSub++;
		}
		if (p_error != no_parse_error)
			break;

		begin_token = s;
		end_token = end_s;
		s = get_next_token(&begin_token, &end_token, &t);
		if (s == NULL || t == no_token) {
			p_error = parse_unexpected_data_end_rule;
			break;
		} else if (t == close_paren_token) {
			doElide = FALSE;
			elide = '\0';
		} else if (t == comma_token) {
			begin_token = s;
			end_token = end_s;
			s = get_next_token(&begin_token, &end_token, &t);
			if (s != NULL && t == quoted_string_token &&
			    (end_token == begin_token + 1 ||
			    (*begin_token == ESCAPE_CHAR &&
			    end_token == begin_token + 2))) {
				if (numSubElements != 1 ||
				    subElement->type == me_extract ||
				    subElement->type == me_split) {
					p_error = parse_cannot_elide;
					break;
				}
				if (subElement->type == me_item &&
				    !subElement->element.item.repeat) {
					p_error = parse_cannot_elide;
					break;
				}
				elide = *begin_token;
				doElide = TRUE;

			} else {
				p_error = parse_bad_elide_char;
				break;
			}
			s = skip_token(s, end_s, close_paren_token);
			if (s == NULL)
				break;
		}

		e->type = me_print;
		e->element.print.fmt = base;
		e->element.print.numSubElements = numSubElements;
		e->element.print.subElement = subElement;
		e->element.print.elide = elide;
		e->element.print.doElide = doElide;

		if (p_error == no_parse_error)
			return (s);
	}
	if (base)
		free_mapping_format(base);
	if (subElement != NULL) {
		for (n = 0; n < numSubElements; n++)
			free_mapping_sub_element(&subElement[n]);
		free(subElement);
	}

	return (NULL);
}

/*
 * FUNCTION:	get_mapping_item
 *
 *	Parse attribute string to get mapping item
 *
 * RETURN VALUE:	NULL if error
 *			position of beginning next token after item
 *
 * INPUT:		the attribute value and mapping rule type
 */

static const char *
get_mapping_item(
	const char			*s,
	const char			*end_s,
	__nis_mapping_item_t		*item,
	__nis_mapping_item_type_t	type)
{
	token_type			t;
	const char			*begin_token;
	const char			*end_token;
	char				*name		= NULL;
	char				*index_string;
	const char			*s_sav;
	int				len;

	(void) memset(item, 0, sizeof (*item));

	/*
	 * A namepec is defined as follows:
	 * namespec	= ["ldap:"] attrspec [searchTriple] |
	 *		  ["nis+:"] colspec  [objectspec]
	 *
	 * The form of the item is assumed to be as follows:
	 * ["ldap:"] attrspec [searchTriple]
	 * attrspec = attribute | "(" attribute ")"
	 * searchTriple	= ":" [baseDN] ["?" [scope] ["?" [filter]]]
	 * baseDN = Base DN for search
	 * scope = "base" | "one" | "sub"
	 * filter = LDAP search filter
	 *
	 * The form of the objectspec is as follows:
	 * ["nis+:"] colspec  [objectspec]
	 * objectspec	= objectname | "[" indexlist "]" tablename
	 * objectname	= The name of a NIS+ object
	 * tablename	= The name of a NIS+ table
	 * indexlist	= colspec ["," colspec]
	 * colspec	= colname "=" colvalue
	 * colname	= The name of a column in the table
	 * colvalue	= colvaluestring | \" colvaluestring \"
	 */

	for (; p_error == no_parse_error; ) {
		while (s < end_s && is_whitespace(*s))
			s++;
		len = end_s - s;
		if (yp2ldap) {
			if ((begin_token = skip_string("ldap:", s,
				len)) != NULL) {
				item->type = mit_ldap;
			} else if ((begin_token = skip_string("yp:", s,
				len)) != NULL) {
				item->type = mit_nisplus;
			} else {
				item->type = type;
				begin_token = s;
			}
		} else {
			if ((begin_token = skip_string("ldap:", s,
				len)) != NULL) {
			item->type = mit_ldap;
			} else if ((begin_token = skip_string("nis+:", s,
				len)) != NULL) {
				item->type = mit_nisplus;
			} else if ((begin_token = skip_string("nisplus:", s,
				len)) != NULL) {
				item->type = mit_nisplus;
			} else {
				item->type = type;
				begin_token = s;
			}
		}

		end_token = end_s;
		s = get_next_token(&begin_token, &end_token, &t);
		if (s == NULL || t != string_token) {
			p_error = parse_bad_item_format;
			break;
		}

		item->name = s_strndup_esc(begin_token,
			end_token - begin_token);
		if (item->name == NULL)
			break;
		if (item->type == mit_ldap) {
			item->searchSpec.triple.scope = LDAP_SCOPE_UNKNOWN;
			begin_token = s;
			end_token = end_s;
			s_sav = s;
			s = get_next_token(&begin_token, &end_token, &t);
			if (s != NULL && t == colon_token) {
				s = get_search_triple(s, end_s,
					&item->searchSpec.triple);
				if (s == NULL)
					break;
			} else
				s = s_sav;
		} else if (item->type == mit_nisplus) {
			while (s < end_s && is_whitespace(*s))
				s++;

			if (s < end_s && *s == OPEN_BRACKET) {
				index_string = getIndex(&s, end_s);
				if (index_string == NULL)
					break;
				(void) parse_index(index_string,
					index_string + strlen(index_string),
					&item->searchSpec.obj.index);
				free(index_string);
				if (p_error != no_parse_error)
					break;
			}
			s_sav = s;
			begin_token = s;
			end_token = end_s;
			s = get_next_token(&begin_token, &end_token, &t);
			if (s != NULL && t == string_token) {
				name = s_strndup_esc(begin_token,
					end_token - begin_token);
				if (name == NULL)
					break;
				item->searchSpec.obj.name = name;
			} else
				s = s_sav;
		}
		if (p_error == no_parse_error)
			return (s);
	}
	free_mapping_item(item);
	(void) memset(item, 0, sizeof (*item));
	if (name == NULL)
		free(name);
	return (NULL);
}

static const char *
get_print_sub_element(const char		*s,
		const char			*end_s,
		__nis_mapping_item_type_t	type,
		__nis_mapping_sub_element_t	*sub)
{

	int			k;
	int			n;
	const char		*begin_token;
	const char		*end_token;
	token_type		t;
	__nis_mapping_format_t	*base;
	__nis_mapping_item_t	*print_item;

	k = 0;
	base = sub->element.print.fmt;
	print_item = sub->element.print.item;
	sub->element.print.doElide = FALSE;
	sub->element.print.elide = '\0';

	for (n = 0; base[n].type != mmt_end; n++) {
		if (base[n].type != mmt_item && base[n].type != mmt_berstring) {
			if (base[n].type == mmt_berstring_null)
					base[n].type = mmt_berstring;
			continue;
		}
		s = skip_token(s, end_s, comma_token);
		if (s == NULL) {
			p_error = parse_bad_print_format;
			break;
		}

		begin_token = s;
		end_token = end_s;
		s = get_next_token(&begin_token, &end_token, &t);
		if (s == NULL)
			break;
		/*
		 * Determine if of the form
		 * ("fmt", (item), "delim") or
		 * ("fmt", item1, item2, ..., item n)
		 */
		if (t == open_paren_token) {
			if (sub->element.print.numItems != 1) {
				p_error = parse_invalid_print_arg;
				break;
			}
			s = get_mapping_item(s, end_s, &print_item[k++], type);
			s = skip_token(s, end_s, close_paren_token);
			s = skip_token(s, end_s, comma_token);
			if (s == NULL) {
				p_error = parse_bad_print_format;
				break;
			}
			begin_token = s;
			end_token = end_s;
			s = get_next_token(&begin_token, &end_token, &t);
			if (s == NULL)
				break;
			if (t != quoted_string_token ||
				    begin_token + 1 != end_token) {
				p_error = parse_bad_elide_char;
				break;
			}
			sub->element.print.elide = *begin_token;
			sub->element.print.doElide = TRUE;
			print_item[0].repeat = TRUE;
			break;
		}
		s = get_mapping_item(begin_token, end_s,
			&print_item[k++], type);
		if (s == NULL)
			break;

		if (p_error != no_parse_error)
			break;
	}

	return (p_error == no_parse_error ? s : NULL);
}

/*
 * FUNCTION:	get_subElement
 *
 *	Parse attribute string to get sub element item
 *
 * RETURN VALUE:	NULL if error
 *			position of beginning next token after item
 *
 * INPUT:		the attribute value and mapping rule type
 */

static const char *
get_subElement(
	const char			*s,
	const char			*end_s,
	__nis_mapping_sub_element_t	*subelement,
	__nis_mapping_item_type_t	type)
{
	token_type			t;
	const char			*begin_token;
	const char			*end_token;
	char				*fmt_string;
	__nis_mapping_item_t		item;
	__nis_mapping_element_type_t	e_type;
	__nis_mapping_item_t		*print_item	= NULL;
	__nis_mapping_format_t		*base		= NULL;
	int				n		= 0;
	int				numItems	= 0;
	unsigned char			delim;
	__nis_mapping_sub_element_t	sub;

/*
 *	What is the form of we are expecting here
 *	item					me_item
 *	(item)					me_item
 *	("fmt", item1, item2, ..., item n)	me_print
 *	("fmt", (item), "elide")		me_print
 *	(name, "delim")				me_split
 *	(item, "fmt")				me_extract
 */
	(void) memset(&item, 0, sizeof (item));

	for (; p_error == no_parse_error; ) {
		begin_token = s;
		end_token = end_s;
		s = get_next_token(&begin_token, &end_token, &t);
		if (s == NULL)
			break;
		if (t == string_token) {	/* me_item */
			s = get_mapping_item(begin_token, end_s,
				&subelement->element.item, type);
			if (s == NULL)
				break;
			subelement->type = me_item;
			return (s);
		} else if (t != open_paren_token) {
			p_error = parse_item_expected_error;
			break;
		}

		begin_token = s;
		end_token = end_s;
		s = get_next_token(&begin_token, &end_token, &t);
		if (s == NULL)
			break;

		if (t != string_token && t != quoted_string_token) {
			p_error = parse_item_expected_error;
			break;
		}
		e_type = me_print;
		if (t == string_token) {
			/* me_item, me_extract or me_split */
			s = get_mapping_item(begin_token, end_s, &item, type);
			if (s == NULL)
				break;

			begin_token = s;
			end_token = end_s;
			s = get_next_token(&begin_token, &end_token, &t);
			if (s == NULL) {
				p_error = parse_unexpected_data_end_rule;
				break;
			} else if (t == close_paren_token) {
				subelement->type = me_item;
				item.repeat = TRUE;
				subelement->element.item = item;
				if (yp2ldap) {
					while (s < end_s && is_whitespace(*s))
						s++;
					if (s == end_s) {
						p_error =
						parse_unexpected_data_end_rule;
						break;
					}
					if (*s == DASH_CHAR && s < end_s) {
						s++;
						while (s < end_s &&
							is_whitespace(*s))
							s++;
						begin_token = s;
						end_token = end_s;

						subelement->element.item.exItem
							=
							(__nis_mapping_item_t *)
					s_malloc(sizeof (__nis_mapping_item_t));
						if (!subelement->
						element.item.exItem)
							break;
						s = get_mapping_item(s, end_s,
							subelement->
							element.item.exItem,
							type);
						if (s == NULL) {
							p_error =
							parse_internal_error;
							free_mapping_item(
							subelement->
							element.item.exItem);
							subelement->
							element.item.exItem =
								NULL;
							break;
						}
					}
				}
				return (s);
			} else if (t != comma_token) {
				p_error = parse_comma_expected_error;
				break;
			}

			begin_token = s;
			end_token = end_s;
			s = get_next_token(&begin_token, &end_token, &t);
			if (s == NULL || t != quoted_string_token) {
				p_error = parse_format_string_expected_error;
				break;
			}
			if (end_token == begin_token + 1 ||
			    (*begin_token == ESCAPE_CHAR &&
			    end_token == begin_token + 2)) {
					/* me_split */
				delim = (unsigned char)end_token[-1];
				s = skip_token(s, end_s, close_paren_token);
				if (s == NULL)
					break;
				subelement->element.split.item = item;
				subelement->element.split.delim = delim;
				subelement->type = me_split;
				return (s);
			}
			e_type = me_extract;
		}
		fmt_string = s_strndup(begin_token, end_token - begin_token);
		if (fmt_string == NULL)
			break;
		if (!get_mapping_format(fmt_string, &base, &n, &numItems,
		    e_type == me_print)) {
			free(fmt_string);
			break;
		}
		free(fmt_string);

		if (numItems != 1 && e_type == me_extract) {
			p_error = numItems == 0 ?
				parse_not_enough_extract_items :
				parse_too_many_extract_items;
			break;
		} else if (numItems > 0 && e_type == me_print) {
			print_item = (__nis_mapping_item_t *)s_calloc(numItems,
				sizeof (__nis_mapping_item_t));
			if (print_item == NULL)
				break;
		}

		if (e_type == me_print) {
			sub.element.print.numItems = numItems;
			sub.element.print.fmt = base;
			sub.element.print.item = print_item;
			s = get_print_sub_element(s, end_s, type, &sub);
			if (s == NULL)
				break;
		}
		s = skip_token(s, end_s, close_paren_token);
		if (s == NULL)
			break;

		subelement->type = e_type;
		if (e_type == me_extract) {
			subelement->element.extract.fmt = base;
			subelement->element.extract.item = item;
		} else {
			subelement->type = me_print;
			subelement->element.print.fmt = base;
			subelement->element.print.numItems = numItems;
			subelement->element.print.item = print_item;
			subelement->element.print.doElide =
				sub.element.print.doElide;
			subelement->element.print.elide =
				sub.element.print.elide;
		}
		if (p_error == no_parse_error)
			return (s);
	}
	free_mapping_item(&item);
	if (base != NULL)
		free_mapping_format(base);
	if (print_item) {
		for (n = 0; n < numItems; n++)
			free_mapping_item(&print_item[n]);
		free(print_item);
	}

	return (NULL);
}

/*
 * FUNCTION:	skip_get_dn
 *
 *	Get first token after dn
 *
 * RETURN VALUE:	NULL if error (not valid dn)
 *			position of beginning next token after dn
 *
 * INPUT:		the attribute value
 */

const char *
skip_get_dn(const char *dn, const char *end)
{
	size_t		len		= 0;
	bool_t		in_quote	= FALSE;
	bool_t		goteq		= FALSE;
	bool_t		gotch		= FALSE;
	bool_t		done		= FALSE;
	bool_t		last_comma	= FALSE;
	const char	*last_dn	= dn;

	while (!done) {
		dn += len;
		if (last_comma) {
			last_dn = dn;
			last_comma = FALSE;
		}
		if (dn >= end)
			break;
		len = 1;
		switch (*dn) {
			case ESCAPE_CHAR:
				len = 2;
				gotch = TRUE;
				break;
			case DOUBLE_QUOTE_CHAR:
				in_quote = !in_quote;
				break;
			case QUESTION_MARK:
			case CLOSE_PAREN_CHAR:
			case COLON_CHAR:
				done = !in_quote;
				/* FALLTHRU */
			case SEMI_COLON_CHAR:
			case PLUS_SIGN:
			case COMMA_CHAR:
				if (!in_quote) {
					if (!goteq || !gotch)
						return (last_dn);
					goteq = FALSE;
					gotch = FALSE;
					if (*dn != PLUS_SIGN)
						last_dn = dn;
					last_comma = *dn == COMMA_CHAR;
				} else {
					gotch = TRUE;
				}
				break;
			case EQUAL_CHAR:
				if (!in_quote) {
					if (!gotch || goteq)
						return (NULL);
					goteq = TRUE;
					gotch = FALSE;
				} else {
					gotch = TRUE;
				}
				break;
			default:
				if (!is_whitespace(*dn))
					gotch = TRUE;
				break;
		}
	}

	if (dn == end) {
		if (!in_quote && goteq && gotch)
			last_dn = dn;
	}

	return (last_dn);
}

/*
 * FUNCTION:	get_ldap_filter_element
 *
 *	Get an ldap filter element for a given string
 *
 * RETURN VALUE:	NULL if error
 *			__nis_mapping_element_t if success
 *
 * INPUT:		the string to parse
 */

static __nis_mapping_element_t *
get_ldap_filter_element(
	const char			*s,
	const char			*end_s
)
{
	token_type			t;
	const char			*begin_token;
	const char			*end_token;
	char				*format_str;
	__nis_mapping_element_t		*e		= NULL;

	begin_token = s;
	end_token = end_s;
	s = get_next_token(&begin_token, &end_token, &t);
	if (s == NULL || t != open_paren_token)
		return (NULL);

	begin_token = s;
	end_token = end_s;
	s = get_next_token(&begin_token, &end_token, &t);
	if (s == NULL || t != quoted_string_token)
		return (NULL);

	format_str = s_strndup(begin_token, end_token - begin_token);
	if (format_str == NULL)
		return (NULL);
	e = (__nis_mapping_element_t *)
		s_calloc(1, sizeof (__nis_mapping_element_t));
	if (e != NULL) {
		(void) get_print_mapping_element(s, end_s,
				format_str, e, mit_nisplus);
		if (p_error != no_parse_error) {
			free_mapping_element(e);
			e = NULL;
		}
	}
	free(format_str);
	return (e);
}

/*
 * FUNCTION:	get_search_triple
 *
 *	Get the search triple or if NULL determine if valid
 *
 * RETURN VALUE:	NULL if error
 *			position of beginning next token after
 *			search triple
 *
 * INPUT:		the attribute value
 */

const char *
get_search_triple(
	const char			*s,
	const char			*end_s,
	__nis_search_triple_t		*triple
)
{
	const char	*begin_token;
	const char	*end_token;
	char		*search_base	= NULL;
	int		scope		= LDAP_SCOPE_ONELEVEL;
	char		*filter		= NULL;
	const char	*s1;
	__nis_mapping_element_t
			*element	= NULL;

	/*
	 * The form of the searchTriple is assumed to be as follows:
	 * searchTriple	= [baseDN] ["?" [scope] ["?" [filter]]]
	 * baseDN = Base DN for search
	 * scope = "base" | "one" | "sub"
	 * filter = LDAP search filter
	 */
	for (; p_error == no_parse_error; ) {
		while (s < end_s && is_whitespace(*s))
			s++;
		if (s == end_s)
			break;

		if (!IS_TERMINAL_CHAR(*s)) {
			begin_token = s;
			s = skip_get_dn(begin_token, end_s);
			if (s == NULL) {
				p_error = parse_invalid_dn;
				break;
			}
			if (triple != NULL) {
				search_base = s_strndup(begin_token,
					s - begin_token);
				if (search_base == NULL)
					break;
			}
			while (s < end_s && is_whitespace(*s))
				s++;
			if (s == end_s)
				break;
		}

		if (!IS_TERMINAL_CHAR(*s)) {
			p_error = parse_bad_ldap_item_format;
			break;
		}
		if (*s != QUESTION_MARK)
			break;

		s++;
		while (s < end_s && is_whitespace(*s))
			s++;
		if (s == end_s)
			break;

		/* base, one, or sub, or empty value */
		if (!IS_TERMINAL_CHAR(*s)) {
			if ((s1 = skip_string("base", s, end_s - s)) != NULL) {
				scope = LDAP_SCOPE_BASE;
			} else if ((s1 = skip_string("one", s, end_s - s)) !=
					NULL) {
				scope = LDAP_SCOPE_ONELEVEL;
			} else if ((s1 = skip_string("sub", s, end_s - s)) !=
					NULL) {
				scope = LDAP_SCOPE_SUBTREE;
			} else if (s + 1 < end_s && *s != QUESTION_MARK) {
				p_error = parse_invalid_scope;
				break;
			}
			if (s1 != NULL)
				s = s1;
			while (s < end_s && is_whitespace(*s))
				s++;
		}

		if (s == end_s)
			break;
		if (*s != QUESTION_MARK)
			break;
		s++;
		while (s < end_s && is_whitespace(*s))
			s++;
		if (s == end_s || IS_TERMINAL_CHAR(*s))
			break;

		/* LDAP search filter */
		if (*s == OPEN_PAREN_CHAR) {
		    begin_token = s;
		    end_token = end_s;
		    s = get_ldap_filter(&begin_token, &end_token);
		    if (s == NULL)
			break;
		    s = end_token;
		    element = get_ldap_filter_element(begin_token, end_token);
		    if (element != NULL)
			break;
		} else {
		    begin_token = s;
		    end_token = end_s;
		    s = get_ava_list(&begin_token, &end_token, TRUE);
		    if (s == NULL)
			break;
		    s = end_token;
		}
		if (triple != NULL)
			filter = s_strndup(begin_token, s - begin_token);
		if (p_error == no_parse_error)
			break;
	}
	if (p_error == no_parse_error && triple != NULL) {
		triple->base = search_base;
		triple->scope = scope;
		triple->attrs = filter;
		triple->element = element;
		element = NULL;
		filter = NULL;
		search_base = NULL;
	}

	if (search_base != NULL)
		free(search_base);
	if (filter != NULL)
		free(filter);
	if (element != NULL) {
		free_mapping_element(element);
		free(element);
	}
	return (p_error == no_parse_error ? s : NULL);
}

/*
 * FUNCTION:	get_mapping_format
 *
 *	Get the __nis_mapping_format_t from the string
 *
 * RETURN VALUE:	FALSE if error
 *			TRUE if __nis_mapping_format_t returned
 *
 * INPUT:		the format string
 */

static bool_t
get_mapping_format(
	const char		*fmt_string,
	__nis_mapping_format_t	**fmt,
	int			*nfmt,
	int			*numItems,
	bool_t			print_mapping)
{
	const char		*f	= fmt_string;
	const char		*ef;
	__nis_mapping_format_t	*b;
	__nis_mapping_format_t	*base	= NULL;
	int			n	= 0;
	int			nItems	= 0;

	f = fmt_string;
	ef = f + strlen(f);
	base = (__nis_mapping_format_t *)
	    s_calloc(1, sizeof (__nis_mapping_format_t));

	if (base == NULL)
		return (FALSE);
	base->type = mmt_begin;
	n++;

	for (;;) {
		b = (__nis_mapping_format_t *)s_realloc(
		    base, (n + 1) * sizeof (__nis_mapping_format_t));

		if (b == NULL)
			break;
		base = b;
		base[n].type = mmt_end;
		if (f == ef) {
			if (nfmt)
				*nfmt = n + 1;
			*fmt = base;
			if (numItems)
				*numItems = nItems;
			return (TRUE);
		}
		if (print_mapping)
		    f = get_next_print_format_item(f, ef, &base[n]);
		else
		    f = get_next_extract_format_item(f, ef, &base[n]);


		if (f == NULL)
			break;
		if (base[n].type == mmt_item ||
			base[n].type == mmt_berstring)
			nItems++;
		n++;
	}
	if (base != NULL)
		free_mapping_format(base);
	return (FALSE);
}

/*
 * FUNCTION:	getIndex
 *
 *	Returns a string containing the index
 *
 * RETURN VALUE:	NULL if error
 *			a string containing the index
 *
 * INPUT:		attribute containing the index
 */

static char *
getIndex(const char **s_cur, const char *s_end)
{
	const char	*s		= *s_cur + 1;
	const char	*s1;
	char		*s_index;
	char		*s_index1;
	char		*s_index_end;
	int		n_brackets	= 1;
	bool_t		in_quotes	= FALSE;
	char		*index		= NULL;

	while (s < s_end && is_whitespace(*s))
		s++;
	for (s1 = s; s1 < s_end; s1++) {
		if (*s1 == ESCAPE_CHAR)
			s1++;
		else if (*s1 == DOUBLE_QUOTE_CHAR) {
			in_quotes = !in_quotes;
		} else if (in_quotes)
			;
		else if (*s1 == CLOSE_BRACKET) {
			if (--n_brackets == 0)
				break;
		} else if (*s1 == OPEN_BRACKET)
			n_brackets++;
	}

	if (n_brackets == 0) {
		index = s_strndup(s, s1 - s);
		if (index != NULL) {
			s_index_end = index + (s1 - s);
			s_index1 = index;
			for (s_index = index; s_index < s_index_end;
			    s_index++) {
				if (*s_index == ESCAPE_CHAR) {
					*s_index1++ = *s_index++;
				} else if (*s_index == DOUBLE_QUOTE_CHAR) {
					in_quotes = !in_quotes;
				} else if (!in_quotes &&
				    is_whitespace(*s_index)) {
					continue;
				}
				*s_index1++ = *s_index;
			}
			*s_index1 = *s_index;

			s = s1 + 1;

			while (s < s_end && is_whitespace(*s))
				s++;
			*s_cur = s;
		}
	} else
		p_error = parse_mismatched_brackets;

	return (index);
}

/*
 * FUNCTION:	parse_index
 *
 *	Parse attribute string to get __nis_index_t
 *
 * RETURN VALUE:	FALSE if error
 *			TRUE if __nis_index_t returned
 *
 * INPUT:		the attribute value to parse
 */

bool_t
parse_index(const char *s, const char *end_s, __nis_index_t *index)
{
	const char		*begin_token;
	const char		*end_token;
	char			*name_str	= NULL;
	char			**name;
	char			*fmt_string	= NULL;
	__nis_mapping_format_t	*v		= NULL;
	__nis_mapping_format_t	**value;
	token_type		t;
	int			n		 = 0;

	if (index != NULL)
		(void) memset(index, 0, sizeof (*index));

	while (s < end_s) {
		if (n > 0) {
			s = skip_token(s, end_s, comma_token);
			if (s == NULL) {
				p_error = parse_bad_index_format;
				break;
			}
		}
		begin_token = s;
		end_token = end_s;
		s = get_next_token(&begin_token, &end_token, &t);
		if (s == NULL)
			break;
		if (t != string_token) {
			p_error = parse_bad_index_format;
			break;
		}
		s = skip_token(s, end_s, equal_token);
		if (s == NULL) {
			p_error = parse_bad_index_format;
			break;
		}
		if (index != NULL) {
			name_str = s_strndup_esc(begin_token,
				end_token - begin_token);
			if (name_str == NULL)
				break;
		}
		begin_token = s;
		end_token = end_s;
		s = get_next_token(&begin_token, &end_token, &t);
		if (s == NULL)
			break;
		if (t != string_token && t != quoted_string_token) {
			p_error = parse_bad_index_format;
			break;
		}
		fmt_string = s_strndup(begin_token, end_token - begin_token);
		if (fmt_string == NULL)
			break;
		if (!get_mapping_format(fmt_string, &v, NULL, NULL, FALSE))
			break;
		free(fmt_string);
		fmt_string = NULL;
		if (index != NULL) {
			name = s_realloc(index->name,
				(n + 1) * sizeof (char *));
			if (name == NULL)
				break;
			value = s_realloc(index->value,
				(n + 1) * sizeof (__nis_mapping_format_t *));
			if (value == NULL)
				break;
			name[n] = name_str;
			name_str = NULL;
			value[n] = v;
			v = NULL;
			index->numIndexes = ++n;
			index->name = name;
			index->value = value;
		} else if (v != NULL) {
			free_mapping_format(v);
			v = NULL;
		}
	}
	if (p_error != no_parse_error) {
		if (name_str != NULL)
			free(name_str);
		if (v != NULL)
			free_mapping_format(v);
		if (fmt_string != NULL)
			free(fmt_string);
		if (index != NULL)
			free_index(index);
	}
	return (p_error != no_parse_error);
}

/*
 * FUNCTION:	get_deleteDisp
 *
 *	Parse deleteDisp. Sets p_error if an error occurred.
 *
 * RETURN VALUE:	TRUE on success
 *			FAILURE on failure
 *
 * INPUT:		begin and end of string and __nis_object_dn_t
 */

static bool_t
get_deleteDisp(const char *s_begin, const char *s_end,
		__nis_object_dn_t *obj_dn)
{
	/*
	 * deleteDisp: "always" | perDbId | "never"
	 * perDbId: "dbid" "=" delDatabaseId
	 */

	if (same_string("always", s_begin, s_end - s_begin)) {
		obj_dn->delDisp = dd_always;
	} else if (same_string("never", s_begin, s_end - s_begin)) {
		obj_dn->delDisp = dd_never;
	} else if ((s_begin = skip_string("dbid", s_begin, s_end - s_begin))
			!= NULL) {
		obj_dn->delDisp = dd_perDbId;
		while (s_begin < s_end && is_whitespace(*s_begin))
			s_begin++;
		if (s_begin == s_end || *s_begin != EQUAL_CHAR) {
			p_error = parse_object_dn_syntax_error;
		} else {
			s_begin++;
			while (s_begin < s_end && is_whitespace(*s_begin))
				s_begin++;
			while (s_begin < s_end && is_whitespace(s_end[-1]))
				s_end--;
			if (s_begin == s_end) {
				p_error = parse_object_dn_syntax_error;
			} else {
				obj_dn->dbIdName =
					s_strndup(s_begin, s_end - s_begin);
			}
		}
	} else {
		p_error = parse_object_dn_syntax_error;
	}
	return (p_error == no_parse_error);
}