lib/libnisdb/ldap_val.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


#include <lber.h>
#include <ldap.h>
#include <strings.h>
#include <errno.h>

#include "nisdb_mt.h"

#include "ldap_util.h"
#include "ldap_op.h"
#include "ldap_ruleval.h"
#include "ldap_attr.h"
#include "ldap_val.h"
#include "ldap_ldap.h"

extern int yp2ldap;


__nis_mapping_format_t *
cloneMappingFormat(__nis_mapping_format_t *m) {
	__nis_mapping_format_t	*new;
	int			i, nf, err;
	char			*myself = "cloneMappingFormat";

	if (m == 0)
		return (0);

	for (nf = 0; m[nf].type != mmt_end; nf++);
	nf++;

	new = am(myself, nf * sizeof (new[0]));
	if (new == 0)
		return (0);

	/* Copy the whole array */
	memcpy(new, m, nf * sizeof (new[0]));

	/* Make copies of allocated stuff */
	for (i = 0, err = 0; i < nf; i++) {
		switch (m[i].type) {
		case mmt_string:
			new[i].match.string = sdup(myself, T,
							m[i].match.string);
			if (new[i].match.string == 0 && m[i].match.string != 0)
				err++;
			break;
		case mmt_single:
			new[i].match.single.lo =
				am(myself, m[i].match.single.numRange *
					sizeof (new[i].match.single.lo[0]));
			new[i].match.single.hi =
				am(myself, m[i].match.single.numRange *
					sizeof (new[i].match.single.hi[0]));
			if (new[i].match.single.lo != 0)
				memcpy(new[i].match.single.lo,
					m[i].match.single.lo,
					m[i].match.single.numRange);
			else if (m[i].match.single.lo != 0)
				err++;
			if (new[i].match.single.hi != 0)
				memcpy(new[i].match.single.hi,
					m[i].match.single.hi,
					m[i].match.single.numRange);
			else if (m[i].match.single.hi != 0)
				err++;
			break;
		case mmt_berstring:
			new[i].match.berString = sdup(myself, T,
							m[i].match.berString);
			if (new[i].match.berString == 0 &&
					m[i].match.berString != 0)
				err++;
			break;
		case mmt_item:
		case mmt_limit:
		case mmt_any:
		case mmt_begin:
		case mmt_end:
		default:
			break;
		}
	}

	/* If there were memory allocation errors, free the copy */
	if (err > 0) {
		freeMappingFormat(new);
		new = 0;
	}

	return (new);
}

void
freeMappingFormat(__nis_mapping_format_t *m) {
	int	i;

	if (m == 0)
		return;

	for (i = 0; m[i].type != mmt_end; i++) {
		switch (m[i].type) {
		case mmt_string:
			sfree(m[i].match.string);
			break;
		case mmt_single:
			sfree(m[i].match.single.lo);
			sfree(m[i].match.single.hi);
			break;
		case mmt_berstring:
			sfree(m[i].match.berString);
			break;
		case mmt_item:
		case mmt_limit:
		case mmt_any:
		case mmt_begin:
		case mmt_end:
		default:
			break;
		}
	}

	free(m);
}


void
copyIndex(__nis_index_t *old, __nis_index_t *new, int *err) {
	int	i;
	char	*myself = "copyIndex";

	if (old == 0 || new == 0) {
		*err = EINVAL;
		return;
	}

	for (i = 0; i < old->numIndexes; i++) {
		new->name[i] = sdup(myself, T, old->name[i]);
		if (new->name[i] == 0 && old->name[i] != 0) {
			*err = ENOMEM;
			return;
		}
		new->value[i] = cloneMappingFormat(old->value[i]);
		if (new->value[i] == 0 && old->value[i] != 0) {
			*err = ENOMEM;
			return;
		}
	}

	new->numIndexes = old->numIndexes;
}

__nis_index_t *
cloneIndex(__nis_index_t *old) {
	char		*myself = "cloneIndex";
	int		err = 0;
	__nis_index_t	*new = am(myself, sizeof (*new));

	if (old == 0)
		return (0);

	if (new != 0) {
		copyIndex(old, new, &err);
		if (err != 0) {
			freeIndex(new, 1);
			new = 0;
		}
	}

	return (new);
}

void
freeIndex(__nis_index_t *old, bool_t doFree) {
	int	i;

	if (old == 0)
		return;

	for (i = 0; i < old->numIndexes; i++) {
		sfree(old->name[i]);
		freeMappingFormat(old->value[i]);
	}

	if (doFree)
		free(old);
}

char **
cloneName(char **name, int numNames) {
	char	**new;
	int	i;
	char	*myself = "cloneName";

	if (name == 0 || numNames <= 0)
		return (0);

	new = am(myself, numNames * sizeof (new[0]));
	if (new == 0)
		return (0);

	for (i = 0; i < numNames; i++) {
		if (name[i] != 0) {
			new[i] = sdup(myself, T, name[i]);
			if (new[i] == 0) {
				for (i--; i >= 0; i--) {
					sfree(new[i]);
				}
				sfree(new);
				return (0);
			}
		} else {
			new[i] = 0;
		}
	}

	return (new);
}

void
freeValue(__nis_value_t *val, int count) {
	int	c, i;

	if (val == 0)
		return;

	for (c = 0; c < count; c++) {
		if (val[c].val != 0) {
			for (i = 0; i < val[c].numVals; i++) {
				sfree(val[c].val[i].value);
			}
			free(val[c].val);
		}
	}

	free(val);
}

__nis_value_t *
cloneValue(__nis_value_t *val, int count) {
	__nis_value_t	*n;
	int		c, i;
	char		*myself = "cloneValue";

	if (count <= 0 || val == 0)
		return (0);

	n = am(myself, count * sizeof (*n));
	if (n == 0)
		return (0);

	for (c = 0; c < count; c++) {
		n[c].type = val[c].type;
		n[c].repeat = val[c].repeat;
		n[c].numVals = val[c].numVals;
		if (n[c].numVals > 0) {
			n[c].val = am(myself, n[c].numVals *
						sizeof (n[c].val[0]));
			if (n[c].val == 0) {
				freeValue(n, c);
				return (0);
			}
		} else {
			n[c].val = 0;
		}
		for (i = 0; i < n[c].numVals; i++) {
			int	amlen = val[c].val[i].length;

			/*
			 * The functions that create string values try to
			 * make sure that there's a NUL at the end. However,
			 * both NIS+ and LDAP have a tendency to store strings
			 * without a NUL, so the value length may not include
			 * the NUL (even though it's there). In order to
			 * preserve that NUL, we add a byte to the length if
			 * the type is vt_string, and there isn't already a
			 * NUL at the end. The memory allocation function
			 * (am()) will take care of actually putting the NUL
			 * in place, since it allocates zero-initialized
			 * memory.
			 */
			n[c].val[i].length = val[c].val[i].length;
			if (n[c].type == vt_string && amlen > 0 &&
				((char *)val[c].val[i].value)[amlen-1] !=
					'\0') {
				amlen++;
			}
			n[c].val[i].value = am(myself, amlen);
			if (amlen > 0 && n[c].val[i].value == 0) {
				freeValue(n, c);
				return (0);
			}
			memcpy(n[c].val[i].value, val[c].val[i].value,
				n[c].val[i].length);
		}
	}

	return (n);
}

/* Define LBER_USE_DER per ber_decode(3LDAP) */
#ifndef	LBER_USE_DER
#define	LBER_USE_DER	0x01
#endif	/* LBER_USE_DER */

/*
 * Return a copy of 'valIn' where each value has been replaced by the
 * BER encoded equivalent specified by 'berstring'. 'valIn' is unchanged.
 */
__nis_value_t *
berEncode(__nis_value_t *valIn, char *berstring) {
	char		*myself = "berEncode";
	__nis_value_t	*val;
	int		i;

	if (valIn == 0 || berstring == 0)
		return (0);

	val = cloneValue(valIn, 1);
	if (val == 0)
		return (0);

	for (i = 0; i < val->numVals; i++) {
		BerElement	*ber = ber_alloc();
		struct berval	*bv = 0;
		int		ret;

		if (ber == 0) {
			logmsg(MSG_NOMEM, LOG_ERR, "%s: ber_alloc() => NULL",
				myself);
			freeValue(val, 1);
			return (0);
		}

		if ((strcmp("b", berstring) == 0 ||
				strcmp("i", berstring) == 0)) {
			if (val->val[i].length >= sizeof (int)) {
				ret = ber_printf(ber, berstring,
					*((int *)(val->val[i].value)));
			} else {
				ret = -1;
			}
		} else if (strcmp("B", berstring) == 0) {
			ret = ber_printf(ber, berstring,
				val->val[i].value,
				val->val[i].length * 8);
		} else if (strcmp("n", berstring) == 0) {
			ret = ber_printf(ber, berstring);
		} else if (strcmp("o", berstring) == 0) {
			ret = ber_printf(ber, berstring,
				val->val[i].value, val->val[i].length);
		} else if (strcmp("s", berstring) == 0) {
			char	*str = am(myself, val->val[i].length + 1);

			if (str != 0) {
				ret = ber_printf(ber, berstring, str);
				free(str);
			} else {
				ret = -1;
			}
		} else {
			ret = -1;
		}

		if (ret == -1) {
			reportError(NPL_BERENCODE, "%s: BER encoding error",
					myself);
			ber_free(ber, 1);
			freeValue(val, 1);
			return (0);
		}

		if (ber_flatten(ber, &bv) != 0 || bv == 0) {
			reportError(NPL_BERENCODE, "%s: ber_flatten() error",
					myself);
			ber_free(ber, 1);
			freeValue(val, 1);
			return (0);
		}

		sfree(val->val[i].value);
		val->val[i].length = bv->bv_len;
		val->val[i].value = bv->bv_val;

		ber_free(ber, 1);
	}

	val->type = vt_ber;

	return (val);
}

__nis_value_t *
berDecode(__nis_value_t *valIn, char *berstring) {
	__nis_value_t	*val;
	int		i;
	char		*myself = "berDecode";

	if (valIn == 0 || berstring == 0)
		return (0);

	val = cloneValue(valIn, 1);
	if (val == 0)
		return (0);

	for (i = 0; i < val->numVals; i++) {
		void		*v = 0;
		int		ret, len = 0;
		struct berval	bv;
		BerElement	*ber;

		if (val->val[i].value == 0 || val->val[i].length <= 0)
			continue;

		bv.bv_val = val->val[i].value;
		bv.bv_len = val->val[i].length;
		ber = ber_init(&bv);
		if (ber == 0) {
			reportError(NPL_BERDECODE, "%s: ber_init() error",
				myself);
			freeValue(val, 1);
			return (0);
		}

		if ((strcmp("b", berstring) == 0 ||
				strcmp("i", berstring) == 0)) {
			len = sizeof (int);
			v = am(myself, len);
			if (v != 0) {
				ret = ber_scanf(ber, berstring, v);
			} else {
				ret = -1;
			}
		} else if (strcmp("B", berstring) == 0) {
			long	llen;

			ret = ber_scanf(ber, berstring, &v, &llen);
			if (ret != -1) {
				len = llen/8;
			}
		} else if (strcmp("n", berstring) == 0) {
			ret = 0;
		} else if (strcmp("o", berstring) == 0) {
			struct berval	*bv = am(myself, sizeof (*bv));

			if (bv != 0) {
				ret = ber_scanf(ber, "O", &bv);
				if (ret != -1 && bv != 0) {
					v = bv->bv_val;
					len = bv->bv_len;
				} else {
					ret = -1;
				}
				/* Only free 'bv' itself */
				free(bv);
			} else {
				ret = -1;
			}
		} else if (strcmp("s", berstring) == 0) {
			ret = ber_scanf(ber, "a", &v);
			if (ret != -1) {
				len = slen(v);
			}
		} else {
			ret = -1;
		}

		if (ret == -1) {
			reportError(NPL_BERDECODE, "%s: BER decoding error",
					myself);
			freeValue(val, 1);
			return (0);
		}

		/* Free the old value, and replace it with the decoded one */
		sfree(val->val[i].value);
		val->val[i].value = v;
		val->val[i].length = len;
	}

	return (val);
}

/*
 * Return the value of the specified item.
 */
__nis_value_t *
getMappingItemVal(__nis_mapping_item_t *item, __nis_mapping_item_type_t native,
		__nis_rule_value_t *rv, char *berstring, int *np_ldap_stat) {
	__nis_value_t				*val = 0, *nameVal, *exVal = 0;
	int					numName, caseInsens, cmp;
	int					i, j, k;
	char					**name;
	enum {rvOnly, rvThenLookup, lookupOnly}	check;
	unsigned char				fromldap = '\0';

	if (item == 0)
		return (0);

	/*
	 * First, we decide if we should look for the value in 'rv',
	 * directly from NIS+/LDAP, or both.
	 */
	switch (item->type) {
	case mit_nisplus:
		/* Do we have a valid index/object spec ? */
		if (item->searchSpec.obj.index.numIndexes <= 0 &&
				item->searchSpec.obj.name == 0) {
			/*
			 * No valid index/object. If we have a rule-value,
			 * use it. Otherwise, return error.
			 */
			if (rv != 0) {
				name = rv->colName;
				nameVal = rv->colVal;
				numName = rv->numColumns;
				caseInsens = 0;
				check = rvOnly;
			} else {
				return (0);
			}
		} else {
			/*
			 * Valid index, so skip the rule-value and do
			 * a direct NIS+ lookup.
			 */
			check = lookupOnly;
		}
		break;
	case mit_ldap:
		if (rv != 0) {
			name = rv->attrName;
			nameVal = rv->attrVal;
			numName = rv->numAttrs;
			caseInsens = 1;
			fromldap = '1';
		}
		/* Do we have a valid triple ? */
		if (item->searchSpec.triple.scope == LDAP_SCOPE_UNKNOWN) {
			/*
			 * No valid triple. If we have a rule-value, use it.
			 * Otherwise, return error.
			 */
			if (rv != 0) {
				check = rvOnly;
			} else {
				return (0);
			}
		} else if (item->searchSpec.triple.base == 0 &&
				item->searchSpec.triple.scope ==
					LDAP_SCOPE_ONELEVEL &&
				item->searchSpec.triple.attrs == 0 &&
				item->searchSpec.triple.element == 0) {
			/*
			 * We have a valid triple, but it points to the
			 * current LDAP container. Thus, first look in
			 * the rule-value; if that fails, perform a direct
			 * LDAP lookup.
			 */
			if (rv != 0) {
				check = rvThenLookup;
			} else {
				check = lookupOnly;
			}
		} else {
			/*
			 * Valid triple, and it's not the current container
			 * (at least not in the trivial sense). Hence, do
			 * a direct LDAP lookup.
			 */
			check = lookupOnly;
		}
		break;
	default:
		return (0);
	}

	/* Check the rule-value */
	if (check == rvOnly || check == rvThenLookup) {
		for (i = 0; i < numName; i++) {
			if (caseInsens)
				cmp = strcasecmp(item->name, name[i]);
			else
				cmp = strcmp(item->name, name[i]);
			if (cmp == 0) {
				if (nameVal[i].numVals <= 0)
					break;
				if (berstring == 0) {
					val = cloneValue(&nameVal[i], 1);
				} else if (yp2ldap && berstring[0] == 'a') {
					val = cloneValue(&nameVal[i], 1);
				} else {
					val = berDecode(&nameVal[i],
						berstring);
				}
				if (val != 0) {
					val->repeat = item->repeat;
					/*
					 * If value for nis+ column is
					 * passed with value, val is
					 * manipulated in cloneValue().
					 * To decide whether there are
					 * enough nis+ column values
					 * for rule to produce a value,
					 * we need nis+ column values
					 * as well as nis_mapping_element
					 * from the rule. If we are here,
					 * it indicates that the 'val has
					 * an valid value for the column
					 * item-> name. So set
					 * NP_LDAP_MAP_SUCCESS
					 * to np_ldap-stat.
					 */

					if (np_ldap_stat != NULL)
						*np_ldap_stat =
							NP_LDAP_MAP_SUCCESS;
				}
				break;
			}
		}
	}

	/* Do a direct lookup ? */
	if (val == 0 && (check == rvThenLookup || check == lookupOnly)) {
		if (item->type == mit_ldap) {
			int	err = 0;
			__nis_search_triple_t	triple;
			char			*baseDN;

			/*
			 * If item->searchSpec.triple.base is NULL, or ends
			 * in a comma, append the current search base from
			 * the TSD (put there by an upper layer).
			 *
			 * Special case for N2L mode:
			 * if item->searchSpec.triple.base ends in a comma,
			 * the current domain Context is used.
			 */
			if (yp2ldap && item->searchSpec.triple.base &&
				strlen(item->searchSpec.triple.base) > 0) {
				baseDN = __nisdb_get_tsd()->domainContext;
			} else {
				baseDN = __nisdb_get_tsd()->searchBase;
			}
			triple.base = appendBase(item->searchSpec.triple.base,
				baseDN, &err, 0);
			if (err == 0) {
				triple.scope = item->searchSpec.triple.scope;
				triple.attrs = item->searchSpec.triple.attrs;
				triple.element =
					item->searchSpec.triple.element;
				val = lookupLDAP(&triple, item->name, rv, 0,
					np_ldap_stat);
				fromldap = '1';
			} else {
				val = 0;
			}
			sfree(triple.base);
		}
	}


	/* Special processing for NIS to LDAP mode */
	if (yp2ldap && val != 0) {

		/*
		 * Escape special chars from dn before sending to DIT,
		 * provided val is not ldap-based
		 */
		if (fromldap == '\0' && __nisdb_get_tsd()->escapeFlag == '1') {
			if (escapeSpecialChars(val) < 0) {
				freeValue(val, 1);
				return (0);
			}
		} else if (__nisdb_get_tsd()->escapeFlag == '2') {
			/* Remove escape chars from data received from DIT */
			(void) removeEscapeChars(val);
		}

		/*
		 * Remove from 'val', any values obtained using
		 * the 'removespec' syntax
		 */

		/* Obtain exVal */
		if (item->exItem)
			exVal = getMappingItemVal(item->exItem, native, rv,
			    berstring, NULL);

		/* delete */
		if (exVal != 0) {
			for (i = 0; i < val->numVals; ) {
				for (j = 0; j < exVal->numVals; j++) {
					if (sstrncmp(val->val[i].value,
							exVal->val[j].value,
							MAX(val->val[i].length,
							exVal->val[j].length))
							== 0)
						break;
				}
				if (j < exVal->numVals) {
					sfree(val->val[i].value);
					val->val[i].value = 0;
					val->val[i].length = 0;
					for (k = i; k < val->numVals - 1; k++) {
						val->val[k] = val->val[k + 1];
						val->val[k + 1].value = 0;
						val->val[k + 1].length = 0;
					}
					val->numVals--;
				} else
					i++;
			}

			freeValue(exVal, 1);

			/*
			 * If val->numVals <= 0, then we have no val to
			 * return. So free up stuff.
			 */
			if (val->numVals <= 0) {
				free(val->val);
				val->val = 0;
				free(val);
				return (0);
			}
		}
	}

	return (val);
}

__nis_value_t *
getMappingFormat(__nis_mapping_format_t *f, __nis_rule_value_t *rv,
			__nis_format_arg_t at, void *a, int *numArg) {
	char		*myself = "getMappingFormat";
	__nis_value_t	*val = 0;
	__nis_buffer_t	b = {0, 0};
	int		i;

	if (f == 0)
		return (0);

	if (rv == 0) {
		val = am(myself, sizeof (*val));
		if (val == 0)
			return (0);

		switch (f->type) {
		case mmt_item:
			bp2buf(myself, &b, "%%s");
			break;
		case mmt_string:
			bp2buf(myself, &b, "%s", NIL(f->match.string));
			break;
		case mmt_single:
			bp2buf(myself, &b, "[");
			for (i = 0; i < f->match.single.numRange; i++) {
				if (f->match.single.lo[i] ==
						f->match.single.hi[i])
					bp2buf(myself, &b, "%c",
						f->match.single.lo[i]);
				else
					bp2buf(myself, &b, "%c-%c",
						f->match.single.lo[i],
						f->match.single.hi[i]);
			}
			bp2buf(myself, &b, "]");
			break;
		case mmt_limit:
			break;
		case mmt_any:
			bp2buf(myself, &b, "*");
			break;
		case mmt_berstring:
			bp2buf(myself, &b, "%s", NIL(f->match.berString));
			break;
		case mmt_begin:
		case mmt_end:
			bp2buf(myself, &b, "\"");
			break;
		default:
			bp2buf(myself, &b, "<unknown>");
		}
		val->type = vt_string;
		val->numVals = 1;
		val->val = am(myself, sizeof (val->val[0]));
		if (val->val == 0) {
			sfree(val);
			return (0);
		}
		val->val[0].value = b.buf;
		val->val[0].length = b.len;
	} else {
		switch (f->type) {
		case mmt_item:
		case mmt_berstring:
			if (a != 0) {
				if (at == fa_item) {
					val = getMappingItemVal(
						(__nis_mapping_item_t *)a,
						mit_any, rv,
		(f->type == mmt_berstring) ? f->match.berString : 0, NULL);
					if (numArg != 0)
						(*numArg)++;
				} else {
					val = cloneValue(
						(__nis_value_t *)a, 1);
					if (numArg != 0)
						(*numArg)++;
				}
			}
			break;
		case mmt_string:
			val = am(myself, sizeof (*val));
			if (val == 0)
				return (0);
			val->type = vt_string;
			val->numVals = 1;
			val->val = am(myself, sizeof (val->val[0]));
			if (val->val == 0) {
				sfree(val);
				return (0);
			}
			val->val[0].value = sdup(myself, T, f->match.string);
			val->val[0].length = strlen(val->val[0].value);
			break;
		case mmt_single:
		case mmt_limit:
		case mmt_any:
		case mmt_begin:
		case mmt_end:
			/* Not an error, so return an empty value */
			val = am(myself, sizeof (*val));
			if (val == 0)
				return (0);
			val->type = vt_string;
			val->numVals = 0;
			val->val = 0;
			break;
		default:
			/* Do nothing */
			val = 0;
			break;
		}
	}
	return (val);
}

/*
 * Used when evaluating an expression. Typically, the value of the
 * expression so far will be kept in 'v1', and 'v2' is the value
 * of the current component of the expression. In the general case,
 * both will be multi-valued, and the result is an "explosion"
 * resulting in N*M new values (if 'v1' had N values, and 'v2'
 * M ditto).
 *
 * For example, if v1 = {"ab", "cd", "ef"}, and v2 = {"gh", "ij", "kl"},
 * the result will be {"abgh", "abij", "abkl", "cdgh", "cdij", "cdkl",
 * "efgh", "efij", "efkl"}.
 *
 * There are special cases when v1->repeat and/or v2->repeat are set.
 * Repeat mostly makes sense with single values; for example, if
 * v1 = {"x="} with repeat on, and v2 = {"1", "2", "3"}, the result
 * is {"x=1", "x=2", "x=3"}.
 *
 * The result if v2 also had repeat on would be {"x=1x=2x=3"}. It's
 * not clear if there's a useful application for this, but the code's
 * there for the sake of orthogonality.
 */
__nis_value_t *
explodeValues(__nis_value_t *v1, __nis_value_t *v2) {
	int		i1, i2, n, nv;
	__nis_value_t	*v;
	__nis_buffer_t	b = {0, 0};
	char		*myself = "explodeValues";

	if (v1 == 0 || v1->numVals <= 0)
		return (cloneValue(v2, 1));
	if (v2 == 0 || v2->numVals <= 0)
		return (cloneValue(v1, 1));

	/*
	 * XXX What should we do if (v1->type != v2->type) ?
	 * Policy: Just explode anyway, even though the result is
	 * unlikely to be very useful.
	 */

	v = am(myself, sizeof (*v));
	if (v == 0)
		return (0);

	if (!v1->repeat && !v2->repeat)
		nv = v1->numVals * v2->numVals;
	else if (v1->repeat && !v2->repeat)
		nv = v2->numVals;
	else if (!v1->repeat && v2->repeat)
		nv = v1->numVals;
	else /* v1->repeat && v2->repeat */
		nv = 1;

	v->val = am(myself, nv * sizeof (v->val[0]));
	if (v->val == 0) {
		free(v);
		return (0);
	}

	/*
	 * Four different cases, depending on the 'repeat' flags.
	 */
	if (!v1->repeat && !v2->repeat) {
		for (i1 = 0, n = 0; i1 < v1->numVals; i1++) {
			for (i2 = 0; i2 < v2->numVals; i2++) {
				if (v1->type == vt_string)
					sbc2buf(myself, v1->val[i1].value,
						v1->val[i1].length,
						&b);
				else
					bc2buf(myself, v1->val[i1].value,
						v1->val[i1].length,
						&b);
				if (v2->type == vt_string)
					sbc2buf(myself, v2->val[i2].value,
						v2->val[i2].length,
						&b);
				else
					bc2buf(myself, v2->val[i2].value,
						v2->val[i2].length,
						&b);
				v->val[n].value = b.buf;
				v->val[n].length = b.len;
				n++;
				b.buf = 0;
				b.len = 0;
			}
		}
	} else if (v1->repeat && !v2->repeat) {
		for (i2 = 0; i2 < v2->numVals; i2++) {
			for (i1 = 0, n = 0; i1 < v1->numVals; i1++) {
				if (v1->type == vt_string)
					sbc2buf(myself, v1->val[i1].value,
						v1->val[i1].length,
						&b);
				else
					bc2buf(myself, v1->val[i1].value,
						v1->val[i1].length,
						&b);
				if (v2->type == vt_string)
					sbc2buf(myself, v2->val[i2].value,
						v2->val[i2].length,
						&b);
				else
					bc2buf(myself, v2->val[i2].value,
						v2->val[i2].length,
						&b);
			}
			v->val[n].value = b.buf;
			v->val[n].length = b.len;
			n++;
			b.buf = 0;
			b.len = 0;
		}
	} else if (!v1->repeat && v2->repeat) {
		for (i1 = 0, n = 0; i1 < v1->numVals; i1++) {
			for (i2 = 0; i2 < v2->numVals; i2++) {
				if (v1->type == vt_string)
					sbc2buf(myself, v1->val[i1].value,
						v1->val[i1].length,
						&b);
				else
					bc2buf(myself, v1->val[i1].value,
						v1->val[i1].length,
						&b);
				if (v2->type == vt_string)
					sbc2buf(myself, v2->val[i2].value,
						v2->val[i2].length,
						&b);
				else
					bc2buf(myself, v2->val[i2].value,
						v2->val[i2].length,
						&b);
			}
			v->val[n].value = b.buf;
			v->val[n].length = b.len;
			n++;
			b.buf = 0;
			b.len = 0;
		}
	} else { /* v1->repeat && v2->repeat */
		for (i1 = 0, n = 0; i1 < v1->numVals; i1++) {
			for (i2 = 0; i2 < v2->numVals; i2++) {
				if (v1->type == vt_string)
					sbc2buf(myself, v1->val[i1].value,
						v1->val[i1].length,
						&b);
				else
					bc2buf(myself, v1->val[i1].value,
						v1->val[i1].length,
						&b);
				if (v2->type == vt_string)
					sbc2buf(myself, v2->val[i2].value,
						v2->val[i2].length,
						&b);
				else
					bc2buf(myself, v2->val[i2].value,
						v2->val[i2].length,
						&b);
			}
		}
		v->val[n].value = b.buf;
		v->val[n].length = b.len;
		n++;
		b.buf = 0;
		b.len = 0;
	}

#ifdef	NISDB_LDAP_DEBUG
	/* Sanity check */
	if (n != nv)
		abort();
#endif	/* NISD__LDAP_DEBUG */

	v->type = (v1->type == vt_string) ?
			((v2->type == vt_string) ?
				vt_string : vt_ber) : vt_ber;
	v->repeat = 0;
	v->numVals = n;

	return (v);
}

__nis_value_t *
getMappingFormatArray(__nis_mapping_format_t *a, __nis_rule_value_t *rv,
			__nis_format_arg_t at, int numArgs, void *arg) {
	int			i, ia = 0;
	__nis_value_t		*val, *v = 0;
	bool_t			moreFormat = (a != 0);
	bool_t			moreArgs = (numArgs > 0);

	while (moreFormat && (arg == 0 || ia < numArgs)) {
		for (i = 0; moreFormat; i++) {
			moreFormat = (a[i].type != mmt_end);
			if (at == fa_item) {
				__nis_mapping_item_t *item = arg;
				val = getMappingFormat(&a[i], rv, at,
					((item != 0) ? &item[ia] : 0), &ia);
			} else {
				__nis_value_t **ival = arg;
				val = getMappingFormat(&a[i], rv, at,
					((ival != 0) ? ival[ia] : 0), &ia);
			}
			if (val != 0) {
				__nis_value_t	*new = explodeValues(v, val);

				freeValue(v, 1);
				freeValue(val, 1);
				if (new == 0)
					return (0);

				v = new;
			} else {
				freeValue(v, 1);
				return (0);
			}
			/*
			 * If we run out of arguments, but still have format
			 * remaining, repeat the last argument. Keep track of
			 * the fact that we've really consumed all arguments.
			 */
			if (moreFormat && ia >= numArgs) {
				ia = (numArgs > 0) ? numArgs - 1 : 0;
				moreArgs = FALSE;
			}
		}
		/*
		 * We've run out of format, so if we still have arguments
		 * left, start over on the format.
		 */
		if (ia < numArgs && moreArgs) {
			/*
			 * However, if we didn't consume any arguments going
			 * through the format once, abort to avoid an infinite
			 * loop.
			 */
			if (numArgs > 0 && ia <= 0) {
				freeValue(v, 1);
				return (0);
			}
			moreFormat = 1;
		}
	}

	return (v);
}

/*
 * Returns a string representation (such as "[name=foo, value=bar]")
 * of a nis_index_t.
 */
char *
getIndex(__nis_index_t *i, int *len) {
	int		n;
	__nis_buffer_t	b = {0, 0};
	char		*myself = "getIndex";

	if (i == 0)
		return (0);

	if (i->numIndexes > 0) {
		bp2buf(myself, &b, "[");
		for (n = 0; n < i->numIndexes; n++) {
			__nis_value_t	*val;
			int		j;

			val = getMappingFormatArray(i->value[n],
						0, fa_any, 0, 0);
			if (n > 0)
				bp2buf(myself, &b, ", ");
			bp2buf(myself, &b, "%s=", i->name[n]);
			if (val != 0) {
				for (j = 0; j < val->numVals; j++) {
					bc2buf(myself, val->val[j].value,
						val->val[j].length, &b);
				}
			} else {
				bp2buf(myself, &b, "<no-vals>");
			}
			freeValue(val, 1);
		}
		bp2buf(myself, &b, "]");
	}
	if (len != 0)
		*len = b.len;
	return (b.buf);
}

char *
getObjSpec(__nis_obj_spec_t *o, int *len) {
	__nis_buffer_t	b = {0, 0};
	char		*myself = "getObjSpec";

	if (o == 0)
		return (0);

	b.buf = getIndex(&o->index, &b.len);
	sbc2buf(myself, o->name, slen(o->name), &b);
	if (len != 0)
		*len = b.len;
	return (b.buf);
}

/*
 * Returns a string representation of the LDAP scope. Note that the
 * returned value is a static entity, and must be copied by the
 * caller (but, obviously, must not be freed).
 */
char *
getScope(int scope) {
	switch (scope) {
	case LDAP_SCOPE_BASE:
		return ("base");
	case LDAP_SCOPE_ONELEVEL:
		return ("one");
	case LDAP_SCOPE_SUBTREE:
		return ("sub");
	default:
		return ("one");
	}
}

/*
 * Return a string representation of an LDAP search triple (such as
 * "ou=Hosts,dc=eng,dc=sun,dc=com?one?cn=xyzzy").
 */
char *
getSearchTriple(__nis_search_triple_t *s, int *len) {
	__nis_buffer_t	b = {0, 0};
	char		*a;
	int		l;
	char		*myself = "getSearchTriple";

	/* If the scope is LDAP_SCOPE_UNKNOWN, the search triple is unused */
	if (s == 0 || s->scope == LDAP_SCOPE_UNKNOWN) {
		if (len != 0)
			*len = 0;
		return (0);
	}

	if (s->base != 0)
		sbc2buf(myself, s->base, slen(s->base), &b);
	if (!(s->scope == LDAP_SCOPE_ONELEVEL &&
			(s->base == 0 || s->base[0] == '\0'))) {
		bp2buf(myself, &b, "?%s?", getScope(s->scope));
	}
	if ((l = slen(s->attrs)) > 0) {
		/*
		 * Remove white space from the filter/attribute list.
		 * The parser usually keeps any white space from the
		 * config file (or LDAP/command line), but we don't
		 * want it.
		 */
		a = am(myself, l+1);
		if (a != 0) {
			int	i, la;

			for (i = 0, la = 0; i < l; i++) {
				if (s->attrs[i] != ' ' &&
						s->attrs[i] != '\t')
					a[la++] = s->attrs[i];
			}
			sbc2buf(myself, a, la, &b);
			sfree(a);
		} else {
			sbc2buf(myself, s->attrs, slen(s->attrs), &b);
		}
	}

	if (len != 0)
		*len = b.len;
	return (b.buf);
}

__nis_value_t *
getMappingItem(__nis_mapping_item_t *i, __nis_mapping_item_type_t native,
		__nis_rule_value_t *rv, char *berstring, int *np_ldap_stat) {
	char		*myself = "getMappingItem";
	__nis_value_t	*val = 0;
	__nis_buffer_t	b = {0, 0};
	int		len = 0;
	char		*buf;

	if (i == 0)
		return (0);

	if (rv != 0)
		return (getMappingItemVal(i, native, rv, berstring,
			np_ldap_stat));

	val = am(myself, sizeof (*val));
	if (val == 0)
		return (0);

	switch (i->type) {
	case mit_nisplus:
		if (native != mit_nisplus)
			bp2buf(myself, &b, "nis+:");
		bp2buf(myself, &b, "%s", NIL(i->name));
		buf = getObjSpec(&i->searchSpec.obj, &len);
		if (buf != 0 && len > 0) {
			bc2buf(myself, ":", 1, &b);
			sbc2buf(myself, buf, len, &b);
		}
		sfree(buf);
		val->type = vt_string;
		val->repeat = i->repeat;
		val->numVals = 1;
		val->val = am(myself, sizeof (val->val[0]));
		if (val->val == 0) {
			sfree(b.buf);
			free(val);
			return (0);
		}
		val->val[0].value = b.buf;
		val->val[0].length = b.len;
		break;
	case mit_ldap:
		if (native != mit_ldap)
			bp2buf(myself, &b, "ldap:");
		bp2buf(myself, &b, "%s", NIL(i->name));
		buf = getSearchTriple(&i->searchSpec.triple, &len);
		if (buf != 0 && len > 0) {
			bc2buf(myself, ":", 1, &b);
			sbc2buf(myself, buf, len, &b);
		}
		sfree(buf);
		val->type = vt_string;
		val->repeat = i->repeat;
		val->numVals = 1;
		val->val = am(myself, sizeof (val->val[0]));
		if (val->val == 0) {
			sfree(b.buf);
			free(val);
			return (0);
		}
		val->val[0].value = b.buf;
		val->val[0].length = b.len;
		break;
	default:
		p2buf(myself, "<unknown>:");
		p2buf(myself, "%s", NIL(i->name));
		break;
	}

	return (val);
}

void
copyObjSpec(__nis_obj_spec_t *old, __nis_obj_spec_t *new, int *err) {
	char	*myself = "copyObjSpec";

	if (old == 0 || new == 0) {
		*err = EINVAL;
		return;
	}

	if (new->index.name == 0) {
		new->index.name = am(myself, old->index.numIndexes *
						sizeof (new->index.name[0]));
		if (old->index.numIndexes > 0 && new->index.name == 0) {
			*err = ENOMEM;
			return;
		}
		new->index.value = am(myself, old->index.numIndexes *
						sizeof (new->index.value[0]));
		if (old->index.numIndexes > 0 && new->index.value == 0) {
			*err = ENOMEM;
			return;
		}
	}
	new->name = sdup(myself, T, old->name);
	if (new->name == 0 && old->name != 0) {
		*err = ENOMEM;
		return;
	}
	copyIndex(&old->index, &new->index, err);
}

__nis_obj_spec_t *
cloneObjSpec(__nis_obj_spec_t *old) {
	char			*myself = "cloneObjSpec";
	int			err = 0;
	__nis_obj_spec_t	*new = am(myself, sizeof (*new));

	if (new != 0) {
		copyObjSpec(old, new, &err);
		if (err != 0) {
			freeObjSpec(new, 1);
			new = 0;
		}
	}

	return (new);
}

void
freeObjSpec(__nis_obj_spec_t *old, bool_t doFree) {

	if (old == 0)
		return;

	sfree(old->name);
	freeIndex(&old->index, FALSE);
	if (doFree)
		free(old);
}

void
copySearchTriple(__nis_search_triple_t *old, __nis_search_triple_t *new,
		int *err) {
	char			*myself = "copySearchTriple";

	*err = 0;

	if (old == 0 || new == 0) {
		*err = EINVAL;
		return;
	}

	if (old->base != NULL)
		new->base = sdup(myself, T, old->base);
	else
		new->base = NULL;
	if (old->attrs != NULL)
		new->attrs = sdup(myself, T, old->attrs);
	else
		new->attrs = NULL;
	if ((new->base == 0 && old->base != 0) ||
			(new->attrs == 0 && old->attrs != 0)) {
		sfree(new->base);
		new->base = 0;
		sfree(new->attrs);
		new->attrs = 0;
		*err = ENOMEM;
		return;
	}
	new->scope = old->scope;
	/*
	 * XXX Really should have a cloneMappingElement() function.
	 * However, since whatever the 'element' field points to
	 * is allocated at parse time, and never is freed or modified,
	 * it's sufficient to copy the pointer value.
	 */
	new->element = old->element;
}

__nis_search_triple_t *
cloneSearchTriple(__nis_search_triple_t *old) {
	char			*myself = "cloneSearchTriple";
	int			err = 0;
	__nis_search_triple_t	*new = am(myself, sizeof (*new));

	if (new != 0) {
		copySearchTriple(old, new, &err);
		if (err != 0) {
			freeSearchTriple(new, 1);
			new = 0;
		}
	}

	return (new);
}

void
freeSearchTriple(__nis_search_triple_t *old, bool_t doFree) {

	if (old == 0)
		return;

	sfree(old->base);
	sfree(old->attrs);
	/*
	 * Since we only copied the element pointer when this structure
	 * was created, we don't free old->element.
	 */
	if (doFree)
		free(old);
}

void
copyTripleOrObj(__nis_mapping_item_type_t type,
		__nis_triple_or_obj_t *old, __nis_triple_or_obj_t *new,
		int *err) {

	*err = 0;

	if (old == 0 || new == 0) {
		*err = EINVAL;
		return;
	}

	if (type == mit_nisplus) {
		copyObjSpec(&old->obj, &new->obj, err);
	} else if (type == mit_ldap) {
		copySearchTriple(&old->triple, &new->triple, err);
	}
}

__nis_triple_or_obj_t *
cloneTripleOrObj(__nis_mapping_item_type_t type, __nis_triple_or_obj_t *old) {
	char			*myself = "cloneTripleOrObj";
	int			err = 0;
	__nis_triple_or_obj_t	*new = am(myself, sizeof (*new));

	if (new != 0) {
		copyTripleOrObj(type, old, new, &err);
		if (err != 0) {
			freeTripleOrObj(type, new, 1);
			new = 0;
		}
	}

	return (new);
}

void
freeTripleOrObj(__nis_mapping_item_type_t type, __nis_triple_or_obj_t *old,
		bool_t doFree) {

	if (old == 0)
		return;

	if (type == mit_nisplus)
		freeObjSpec(&old->obj, doFree);
	else if (type == mit_ldap)
		freeSearchTriple(&old->triple, doFree);

	if (doFree)
		free(old);
}

void
copyItem(__nis_mapping_item_t *old, __nis_mapping_item_t *new, int *err) {

	*err = 0;

	if (old == 0 || new == 0) {
		*err = EINVAL;
		return;
	}

	new->type = old->type;
	new->repeat = old->repeat;
	if (old->name != 0) {
		new->name = strdup(old->name);
		if (new->name == 0) {
			*err = ENOMEM;
			return;
		}
	} else {
		new->name = 0;
	}
	if (old->type == mit_nisplus || old->type == mit_ldap)
		copyTripleOrObj(old->type, &old->searchSpec, &new->searchSpec,
				err);
	else
		memset(&new->searchSpec, 0, sizeof (new->searchSpec));
}

__nis_mapping_item_t *
cloneItem(__nis_mapping_item_t *old) {
	__nis_mapping_item_t	*new;
	int			err = 0;
	char			*myself = "cloneItem";

	if (old == 0)
		return (0);

	new = am(myself, sizeof (*new));
	if (new == 0)
		return (0);

	copyItem(old, new, &err);
	if (err != 0) {
		freeMappingItem(new, 1);
		return (0);
	}

	return (new);
}

void
freeMappingItem(__nis_mapping_item_t *item, int numItems) {
	int	i;

	if (item == 0)
		return;

	for (i = 0; i < numItems; i++) {
		sfree(item[i].name);
		freeTripleOrObj(item[i].type, &item[i].searchSpec, FALSE);
	}
	sfree(item);
}

__nis_mapping_item_t *
concatenateMappingItem(__nis_mapping_item_t *old, int numItems,
		__nis_mapping_item_t *cat) {
	__nis_mapping_item_t	*new;
	int			i, err = 0;
	char			*myself = "concatenateMappingItem";

	if (old == 0 || numItems < 1)
		return (cloneItem(cat));

	new = am(myself, (numItems + 1) * sizeof (*new));
	if (new == 0)
		return (0);

	for (i = 0; i < numItems; i++) {
		copyItem(&old[i], &new[i], &err);
		if (err != 0) {
			freeMappingItem(new, i);
			return (0);
		}
	}
	copyItem(cat, &new[numItems], &err);
	if (err != 0) {
		freeMappingItem(new, numItems);
		new = 0;
	}

	return (new);
}

__nis_value_t *
concatenateValues(__nis_value_t *v1, __nis_value_t *v2) {
	int		i, n, a;
	__nis_value_t	*v;
	char		*myself = "concatenateValues";

	if (v1 == 0 || v1->numVals <= 0)
		return (cloneValue(v2, 1));
	if (v2 == 0 || v2->numVals <= 0)
		return (cloneValue(v1, 1));

	if (v1->type != v2->type)
		return (0);

	n = v1->numVals + v2->numVals;
	v = am(myself, sizeof (*v));
	if (v == 0)
		return (0);
	v->val = am(myself, n * sizeof (v->val[0]));
	if (v->val == 0) {
		free(v);
		return (0);
	}
	v->type = v1->type;
	v->numVals = 0;

	for (a = 0; a < 2; a++) {
		__nis_single_value_t	*val = (a == 0) ? v1->val : v2->val;
		int			numv = (a == 0) ? v1->numVals :
							v2->numVals;
		for (i = 0; i < numv; i++) {
			int	clen, alen = val[i].length;

			clen = alen;

			/*
			 * Make sure there's a NUL at the end of a string,
			 * but avoid adding to the allocated length if there's
			 * already a NUL at the end.
			 */
			if (alen > 0 && v->type == vt_string &&
					((char *)val[i].value)[alen-1] != '\0')
				alen += 1;
			v->val[v->numVals].value = am(myself, alen);
			if (v->val[v->numVals].value == 0) {
				freeValue(v, 1);
				return (0);
			}
			memcpy(v->val[v->numVals].value, val[i].value, clen);
			v->val[v->numVals].length = val[i].length;
			v->numVals++;
		}
	}

	return (v);
}

__nis_value_t *
splitMappingItem(__nis_mapping_item_t *item, char delim,
		__nis_rule_value_t *rv) {
	__nis_value_t		*val = getMappingItem(item, mit_any,
			rv, 0, NULL);
	__nis_single_value_t	*nval;
	int			i, n, nv;

	if (val == 0)
		return (0);
	else if (delim == 0 || val->val == 0 || val->numVals <= 0 ||
			val->type != vt_string) {
		freeValue(val, 1);
		return (0);
	}

	nval = val->val;
	nv = val->numVals;
	val->repeat = FALSE;
	val->val = 0;
	val->numVals = 0;

	/* In N2L, space and tab delimiters are treated the same */
	if (yp2ldap && delim == '\t')
		delim = ' ';

	/* If the item has multiple values, we split each one independently */
	for (i = 0; i < nv; i++) {
		char			*str;
		int			s, e;
		char			*newstr;
		__nis_single_value_t	*newval;

		if (yp2ldap && delim == ' ')
			nval[i].value = trimWhiteSpaces(nval[i].value,
							&nval[i].length, 1);

		str = nval[i].value;

		if (nval[i].value == 0)
			continue;

		for (s = 0; s < nval[i].length; s = e+1) {
			/* Find the next delimiter, or end-of-string */
			for (e = s; str[e] != '\0' && str[e] != delim; e++);
			/*
			 * 'str[e]' is either a delimiter, or the concluding
			 * NUL. Make sure it's NUL.
			 */
			str[e] = '\0';
			/* Add to val->val */
			newstr = strdup(&str[s]);
			newval = realloc(val->val,
					(val->numVals+1) *
						sizeof (val->val[0]));
			if (newval != 0)
				val->val = newval;
			if (newstr == 0 || newval == 0) {
				freeValue(val, 1);
				for (n = i; n < nv; n++) {
					sfree(nval[n].value);
				}
				free(nval);
				sfree(newstr);
				return (0);
			}
			val->val[val->numVals].value = newstr;
			val->val[val->numVals].length = strlen(newstr) + 1;
			val->numVals++;
		}
		free(nval[i].value);
		nval[i].value = 0;
	}
	/* Already freed the nval[i].value's as we traversed nval */
	free(nval);

	return (val);
}

/*
 * Match the format spec 'f[curf]' to the input value string 'str'.
 *
 * If successful, returns the updated position in the value string 'str'.
 * Otherwise, NULL is returned.
 *
 * curf		Current index (i.e., the one we should look at) in 'f'
 * nf		Number of elements in 'f', including 'mmt_end'
 * str		The value string we're scanning
 * val		Pointer to where an item value (if any) should be returned
 *		Set to NULL if not an 'mmt_item'.
 * fmtstart	If non-zero on entry, skip characters in 'str' until we find
 *		the f[curf].type data, if doing so makes any sense. On exit,
 *		set to the start of the fmt element data (which will be 'str',
 *		unless we did skip characters)
 * sepset	List of separators
 */
char *
scanMappingFormat(__nis_mapping_format_t *f, int curf, int nf, char *str,
		char **val, char **fmtstart, char *sepset) {
	char	*mstr, *next, *start = 0, *tmpstr;
	int	i, len;
	bool_t	match;
	char	*myself = "scanMappingFormat";
	/* N2L variables */
	int	af, skipspaces = 0;
	bool_t	ipaddr = FALSE;
	char	*spacestr = " ", *emptystr = "";


	if (f == 0 || curf < 0 || nf <= 0 || str == 0)
		return (0);

	/*
	 * If separator list is NULL (which will be the case for
	 * nis+2ldap), then simply use empty string
	 */
	if (sepset == 0)
		sepset = emptystr;

	if (curf >= nf) {
		/* OK if the string also is exhausted */
		if (strchr(sepset, *str) != 0)
			return (str);
		else
			return (0);
	}

	switch (f[curf].type) {
	case mmt_berstring:
		if (f[curf].match.berString[0] != 'a') {
			/* Not a matchable element */
			return (0);
		}

		/*
		 * If here, it means it's an IP address (N2L case)
		 * So continue processing as if it was mmt_item
		 */
		ipaddr = TRUE;

	case mmt_item:
		/*
		 * In order to find the end of the item value, we must look
		 * ahead and determine the start of the next formatting element.
		 * If successful, 'next' will be the start of the fmt element
		 * after the next one; we don't care about that, other than to
		 * check for error.
		 *
		 * Since an item match is somewhat like an any match, in that
		 * we don't know a priori if the first occurence of the next
		 * element really is the one we want, we have to scan ahead
		 * until we've reached the end.
		 */
		tmpstr = str;
		while ((next = scanMappingFormat(f, curf+1, nf, tmpstr, 0,
				&start, sepset)) != 0) {
			char	*tmp = next;
			int	cf;

			for (cf = curf+2; cf < nf; cf++) {
				tmp = scanMappingFormat(f, cf, nf, tmp, 0,
					0, sepset);
				if (tmp == 0)
					break;
			}
			if (tmp == 0) {
				tmpstr = next;
			} else if (strchr(sepset, *tmp) != 0) {
				break;
			} else {
				return (0);
			}

		}
		if (next == 0 || start == 0)
			return (0);

		if (val != 0) {
			len = (int)((long)start - (long)str);
			*val = am(myself, len + 1);
			if (*val == 0)
				return (0);
			memcpy(*val, str, len);
			(*val)[len] = '\0';

			if (ipaddr == TRUE) {
				/*
				 * In N2L, we need to check if *val is truly an
				 * IP address
				 */
				af = checkIPaddress(*val, len, &tmpstr);

				if (af == -2) {
					logmsg(MSG_NOTIMECHECK, LOG_WARNING,
						"%s:Internal error while "
						"processing IPaddress %s",
						myself, *val);
					sfree(*val);
					return (0);
				} else if (af == -1) {
					logmsg(MSG_NOTIMECHECK, LOG_WARNING,
						"%s:%s is not an IP address",
						myself, *val);
					sfree(*val);
					return (0);
				} else if (af == 0) {
					logmsg(MSG_NOTIMECHECK, LOG_WARNING,
						"%s:IP address %s is not "
						"supported by rfc2307bis",
						myself, *val);
					sfree(*val);
					return (0);
				} else if (sstrncmp(*val, tmpstr, len) != 0) {
					logmsg(MSG_NOTIMECHECK, LOG_WARNING,
						"%s:IPaddress %s converted "
						"to %s", myself, *val, tmpstr);
				}

				sfree(*val);
				*val = tmpstr;
			}
		}

		if (fmtstart != 0)
			*fmtstart = str;

		return (start);

	case mmt_string:
		if ((mstr = f[curf].match.string) == 0 || *mstr == '\0') {
			/*
			 * Count this as a successful match of an empty
			 * string.
			 */
			if (fmtstart != 0)
				*fmtstart = str;
			return (str);
		}

		/*
		 * In N2L, if the format string 'mstr' contains only
		 * whitespaces (spaces and tabs), then it should
		 * match one or more whitespaces from the input
		 * string 'str'.
		 */
		if (yp2ldap && strspn(mstr, " \t") == strlen(mstr)) {
				mstr = spacestr;
				skipspaces = 1;
				next = str + strcspn(str, " \t");
				/*
				 * Even if there is no whitespace in 'str',
				 * it's OK. This is to allow formats like
				 * "%s %s %s" to match inputs like "foo bar".
				 */
				if (*next == '\0')
					mstr = emptystr;
		} else {
			/* No match string in 'str' => failure */
			if ((next = strstr(str, mstr)) == 0)
				return (0);
		}

		/* If 'fmtstart' == 0, we require 'next' == 'str' */
		if (fmtstart == 0 && next != str)
			return (0);
		/* Success; save start of match string if requested */
		if (fmtstart != 0)
			*fmtstart = next;
		/* Update position in the value string */
		str = (char *)((long)next + (long)strlen(mstr));

		/* Skip whitespaces for N2L */
		if (skipspaces == 1)
			for (; *str == ' ' || *str == '\t'; str++);

		return (str);

	case mmt_single:
		if (fmtstart != 0) {
			match = FALSE;
			/* Skip ahead until we match */
			for (next = str; *next != '\0'; next++) {
				unsigned char	*lo = f[curf].match.single.lo;
				unsigned char	*hi = f[curf].match.single.hi;

				for (i = 0; i < f[curf].match.single.numRange;
						i++) {
					if (*next >= lo[i] && *next <= hi[i]) {
						match = TRUE;
						break;
					}
				}
				if (match)
					break;
			}
			if (!match)
				return (0);
			*fmtstart = next;
			str = next;
		} else {
			match = FALSE;
			for (i = 0; i < f[curf].match.single.numRange; i++) {
				if (*str >= f[curf].match.single.lo[i] &&
					*str <= f[curf].match.single.hi[i]) {
					match = TRUE;
					break;
				}
			}
			if (!match)
				return (0);
		}
		/* Step over the matched character */
		str++;
		return (str);

	case mmt_any:
		/*
		 * Look ahead to find the beginning of the next element.
		 * Because a wildcard-match isn't necessarily uniquely
		 * determined until we've reached the end, we then continue
		 * to scan ahead.
		 */
		while ((next = scanMappingFormat(f, curf+1, nf, str, 0,
						&start, sepset)) != 0) {
			char	*tmp = next;
			int	cf;

			for (cf = curf+2; cf < nf; cf++) {
				tmp = scanMappingFormat(f, cf, nf, tmp, 0,
					0, sepset);
				if (tmp == 0)
					break;
			}
			if (tmp == 0) {
				str = next;
			} else if (*tmp == '\0') {
				break;
			} else {
				return (0);
			}
		}
		if (next == 0 || start == 0)
			return (0);

		if (fmtstart != 0)
			*fmtstart = str;

		return (start);

	case mmt_limit:
		if (f[curf].match.limit == eos) {
			if (fmtstart != 0) {
				/* Skip to the end */
				str = str + strcspn(str, sepset);
				*fmtstart = str;
			} else if (strchr(sepset, *str) == 0) {
				return (0);
			}
		}
		return (str);

	case mmt_begin:
		if (fmtstart != 0)
			*fmtstart = str;
		return (str);

	case mmt_end:
		if (fmtstart != 0) {
			/* Skip to the end */
			str = str + strcspn(str, sepset);
			*fmtstart = str;
			return (str);
		}
		/* No skipping, so we must be at the end of the value */
		if (strchr(sepset, *str) == 0)
			return (0);
		return (str);

	default:
		break;
	}

	return (0);
}

/*
 * Verify that the string 'str' matches the mapping format array 'f'.
 * Returns 1 in case of a match, 0 otherwise.
 */
int
verifyMappingMatch(__nis_mapping_format_t *f, char *str) {
	int			n, nf;
	__nis_mapping_format_t	*ftmp;

	/* Count the number of format elements in the format */
	for (nf = 0, ftmp = f; ftmp->type != mmt_end; ftmp++) {
		nf++;
	}
	/* Count the mmt_end as well */
	nf++;

	for (n = 0; n < nf; n++) {
		str = scanMappingFormat(f, n, nf, str, 0, 0, 0);
		if (str == 0)
			break;
	}

	return ((str != 0) ? 1 : 0);
}

/*
 * Perform a match operation. For example, given the rule
 *	("{%s}%s", auth_name, public_data)=nisPublicKey
 * and assuming that 'nisPublicKey' has the value "{dh640-0}abcdef12345",
 * assign "dh640-0" to 'auth_name' and "abcdef12345" to 'public_data'.
 *
 * Note that this function doesn't perform the actual assignment. Rather,
 * it returns an array of __nis_value_t's, with element zero of the value
 * array being the new value of the first matched item, element one the
 * value of the second matched item, etc. In the example above, we'd
 * return a value array with two elements.
 *
 * If there is more than one input value (inVal->numVals > 1), the
 * output array elements will also be multi-valued.
 *
 * f		The match format
 * inVal	Input value(s)
 * numVal	Number of elements in the output value array
 * sepset	List of separators
 * outstr	Points to the updated position upto which the
 *		input string has been matched
 */
__nis_value_t **
matchMappingItem(__nis_mapping_format_t *f, __nis_value_t *inVal,
		int *numVals, char *sepset, char **outstr) {
	__nis_value_t		**v = 0;
	int			i, n, ni, numItems, nf, nv = 0;
	char			*str, *valstr;
	__nis_mapping_format_t	*ftmp;
	char			*myself = "matchMappingItem";

	if (f == 0 ||
		inVal == 0 || inVal->numVals < 1 || inVal->type != vt_string)
		return (0);

	/* Count the number of format elements and items in the format */
	for (nf = numItems = 0, ftmp = f; ftmp->type != mmt_end; ftmp++) {
		nf++;

		/*
		 * Count mmt_item and mmt_berstring (used by N2L to
		 * represent address %a)
		 */
		if (ftmp->type == mmt_item)
				numItems++;
		else if (ftmp->type == mmt_berstring && ftmp->match.berString &&
				ftmp->match.berString[0] == 'a')
				numItems++;
	}
	/* Count the mmt_end as well */
	nf++;

	/*
	 * If no items, there will be no values. This isn't exactly an error
	 * from the limited point of view of this function, so we return a
	 * __nis_value_t with zero values.
	 */
	if (numItems <= 0) {
		v = am(myself, sizeof (v[0]));
		if (v == 0)
			return (0);
		v[0] = am(myself, sizeof (*v[0]));
		if (v[0] == 0) {
			sfree(v);
			return (0);
		}
		v[0]->type = vt_string;
		v[0]->numVals = 0;
		v[0]->val = 0;
		if (numVals != 0)
			*numVals = 1;
		return (v);
	}

	/* Allocate and initialize the return array */
	v = am(myself, numItems * sizeof (v[0]));
	if (v == 0)
		return (0);
	for (n = 0; n < numItems; n++) {
		v[n] = am(myself, sizeof (*v[n]));
		if (v[n] == 0) {
			int	j;

			for (j = 0; j < n; j++)
				freeValue(v[j], 1);
			sfree(v);
			return (0);
		}
		v[n]->type = vt_string;
		v[n]->numVals = 0;
		v[n]->val = am(myself, inVal->numVals * sizeof (v[n]->val[0]));
		if (v[n]->val == 0) {
			int	j;

			for (j = 0; j < n; j++)
				freeValue(v[j], 1);
			sfree(v);
			return (0);
		}
		for (i = 0; i < inVal->numVals; i++) {
			v[n]->val[i].length = 0;
			v[n]->val[i].value = 0;
		}
	}

	/* For each input value, perform the match operation */
	for (i = 0; i < inVal->numVals; i++) {
		str = inVal->val[i].value;
		if (str == 0)
			continue;
		for (n = 0, ni = 0; n < nf; n++) {
			valstr = 0;
			str = scanMappingFormat(f, n, nf, str, &valstr,
				0, sepset);
			if (str == 0)
				break;
			if (valstr != 0 && ni < numItems &&
					v[ni]->numVals < inVal->numVals) {
				v[ni]->val[v[ni]->numVals].value = valstr;
				v[ni]->val[v[ni]->numVals].length =
							strlen(valstr) + 1;
				v[ni]->numVals++;
				ni++;
			} else if (valstr != 0) {
				sfree(valstr);
			}
		}
		if (str == 0) {
			for (n = 0; n < numItems; n++)
				freeValue(v[n], 1);
			sfree(v);
			return (0);
		}
	}

	if (numVals != 0)
		*numVals = numItems;

	/*
	 * Update the return string upto the point it has been matched
	 * This string will be used by the N2L code in its next call
	 * to this function
	 */
	if (outstr != 0)
		*outstr = str;

	return (v);
}

/*
 * Perform an extract operation. For example, given the expression
 *	(name, "%s.*")
 * and assuming 'name' is an item with the value "some.thing", the
 * value returned by the extract is "some".
 */
__nis_value_t *
extractMappingItem(__nis_mapping_item_t *item, __nis_mapping_format_t *f,
		__nis_rule_value_t *rv, int *stat) {
	__nis_value_t		*val = getMappingItem(item, mit_any,
			rv, 0, stat);
	__nis_single_value_t	*nval;
	int			i, n, nv, nf;
	__nis_mapping_format_t	*ftmp;

	if (val == 0)
		return (0);
	else if (f == 0 || rv == 0 || val->val == 0 ||
			val->numVals <= 0 || val->type != vt_string) {
		freeValue(val, 1);
		return (0);
	}

	/* Sanity check the format; it must have one and only one mmt_item */
	{
		int	numitem;

		for (nf = numitem = 0, ftmp = f; ftmp->type != mmt_end;
				ftmp++) {
			nf++;
			if (ftmp->type == mmt_item)
				numitem++;
		}
		/* Count the mmt_end as well */
		nf++;
		if (numitem != 1) {
			freeValue(val, 1);
			return (0);
		}
	}

	nval = val->val;
	nv = val->numVals;
	val->repeat = FALSE;
	val->val = 0;
	val->numVals = 0;

	/* If the item has multiple values, we extract each one independently */
	for (i = 0; i < nv; i++) {
		char			*str = nval[i].value;
		char			*newstr = 0;
		__nis_single_value_t	*newval;

		if (nval[i].value == 0)
			continue;

		/*
		 * We match the whole string, even if we find a value for
		 * the item before exhausting all format elements. By doing
		 * this, we ensure that the string really matches the complete
		 * format specification.
		 */
		for (n = 0; n < nf; n++) {
			str = scanMappingFormat(f, n, nf, str, &newstr, 0, 0);
			if (str == 0)
				break;
		}

		/*
		 * *str should now be NUL, meaning we've reached the end of
		 * the string (value), and it completely matched the format.
		 * If 'str' is NULL, there was an error, and if 'newstr' is
		 * 0, we somehow failed to obtain a value.
		 */
		if (str == 0 || *str != '\0' || newstr == 0 ||
				(newval = realloc(val->val,
					(val->numVals+1) *
					sizeof (val->val[0]))) == 0) {
			freeValue(val, 1);
			for (n = 0; n < nv; n++) {
				sfree(nval[n].value);
			}
			free(nval);
			sfree(newstr);
			return (0);
		}

		val->val = newval;
		val->val[val->numVals].value = newstr;
		val->val[val->numVals].length = strlen(newstr) + 1;
		val->numVals++;

		free(nval[i].value);
		nval[i].value = 0;
	}
	free(nval);

	return (val);
}

/*
 * For each value in 'val', remove the last character, provided that
 * it matches 'elide'.
 */
void
stringElide(__nis_value_t *val, char elide) {

	if (val != 0 && val->type == vt_string) {
		int	i;

		for (i = 0; i < val->numVals; i++) {
			int	end = val->val[i].length;
			char	*str = val->val[i].value;

			if (str == 0 || end <= 0)
				continue;

			/*
			 * If the NUL was counted in the length, step back
			 * over it.
			 */
			if (str[end-1] == '\0')
				end--;
			if (end > 0 && str[end-1] == elide) {
				str[end-1] = '\0';
				val->val[i].length--;
			}
		}
	}
}

/*
 * Obtain the value for the mapping sub-element 'e', given the input
 * rule-value 'rv'.
 */
__nis_value_t *
getMappingSubElement(__nis_mapping_sub_element_t *e,
	__nis_rule_value_t *rv, int *np_ldap_stat) {
	__nis_value_t	*val;

	if (e == 0)
		return (0);

	switch (e->type) {
	case me_item:
		val = getMappingItem(&e->element.item, mit_any, rv, 0,
			np_ldap_stat);
		break;
	case me_print:
		val = getMappingFormatArray(e->element.print.fmt, rv,
						fa_item,
						e->element.print.numItems,
						e->element.print.item);
		if (e->element.print.doElide)
			stringElide(val, e->element.print.elide);
		break;
	case me_split:
		val = splitMappingItem(&e->element.split.item,
					e->element.split.delim,
					rv);
		break;
	case me_extract:
		val = extractMappingItem(&e->element.extract.item,
					e->element.extract.fmt,
					rv, np_ldap_stat);
		break;
	case me_match:
	default:
		val = 0;
		break;
	}

	return (val);
}

/*
 * Obtain the value of the mapping element 'e', given the input rule-
 * value 'rv'. The 'native' mapping type is used when 'rv' is NULL,
 * and the result is a string representation of the mapping element;
 * in that case, items of the 'native' type are printed without their
 * type designation ("nis+" or "ldap").
 */
__nis_value_t *
getMappingElement(__nis_mapping_element_t *e, __nis_mapping_item_type_t native,
		__nis_rule_value_t *rv, int *stat) {
	__nis_value_t	*val, **tv;
	int		i, success = 0, novalue = 0;
	int *np_ldap_stat;
	char		*myself = "getMappingElement";

	switch (e->type) {
	case me_item:
		val = getMappingItem(&e->element.item, native, rv, 0, NULL);
		break;
	case me_print:
		tv = am(myself, e->element.print.numSubElements *
			sizeof (tv[0]));
		np_ldap_stat = am(myself,
			e->element.print.numSubElements * sizeof (int));
		if ((e->element.print.numSubElements > 0) &&
				(tv == 0 || np_ldap_stat == 0)) {
			val = 0;
			sfree(tv);
			sfree(np_ldap_stat);
			break;
		}
		for (i = 0; i < e->element.print.numSubElements; i++) {
			np_ldap_stat[i] = 0;
			tv[i] = getMappingSubElement(
				&e->element.print.subElement[i],
				rv, &np_ldap_stat[i]);
		}
		/*
		 * if we get NP_LDAP_NO_VALUE to any of the subelement
		 * and we get NP_LDAP_MAP_SUCCESS to all other subelement
		 * then we had enough nis+ column values which can
		 * produce value for this rule, but didn't. So return
		 * NP_LDAP_RULES_NO_VALUE to indicate to proceed to
		 * next database id.
		 */
		for (i = 0; i < e->element.print.numSubElements; i++) {
			if (np_ldap_stat[i] == NP_LDAP_MAP_SUCCESS)
				success++;
			if (np_ldap_stat[i] == NP_LDAP_NO_VALUE)
				novalue++;
		}
		if (stat != NULL && novalue > 0 &&
				((novalue+success) ==
					e->element.print.numSubElements))
					    *stat = NP_LDAP_RULES_NO_VALUE;
		val = getMappingFormatArray(e->element.print.fmt, rv,
						fa_value,
						e->element.print.numSubElements,
						tv);
		for (i = 0; i < e->element.print.numSubElements; i++) {
			freeValue(tv[i], 1);
		}
		sfree(tv);
		sfree(np_ldap_stat);
		if (e->element.print.doElide)
			stringElide(val, e->element.print.elide);
		break;
	case me_split:
		val = splitMappingItem(&e->element.split.item,
					e->element.split.delim,
					rv);
		break;
	case me_match:
		/*
		 * A match doesn't produce an assignable value per se,
		 * so we shouldn't get one here.
		 */
		val = 0;
		break;
	case me_extract:
		val = extractMappingItem(&e->element.extract.item,
					e->element.extract.fmt,
					rv, NULL);
		break;
	default:
		val = 0;
		break;
	}

	return (val);
}