Back to index

glibc  2.9
Classes | Defines | Typedefs | Enumerations | Functions
xdr.h File Reference
#include <features.h>
#include <sys/types.h>
#include <rpc/types.h>
#include <stdio.h>
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  XDR
struct  XDR::xdr_ops
struct  xdr_discrim
struct  netobj

Defines

#define BYTES_PER_XDR_UNIT   (4)
#define RNDUP(x)   (((x) + BYTES_PER_XDR_UNIT - 1) & ~(BYTES_PER_XDR_UNIT - 1))
#define XDR_GETINT32(xdrs, int32p)   (*(xdrs)->x_ops->x_getint32)(xdrs, int32p)
#define xdr_getint32(xdrs, int32p)   (*(xdrs)->x_ops->x_getint32)(xdrs, int32p)
#define XDR_PUTINT32(xdrs, int32p)   (*(xdrs)->x_ops->x_putint32)(xdrs, int32p)
#define xdr_putint32(xdrs, int32p)   (*(xdrs)->x_ops->x_putint32)(xdrs, int32p)
#define XDR_GETLONG(xdrs, longp)   (*(xdrs)->x_ops->x_getlong)(xdrs, longp)
#define xdr_getlong(xdrs, longp)   (*(xdrs)->x_ops->x_getlong)(xdrs, longp)
#define XDR_PUTLONG(xdrs, longp)   (*(xdrs)->x_ops->x_putlong)(xdrs, longp)
#define xdr_putlong(xdrs, longp)   (*(xdrs)->x_ops->x_putlong)(xdrs, longp)
#define XDR_GETBYTES(xdrs, addr, len)   (*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)
#define xdr_getbytes(xdrs, addr, len)   (*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)
#define XDR_PUTBYTES(xdrs, addr, len)   (*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)
#define xdr_putbytes(xdrs, addr, len)   (*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)
#define XDR_GETPOS(xdrs)   (*(xdrs)->x_ops->x_getpostn)(xdrs)
#define xdr_getpos(xdrs)   (*(xdrs)->x_ops->x_getpostn)(xdrs)
#define XDR_SETPOS(xdrs, pos)   (*(xdrs)->x_ops->x_setpostn)(xdrs, pos)
#define xdr_setpos(xdrs, pos)   (*(xdrs)->x_ops->x_setpostn)(xdrs, pos)
#define XDR_INLINE(xdrs, len)   (*(xdrs)->x_ops->x_inline)(xdrs, len)
#define xdr_inline(xdrs, len)   (*(xdrs)->x_ops->x_inline)(xdrs, len)
#define XDR_DESTROY(xdrs)
#define xdr_destroy(xdrs)
#define NULL_xdrproc_t   ((xdrproc_t)0)
#define IXDR_GET_INT32(buf)   ((int32_t)ntohl((uint32_t)*(buf)++))
#define IXDR_PUT_INT32(buf, v)   (*(buf)++ = (int32_t)htonl((uint32_t)(v)))
#define IXDR_GET_U_INT32(buf)   ((uint32_t)IXDR_GET_INT32(buf))
#define IXDR_PUT_U_INT32(buf, v)   IXDR_PUT_INT32(buf, (int32_t)(v))
#define IXDR_GET_LONG(buf)   ((long)IXDR_GET_U_INT32(buf))
#define IXDR_PUT_LONG(buf, v)   ((long)IXDR_PUT_INT32(buf, (long)(v)))
#define IXDR_GET_U_LONG(buf)   ((u_long)IXDR_GET_LONG(buf))
#define IXDR_PUT_U_LONG(buf, v)   IXDR_PUT_LONG(buf, (long)(v))
#define IXDR_GET_BOOL(buf)   ((bool_t)IXDR_GET_LONG(buf))
#define IXDR_GET_ENUM(buf, t)   ((t)IXDR_GET_LONG(buf))
#define IXDR_GET_SHORT(buf)   ((short)IXDR_GET_LONG(buf))
#define IXDR_GET_U_SHORT(buf)   ((u_short)IXDR_GET_LONG(buf))
#define IXDR_PUT_BOOL(buf, v)   IXDR_PUT_LONG(buf, (long)(v))
#define IXDR_PUT_ENUM(buf, v)   IXDR_PUT_LONG(buf, (long)(v))
#define IXDR_PUT_SHORT(buf, v)   IXDR_PUT_LONG(buf, (long)(v))
#define IXDR_PUT_U_SHORT(buf, v)   IXDR_PUT_LONG(buf, (long)(v))
#define MAX_NETOBJ_SZ   1024

Typedefs

typedef struct XDR
typedef bool_t(* xdrproc_t )(XDR *, void *,...)
typedef struct netobj

Enumerations

enum  xdr_op { XDR_ENCODE = 0, XDR_DECODE = 1, XDR_FREE = 2 }

Functions

bool_t xdr_void (void) __THROW
bool_t xdr_short (XDR *__xdrs, short *__sp) __THROW
bool_t xdr_u_short (XDR *__xdrs, u_short *__usp) __THROW
bool_t xdr_int (XDR *__xdrs, int *__ip) __THROW
bool_t xdr_u_int (XDR *__xdrs, u_int *__up) __THROW
bool_t xdr_long (XDR *__xdrs, long *__lp) __THROW
bool_t xdr_u_long (XDR *__xdrs, u_long *__ulp) __THROW
bool_t xdr_hyper (XDR *__xdrs, quad_t *__llp) __THROW
bool_t xdr_u_hyper (XDR *__xdrs, u_quad_t *__ullp) __THROW
bool_t xdr_longlong_t (XDR *__xdrs, quad_t *__llp) __THROW
bool_t xdr_u_longlong_t (XDR *__xdrs, u_quad_t *__ullp) __THROW
bool_t xdr_int8_t (XDR *__xdrs, int8_t *__ip) __THROW
bool_t xdr_uint8_t (XDR *__xdrs, uint8_t *__up) __THROW
bool_t xdr_int16_t (XDR *__xdrs, int16_t *__ip) __THROW
bool_t xdr_uint16_t (XDR *__xdrs, uint16_t *__up) __THROW
bool_t xdr_int32_t (XDR *__xdrs, int32_t *__ip) __THROW
bool_t xdr_uint32_t (XDR *__xdrs, uint32_t *__up) __THROW
bool_t xdr_int64_t (XDR *__xdrs, int64_t *__ip) __THROW
bool_t xdr_uint64_t (XDR *__xdrs, uint64_t *__up) __THROW
bool_t xdr_quad_t (XDR *__xdrs, quad_t *__ip) __THROW
bool_t xdr_u_quad_t (XDR *__xdrs, u_quad_t *__up) __THROW
bool_t xdr_bool (XDR *__xdrs, bool_t *__bp) __THROW
bool_t xdr_enum (XDR *__xdrs, enum_t *__ep) __THROW
bool_t xdr_array (XDR *_xdrs, caddr_t *__addrp, u_int *__sizep, u_int __maxsize, u_int __elsize, xdrproc_t __elproc) __THROW
bool_t xdr_bytes (XDR *__xdrs, char **__cpp, u_int *__sizep, u_int __maxsize) __THROW
bool_t xdr_opaque (XDR *__xdrs, caddr_t __cp, u_int __cnt) __THROW
bool_t xdr_string (XDR *__xdrs, char **__cpp, u_int __maxsize) __THROW
bool_t xdr_union (XDR *__xdrs, enum_t *__dscmp, char *__unp, __const struct xdr_discrim *__choices, xdrproc_t dfault) __THROW
bool_t xdr_char (XDR *__xdrs, char *__cp) __THROW
bool_t xdr_u_char (XDR *__xdrs, u_char *__cp) __THROW
bool_t xdr_vector (XDR *__xdrs, char *__basep, u_int __nelem, u_int __elemsize, xdrproc_t __xdr_elem) __THROW
bool_t xdr_float (XDR *__xdrs, float *__fp) __THROW
bool_t xdr_double (XDR *__xdrs, double *__dp) __THROW
bool_t xdr_reference (XDR *__xdrs, caddr_t *__xpp, u_int __size, xdrproc_t __proc) __THROW
bool_t xdr_pointer (XDR *__xdrs, char **__objpp, u_int __obj_size, xdrproc_t __xdr_obj) __THROW
bool_t xdr_wrapstring (XDR *__xdrs, char **__cpp) __THROW
u_long xdr_sizeof (xdrproc_t, void *) __THROW
bool_t xdr_netobj (XDR *__xdrs, struct netobj *__np) __THROW
void xdrmem_create (XDR *__xdrs, __const caddr_t __addr, u_int __size, enum xdr_op __xop) __THROW
void xdrstdio_create (XDR *__xdrs, FILE *__file, enum xdr_op __xop) __THROW
void xdrrec_create (XDR *__xdrs, u_int __sendsize, u_int __recvsize, caddr_t __tcp_handle, int(*__readit)(char *, char *, int), int(*__writeit)(char *, char *, int)) __THROW
bool_t xdrrec_endofrecord (XDR *__xdrs, bool_t __sendnow) __THROW
bool_t xdrrec_skiprecord (XDR *__xdrs) __THROW
bool_t xdrrec_eof (XDR *__xdrs) __THROW
void xdr_free (xdrproc_t __proc, char *__objp) __THROW

Class Documentation

struct XDR

Definition at line 112 of file xdr.h.

Collaboration diagram for XDR:
Class Members
caddr_t x_base
u_int x_handy
enum xdr_op struct xdr_ops * x_ops
caddr_t x_private
caddr_t x_public
struct xdr_discrim

Definition at line 234 of file xdr.h.

Collaboration diagram for xdr_discrim:
Class Members
xdrproc_t proc
int value
struct netobj

Definition at line 338 of file xdr.h.

Class Members
char * n_bytes
u_int n_len

Define Documentation

#define BYTES_PER_XDR_UNIT   (4)

Definition at line 92 of file xdr.h.

#define IXDR_GET_BOOL (   buf)    ((bool_t)IXDR_GET_LONG(buf))

Definition at line 271 of file xdr.h.

#define IXDR_GET_ENUM (   buf,
  t 
)    ((t)IXDR_GET_LONG(buf))

Definition at line 272 of file xdr.h.

#define IXDR_GET_INT32 (   buf)    ((int32_t)ntohl((uint32_t)*(buf)++))

Definition at line 256 of file xdr.h.

#define IXDR_GET_LONG (   buf)    ((long)IXDR_GET_U_INT32(buf))

Definition at line 265 of file xdr.h.

#define IXDR_GET_SHORT (   buf)    ((short)IXDR_GET_LONG(buf))

Definition at line 273 of file xdr.h.

#define IXDR_GET_U_INT32 (   buf)    ((uint32_t)IXDR_GET_INT32(buf))

Definition at line 258 of file xdr.h.

#define IXDR_GET_U_LONG (   buf)    ((u_long)IXDR_GET_LONG(buf))

Definition at line 267 of file xdr.h.

#define IXDR_GET_U_SHORT (   buf)    ((u_short)IXDR_GET_LONG(buf))

Definition at line 274 of file xdr.h.

#define IXDR_PUT_BOOL (   buf,
 
)    IXDR_PUT_LONG(buf, (long)(v))

Definition at line 276 of file xdr.h.

#define IXDR_PUT_ENUM (   buf,
 
)    IXDR_PUT_LONG(buf, (long)(v))

Definition at line 277 of file xdr.h.

#define IXDR_PUT_INT32 (   buf,
 
)    (*(buf)++ = (int32_t)htonl((uint32_t)(v)))

Definition at line 257 of file xdr.h.

#define IXDR_PUT_LONG (   buf,
 
)    ((long)IXDR_PUT_INT32(buf, (long)(v)))

Definition at line 266 of file xdr.h.

#define IXDR_PUT_SHORT (   buf,
 
)    IXDR_PUT_LONG(buf, (long)(v))

Definition at line 278 of file xdr.h.

#define IXDR_PUT_U_INT32 (   buf,
 
)    IXDR_PUT_INT32(buf, (int32_t)(v))

Definition at line 259 of file xdr.h.

#define IXDR_PUT_U_LONG (   buf,
 
)    IXDR_PUT_LONG(buf, (long)(v))

Definition at line 268 of file xdr.h.

#define IXDR_PUT_U_SHORT (   buf,
 
)    IXDR_PUT_LONG(buf, (long)(v))

Definition at line 279 of file xdr.h.

#define MAX_NETOBJ_SZ   1024

Definition at line 337 of file xdr.h.

#define NULL_xdrproc_t   ((xdrproc_t)0)

Definition at line 233 of file xdr.h.

#define RNDUP (   x)    (((x) + BYTES_PER_XDR_UNIT - 1) & ~(BYTES_PER_XDR_UNIT - 1))

Definition at line 99 of file xdr.h.

#define XDR_DESTROY (   xdrs)
Value:
do {                                             \
              if ((xdrs)->x_ops->x_destroy)                    \
                     (*(xdrs)->x_ops->x_destroy)(xdrs); \
       } while (0)

Definition at line 212 of file xdr.h.

#define xdr_destroy (   xdrs)
Value:
do {                                             \
              if ((xdrs)->x_ops->x_destroy)                    \
                     (*(xdrs)->x_ops->x_destroy)(xdrs); \
       } while (0)

Definition at line 217 of file xdr.h.

#define XDR_GETBYTES (   xdrs,
  addr,
  len 
)    (*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)

Definition at line 187 of file xdr.h.

#define xdr_getbytes (   xdrs,
  addr,
  len 
)    (*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)

Definition at line 189 of file xdr.h.

#define XDR_GETINT32 (   xdrs,
  int32p 
)    (*(xdrs)->x_ops->x_getint32)(xdrs, int32p)

Definition at line 167 of file xdr.h.

#define xdr_getint32 (   xdrs,
  int32p 
)    (*(xdrs)->x_ops->x_getint32)(xdrs, int32p)

Definition at line 169 of file xdr.h.

#define XDR_GETLONG (   xdrs,
  longp 
)    (*(xdrs)->x_ops->x_getlong)(xdrs, longp)

Definition at line 177 of file xdr.h.

#define xdr_getlong (   xdrs,
  longp 
)    (*(xdrs)->x_ops->x_getlong)(xdrs, longp)

Definition at line 179 of file xdr.h.

#define XDR_GETPOS (   xdrs)    (*(xdrs)->x_ops->x_getpostn)(xdrs)

Definition at line 197 of file xdr.h.

#define xdr_getpos (   xdrs)    (*(xdrs)->x_ops->x_getpostn)(xdrs)

Definition at line 199 of file xdr.h.

#define XDR_INLINE (   xdrs,
  len 
)    (*(xdrs)->x_ops->x_inline)(xdrs, len)

Definition at line 207 of file xdr.h.

#define xdr_inline (   xdrs,
  len 
)    (*(xdrs)->x_ops->x_inline)(xdrs, len)

Definition at line 209 of file xdr.h.

#define XDR_PUTBYTES (   xdrs,
  addr,
  len 
)    (*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)

Definition at line 192 of file xdr.h.

#define xdr_putbytes (   xdrs,
  addr,
  len 
)    (*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)

Definition at line 194 of file xdr.h.

#define XDR_PUTINT32 (   xdrs,
  int32p 
)    (*(xdrs)->x_ops->x_putint32)(xdrs, int32p)

Definition at line 172 of file xdr.h.

#define xdr_putint32 (   xdrs,
  int32p 
)    (*(xdrs)->x_ops->x_putint32)(xdrs, int32p)

Definition at line 174 of file xdr.h.

#define XDR_PUTLONG (   xdrs,
  longp 
)    (*(xdrs)->x_ops->x_putlong)(xdrs, longp)

Definition at line 182 of file xdr.h.

#define xdr_putlong (   xdrs,
  longp 
)    (*(xdrs)->x_ops->x_putlong)(xdrs, longp)

Definition at line 184 of file xdr.h.

#define XDR_SETPOS (   xdrs,
  pos 
)    (*(xdrs)->x_ops->x_setpostn)(xdrs, pos)

Definition at line 202 of file xdr.h.

#define xdr_setpos (   xdrs,
  pos 
)    (*(xdrs)->x_ops->x_setpostn)(xdrs, pos)

Definition at line 204 of file xdr.h.


Typedef Documentation

typedef struct netobj

Definition at line 343 of file xdr.h.

typedef struct XDR

Definition at line 111 of file xdr.h.

typedef bool_t(* xdrproc_t)(XDR *, void *,...)

Definition at line 154 of file xdr.h.


Enumeration Type Documentation

enum xdr_op
Enumerator:
XDR_ENCODE 
XDR_DECODE 
XDR_FREE 

Definition at line 83 of file xdr.h.

            {
  XDR_ENCODE = 0,
  XDR_DECODE = 1,
  XDR_FREE = 2
};

Function Documentation

bool_t xdr_array ( XDR _xdrs,
caddr_t __addrp,
u_int __sizep,
u_int  __maxsize,
u_int  __elsize,
xdrproc_t  __elproc 
)

Definition at line 65 of file xdr_array.c.

{
  u_int i;
  caddr_t target = *addrp;
  u_int c;           /* the actual element count */
  bool_t stat = TRUE;

  /* like strings, arrays are really counted arrays */
  if (!INTUSE(xdr_u_int) (xdrs, sizep))
    {
      return FALSE;
    }
  c = *sizep;
  /*
   * XXX: Let the overflow possibly happen with XDR_FREE because mem_free()
   * doesn't actually use its second argument anyway.
   */
  if ((c > maxsize || c > UINT_MAX / elsize) && (xdrs->x_op != XDR_FREE))
    {
      return FALSE;
    }

  /*
   * if we are deserializing, we may need to allocate an array.
   * We also save time by checking for a null array if we are freeing.
   */
  if (target == NULL)
    switch (xdrs->x_op)
      {
      case XDR_DECODE:
       if (c == 0)
         return TRUE;
       *addrp = target = calloc (c, elsize);
       if (target == NULL)
         {
           (void) __fxprintf (NULL, "%s: %s", __func__, _("out of memory\n"));
           return FALSE;
         }
       break;

      case XDR_FREE:
       return TRUE;
      default:
       break;
      }

  /*
   * now we xdr each element of array
   */
  for (i = 0; (i < c) && stat; i++)
    {
      stat = (*elproc) (xdrs, target, LASTUNSIGNED);
      target += elsize;
    }

  /*
   * the array may need freeing
   */
  if (xdrs->x_op == XDR_FREE)
    {
      mem_free (*addrp, c * elsize);
      *addrp = NULL;
    }
  return stat;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool_t xdr_bool ( XDR __xdrs,
bool_t __bp 
)

Definition at line 395 of file xdr.c.

{
  long lb;

  switch (xdrs->x_op)
    {
    case XDR_ENCODE:
      lb = *bp ? XDR_TRUE : XDR_FALSE;
      return XDR_PUTLONG (xdrs, &lb);

    case XDR_DECODE:
      if (!XDR_GETLONG (xdrs, &lb))
       {
         return FALSE;
       }
      *bp = (lb == XDR_FALSE) ? FALSE : TRUE;
      return TRUE;

    case XDR_FREE:
      return TRUE;
    }
  return FALSE;
}

Here is the caller graph for this function:

bool_t xdr_bytes ( XDR __xdrs,
char **  __cpp,
u_int __sizep,
u_int  __maxsize 
)

Definition at line 528 of file xdr.c.

{
  char *sp = *cpp;   /* sp is the actual string pointer */
  u_int nodesize;

  /*
   * first deal with the length since xdr bytes are counted
   */
  if (!INTUSE(xdr_u_int) (xdrs, sizep))
    {
      return FALSE;
    }
  nodesize = *sizep;
  if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE))
    {
      return FALSE;
    }

  /*
   * now deal with the actual bytes
   */
  switch (xdrs->x_op)
    {
    case XDR_DECODE:
      if (nodesize == 0)
       {
         return TRUE;
       }
      if (sp == NULL)
       {
         *cpp = sp = (char *) mem_alloc (nodesize);
       }
      if (sp == NULL)
       {
         (void) __fxprintf (NULL, "%s: %s", __func__, _("out of memory\n"));
         return FALSE;
       }
      /* fall into ... */

    case XDR_ENCODE:
      return INTUSE(xdr_opaque) (xdrs, sp, nodesize);

    case XDR_FREE:
      if (sp != NULL)
       {
         mem_free (sp, nodesize);
         *cpp = NULL;
       }
      return TRUE;
    }
  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool_t xdr_char ( XDR __xdrs,
char *  __cp 
)

Definition at line 361 of file xdr.c.

{
  int i;

  i = (*cp);
  if (!INTUSE(xdr_int) (xdrs, &i))
    {
      return FALSE;
    }
  *cp = i;
  return TRUE;
}

Here is the call graph for this function:

bool_t xdr_double ( XDR __xdrs,
double *  __dp 
)

Definition at line 209 of file xdr_float.c.

{
#ifdef vax
       struct ieee_double id;
       struct vax_double vd;
       register struct dbl_limits *lim;
       int i;
#endif

       switch (xdrs->x_op) {

       case XDR_ENCODE:
#ifdef vax
              vd = *((struct vax_double *)dp);
              for (i = 0, lim = dbl_limits;
                     i < sizeof(dbl_limits)/sizeof(struct dbl_limits);
                     i++, lim++) {
                     if ((vd.mantissa4 == lim->d.mantissa4) &&
                            (vd.mantissa3 == lim->d.mantissa3) &&
                            (vd.mantissa2 == lim->d.mantissa2) &&
                            (vd.mantissa1 == lim->d.mantissa1) &&
                            (vd.exp == lim->d.exp)) {
                            id = lim->ieee;
                            goto shipit;
                     }
              }
              id.exp = vd.exp - VAX_DBL_BIAS + IEEE_DBL_BIAS;
              id.mantissa1 = (vd.mantissa1 << 13) | (vd.mantissa2 >> 3);
              id.mantissa2 = ((vd.mantissa2 & MASK(3)) << 29) |
                            (vd.mantissa3 << 13) |
                            ((vd.mantissa4 >> 3) & MASK(13));
       shipit:
              id.sign = vd.sign;
              dp = (double *)&id;
#endif
              if (2*sizeof(long) == sizeof(double)) {
                     long *lp = (long *)dp;
                     return (XDR_PUTLONG(xdrs, lp+!LSW) &&
                            XDR_PUTLONG(xdrs, lp+LSW));
              } else if (2*sizeof(int) == sizeof(double)) {
                     int *ip = (int *)dp;
                     long tmp[2];
                     tmp[0] = ip[!LSW];
                     tmp[1] = ip[LSW];
                     return (XDR_PUTLONG(xdrs, tmp) &&
                            XDR_PUTLONG(xdrs, tmp+1));
              }
              break;

       case XDR_DECODE:
#ifdef vax
              lp = (long *)&id;
              if (!XDR_GETLONG(xdrs, lp++) || !XDR_GETLONG(xdrs, lp))
                     return (FALSE);
              for (i = 0, lim = dbl_limits;
                     i < sizeof(dbl_limits)/sizeof(struct dbl_limits);
                     i++, lim++) {
                     if ((id.mantissa2 == lim->ieee.mantissa2) &&
                            (id.mantissa1 == lim->ieee.mantissa1) &&
                            (id.exp == lim->ieee.exp)) {
                            vd = lim->d;
                            goto doneit;
                     }
              }
              vd.exp = id.exp - IEEE_DBL_BIAS + VAX_DBL_BIAS;
              vd.mantissa1 = (id.mantissa1 >> 13);
              vd.mantissa2 = ((id.mantissa1 & MASK(13)) << 3) |
                            (id.mantissa2 >> 29);
              vd.mantissa3 = (id.mantissa2 >> 13);
              vd.mantissa4 = (id.mantissa2 << 3);
       doneit:
              vd.sign = id.sign;
              *dp = *((double *)&vd);
              return (TRUE);
#else
              if (2*sizeof(long) == sizeof(double)) {
                     long *lp = (long *)dp;
                     return (XDR_GETLONG(xdrs, lp+!LSW) &&
                            XDR_GETLONG(xdrs, lp+LSW));
              } else if (2*sizeof(int) == sizeof(double)) {
                     int *ip = (int *)dp;
                     long tmp[2];
                     if (XDR_GETLONG(xdrs, tmp+!LSW) &&
                         XDR_GETLONG(xdrs, tmp+LSW)) {
                            ip[0] = tmp[0];
                            ip[1] = tmp[1];
                            return (TRUE);
                     }
              }
              break;
#endif

       case XDR_FREE:
              return (TRUE);
       }
       return (FALSE);
}
bool_t xdr_enum ( XDR __xdrs,
enum_t __ep 
)

Definition at line 424 of file xdr.c.

{
  enum sizecheck
    {
      SIZEVAL
    };                      /* used to find the size of an enum */

  /*
   * enums are treated as ints
   */
  if (sizeof (enum sizecheck) == 4)
    {
#if INT_MAX < LONG_MAX
      long l;

      switch (xdrs->x_op)
       {
       case XDR_ENCODE:
         l = *ep;
         return XDR_PUTLONG (xdrs, &l);

       case XDR_DECODE:
         if (!XDR_GETLONG (xdrs, &l))
           {
             return FALSE;
           }
         *ep = l;
       case XDR_FREE:
         return TRUE;

       }
      return FALSE;
#else
      return INTUSE(xdr_long) (xdrs, (long *) ep);
#endif
    }
  else if (sizeof (enum sizecheck) == sizeof (short))
    {
      return INTUSE(xdr_short) (xdrs, (short *) ep);
    }
  else
    {
      return FALSE;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool_t xdr_float ( XDR __xdrs,
float *  __fp 
)

Definition at line 89 of file xdr_float.c.

{
#ifdef vax
       struct ieee_single is;
       struct vax_single vs, *vsp;
       struct sgl_limits *lim;
       int i;
#endif
       switch (xdrs->x_op) {

       case XDR_ENCODE:
#ifdef vax
              vs = *((struct vax_single *)fp);
              for (i = 0, lim = sgl_limits;
                     i < sizeof(sgl_limits)/sizeof(struct sgl_limits);
                     i++, lim++) {
                     if ((vs.mantissa2 == lim->s.mantissa2) &&
                            (vs.exp == lim->s.exp) &&
                            (vs.mantissa1 == lim->s.mantissa1)) {
                            is = lim->ieee;
                            goto shipit;
                     }
              }
              is.exp = vs.exp - VAX_SNG_BIAS + IEEE_SNG_BIAS;
              is.mantissa = (vs.mantissa1 << 16) | vs.mantissa2;
       shipit:
              is.sign = vs.sign;
              return (XDR_PUTLONG(xdrs, (long *)&is));
#else
              if (sizeof(float) == sizeof(long))
                     return (XDR_PUTLONG(xdrs, (long *)fp));
              else if (sizeof(float) == sizeof(int)) {
                     long tmp = *(int *)fp;
                     return (XDR_PUTLONG(xdrs, &tmp));
              }
              break;
#endif

       case XDR_DECODE:
#ifdef vax
              vsp = (struct vax_single *)fp;
              if (!XDR_GETLONG(xdrs, (long *)&is))
                     return (FALSE);
              for (i = 0, lim = sgl_limits;
                     i < sizeof(sgl_limits)/sizeof(struct sgl_limits);
                     i++, lim++) {
                     if ((is.exp == lim->ieee.exp) &&
                            (is.mantissa == lim->ieee.mantissa)) {
                            *vsp = lim->s;
                            goto doneit;
                     }
              }
              vsp->exp = is.exp - IEEE_SNG_BIAS + VAX_SNG_BIAS;
              vsp->mantissa2 = is.mantissa;
              vsp->mantissa1 = (is.mantissa >> 16);
       doneit:
              vsp->sign = is.sign;
              return (TRUE);
#else
              if (sizeof(float) == sizeof(long))
                     return (XDR_GETLONG(xdrs, (long *)fp));
              else if (sizeof(float) == sizeof(int)) {
                     long tmp;
                     if (XDR_GETLONG(xdrs, &tmp)) {
                            *(int *)fp = tmp;
                            return (TRUE);
                     }
              }
              break;
#endif

       case XDR_FREE:
              return (TRUE);
       }
       return (FALSE);
}
void xdr_free ( xdrproc_t  __proc,
char *  __objp 
)

Definition at line 73 of file xdr.c.

{
  XDR x;

  x.x_op = XDR_FREE;
  (*proc) (&x, objp);
}

Here is the caller graph for this function:

bool_t xdr_hyper ( XDR __xdrs,
quad_t __llp 
)

Definition at line 226 of file xdr.c.

{
  long int t1, t2;

  if (xdrs->x_op == XDR_ENCODE)
    {
      t1 = (long) ((*llp) >> 32);
      t2 = (long) (*llp);
      return (XDR_PUTLONG(xdrs, &t1) && XDR_PUTLONG(xdrs, &t2));
    }

  if (xdrs->x_op == XDR_DECODE)
    {
      if (!XDR_GETLONG(xdrs, &t1) || !XDR_GETLONG(xdrs, &t2))
       return FALSE;
      *llp = ((quad_t) t1) << 32;
      *llp |= (uint32_t) t2;
      return TRUE;
    }

  if (xdrs->x_op == XDR_FREE)
    return TRUE;

  return FALSE;
}

Here is the caller graph for this function:

bool_t xdr_int ( XDR __xdrs,
int __ip 
)

Definition at line 95 of file xdr.c.

{

#if INT_MAX < LONG_MAX
  long l;

  switch (xdrs->x_op)
    {
    case XDR_ENCODE:
      l = (long) *ip;
      return XDR_PUTLONG (xdrs, &l);

    case XDR_DECODE:
      if (!XDR_GETLONG (xdrs, &l))
       {
         return FALSE;
       }
      *ip = (int) l;
    case XDR_FREE:
      return TRUE;
    }
  return FALSE;
#elif INT_MAX == LONG_MAX
  return INTUSE(xdr_long) (xdrs, (long *) ip);
#elif INT_MAX == SHRT_MAX
  return INTUSE(xdr_short) (xdrs, (short *) ip);
#else
#error unexpected integer sizes in_xdr_int()
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool_t xdr_int16_t ( XDR __xdrs,
int16_t __ip 
)

Definition at line 121 of file xdr_intXX_t.c.

{
  int32_t t;

  switch (xdrs->x_op)
    {
    case XDR_ENCODE:
      t = (int32_t) *ip;
      return XDR_PUTINT32 (xdrs, &t);
    case XDR_DECODE:
      if (!XDR_GETINT32 (xdrs, &t))
       return FALSE;
      *ip = (int16_t) t;
      return TRUE;
    case XDR_FREE:
      return TRUE;
    default:
      return FALSE;
    }
}
bool_t xdr_int32_t ( XDR __xdrs,
int32_t __ip 
)
bool_t xdr_int64_t ( XDR __xdrs,
int64_t __ip 
)

Definition at line 32 of file xdr_intXX_t.c.

{
  int32_t t1, t2;

  switch (xdrs->x_op)
    {
    case XDR_ENCODE:
      t1 = (int32_t) ((*ip) >> 32);
      t2 = (int32_t) (*ip);
      return (XDR_PUTINT32(xdrs, &t1) && XDR_PUTINT32(xdrs, &t2));
    case XDR_DECODE:
      if (!XDR_GETINT32(xdrs, &t1) || !XDR_GETINT32(xdrs, &t2))
        return FALSE;
      *ip = ((int64_t) t1) << 32;
      *ip |= (uint32_t) t2; /* Avoid sign extension.  */
      return TRUE;
    case XDR_FREE:
      return TRUE;
    default:
      return FALSE;
    }
}
bool_t xdr_int8_t ( XDR __xdrs,
int8_t __ip 
)

Definition at line 167 of file xdr_intXX_t.c.

{
  int32_t t;

  switch (xdrs->x_op)
    {
    case XDR_ENCODE:
      t = (int32_t) *ip;
      return XDR_PUTINT32 (xdrs, &t);
    case XDR_DECODE:
      if (!XDR_GETINT32 (xdrs, &t))
       return FALSE;
      *ip = (int8_t) t;
      return TRUE;
    case XDR_FREE:
      return TRUE;
    default:
      return FALSE;
    }
}
bool_t xdr_long ( XDR __xdrs,
long *  __lp 
)

Definition at line 168 of file xdr.c.

{

  if (xdrs->x_op == XDR_ENCODE
      && (sizeof (int32_t) == sizeof (long)
         || (int32_t) *lp == *lp))
    return XDR_PUTLONG (xdrs, lp);

  if (xdrs->x_op == XDR_DECODE)
    return XDR_GETLONG (xdrs, lp);

  if (xdrs->x_op == XDR_FREE)
    return TRUE;

  return FALSE;
}

Here is the caller graph for this function:

bool_t xdr_longlong_t ( XDR __xdrs,
quad_t __llp 
)

Definition at line 287 of file xdr.c.

{
  return INTUSE(xdr_hyper) (xdrs, llp);
}

Here is the call graph for this function:

bool_t xdr_netobj ( XDR __xdrs,
struct netobj __np 
)

Definition at line 590 of file xdr.c.

{

  return INTUSE(xdr_bytes) (xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool_t xdr_opaque ( XDR __xdrs,
caddr_t  __cp,
u_int  __cnt 
)

Definition at line 477 of file xdr.c.

{
  u_int rndup;
  static char crud[BYTES_PER_XDR_UNIT];

  /*
   * if no data we are done
   */
  if (cnt == 0)
    return TRUE;

  /*
   * round byte count to full xdr units
   */
  rndup = cnt % BYTES_PER_XDR_UNIT;
  if (rndup > 0)
    rndup = BYTES_PER_XDR_UNIT - rndup;

  switch (xdrs->x_op)
    {
    case XDR_DECODE:
      if (!XDR_GETBYTES (xdrs, cp, cnt))
       {
         return FALSE;
       }
      if (rndup == 0)
       return TRUE;
      return XDR_GETBYTES (xdrs, (caddr_t)crud, rndup);

    case XDR_ENCODE:
      if (!XDR_PUTBYTES (xdrs, cp, cnt))
       {
         return FALSE;
       }
      if (rndup == 0)
       return TRUE;
      return XDR_PUTBYTES (xdrs, xdr_zero, rndup);

    case XDR_FREE:
      return TRUE;
    }
  return FALSE;
}

Here is the caller graph for this function:

bool_t xdr_pointer ( XDR __xdrs,
char **  __objpp,
u_int  __obj_size,
xdrproc_t  __xdr_obj 
)

Definition at line 125 of file xdr_ref.c.

{

  bool_t more_data;

  more_data = (*objpp != NULL);
  if (!INTUSE(xdr_bool) (xdrs, &more_data))
    {
      return FALSE;
    }
  if (!more_data)
    {
      *objpp = NULL;
      return TRUE;
    }
  return INTUSE(xdr_reference) (xdrs, objpp, obj_size, xdr_obj);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool_t xdr_quad_t ( XDR __xdrs,
quad_t __ip 
)
bool_t xdr_reference ( XDR __xdrs,
caddr_t __xpp,
u_int  __size,
xdrproc_t  __proc 
)

Definition at line 66 of file xdr_ref.c.

{
  caddr_t loc = *pp;
  bool_t stat;

  if (loc == NULL)
    switch (xdrs->x_op)
      {
      case XDR_FREE:
       return TRUE;

      case XDR_DECODE:
       *pp = loc = (caddr_t) calloc (1, size);
       if (loc == NULL)
         {
           (void) __fxprintf (NULL, "%s: %s", __func__, _("out of memory\n"));
           return FALSE;
         }
       break;
      default:
       break;
      }

  stat = (*proc) (xdrs, loc, LASTUNSIGNED);

  if (xdrs->x_op == XDR_FREE)
    {
      mem_free (loc, size);
      *pp = NULL;
    }
  return stat;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool_t xdr_short ( XDR __xdrs,
short *  __sp 
)

Definition at line 302 of file xdr.c.

{
  long l;

  switch (xdrs->x_op)
    {
    case XDR_ENCODE:
      l = (long) *sp;
      return XDR_PUTLONG (xdrs, &l);

    case XDR_DECODE:
      if (!XDR_GETLONG (xdrs, &l))
       {
         return FALSE;
       }
      *sp = (short) l;
      return TRUE;

    case XDR_FREE:
      return TRUE;
    }
  return FALSE;
}

Here is the caller graph for this function:

u_long xdr_sizeof ( xdrproc_t  ,
void *   
)

Definition at line 129 of file xdr_sizeof.c.

{
  XDR x;
  struct xdr_ops ops;
  bool_t stat;
  /* to stop ANSI-C compiler from complaining */
  typedef bool_t (*dummyfunc1) (XDR *, long *);
  typedef bool_t (*dummyfunc2) (XDR *, caddr_t, u_int);
  typedef bool_t (*dummyfunc3) (XDR *, int32_t *);

  ops.x_putlong = x_putlong;
  ops.x_putbytes = x_putbytes;
  ops.x_inline = x_inline;
  ops.x_getpostn = x_getpostn;
  ops.x_setpostn = x_setpostn;
  ops.x_destroy = x_destroy;
  ops.x_putint32 = x_putint32;

  /* the other harmless ones */
  ops.x_getlong = (dummyfunc1) harmless;
  ops.x_getbytes = (dummyfunc2) harmless;
  ops.x_getint32 = (dummyfunc3) harmless;

  x.x_op = XDR_ENCODE;
  x.x_ops = &ops;
  x.x_handy = 0;
  x.x_private = (caddr_t) NULL;
  x.x_base = (caddr_t) 0;

  stat = func (&x, data);
  free (x.x_private);
  return stat == TRUE ? x.x_handy : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool_t xdr_string ( XDR __xdrs,
char **  __cpp,
u_int  __maxsize 
)

Definition at line 663 of file xdr.c.

{
  char *sp = *cpp;   /* sp is the actual string pointer */
  u_int size;
  u_int nodesize;

  /*
   * first deal with the length since xdr strings are counted-strings
   */
  switch (xdrs->x_op)
    {
    case XDR_FREE:
      if (sp == NULL)
       {
         return TRUE;              /* already free */
       }
      /* fall through... */
    case XDR_ENCODE:
      if (sp == NULL)
       return FALSE;
      size = strlen (sp);
      break;
    case XDR_DECODE:
      break;
    }
  if (!INTUSE(xdr_u_int) (xdrs, &size))
    {
      return FALSE;
    }
  if (size > maxsize)
    {
      return FALSE;
    }
  nodesize = size + 1;
  if (nodesize == 0)
    {
      /* This means an overflow.  It a bug in the caller which
        provided a too large maxsize but nevertheless catch it
        here.  */
      return FALSE;
    }

  /*
   * now deal with the actual bytes
   */
  switch (xdrs->x_op)
    {
    case XDR_DECODE:
      if (sp == NULL)
       *cpp = sp = (char *) mem_alloc (nodesize);
      if (sp == NULL)
       {
         (void) __fxprintf (NULL, "%s: %s", __func__, _("out of memory\n"));
         return FALSE;
       }
      sp[size] = 0;
      /* fall into ... */

    case XDR_ENCODE:
      return INTUSE(xdr_opaque) (xdrs, sp, size);

    case XDR_FREE:
      mem_free (sp, nodesize);
      *cpp = NULL;
      return TRUE;
    }
  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool_t xdr_u_char ( XDR __xdrs,
u_char __cp 
)

Definition at line 378 of file xdr.c.

{
  u_int u;

  u = (*cp);
  if (!INTUSE(xdr_u_int) (xdrs, &u))
    {
      return FALSE;
    }
  *cp = u;
  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool_t xdr_u_hyper ( XDR __xdrs,
u_quad_t __ullp 
)

Definition at line 259 of file xdr.c.

{
  long int t1, t2;

  if (xdrs->x_op == XDR_ENCODE)
    {
      t1 = (unsigned long) ((*ullp) >> 32);
      t2 = (unsigned long) (*ullp);
      return (XDR_PUTLONG(xdrs, &t1) && XDR_PUTLONG(xdrs, &t2));
    }

  if (xdrs->x_op == XDR_DECODE)
    {
      if (!XDR_GETLONG(xdrs, &t1) || !XDR_GETLONG(xdrs, &t2))
       return FALSE;
      *ullp = ((u_quad_t) t1) << 32;
      *ullp |= (uint32_t) t2;
      return TRUE;
    }

  if (xdrs->x_op == XDR_FREE)
    return TRUE;

  return FALSE;
}

Here is the caller graph for this function:

bool_t xdr_u_int ( XDR __xdrs,
u_int __up 
)

Definition at line 131 of file xdr.c.

{
#if UINT_MAX < ULONG_MAX
  long l;

  switch (xdrs->x_op)
    {
    case XDR_ENCODE:
      l = (u_long) * up;
      return XDR_PUTLONG (xdrs, &l);

    case XDR_DECODE:
      if (!XDR_GETLONG (xdrs, &l))
       {
         return FALSE;
       }
      *up = (u_int) (u_long) l;
    case XDR_FREE:
      return TRUE;
    }
  return FALSE;
#elif UINT_MAX == ULONG_MAX
  return INTUSE(xdr_u_long) (xdrs, (u_long *) up);
#elif UINT_MAX == USHRT_MAX
  return INTUSE(xdr_short) (xdrs, (short *) up);
#else
#error unexpected integer sizes in_xdr_u_int()
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool_t xdr_u_long ( XDR __xdrs,
u_long __ulp 
)

Definition at line 192 of file xdr.c.

{
  switch (xdrs->x_op)
    {
    case XDR_DECODE:
      {
       long int tmp;

       if (XDR_GETLONG (xdrs, &tmp) == FALSE)
         return FALSE;

       *ulp = (uint32_t) tmp;
       return TRUE;
      }

    case XDR_ENCODE:
      if (sizeof (uint32_t) != sizeof (u_long)
         && (uint32_t) *ulp != *ulp)
       return FALSE;

      return XDR_PUTLONG (xdrs, (long *) ulp);

    case XDR_FREE:
      return TRUE;
    }
  return FALSE;
}

Here is the caller graph for this function:

bool_t xdr_u_longlong_t ( XDR __xdrs,
u_quad_t __ullp 
)

Definition at line 293 of file xdr.c.

{
  return INTUSE(xdr_u_hyper) (xdrs, ullp);
}

Here is the call graph for this function:

bool_t xdr_u_quad_t ( XDR __xdrs,
u_quad_t __up 
)
bool_t xdr_u_short ( XDR __xdrs,
u_short __usp 
)

Definition at line 331 of file xdr.c.

{
  long l;

  switch (xdrs->x_op)
    {
    case XDR_ENCODE:
      l = (u_long) * usp;
      return XDR_PUTLONG (xdrs, &l);

    case XDR_DECODE:
      if (!XDR_GETLONG (xdrs, &l))
       {
         return FALSE;
       }
      *usp = (u_short) (u_long) l;
      return TRUE;

    case XDR_FREE:
      return TRUE;
    }
  return FALSE;
}

Here is the caller graph for this function:

bool_t xdr_uint16_t ( XDR __xdrs,
uint16_t __up 
)

Definition at line 144 of file xdr_intXX_t.c.

{
  uint32_t ut;

  switch (xdrs->x_op)
    {
    case XDR_ENCODE:
      ut = (uint32_t) *uip;
      return XDR_PUTINT32 (xdrs, (int32_t *) &ut);
    case XDR_DECODE:
      if (!XDR_GETINT32 (xdrs, (int32_t *) &ut))
       return FALSE;
      *uip = (uint16_t) ut;
      return TRUE;
    case XDR_FREE:
      return TRUE;
    default:
      return FALSE;
    }
}
bool_t xdr_uint32_t ( XDR __xdrs,
uint32_t __up 
)

Definition at line 104 of file xdr_intXX_t.c.

{
  switch (xdrs->x_op)
    {
    case XDR_ENCODE:
      return XDR_PUTINT32 (xdrs, (int32_t *) ulp);
    case XDR_DECODE:
      return XDR_GETINT32 (xdrs, (int32_t *) ulp);
    case XDR_FREE:
      return TRUE;
    default:
      return FALSE;
    }
}

Here is the caller graph for this function:

bool_t xdr_uint64_t ( XDR __xdrs,
uint64_t __up 
)
bool_t xdr_uint8_t ( XDR __xdrs,
uint8_t __up 
)

Definition at line 190 of file xdr_intXX_t.c.

{
  uint32_t ut;

  switch (xdrs->x_op)
    {
    case XDR_ENCODE:
      ut = (uint32_t) *uip;
      return XDR_PUTINT32 (xdrs, (int32_t *) &ut);
    case XDR_DECODE:
      if (!XDR_GETINT32 (xdrs, (int32_t *) &ut))
       return FALSE;
      *uip = (uint8_t) ut;
      return TRUE;
    case XDR_FREE:
      return TRUE;
    default:
      return FALSE;
    }
}
bool_t xdr_union ( XDR __xdrs,
enum_t __dscmp,
char *  __unp,
__const struct xdr_discrim __choices,
xdrproc_t  dfault 
)

Here is the caller graph for this function:

bool_t xdr_vector ( XDR __xdrs,
char *  __basep,
u_int  __nelem,
u_int  __elemsize,
xdrproc_t  __xdr_elem 
)

Definition at line 149 of file xdr_array.c.

{
  u_int i;
  char *elptr;

  elptr = basep;
  for (i = 0; i < nelem; i++)
    {
      if (!(*xdr_elem) (xdrs, elptr, LASTUNSIGNED))
       {
         return FALSE;
       }
      elptr += elemsize;
    }
  return TRUE;
}
bool_t xdr_void ( void  )

Definition at line 85 of file xdr.c.

{
  return TRUE;
}

Here is the caller graph for this function:

bool_t xdr_wrapstring ( XDR __xdrs,
char **  __cpp 
)

Definition at line 741 of file xdr.c.

{
  if (INTUSE(xdr_string) (xdrs, cpp, LASTUNSIGNED))
    {
      return TRUE;
    }
  return FALSE;
}

Here is the call graph for this function:

void xdrmem_create ( XDR __xdrs,
__const caddr_t  __addr,
u_int  __size,
enum xdr_op  __xop 
)

Here is the caller graph for this function:

void xdrrec_create ( XDR __xdrs,
u_int  __sendsize,
u_int  __recvsize,
caddr_t  __tcp_handle,
int(*)(char *, char *, int __readit,
int(*)(char *, char *, int __writeit 
)

Here is the caller graph for this function:

bool_t xdrrec_endofrecord ( XDR __xdrs,
bool_t  __sendnow 
)

Definition at line 518 of file xdr_rec.c.

{
  RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
  u_long len;        /* fragment length */

  if (sendnow || rstrm->frag_sent
      || rstrm->out_finger + BYTES_PER_XDR_UNIT >= rstrm->out_boundry)
    {
      rstrm->frag_sent = FALSE;
      return flush_out (rstrm, TRUE);
    }
  len = (rstrm->out_finger - (char *) rstrm->frag_header
        - BYTES_PER_XDR_UNIT);
  *rstrm->frag_header = htonl ((u_long) len | LAST_FRAG);
  rstrm->frag_header = (u_int32_t *) rstrm->out_finger;
  rstrm->out_finger += BYTES_PER_XDR_UNIT;
  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool_t xdrrec_eof ( XDR __xdrs)

Definition at line 493 of file xdr_rec.c.

{
  RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;

  while (rstrm->fbtbc > 0 || (!rstrm->last_frag))
    {
      if (!skip_input_bytes (rstrm, rstrm->fbtbc))
       return TRUE;
      rstrm->fbtbc = 0;
      if ((!rstrm->last_frag) && (!set_input_fragment (rstrm)))
       return TRUE;
    }
  if (rstrm->in_finger == rstrm->in_boundry)
    return TRUE;
  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool_t xdrrec_skiprecord ( XDR __xdrs)

Definition at line 470 of file xdr_rec.c.

{
  RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;

  while (rstrm->fbtbc > 0 || (!rstrm->last_frag))
    {
      if (!skip_input_bytes (rstrm, rstrm->fbtbc))
       return FALSE;
      rstrm->fbtbc = 0;
      if ((!rstrm->last_frag) && (!set_input_fragment (rstrm)))
       return FALSE;
    }
  rstrm->last_frag = FALSE;
  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xdrstdio_create ( XDR __xdrs,
FILE __file,
enum xdr_op  __xop 
)

Definition at line 86 of file xdr_stdio.c.

{
  xdrs->x_op = op;
  /* We have to add the const since the `struct xdr_ops' in `struct XDR'
     is not `const'.  */
  xdrs->x_ops = (struct xdr_ops *) &xdrstdio_ops;
  xdrs->x_private = (caddr_t) file;
  xdrs->x_handy = 0;
  xdrs->x_base = 0;
}

Here is the caller graph for this function: