6811333 Remove prom_printf() message in emlxs driver

[opensolaris.git] / usr / src / 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);
}