Back to index

glibc  2.9
Defines | Functions | Variables
xdr.c File Reference
#include <stdio.h>
#include <limits.h>
#include <string.h>
#include <libintl.h>
#include <rpc/types.h>
#include <rpc/xdr.h>

Go to the source code of this file.

Defines

#define XDR_FALSE   ((long) 0)
#define XDR_TRUE   ((long) 1)
#define LASTUNSIGNED   ((u_int) 0-1)

Functions

void xdr_free (xdrproc_t proc, char *objp)
bool_t xdr_void (void)
bool_t xdr_int (XDR *xdrs, int *ip)
bool_t xdr_u_int (XDR *xdrs, u_int *up)
bool_t xdr_long (XDR *xdrs, long *lp)
bool_t xdr_u_long (XDR *xdrs, u_long *ulp)
bool_t xdr_hyper (XDR *xdrs, quad_t *llp)
bool_t xdr_u_hyper (XDR *xdrs, u_quad_t *ullp)
bool_t xdr_longlong_t (XDR *xdrs, quad_t *llp)
bool_t xdr_u_longlong_t (XDR *xdrs, u_quad_t *ullp)
bool_t xdr_short (XDR *xdrs, short *sp)
bool_t xdr_u_short (XDR *xdrs, u_short *usp)
bool_t xdr_char (XDR *xdrs, char *cp)
bool_t xdr_u_char (XDR *xdrs, u_char *cp)
bool_t xdr_bool (XDR *xdrs, bool_t *bp)
bool_t xdr_enum (XDR *xdrs, enum_t *ep)
bool_t xdr_opaque (XDR *xdrs, caddr_t cp, u_int cnt)
bool_t xdr_bytes (XDR *xdrs, char **cpp, u_int *sizep, u_int maxsize)
bool_t xdr_netobj (XDR *xdrs, struct netobj *np)
bool_t xdr_union (XDR *xdrs, enum_t *dscmp, char *unp, const struct xdr_discrim *choices, xdrproc_t dfault)
bool_t xdr_string (XDR *xdrs, char **cpp, u_int maxsize)
bool_t xdr_wrapstring (XDR *xdrs, char **cpp)

Variables

static const char xdr_zero [BYTES_PER_XDR_UNIT] = {0, 0, 0, 0}

Define Documentation

#define LASTUNSIGNED   ((u_int) 0-1)

Definition at line 61 of file xdr.c.

#define XDR_FALSE   ((long) 0)

Definition at line 59 of file xdr.c.

#define XDR_TRUE   ((long) 1)

Definition at line 60 of file xdr.c.


Function Documentation

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_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:

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_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_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:

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_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_union ( XDR xdrs,
enum_t dscmp,
char *  unp,
const struct xdr_discrim choices,
xdrproc_t  dfault 
)

Definition at line 611 of file xdr.c.

{
  enum_t dscm;

  /*
   * we deal with the discriminator;  it's an enum
   */
  if (!INTUSE(xdr_enum) (xdrs, dscmp))
    {
      return FALSE;
    }
  dscm = *dscmp;

  /*
   * search choices for a value that matches the discriminator.
   * if we find one, execute the xdr routine for that value.
   */
  for (; choices->proc != NULL_xdrproc_t; choices++)
    {
      if (choices->value == dscm)
       return (*(choices->proc)) (xdrs, unp, LASTUNSIGNED);
    }

  /*
   * no match - execute the default xdr routine if there is one
   */
  return ((dfault == NULL_xdrproc_t) ? FALSE :
         (*dfault) (xdrs, unp, LASTUNSIGNED));
}

Here is the call graph for this function:

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:


Variable Documentation

const char xdr_zero[BYTES_PER_XDR_UNIT] = {0, 0, 0, 0} [static]

Definition at line 66 of file xdr.c.