usr/src/lib/libnsl/rpc/xdr_refer.c

   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 /*
  24  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  25  * Use is subject to license terms.
  26  */
  27
  28 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
  29 /* All Rights Reserved */
  30 /*
  31  * Portions of this source code were derived from Berkeley
  32  * 4.3 BSD under license from the Regents of the University of
  33  * California.
  34  */
  35
  36 /*
  37  * Generic XDR routines impelmentation.
  38  *
  39  * These are the "non-trivial" xdr primitives used to serialize and de-serialize
  40  * "pointers".  See xdr.h for more info on the interface to xdr.
  41  */
  42 #include "mt.h"
  43 #include <sys/types.h>
  44 #include <syslog.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <rpc/types.h>
  48 #include <rpc/xdr.h>
  49 #include <memory.h>
  50
  51 #define LASTUNSIGNED    ((uint_t)0-1)
  52 char mem_err_msg_ref[] = "xdr_reference: out of memory";
  53
  54 /*
  55  * XDR an indirect pointer
  56  * xdr_reference is for recursively translating a structure that is
  57  * referenced by a pointer inside the structure that is currently being
  58  * translated.  pp references a pointer to storage. If *pp is null
  59  * the  necessary storage is allocated.
  60  * size is the sizeof the referneced structure.
  61  * proc is the routine to handle the referenced structure.
  62  */
  63 bool_t
  64 xdr_reference(XDR *xdrs, caddr_t *pp, uint_t size, const xdrproc_t proc)
  65 {
  66         caddr_t loc = *pp;
  67         bool_t stat;
  68
  69         /* Make sure x_op contains a valid value */
  70         if (xdrs->x_op != XDR_ENCODE &&
  71             xdrs->x_op != XDR_DECODE &&
  72             xdrs->x_op != XDR_FREE)
  73                 return (FALSE);
  74
  75         if (loc == NULL)
  76                 switch (xdrs->x_op) {
  77                 case XDR_FREE:
  78                         return (TRUE);
  79                 case XDR_DECODE:
  80                         *pp = loc = malloc(size);
  81                         if (loc == NULL) {
  82                                 (void) syslog(LOG_ERR, mem_err_msg_ref);
  83                                 return (FALSE);
  84                         }
  85                         (void) memset(loc, 0, (int)size);
  86                         break;
  87         }
  88
  89         stat = (*proc)(xdrs, loc, LASTUNSIGNED);
  90
  91         if (xdrs->x_op == XDR_FREE) {
  92                 free(loc);
  93                 *pp = NULL;
  94         }
  95         return (stat);
  96 }
  97
  98
  99 /*
 100  * xdr_pointer():
 101  *
 102  * XDR a pointer to a possibly recursive data structure. This
 103  * differs with xdr_reference in that it can serialize/deserialiaze
 104  * trees correctly.
 105  *
 106  *  What's sent is actually a union:
 107  *
 108  *  union object_pointer switch (boolean b) {
 109  *  case TRUE: object_data data;
 110  *  case FALSE: void nothing;
 111  *  }
 112  *
 113  * > objpp: Pointer to the pointer to the object.
 114  * > obj_size: size of the object.
 115  * > xdr_obj: routine to XDR an object.
 116  *
 117  */
 118 bool_t
 119 xdr_pointer(XDR *xdrs, char **objpp, uint_t obj_size, const xdrproc_t xdr_obj)
 120 {
 121         bool_t more_data;
 122
 123         more_data = (*objpp != NULL);
 124         if (!xdr_bool(xdrs, &more_data))
 125                 return (FALSE);
 126         if (!more_data) {
 127                 *objpp = NULL;
 128                 return (TRUE);
 129         }
 130         return (xdr_reference(xdrs, objpp, obj_size, xdr_obj));
 131 }