xref: /illumos-gate/usr/src/lib/libnisdb/ldap_xdr.c (revision 7c478bd9)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright (c) 2001 by Sun Microsystems, Inc.
24  * All rights reserved.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <string.h>
30 #include <sys/syslog.h>
31 #include <sys/types.h>
32 #include <rpc/types.h>
33 #include <rpc/xdr.h>
34 #include <rpcsvc/nis.h>
35 
36 #include "db_mindex_c.h"
37 
38 #include "ldap_xdr.h"
39 #include "ldap_util.h"
40 
41 extern bool_t xdr_nis_object();
42 
43 /*
44  * In order not to change the on-disk NIS+ DB format, we need make sure
45  * that XDR does nothing for the new structures added to various C++
46  * classes.
47  */
48 
49 bool_t
50 xdr___nis_table_mapping_t(XDR *xdrs, void *t) {
51 	return (TRUE);
52 }
53 
54 bool_t
55 xdr___nisdb_ptr_t(XDR *xdrs, void *ptr) {
56 	return (TRUE);
57 }
58 
59 bool_t
60 xdr___nisdb_dictionary_defer_t(XDR *xdrs, void *defer) {
61 	return (TRUE);
62 }
63 
64 bool_t
65 xdr___nisdb_rwlock_t(XDR *xdrs, void *rw) {
66 	return (TRUE);
67 }
68 
69 bool_t
70 xdr___nisdb_flag_t(XDR *xdrs, void *flag) {
71 	return (TRUE);
72 }
73 
74 /*
75  * Imported from rpc.nisd/nis_db.c
76  *
77  * Special abbreviated XDR string which knows that the namep parameter (mainly
78  * owner and group) has a trailing end which matches the last 'n' characters
79  * in the domainname part.  It makes use of those common characters to
80  * encode/decode this information.  We append an integer string to the
81  * name to be encoded which denotes the place in the domainname from where the
82  * common string starts.  For example, if the name was "foo.my.domain." and the
83  * domainname was "my.domain.", the name would be encoded as "foo.10" because
84  * the length of the common part "my.domain." is 10.
85  */
86 bool_t
87 xdr_nis_name_abbrev(
88 	XDR		*xdrs,
89 	nis_name	*namep,
90 	nis_name	domainname)	/* domainname field from the table */
91 {
92 	size_t	name_len, dom_len, min_len;
93 	char 	buf[NIS_MAXNAMELEN];
94 	char 	*name;
95 	char	*lenstr, *tmp;
96 	int	i;
97 
98 	switch (xdrs->x_op) {
99 	case XDR_ENCODE:
100 		/* Get the start of the common part */
101 		name = *namep;
102 		name_len = strlen(name);
103 		if (name_len == 0)
104 			return (xdr_nis_name(xdrs, namep));
105 		dom_len = strlen(domainname);
106 		min_len = (name_len < dom_len) ? name_len : dom_len;
107 		for (i = 1; i <= min_len; i++) {
108 			if (name[name_len - i] != domainname[dom_len - i])
109 				break;
110 		}
111 		i--;
112 		memcpy(buf, name, name_len - i);
113 		sprintf(buf + name_len - i, ".%d", dom_len - i);
114 		tmp = buf;
115 		return (xdr_nis_name(xdrs, &tmp));
116 
117 	case XDR_DECODE:
118 		tmp = buf;
119 		if (!xdr_nis_name(xdrs, &tmp))
120 		    return (FALSE);
121 		if ((buf[0] == NULL) || buf[strlen(buf) - 1] == '.') {
122 			/* It is either a FQN or a NULL string */
123 			if (*namep) {
124 				strcpy(*namep, buf);
125 				return (TRUE);
126 			} else {
127 				if ((*namep = strdup(buf)) == NULL)
128 					return (FALSE);
129 				else
130 					return (TRUE);
131 			}
132 		}
133 		/* Now concoct the new name */
134 		if ((lenstr = strrchr(buf, '.')) == NULL) {
135 			/* something went wrong here */
136 			syslog(LOG_ERR,
137 				"xdr_nis_name_abbrev: no dot found in %s", buf);
138 			return (FALSE);
139 		}
140 		i = atoi(lenstr + 1);
141 		strcpy(lenstr, domainname + i);
142 		if (*namep) {
143 			strcpy(*namep, buf);
144 		} else {
145 			if ((*namep = strdup(buf)) == NULL)
146 				return (FALSE);
147 		}
148 		return (TRUE);
149 
150 	default:
151 		return (xdr_nis_name(xdrs, namep));
152 	}
153 }
154 
155 /*
156  * Imported from rpc.nisd/nis_db.c
157  *
158  * special XDR for fetus object.  We create the actual object from the
159  * "forming" object plus the table object.  We create this special object to
160  * save the following components of the nis_object:
161  *	zo_name and zo_domain: replaced by just the length field of 0.  We had
162  *		to keep the length field for backward compatibility.  If we
163  *		ever change the object format, we should fix this.
164  *	zo_owner and zo_group: we condensed it by abbreviating the common part
165  *		shared between the table object and the entry object
166  *	en_type: Avoided altogether
167  *	zo_type and other en_data: Avoided altogether.
168  *
169  * XXX: If the definition of nis_object ever changes, this should be changed.
170  */
171 bool_t
172 xdr_nis_fetus_object(
173 	XDR		*xdrs,
174 	nis_object	*objp,	/* Entry object */
175 	nis_object	*tobj)	/* Table object */
176 {
177 	uint_t	size;
178 
179 	if (xdrs->x_op == XDR_FREE)
180 		return (xdr_nis_object(xdrs, objp));
181 	if (!xdr_nis_oid(xdrs, &objp->zo_oid))
182 		return (FALSE);
183 
184 	/*
185 	 * While encoding of zo_name, we put 0 in the length field, while for
186 	 * decoding, we get the name from the table object.
187 	 */
188 	if (xdrs->x_op == XDR_ENCODE) {
189 		size = 0;
190 		if (!xdr_u_int(xdrs, &size))
191 			return (FALSE);
192 	} else {
193 		if (!xdr_u_int(xdrs, &size))
194 			return (FALSE);
195 		if (size == 0) {	/* shrinked format */
196 			/* get the name from the table object */
197 			if ((objp->zo_name = strdup(tobj->zo_name)) == NULL)
198 				return (FALSE);
199 		} else {
200 			/*
201 			 * We are opening up the xdr_string implementation here
202 			 * because we called xdr_u_int() earlier.
203 			 */
204 			if ((objp->zo_name = (char *)malloc(size + 1)) == NULL)
205 				return (FALSE);
206 			if (!xdr_opaque(xdrs, objp->zo_name, size))
207 				return (FALSE);
208 		}
209 	}
210 
211 	/*
212 	 * We use the xdr_nis_name_abbrev() function for both owner
213 	 * and group which constructs the name from the domain name.
214 	 */
215 	if (!xdr_nis_name_abbrev(xdrs, &objp->zo_owner, tobj->zo_domain))
216 		return (FALSE);
217 	if (!xdr_nis_name_abbrev(xdrs, &objp->zo_group, tobj->zo_domain))
218 		return (FALSE);
219 
220 	/*
221 	 * While encoding of zo_domain, we put 0 in the length field, while for
222 	 * decoding, we get the name from the table object.  Same as above for
223 	 * the name.  Could have used a function instead.
224 	 */
225 	if (xdrs->x_op == XDR_ENCODE) {
226 		size = 0;
227 		if (!xdr_u_int(xdrs, &size))
228 			return (FALSE);
229 	} else {
230 		if (!xdr_u_int(xdrs, &size))
231 			return (FALSE);
232 		if (size == 0) {	/* shrinked format */
233 			/* get the name from the table object */
234 			if ((objp->zo_domain = strdup(tobj->zo_domain)) == NULL)
235 				return (FALSE);
236 		} else {
237 			/*
238 			 * We are opening up the xdr_string implementation here
239 			 * because we called xdr_u_int() earlier.
240 			 */
241 			if ((objp->zo_domain = (char *)malloc(size + 1))
242 				== NULL)
243 				return (FALSE);
244 			if (!xdr_opaque(xdrs, objp->zo_domain, size))
245 				return (FALSE);
246 		}
247 	}
248 
249 	if (!xdr_u_int(xdrs, &objp->zo_access))
250 		return (FALSE);
251 	if (!xdr_u_int(xdrs, &objp->zo_ttl))
252 		return (FALSE);
253 
254 	/*
255 	 * We know that this is an entry object, so we'll save all the entry_obj
256 	 * space because we can recreate it later.
257 	 */
258 	if (xdrs->x_op == XDR_ENCODE)
259 		return (TRUE);
260 	/* Now for the DECODE case, just handcraft the entries and ignore XDR */
261 	objp->zo_data.zo_type = NIS_ENTRY_OBJ;
262 	if ((objp->zo_data.objdata_u.en_data.en_type =
263 		strdup(tobj->zo_data.objdata_u.ta_data.ta_type)) == NULL)
264 		return (FALSE);
265 	objp->zo_data.objdata_u.en_data.en_cols.en_cols_val = NULL;
266 	objp->zo_data.objdata_u.en_data.en_cols.en_cols_len = 0;
267 	return (TRUE);
268 }
269 
270 static const char	*in_directory = "IN_DIRECTORY";
271 
272 /*
273  * Given an input NIS+ object, create the kind
274  * of pseudo-entry_obj (with an XDR-encoded nis_object in the
275  * first column) that's stored in the DB. Note that:
276  *
277  *	If the input object is an entry, it's assumed to have the
278  *	columns moved up one step (col 0 in en_cols.en_cols_val[1],
279  *	etc.). en_cols.en_cols_val[0] will be overwritten. The
280  *	input object will be changed (some pointers set to zero,
281  *	etc.) on exit.
282  *
283  *	'eo' is assumed to be a pointer to an empty entry_obj (or,
284  *	at least, one that can be overwritten). It must not be a
285  *	pointer to the entry_obj in 'obj'. If the input object is
286  *	of a type other than entry, the 'eo' pointer must have
287  *	en_cols.en_cols_val appropriately initialized to an array of
288  *	(at least) length one.
289  *
290  *	'tobj' is a pointer to the table object for the table for
291  *	which the entry_obj is destined. It's needed for entry objects,
292  *	but unused for other object types.
293  */
294 entry_obj *
295 makePseudoEntryObj(nis_object *obj, entry_obj *eo, nis_object *tobj) {
296 	int		bufsize;
297 	char		*buf;
298 	XDR		xdrs;
299 	bool_t		xret;
300 	uint_t		ecl;
301 	entry_col	*ecv;
302 	char		*myself = "makePseudoEntryObj";
303 
304 	if (obj == 0 || eo == 0)
305 		return (0);
306 
307 	if (obj->zo_data.zo_type == NIS_ENTRY_OBJ) {
308 		*eo = obj->zo_data.objdata_u.en_data;
309 		eo->en_type = 0;
310 
311 		/*
312 		 * To prevent the XDR function from making a copy of
313 		 * the entry columns, we set the columns structure to
314 		 * 0 (ie no column data)
315 		 */
316 		ecl = obj->EN_data.en_cols.en_cols_len;
317 		ecv = obj->EN_data.en_cols.en_cols_val;
318 		obj->EN_data.en_cols.en_cols_len  = 0;
319 		obj->EN_data.en_cols.en_cols_val  = 0;
320 	} else {
321 		eo->en_type = (char *)in_directory;
322 	}
323 
324 	bufsize = xdr_sizeof(xdr_nis_object, obj);
325 	buf = am(myself, bufsize);
326 	if (buf == 0) {
327 		if (obj->zo_data.zo_type == NIS_ENTRY_OBJ) {
328 			obj->EN_data.en_cols.en_cols_len = ecl;
329 			obj->EN_data.en_cols.en_cols_val = ecv;
330 		}
331 		return (0);
332 	}
333 
334 	xdrmem_create(&xdrs, (char *)buf, bufsize, XDR_ENCODE);
335 
336 	if (obj->zo_data.zo_type == NIS_ENTRY_OBJ) {
337 		xret = xdr_nis_fetus_object(&xdrs, obj, tobj);
338 	} else {
339 		xret = xdr_nis_object(&xdrs, obj);
340 	}
341 
342 	/* Restore the 'obj' */
343 	if (obj->zo_data.zo_type == NIS_ENTRY_OBJ) {
344 		obj->EN_data.en_cols.en_cols_len = ecl;
345 		obj->EN_data.en_cols.en_cols_val = ecv;
346 	}
347 
348 	if (!xret) {
349 		logmsg(MSG_NOTIMECHECK, LOG_ERR,
350 			"%s: XDR encode failure", myself);
351 		sfree(buf);
352 		return (0);
353 	}
354 
355 	eo->en_cols.en_cols_val[0].ec_value.ec_value_val = buf;
356 	eo->en_cols.en_cols_val[0].ec_value.ec_value_len = xdr_getpos(&xdrs);
357 	eo->en_cols.en_cols_val[0].ec_flags = EN_BINARY+EN_XDR;
358 
359 	return (eo);
360 }
361 
362 nis_object *
363 unmakePseudoEntryObj(entry_obj *e, nis_object *tobj) {
364 	nis_object	*o;
365 	XDR		xdrs;
366 	bool_t		stat;
367 	char		*myself = "unmakePseudoEntryObj";
368 
369 	if (e == 0 || e->en_cols.en_cols_val == 0 ||
370 			e->en_cols.en_cols_len == 0)
371 		return (0);
372 
373 	o = am(myself, sizeof (*o));
374 	if (o == 0)
375 		return (0);
376 
377 	xdrmem_create(&xdrs, e->en_cols.en_cols_val[0].ec_value.ec_value_val,
378 			e->en_cols.en_cols_val[0].ec_value.ec_value_len,
379 			XDR_DECODE);
380 
381 	if (tobj != 0 && (e->en_type == 0 || e->en_type[0] == '\0')) {
382 		stat = xdr_nis_fetus_object(&xdrs, o, tobj);
383 	} else {
384 		stat = xdr_nis_object(&xdrs, o);
385 	}
386 
387 	if (!stat) {
388 		sfree(o);
389 		o = 0;
390 	}
391 
392 	/*
393 	 * If it's an entry object, construct the column information.
394 	 * We make this a copy, so that 'o' can be freed using
395 	 * nis_destroy_object().
396 	 */
397 	if (o != 0 && o->zo_data.zo_type == NIS_ENTRY_OBJ &&
398 			o->zo_data.objdata_u.en_data.en_cols.en_cols_val == 0 &&
399 			e->en_cols.en_cols_len > 1) {
400 		entry_col	*ec, *oec;
401 		uint_t		i, *ocl;
402 
403 		ec = am(myself, (e->en_cols.en_cols_len - 1) * sizeof (ec[0]));
404 		if (ec == 0) {
405 			nis_destroy_object(o);
406 			return (0);
407 		}
408 
409 		o->zo_data.objdata_u.en_data.en_cols.en_cols_val = ec;
410 		o->zo_data.objdata_u.en_data.en_cols.en_cols_len = 0;
411 		ocl = &o->zo_data.objdata_u.en_data.en_cols.en_cols_len;
412 		oec = e->en_cols.en_cols_val;
413 
414 		for (i = 1; i < e->en_cols.en_cols_len; i++) {
415 			uint_t	len;
416 
417 			if (oec[i].ec_value.ec_value_val != 0) {
418 				len = oec[i].ec_value.ec_value_len;
419 				if (len == 0)
420 					len++;
421 				ec[i-1].ec_value.ec_value_val = am(myself, len);
422 				if (ec[i-1].ec_value.ec_value_val == 0) {
423 					nis_destroy_object(o);
424 					return (0);
425 				}
426 				(void) memcpy(ec[i-1].ec_value.ec_value_val,
427 						oec[i].ec_value.ec_value_val,
428 						oec[i].ec_value.ec_value_len);
429 				ec[i-1].ec_value.ec_value_len =
430 						oec[i].ec_value.ec_value_len;
431 			} else {
432 				ec[i-1].ec_value.ec_value_val = 0;
433 				ec[i-1].ec_value.ec_value_len = 0;
434 			}
435 			*ocl += 1;
436 		}
437 	}
438 
439 	/*
440 	 * If it's an entry, and we have the table object, make sure
441 	 * zo_name and en_type either already are set, or get them
442 	 * from the table.
443 	 */
444 	if (o != 0 && o->zo_data.zo_type == NIS_ENTRY_OBJ && tobj != 0) {
445 		if (o->zo_name == 0)
446 			o->zo_name = sdup(myself, T, tobj->zo_name);
447 		if (o->zo_data.objdata_u.en_data.en_type == 0)
448 			o->zo_data.objdata_u.en_data.en_type = sdup(myself, T,
449 				tobj->zo_data.objdata_u.ta_data.ta_type);
450 	}
451 
452 	return (o);
453 }
454 
455 /*
456  * Input:  A (nis_object *), and (optionally) an (entry_obj *) array.
457  * Output: Pointer to an XDR:ed version of an (xdr_nis_object_t).
458  */
459 void *
460 xdrNisObject(nis_object *obj, entry_obj **ea, int numEa, int *xdrLenP) {
461 	xdr_nis_object_t	xno;
462 	void			*buf;
463 	int			xdrLen;
464 	XDR			xdrs;
465 	bool_t			xret;
466 	char			*myself = "xdrNisObject";
467 
468 	if (obj == 0)
469 		return (0);
470 
471 	/*
472 	 * The version tells us what the XDR:ed buffer contains.
473 	 * Should be incremented whenever xdr_nis_object_t changes
474 	 * incompatibly.
475 	 */
476 	xno.xversion = 1;
477 
478 	xno.obj = obj;
479 
480 	if (obj->zo_data.zo_type == NIS_DIRECTORY_OBJ &&
481 			ea != 0 && numEa > 0) {
482 		int	i;
483 
484 		/*
485 		 * The ea[] array is expected to contain the kind of
486 		 * pseudo-entry object stored in the nisdb incarnation
487 		 * of a NIS+ directory. Column zero contains the XDR:ed
488 		 * directory entry object (which we ignore), while column
489 		 * one contains the name of said entry. It's the latter
490 		 * that we borrow for use in the dirEntry[] list of the
491 		 * xdr_nis_object_t.
492 		 */
493 
494 		xno.dirEntry.dirEntry_len = 0;
495 		xno.dirEntry.dirEntry_val = am(myself, numEa *
496 			sizeof (xno.dirEntry.dirEntry_val[0]));
497 		if (xno.dirEntry.dirEntry_val == 0)
498 			return (0);
499 
500 		for (i = 0; i < numEa; i++) {
501 			if (ea[i] == 0 || ea[i]->en_cols.en_cols_val == 0 ||
502 					ea[i]->en_cols.en_cols_len != 2 ||
503 					ea[i]->en_cols.en_cols_val[1].
504 						ec_value.ec_value_len == 0)
505 				continue;
506 			/*
507 			 * Yes, there's a NUL at the end of the dir entry
508 			 * name.
509 			 */
510 			xno.dirEntry.dirEntry_val[xno.dirEntry.dirEntry_len] =
511 				ea[i]->en_cols.en_cols_val[1].
512 					ec_value.ec_value_val;
513 			xno.dirEntry.dirEntry_len++;
514 		}
515 	} else {
516 		/* No directory entries */
517 		xno.dirEntry.dirEntry_len = 0;
518 		xno.dirEntry.dirEntry_val = 0;
519 	}
520 
521 	xdrLen = xdr_sizeof(xdr_xdr_nis_object_t, &xno);
522 	buf = am(myself, xdrLen);
523 	if (buf == 0)
524 		return (0);
525 
526 	xdrmem_create(&xdrs, (char *)buf, xdrLen, XDR_ENCODE);
527 
528 	xret = xdr_xdr_nis_object_t(&xdrs, &xno);
529 
530 	sfree(xno.dirEntry.dirEntry_val);
531 
532 	if (!xret) {
533 		sfree(buf);
534 		return (0);
535 	}
536 
537 	if (xdrLenP != 0)
538 		*xdrLenP = xdrLen;
539 
540 	return (buf);
541 }
542 
543 /*
544  * Input:  Pointer to an XDR:ed version of an (xdr_nis_object_t).
545  * Output: Pointer to a (nis_object *) and (if the object is a
546  *         directory) a pointer to an array of (entry_obj *).
547  */
548 nis_object *
549 unXdrNisObject(void *buf, int bufLen, entry_obj ***eaP, int *numEaP) {
550 	xdr_nis_object_t	*xno;
551 	XDR			xdrs;
552 	bool_t			xret;
553 	entry_obj		**ea;
554 	int			numEa;
555 	nis_object		*o;
556 	char			*myself = "unXdrNisObject";
557 
558 	if (buf == 0 || bufLen <= 0)
559 		return (0);
560 
561 	xno = am(myself, sizeof (*xno));
562 	if (xno == 0)
563 		return (0);
564 
565 	xdrmem_create(&xdrs, buf, bufLen, XDR_DECODE);
566 	xret = xdr_xdr_nis_object_t(&xdrs, xno);
567 
568 	if (!xret) {
569 		sfree(xno);
570 		return (0);
571 	}
572 
573 	switch (xno->xversion) {
574 	case 1:
575 		break;
576 	default:
577 		xdr_free(xdr_xdr_nis_object_t, (char *)xno);
578 		sfree(xno);
579 		logmsg(MSG_NOTIMECHECK, LOG_WARNING,
580 			"%s: Unknown xdr_nis_object_t version %d",
581 			myself, xno->xversion);
582 		return (0);
583 	}
584 
585 	if (eaP != 0 && numEaP != 0 && xno->dirEntry.dirEntry_len > 0 &&
586 			xno->dirEntry.dirEntry_val != 0) {
587 		ea = am(myself, xno->dirEntry.dirEntry_len * sizeof (ea[0]));
588 		if (ea == 0) {
589 			xdr_free(xdr_xdr_nis_object_t, (char *)xno);
590 			sfree(xno);
591 			return (0);
592 		}
593 		for (numEa = 0; numEa < xno->dirEntry.dirEntry_len; numEa++) {
594 			ea[numEa] = am(myself, sizeof (*ea[numEa]));
595 			if (ea[numEa] != 0) {
596 				ea[numEa]->en_cols.en_cols_len = 2;
597 				ea[numEa]->en_cols.en_cols_val = am(myself,
598 					ea[numEa]->en_cols.en_cols_len *
599 				sizeof (ea[numEa]->en_cols.en_cols_val[0]));
600 			}
601 			if (ea[numEa] == 0 ||
602 					ea[numEa]->en_cols.en_cols_val == 0) {
603 				int	i;
604 				for (i = 0; i < numEa; i++) {
605 					sfree(ea[i]->en_cols.en_cols_val);
606 					sfree(ea[i]);
607 				}
608 				sfree(ea);
609 				xdr_free(xdr_xdr_nis_object_t, (char *)xno);
610 				sfree(xno);
611 				return (0);
612 			}
613 			/* Leave column 0 (XDR:ed object) empty */
614 			ea[numEa]->en_cols.en_cols_val[0].
615 				ec_value.ec_value_len = 0;
616 			ea[numEa]->en_cols.en_cols_val[0].
617 				ec_value.ec_value_val = 0;
618 			/*
619 			 * Fill in name of dir entry. The DB counts the NUL
620 			 * as part of the dir entry name; hence, add one
621 			 * to the string length.
622 			 */
623 			ea[numEa]->en_cols.en_cols_val[1].
624 				ec_value.ec_value_len = slen(xno->dirEntry.
625 					dirEntry_val[numEa]) + 1;
626 			ea[numEa]->en_cols.en_cols_val[1].
627 				ec_value.ec_value_val =
628 					xno->dirEntry.dirEntry_val[numEa];
629 		}
630 		*eaP = ea;
631 		*numEaP = numEa;
632 		/*
633 		 * The xno->dirEntry.dirEntry_val[] pointers are duplicated
634 		 * in 'ea'. Set the xno pointers to zero, so that the xdr_free
635 		 * doesn't free the 'ea' data.
636 		 */
637 		if (numEa > 0) {
638 			int	i;
639 			for (i = 0; i < numEa; i++) {
640 				xno->dirEntry.dirEntry_val[i] = 0;
641 			}
642 		}
643 	} else {
644 		if (eaP != 0)
645 			*eaP = 0;
646 		if (numEaP != 0)
647 			*numEaP = 0;
648 	}
649 
650 	o = xno->obj;
651 	xno->obj = 0;
652 	xdr_free(xdr_xdr_nis_object_t, (char *)xno);
653 	sfree(xno);
654 
655 	return (o);
656 }
657 
658 void
659 freeEntryObjArray(entry_obj **ea, int numEa) {
660 	int	i;
661 
662 	if (ea == 0)
663 		return;
664 
665 	for (i = 0; i < numEa; i++) {
666 		int	j;
667 
668 		for (j = 0; j < ea[i]->en_cols.en_cols_len; j++) {
669 			sfree(ea[i]->en_cols.en_cols_val[j].
670 				ec_value.ec_value_val);
671 		}
672 
673 		sfree(ea[i]->en_cols.en_cols_val);
674 	}
675 
676 	sfree(ea);
677 }
678 
679 /*
680  * Return TRUE if 'o1' and 'o2' are the same, FALSE otherwise.
681  * We perform the comparison by XDR encoding the objects, and then
682  * checking the XDR buffers for equality. However, we don't want to
683  * include the zo_oid (i.e., ctime and mtime) in the comparison.
684  */
685 bool_t
686 sameNisPlusObj(nis_object *o1, nis_object *o2) {
687 	XDR		x1, x2;
688 	void		*b1, *b2;
689 	int		l1, l2;
690 	bool_t		ret;
691 	nis_object	obj1, obj2;
692 	char		*myself = "sameNisPlusObj";
693 
694 	if (o1 == o2)
695 		return (TRUE);
696 	else if (o1 == 0 || o2 == 0)
697 		return (FALSE);
698 
699 	/*
700 	 * We want to exclude the zo_oid from the comparison. In order
701 	 * not to modify the objects (even very briefly), we do this by
702 	 * making copies (nis_object itself only, not the underlying
703 	 * structures accessed through pointers), and setting the zo_oid
704 	 * to zero in the copies.
705 	 */
706 	obj1 = *o1;
707 	obj2 = *o2;
708 	obj1.zo_oid.ctime = obj1.zo_oid.mtime = 0;
709 	obj2.zo_oid.ctime = obj2.zo_oid.mtime = 0;
710 
711 	l1 = xdr_sizeof(xdr_nis_object, &obj1);
712 	l2 = xdr_sizeof(xdr_nis_object, &obj2);
713 	if (l1 != l2)
714 		return (FALSE);
715 
716 	b1 = am(myself, l1);
717 	b2 = am(myself, l2);
718 	if (b1 == 0 || b2 == 0) {
719 		sfree(b1);
720 		sfree(b2);
721 		return (FALSE);
722 	}
723 
724 	xdrmem_create(&x1, (char *)b1, l1, XDR_ENCODE);
725 	xdrmem_create(&x2, (char *)b2, l2, XDR_ENCODE);
726 
727 	if (xdr_nis_object(&x1, &obj1) && xdr_nis_object(&x2, &obj2)) {
728 		ret = (memcmp(b1, b2, l1) == 0);
729 	} else {
730 		logmsg(MSG_NOTIMECHECK, LOG_WARNING,
731 			"%s: xdr_nis_object() error",
732 			myself);
733 		ret = FALSE;
734 	}
735 
736 	sfree(b1);
737 	sfree(b2);
738 
739 	return (ret);
740 }
741 
742 /*
743  * A wrapper/convenience function for sameNisPlusObj() that extracts
744  * the object in column zero of 'e2'.
745  */
746 bool_t
747 sameNisPlusPseudoObj(nis_object *o1, entry_obj *e2) {
748 	nis_object	*o2;
749 	bool_t		res;
750 
751 	if (o1 == 0 && e2 == 0)
752 		return (TRUE);
753 	else if (e2 == 0)
754 		return (FALSE);
755 
756 	o2 = unmakePseudoEntryObj(e2, 0);
757 	if (o2 == 0)
758 		return ((o1 == 0) ? TRUE : FALSE);
759 
760 	res = sameNisPlusObj(o1, o2);
761 
762 	nis_destroy_object(o2);
763 
764 	return (res);
765 }
766