lib/libnisdb/ldap_xdr.c

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

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <string.h>
#include <sys/syslog.h>
#include <sys/types.h>
#include <rpc/types.h>
#include <rpc/xdr.h>
#include <rpcsvc/nis.h>

#include "db_mindex_c.h"

#include "ldap_xdr.h"
#include "ldap_util.h"

extern bool_t xdr_nis_object();

/*
 * In order not to change the on-disk NIS+ DB format, we need make sure
 * that XDR does nothing for the new structures added to various C++
 * classes.
 */

bool_t
xdr___nis_table_mapping_t(XDR *xdrs, void *t) {
	return (TRUE);
}

bool_t
xdr___nisdb_ptr_t(XDR *xdrs, void *ptr) {
	return (TRUE);
}

bool_t
xdr___nisdb_dictionary_defer_t(XDR *xdrs, void *defer) {
	return (TRUE);
}

bool_t
xdr___nisdb_rwlock_t(XDR *xdrs, void *rw) {
	return (TRUE);
}

bool_t
xdr___nisdb_flag_t(XDR *xdrs, void *flag) {
	return (TRUE);
}

/*
 * Imported from rpc.nisd/nis_db.c
 *
 * Special abbreviated XDR string which knows that the namep parameter (mainly
 * owner and group) has a trailing end which matches the last 'n' characters
 * in the domainname part.  It makes use of those common characters to
 * encode/decode this information.  We append an integer string to the
 * name to be encoded which denotes the place in the domainname from where the
 * common string starts.  For example, if the name was "foo.my.domain." and the
 * domainname was "my.domain.", the name would be encoded as "foo.10" because
 * the length of the common part "my.domain." is 10.
 */
bool_t
xdr_nis_name_abbrev(
	XDR		*xdrs,
	nis_name	*namep,
	nis_name	domainname)	/* domainname field from the table */
{
	size_t	name_len, dom_len, min_len;
	char 	buf[NIS_MAXNAMELEN];
	char 	*name;
	char	*lenstr, *tmp;
	int	i;

	switch (xdrs->x_op) {
	case XDR_ENCODE:
		/* Get the start of the common part */
		name = *namep;
		name_len = strlen(name);
		if (name_len == 0)
			return (xdr_nis_name(xdrs, namep));
		dom_len = strlen(domainname);
		min_len = (name_len < dom_len) ? name_len : dom_len;
		for (i = 1; i <= min_len; i++) {
			if (name[name_len - i] != domainname[dom_len - i])
				break;
		}
		i--;
		memcpy(buf, name, name_len - i);
		sprintf(buf + name_len - i, ".%d", dom_len - i);
		tmp = buf;
		return (xdr_nis_name(xdrs, &tmp));

	case XDR_DECODE:
		tmp = buf;
		if (!xdr_nis_name(xdrs, &tmp))
		    return (FALSE);
		if ((buf[0] == NULL) || buf[strlen(buf) - 1] == '.') {
			/* It is either a FQN or a NULL string */
			if (*namep) {
				strcpy(*namep, buf);
				return (TRUE);
			} else {
				if ((*namep = strdup(buf)) == NULL)
					return (FALSE);
				else
					return (TRUE);
			}
		}
		/* Now concoct the new name */
		if ((lenstr = strrchr(buf, '.')) == NULL) {
			/* something went wrong here */
			syslog(LOG_ERR,
				"xdr_nis_name_abbrev: no dot found in %s", buf);
			return (FALSE);
		}
		i = atoi(lenstr + 1);
		strcpy(lenstr, domainname + i);
		if (*namep) {
			strcpy(*namep, buf);
		} else {
			if ((*namep = strdup(buf)) == NULL)
				return (FALSE);
		}
		return (TRUE);

	default:
		return (xdr_nis_name(xdrs, namep));
	}
}

/*
 * Imported from rpc.nisd/nis_db.c
 *
 * special XDR for fetus object.  We create the actual object from the
 * "forming" object plus the table object.  We create this special object to
 * save the following components of the nis_object:
 *	zo_name and zo_domain: replaced by just the length field of 0.  We had
 *		to keep the length field for backward compatibility.  If we
 *		ever change the object format, we should fix this.
 *	zo_owner and zo_group: we condensed it by abbreviating the common part
 *		shared between the table object and the entry object
 *	en_type: Avoided altogether
 *	zo_type and other en_data: Avoided altogether.
 *
 * XXX: If the definition of nis_object ever changes, this should be changed.
 */
bool_t
xdr_nis_fetus_object(
	XDR		*xdrs,
	nis_object	*objp,	/* Entry object */
	nis_object	*tobj)	/* Table object */
{
	uint_t	size;

	if (xdrs->x_op == XDR_FREE)
		return (xdr_nis_object(xdrs, objp));
	if (!xdr_nis_oid(xdrs, &objp->zo_oid))
		return (FALSE);

	/*
	 * While encoding of zo_name, we put 0 in the length field, while for
	 * decoding, we get the name from the table object.
	 */
	if (xdrs->x_op == XDR_ENCODE) {
		size = 0;
		if (!xdr_u_int(xdrs, &size))
			return (FALSE);
	} else {
		if (!xdr_u_int(xdrs, &size))
			return (FALSE);
		if (size == 0) {	/* shrinked format */
			/* get the name from the table object */
			if ((objp->zo_name = strdup(tobj->zo_name)) == NULL)
				return (FALSE);
		} else {
			/*
			 * We are opening up the xdr_string implementation here
			 * because we called xdr_u_int() earlier.
			 */
			if ((objp->zo_name = (char *)malloc(size + 1)) == NULL)
				return (FALSE);
			if (!xdr_opaque(xdrs, objp->zo_name, size))
				return (FALSE);
		}
	}

	/*
	 * We use the xdr_nis_name_abbrev() function for both owner
	 * and group which constructs the name from the domain name.
	 */
	if (!xdr_nis_name_abbrev(xdrs, &objp->zo_owner, tobj->zo_domain))
		return (FALSE);
	if (!xdr_nis_name_abbrev(xdrs, &objp->zo_group, tobj->zo_domain))
		return (FALSE);

	/*
	 * While encoding of zo_domain, we put 0 in the length field, while for
	 * decoding, we get the name from the table object.  Same as above for
	 * the name.  Could have used a function instead.
	 */
	if (xdrs->x_op == XDR_ENCODE) {
		size = 0;
		if (!xdr_u_int(xdrs, &size))
			return (FALSE);
	} else {
		if (!xdr_u_int(xdrs, &size))
			return (FALSE);
		if (size == 0) {	/* shrinked format */
			/* get the name from the table object */
			if ((objp->zo_domain = strdup(tobj->zo_domain)) == NULL)
				return (FALSE);
		} else {
			/*
			 * We are opening up the xdr_string implementation here
			 * because we called xdr_u_int() earlier.
			 */
			if ((objp->zo_domain = (char *)malloc(size + 1))
				== NULL)
				return (FALSE);
			if (!xdr_opaque(xdrs, objp->zo_domain, size))
				return (FALSE);
		}
	}

	if (!xdr_u_int(xdrs, &objp->zo_access))
		return (FALSE);
	if (!xdr_u_int(xdrs, &objp->zo_ttl))
		return (FALSE);

	/*
	 * We know that this is an entry object, so we'll save all the entry_obj
	 * space because we can recreate it later.
	 */
	if (xdrs->x_op == XDR_ENCODE)
		return (TRUE);
	/* Now for the DECODE case, just handcraft the entries and ignore XDR */
	objp->zo_data.zo_type = NIS_ENTRY_OBJ;
	if ((objp->zo_data.objdata_u.en_data.en_type =
		strdup(tobj->zo_data.objdata_u.ta_data.ta_type)) == NULL)
		return (FALSE);
	objp->zo_data.objdata_u.en_data.en_cols.en_cols_val = NULL;
	objp->zo_data.objdata_u.en_data.en_cols.en_cols_len = 0;
	return (TRUE);
}

static const char	*in_directory = "IN_DIRECTORY";

/*
 * Given an input NIS+ object, create the kind
 * of pseudo-entry_obj (with an XDR-encoded nis_object in the
 * first column) that's stored in the DB. Note that:
 *
 *	If the input object is an entry, it's assumed to have the
 *	columns moved up one step (col 0 in en_cols.en_cols_val[1],
 *	etc.). en_cols.en_cols_val[0] will be overwritten. The
 *	input object will be changed (some pointers set to zero,
 *	etc.) on exit.
 *
 *	'eo' is assumed to be a pointer to an empty entry_obj (or,
 *	at least, one that can be overwritten). It must not be a
 *	pointer to the entry_obj in 'obj'. If the input object is
 *	of a type other than entry, the 'eo' pointer must have
 *	en_cols.en_cols_val appropriately initialized to an array of
 *	(at least) length one.
 *
 *	'tobj' is a pointer to the table object for the table for
 *	which the entry_obj is destined. It's needed for entry objects,
 *	but unused for other object types.
 */
entry_obj *
makePseudoEntryObj(nis_object *obj, entry_obj *eo, nis_object *tobj) {
	int		bufsize;
	char		*buf;
	XDR		xdrs;
	bool_t		xret;
	uint_t		ecl;
	entry_col	*ecv;
	char		*myself = "makePseudoEntryObj";

	if (obj == 0 || eo == 0)
		return (0);

	if (obj->zo_data.zo_type == NIS_ENTRY_OBJ) {
		*eo = obj->zo_data.objdata_u.en_data;
		eo->en_type = 0;

		/*
		 * To prevent the XDR function from making a copy of
		 * the entry columns, we set the columns structure to
		 * 0 (ie no column data)
		 */
		ecl = obj->EN_data.en_cols.en_cols_len;
		ecv = obj->EN_data.en_cols.en_cols_val;
		obj->EN_data.en_cols.en_cols_len  = 0;
		obj->EN_data.en_cols.en_cols_val  = 0;
	} else {
		eo->en_type = (char *)in_directory;
	}

	bufsize = xdr_sizeof(xdr_nis_object, obj);
	buf = am(myself, bufsize);
	if (buf == 0) {
		if (obj->zo_data.zo_type == NIS_ENTRY_OBJ) {
			obj->EN_data.en_cols.en_cols_len = ecl;
			obj->EN_data.en_cols.en_cols_val = ecv;
		}
		return (0);
	}

	xdrmem_create(&xdrs, (char *)buf, bufsize, XDR_ENCODE);

	if (obj->zo_data.zo_type == NIS_ENTRY_OBJ) {
		xret = xdr_nis_fetus_object(&xdrs, obj, tobj);
	} else {
		xret = xdr_nis_object(&xdrs, obj);
	}

	/* Restore the 'obj' */
	if (obj->zo_data.zo_type == NIS_ENTRY_OBJ) {
		obj->EN_data.en_cols.en_cols_len = ecl;
		obj->EN_data.en_cols.en_cols_val = ecv;
	}

	if (!xret) {
		logmsg(MSG_NOTIMECHECK, LOG_ERR,
			"%s: XDR encode failure", myself);
		sfree(buf);
		return (0);
	}

	eo->en_cols.en_cols_val[0].ec_value.ec_value_val = buf;
	eo->en_cols.en_cols_val[0].ec_value.ec_value_len = xdr_getpos(&xdrs);
	eo->en_cols.en_cols_val[0].ec_flags = EN_BINARY+EN_XDR;

	return (eo);
}

nis_object *
unmakePseudoEntryObj(entry_obj *e, nis_object *tobj) {
	nis_object	*o;
	XDR		xdrs;
	bool_t		stat;
	char		*myself = "unmakePseudoEntryObj";

	if (e == 0 || e->en_cols.en_cols_val == 0 ||
			e->en_cols.en_cols_len == 0)
		return (0);

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

	xdrmem_create(&xdrs, e->en_cols.en_cols_val[0].ec_value.ec_value_val,
			e->en_cols.en_cols_val[0].ec_value.ec_value_len,
			XDR_DECODE);

	if (tobj != 0 && (e->en_type == 0 || e->en_type[0] == '\0')) {
		stat = xdr_nis_fetus_object(&xdrs, o, tobj);
	} else {
		stat = xdr_nis_object(&xdrs, o);
	}

	if (!stat) {
		sfree(o);
		o = 0;
	}

	/*
	 * If it's an entry object, construct the column information.
	 * We make this a copy, so that 'o' can be freed using
	 * nis_destroy_object().
	 */
	if (o != 0 && o->zo_data.zo_type == NIS_ENTRY_OBJ &&
			o->zo_data.objdata_u.en_data.en_cols.en_cols_val == 0 &&
			e->en_cols.en_cols_len > 1) {
		entry_col	*ec, *oec;
		uint_t		i, *ocl;

		ec = am(myself, (e->en_cols.en_cols_len - 1) * sizeof (ec[0]));
		if (ec == 0) {
			nis_destroy_object(o);
			return (0);
		}

		o->zo_data.objdata_u.en_data.en_cols.en_cols_val = ec;
		o->zo_data.objdata_u.en_data.en_cols.en_cols_len = 0;
		ocl = &o->zo_data.objdata_u.en_data.en_cols.en_cols_len;
		oec = e->en_cols.en_cols_val;

		for (i = 1; i < e->en_cols.en_cols_len; i++) {
			uint_t	len;

			if (oec[i].ec_value.ec_value_val != 0) {
				len = oec[i].ec_value.ec_value_len;
				if (len == 0)
					len++;
				ec[i-1].ec_value.ec_value_val = am(myself, len);
				if (ec[i-1].ec_value.ec_value_val == 0) {
					nis_destroy_object(o);
					return (0);
				}
				(void) memcpy(ec[i-1].ec_value.ec_value_val,
						oec[i].ec_value.ec_value_val,
						oec[i].ec_value.ec_value_len);
				ec[i-1].ec_value.ec_value_len =
						oec[i].ec_value.ec_value_len;
			} else {
				ec[i-1].ec_value.ec_value_val = 0;
				ec[i-1].ec_value.ec_value_len = 0;
			}
			*ocl += 1;
		}
	}

	/*
	 * If it's an entry, and we have the table object, make sure
	 * zo_name and en_type either already are set, or get them
	 * from the table.
	 */
	if (o != 0 && o->zo_data.zo_type == NIS_ENTRY_OBJ && tobj != 0) {
		if (o->zo_name == 0)
			o->zo_name = sdup(myself, T, tobj->zo_name);
		if (o->zo_data.objdata_u.en_data.en_type == 0)
			o->zo_data.objdata_u.en_data.en_type = sdup(myself, T,
				tobj->zo_data.objdata_u.ta_data.ta_type);
	}

	return (o);
}

/*
 * Input:  A (nis_object *), and (optionally) an (entry_obj *) array.
 * Output: Pointer to an XDR:ed version of an (xdr_nis_object_t).
 */
void *
xdrNisObject(nis_object *obj, entry_obj **ea, int numEa, int *xdrLenP) {
	xdr_nis_object_t	xno;
	void			*buf;
	int			xdrLen;
	XDR			xdrs;
	bool_t			xret;
	char			*myself = "xdrNisObject";

	if (obj == 0)
		return (0);

	/*
	 * The version tells us what the XDR:ed buffer contains.
	 * Should be incremented whenever xdr_nis_object_t changes
	 * incompatibly.
	 */
	xno.xversion = 1;

	xno.obj = obj;

	if (obj->zo_data.zo_type == NIS_DIRECTORY_OBJ &&
			ea != 0 && numEa > 0) {
		int	i;

		/*
		 * The ea[] array is expected to contain the kind of
		 * pseudo-entry object stored in the nisdb incarnation
		 * of a NIS+ directory. Column zero contains the XDR:ed
		 * directory entry object (which we ignore), while column
		 * one contains the name of said entry. It's the latter
		 * that we borrow for use in the dirEntry[] list of the
		 * xdr_nis_object_t.
		 */

		xno.dirEntry.dirEntry_len = 0;
		xno.dirEntry.dirEntry_val = am(myself, numEa *
			sizeof (xno.dirEntry.dirEntry_val[0]));
		if (xno.dirEntry.dirEntry_val == 0)
			return (0);

		for (i = 0; i < numEa; i++) {
			if (ea[i] == 0 || ea[i]->en_cols.en_cols_val == 0 ||
					ea[i]->en_cols.en_cols_len != 2 ||
					ea[i]->en_cols.en_cols_val[1].
						ec_value.ec_value_len == 0)
				continue;
			/*
			 * Yes, there's a NUL at the end of the dir entry
			 * name.
			 */
			xno.dirEntry.dirEntry_val[xno.dirEntry.dirEntry_len] =
				ea[i]->en_cols.en_cols_val[1].
					ec_value.ec_value_val;
			xno.dirEntry.dirEntry_len++;
		}
	} else {
		/* No directory entries */
		xno.dirEntry.dirEntry_len = 0;
		xno.dirEntry.dirEntry_val = 0;
	}

	xdrLen = xdr_sizeof(xdr_xdr_nis_object_t, &xno);
	buf = am(myself, xdrLen);
	if (buf == 0)
		return (0);

	xdrmem_create(&xdrs, (char *)buf, xdrLen, XDR_ENCODE);

	xret = xdr_xdr_nis_object_t(&xdrs, &xno);

	sfree(xno.dirEntry.dirEntry_val);

	if (!xret) {
		sfree(buf);
		return (0);
	}

	if (xdrLenP != 0)
		*xdrLenP = xdrLen;

	return (buf);
}

/*
 * Input:  Pointer to an XDR:ed version of an (xdr_nis_object_t).
 * Output: Pointer to a (nis_object *) and (if the object is a
 *         directory) a pointer to an array of (entry_obj *).
 */
nis_object *
unXdrNisObject(void *buf, int bufLen, entry_obj ***eaP, int *numEaP) {
	xdr_nis_object_t	*xno;
	XDR			xdrs;
	bool_t			xret;
	entry_obj		**ea;
	int			numEa;
	nis_object		*o;
	char			*myself = "unXdrNisObject";

	if (buf == 0 || bufLen <= 0)
		return (0);

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

	xdrmem_create(&xdrs, buf, bufLen, XDR_DECODE);
	xret = xdr_xdr_nis_object_t(&xdrs, xno);

	if (!xret) {
		sfree(xno);
		return (0);
	}

	switch (xno->xversion) {
	case 1:
		break;
	default:
		xdr_free(xdr_xdr_nis_object_t, (char *)xno);
		sfree(xno);
		logmsg(MSG_NOTIMECHECK, LOG_WARNING,
			"%s: Unknown xdr_nis_object_t version %d",
			myself, xno->xversion);
		return (0);
	}

	if (eaP != 0 && numEaP != 0 && xno->dirEntry.dirEntry_len > 0 &&
			xno->dirEntry.dirEntry_val != 0) {
		ea = am(myself, xno->dirEntry.dirEntry_len * sizeof (ea[0]));
		if (ea == 0) {
			xdr_free(xdr_xdr_nis_object_t, (char *)xno);
			sfree(xno);
			return (0);
		}
		for (numEa = 0; numEa < xno->dirEntry.dirEntry_len; numEa++) {
			ea[numEa] = am(myself, sizeof (*ea[numEa]));
			if (ea[numEa] != 0) {
				ea[numEa]->en_cols.en_cols_len = 2;
				ea[numEa]->en_cols.en_cols_val = am(myself,
					ea[numEa]->en_cols.en_cols_len *
				sizeof (ea[numEa]->en_cols.en_cols_val[0]));
			}
			if (ea[numEa] == 0 ||
					ea[numEa]->en_cols.en_cols_val == 0) {
				int	i;
				for (i = 0; i < numEa; i++) {
					sfree(ea[i]->en_cols.en_cols_val);
					sfree(ea[i]);
				}
				sfree(ea);
				xdr_free(xdr_xdr_nis_object_t, (char *)xno);
				sfree(xno);
				return (0);
			}
			/* Leave column 0 (XDR:ed object) empty */
			ea[numEa]->en_cols.en_cols_val[0].
				ec_value.ec_value_len = 0;
			ea[numEa]->en_cols.en_cols_val[0].
				ec_value.ec_value_val = 0;
			/*
			 * Fill in name of dir entry. The DB counts the NUL
			 * as part of the dir entry name; hence, add one
			 * to the string length.
			 */
			ea[numEa]->en_cols.en_cols_val[1].
				ec_value.ec_value_len = slen(xno->dirEntry.
					dirEntry_val[numEa]) + 1;
			ea[numEa]->en_cols.en_cols_val[1].
				ec_value.ec_value_val =
					xno->dirEntry.dirEntry_val[numEa];
		}
		*eaP = ea;
		*numEaP = numEa;
		/*
		 * The xno->dirEntry.dirEntry_val[] pointers are duplicated
		 * in 'ea'. Set the xno pointers to zero, so that the xdr_free
		 * doesn't free the 'ea' data.
		 */
		if (numEa > 0) {
			int	i;
			for (i = 0; i < numEa; i++) {
				xno->dirEntry.dirEntry_val[i] = 0;
			}
		}
	} else {
		if (eaP != 0)
			*eaP = 0;
		if (numEaP != 0)
			*numEaP = 0;
	}

	o = xno->obj;
	xno->obj = 0;
	xdr_free(xdr_xdr_nis_object_t, (char *)xno);
	sfree(xno);

	return (o);
}

void
freeEntryObjArray(entry_obj **ea, int numEa) {
	int	i;

	if (ea == 0)
		return;

	for (i = 0; i < numEa; i++) {
		int	j;

		for (j = 0; j < ea[i]->en_cols.en_cols_len; j++) {
			sfree(ea[i]->en_cols.en_cols_val[j].
				ec_value.ec_value_val);
		}

		sfree(ea[i]->en_cols.en_cols_val);
	}

	sfree(ea);
}

/*
 * Return TRUE if 'o1' and 'o2' are the same, FALSE otherwise.
 * We perform the comparison by XDR encoding the objects, and then
 * checking the XDR buffers for equality. However, we don't want to
 * include the zo_oid (i.e., ctime and mtime) in the comparison.
 */
bool_t
sameNisPlusObj(nis_object *o1, nis_object *o2) {
	XDR		x1, x2;
	void		*b1, *b2;
	int		l1, l2;
	bool_t		ret;
	nis_object	obj1, obj2;
	char		*myself = "sameNisPlusObj";

	if (o1 == o2)
		return (TRUE);
	else if (o1 == 0 || o2 == 0)
		return (FALSE);

	/*
	 * We want to exclude the zo_oid from the comparison. In order
	 * not to modify the objects (even very briefly), we do this by
	 * making copies (nis_object itself only, not the underlying
	 * structures accessed through pointers), and setting the zo_oid
	 * to zero in the copies.
	 */
	obj1 = *o1;
	obj2 = *o2;
	obj1.zo_oid.ctime = obj1.zo_oid.mtime = 0;
	obj2.zo_oid.ctime = obj2.zo_oid.mtime = 0;

	l1 = xdr_sizeof(xdr_nis_object, &obj1);
	l2 = xdr_sizeof(xdr_nis_object, &obj2);
	if (l1 != l2)
		return (FALSE);

	b1 = am(myself, l1);
	b2 = am(myself, l2);
	if (b1 == 0 || b2 == 0) {
		sfree(b1);
		sfree(b2);
		return (FALSE);
	}

	xdrmem_create(&x1, (char *)b1, l1, XDR_ENCODE);
	xdrmem_create(&x2, (char *)b2, l2, XDR_ENCODE);

	if (xdr_nis_object(&x1, &obj1) && xdr_nis_object(&x2, &obj2)) {
		ret = (memcmp(b1, b2, l1) == 0);
	} else {
		logmsg(MSG_NOTIMECHECK, LOG_WARNING,
			"%s: xdr_nis_object() error",
			myself);
		ret = FALSE;
	}

	sfree(b1);
	sfree(b2);

	return (ret);
}

/*
 * A wrapper/convenience function for sameNisPlusObj() that extracts
 * the object in column zero of 'e2'.
 */
bool_t
sameNisPlusPseudoObj(nis_object *o1, entry_obj *e2) {
	nis_object	*o2;
	bool_t		res;

	if (o1 == 0 && e2 == 0)
		return (TRUE);
	else if (e2 == 0)
		return (FALSE);

	o2 = unmakePseudoEntryObj(e2, 0);
	if (o2 == 0)
		return ((o1 == 0) ? TRUE : FALSE);

	res = sameNisPlusObj(o1, o2);

	nis_destroy_object(o2);

	return (res);
}