xdr(3R)

xdr - External Data Representation (XDR) library routines

As shipped in IRIX 6.5.30. Last changed in IRIX 6.5.30.

NAME
     xdr - External Data Representation (XDR) library routines

SYNOPSIS AND DESCRIPTION
     These routines allow C programmers to describe arbitrary data structures
     in a machine-independent fashion.  Data for remote procedure calls are
     transmitted using these routines.


          #include <rpc/rpc.h>



          bool_t
          xdr_array(XDR *xdrs, caddr_t *arrp, u_int *sizep,
               u_int maxsize, u_int elsize, xdrproc_t elproc)


          A filter primitive that translates between variable-length arrays
          and their corresponding external representations. The parameter arrp
          is the address of the pointer to the array, while sizep is the
          address of the element count of the array; this element count cannot
          exceed maxsize.  The parameter elsize is the sizeof each of the
          array's elements, and elproc is an XDR filter that translates
          between the array elements' C form, and their external
          representation.  This routine returns 1 if it succeeds, 0 otherwise.


          bool_t
          xdr_bool(XDR *xdrs, bool_t *bp)


          A filter primitive that translates between booleans (C integers) and
          their external representations. When encoding data, this filter
          produces values of either 1 or 0.  This routine returns 1 if it
          succeeds, 0 otherwise.


          bool_t
          xdr_bytes(XDR *xdrs, char **sp, u_int *sizep,
               u_int maxsize)


          A filter primitive that translates between counted byte strings and
          their external representations.  The parameter sp is the address of
          the string pointer. The length of the string is located at address
          sizep; strings cannot be longer than maxsize.  This routine returns
          1 if it succeeds, 0 otherwise.

          bool_t
          xdr_char(XDR *xdrs, char *cp)


          A filter primitive that translates between C characters and their
          external representations.  This routine returns 1 if it succeeds, 0
          otherwise.  Note: encoded characters are not packed, and occupy 4
          bytes each. For arrays of characters, it is worthwhile to consider
          xdr_bytes(), xdr_opaque() or xdr_string().


          void
          xdr_destroy(XDR *xdrs)


          A macro that invokes the destroy routine associated with the XDR
          stream, xdrs.  Destruction usually involves freeing private data
          structures associated with the stream.  Using xdrs after invoking
          xdr_destroy() is undefined.


          bool_t
          xdr_double(XDR *xdrs, double *dp)


          A filter primitive that translates between C double precision
          numbers and their external representations.  This routine returns 1
          if it succeeds, 0 otherwise.


          bool_t
          xdr_enum(XDR *xdrs, enum_t *ep)


          A filter primitive that translates between C enums (actually
          integers) and their external representations.  This routine returns
          1 if it succeeds, 0 otherwise.


          bool_t
          xdr_float(XDR *xdrs, float *fp)


          A filter primitive that translates between C floats and their
          external representations.  This routine returns 1 if it succeeds, 0
          otherwise.


          void
          xdr_free(xdrproc_t proc, char *objp)

          Generic freeing routine. The first argument is the XDR routine for
          the object being freed. The second argument is a pointer to the
          object itself. Note: the pointer passed to this routine is not
          freed, but what it points to is freed (recursively).


          u_int
          xdr_getpos(XDR *xdrs)


          A macro that invokes the get-position routine associated with the
          XDR stream, xdrs.  The routine returns an unsigned integer, which
          indicates the position of the XDR byte stream.  A desirable feature
          of XDR streams is that simple arithmetic works with this number,
          although the XDR stream instances need not guarantee this.


          bool_t
          xdr_int(XDR *xdrs, int *ip)
          bool_t
          xdr_int32(XDR *xdrs, int *ip)


          A filter primitive that translates between C integers and their
          external representations.  This routine returns 1 if it succeeds, 0
          otherwise.  xdr_int32 is an synonym for xdr_int.


          bool_t
          xdr_long(XDR *xdrs, long *lp)


          A filter primitive that translates between C long integers and their
          external representations.  This routine returns 1 if it succeeds, 0
          otherwise.

          Warning: In the IRIX 64-bit ABI, this routine may be somewhat
          misleading. The external representation of a long integer is defined
          by the XDR standard to be a 32 bit encoding, but in the IRIX 64-bit
          ABI, a long integer is 64 bits. Hence, in the IRIX 64-bit ABI, long
          integers are truncated by xdr_long(), and xdr_long() is only useful
          for encoding/decoding values in the range of -2147483648 to
          2147483647.

          bool_t
          xdr_longlong_t(XDR *xdrs, __int64_t *ulp)
          bool_t
          xdr_longlong(XDR *xdrs, __int64_t *ulp)
          bool_t
          xdr_int64(XDR *xdrs, __int64_t *ulp)
          bool_t
          xdr_hyper(XDR *xdrs, __int64_t *ulp)
          A filter primitive that translates between C 64-bit integers and
          their external representations.  This routine returns 1 if it
          succeeds, 0 otherwise.  xdr_longlong, xdr_hyper and xdr_int64 are
          synonyms for xdr_longlong_t.


          bool_t
          xdr_opaque(XDR *xdrs, void *cp, u_int cnt)


          A filter primitive that translates between fixed size opaque data
          and its external representation.  The parameter cp is the address of
          the opaque object, and cnt is its size in bytes.  This routine
          returns 1 if it succeeds, 0 otherwise.


          bool_t
          xdr_pointer(XDR *xdrs, char **objpp,
               u_int objsize, xdrproc_t xdrobj)


          Like xdr_reference() except that it serializes NULL pointers,
          whereas xdr_reference() does not.  Thus, xdr_pointer() can represent
          recursive data structures, such as binary trees or linked lists.



          bool_t
          xdr_reference(XDR *xdrs, char **pp,
               u_int size, xdrproc_t proc)


          A primitive that provides pointer chasing within structures.  The
          parameter pp is the address of the pointer; size is the sizeof the
          structure that *pp points to; and proc is an XDR procedure that
          filters the structure between its C form and its external
          representation.  This routine returns 1 if it succeeds, 0 otherwise.

          Warning: this routine does not understand NULL pointers. Use
          xdr_pointer() instead.


          bool_t
          xdr_setpos(XDR *xdrs, u_int pos)


          A macro that invokes the set position routine associated with the
          XDR stream xdrs.  The parameter pos is a position value obtained
          from xdr_getpos().  This routine returns 1 if the XDR stream could
          be repositioned, and 0 otherwise.

          Warning: it is difficult to reposition some types of XDR streams, so
          this routine may fail with one type of stream and succeed with
          another.


          bool_t
          xdr_short(XDR *xdrs, short *sp)


          A filter primitive that translates between C short integers and
          their external representations.  This routine returns 1 if it
          succeeds, 0 otherwise.


          bool_t
          xdr_string(XDR *xdrs, char **sp, u_int maxsize)


          A filter primitive that translates between C strings and their
          corresponding external representations.  Strings cannot be longer
          than maxsize.  Note: sp is the address of the string's pointer.
          This routine returns 1 if it succeeds, 0 otherwise.


          bool_t
          xdr_time_t(XDR *xdrs, time_t *tp);


          A filter primitive that translates between local representation of
          time_t, which on Irix is a 32bit integer, and its external
          representations. This routine returns 1 if it succeeds, 0 otherwise.


          bool_t
          xdr_u_char(XDR *xdrs, unsigned char *cp)


          A filter primitive that translates between unsigned C characters and
          their external representations.  This routine returns 1 if it
          succeeds, 0 otherwise.


          bool_t
          xdr_u_int(XDR *xdrs, unsigned *up)
          bool_t
          xdr_uint32(XDR *xdrs, unsigned *up)


          A filter primitive that translates between C unsigned integers and
          their external representations.  This routine returns 1 if it
          succeeds, 0 otherwise.  xdr_uint32 is a synonym for xdr_u_int.

          bool_t
          xdr_u_long(XDR *xdrs, unsigned long *ulp)


          A filter primitive that translates between C unsigned long integers
          and their external representations.  This routine returns 1 if it
          succeeds, 0 otherwise.

          Warning: In the IRIX 64-bit ABI, this routine may be somewhat
          misleading. The external representation of an unsigned long integer
          is defined by the XDR standard to be a 32 bit encoding, but in the
          IRIX 64-bit ABI, an unsigned long integer is 64 bits. Hence, in the
          IRIX 64-bit ABI, unsigned long integers are truncated by
          xdr_u_long(), and xdr_u_long() is only useful for encoding/decoding
          values in the range of 0 to 4294967295.


          bool_t
          xdr_u_longlong_t(XDR *xdrs, __uint64_t *ulp)
          bool_t
          xdr_u_longlong(XDR *xdrs, __uint64_t *lp);
          bool_t
          xdr_uint64(XDR *xdrs, __uint64_t *lp);
          bool_t
          xdr_u_hyper(XDR *xdrs, __uint64_t *lp);


          A filter primitive that translates between C unsigned 64-bit
          integers and their external representations.  This routine returns 1
          if it succeeds, 0 otherwise.  xdr_u_longlong, xdr_u_hyper and
          xdr_uint64 are synonyms for xdr_u_longlong_t.


          bool_t
          xdr_u_short(XDR *xdrs, unsigned short *usp)


          A filter primitive that translates between C unsigned short integers
          and their external representations.  This routine returns 1 if it
          succeeds, 0 otherwise.


          bool_t
          xdr_union(XDR *xdrs, enum_t *dscmp, void *unp,
               struct xdr_discrim *choices, xdrproc_t dfault)


          A filter primitive that translates between a discriminated C union
          and its corresponding external representation. It first translates
          the discriminant of the union located at dscmp.  This discriminant
          is always an enum_t.  Next the union located at unp is translated.
          The parameter choices is a pointer to an array of xdr_discrim()
          structures. Each structure contains an ordered pair of [value,
          proc].  If the union's discriminant is equal to the associated
          value, then the proc is called to translate the union.  The end of
          the xdr_discrim() structure array is denoted by a routine of value
          NULL.  If the discriminant is not found in the choices array, then
          the defaultarm procedure is called (if it is not NULL).  Returns 1
          if it succeeds, 0 otherwise.


          bool_t
          xdr_vector(XDR *xdrs, char *arrp,
               u_int size, u_int elsize, xdrproc_t elproc)


          A filter primitive that translates between fixed-length arrays and
          their corresponding external representations.  The parameter arrp is
          the address of the pointer to the array, while size is the element
          count of the array.  The parameter elsize is the sizeof each of the
          array's elements, and elproc is an XDR filter that translates
          between the array elements' C form, and their external
          representation.  This routine returns 1 if it succeeds, 0 otherwise.


          bool_t
          xdr_void(XDR *xdrs, void *v)


          This routine always returns 1.  It may be passed to RPC routines
          that require a function parameter, where nothing is to be done.


          bool_t
          xdr_wrapstring(XDR *xdrs, char **sp)


          A primitive that calls

               xdr_string(xdrs, sp, UINT_MAX);

          where UINT_MAX is the maximum value of an unsigned integer, as
          defined in <limits.h>.  xdr_wrapstring() is handy because the RPC
          package passes a maximum of two XDR routines as parameters, and
          xdr_string(), one of the most frequently used primitives, requires
          three.  Returns 1 if it succeeds, 0 otherwise.


          void
          xdrmem_create(XDR *xdrs, void *addr,
               u_int size, enum xdr_op op)

          This routine initializes the XDR stream object pointed to by xdrs.
          The stream's data is written to, or read from, a chunk of memory at
          location addr whose length is no more than size bytes long.  The op
          determines the direction of the XDR stream (either XDR_ENCODE,
          XDR_DECODE, or XDR_FREE).


          void
          xdrrec_create(XDR *xdrs, u_int sendsize, u_int recvsize,
               void *handle,
               int (*readit)(void *, void *, u_int),
               int (*writeit)(void *, void *, u_int))


          This routine initializes the XDR stream object pointed to by xdrs.
          The stream's data is written to a buffer of size sendsize; a value
          of 0 indicates the system should use a suitable default. The
          stream's data is read from a buffer of size recvsize; it too can be
          set to a suitable default by passing a zero value.  When a stream's
          output buffer is full, writeit is called.  Similarly, when a
          stream's input buffer is empty, readit is called.  The behavior of
          these two routines is similar to the system calls read(2) and
          write(2), except that handle is passed to the former routines as the
          first parameter.  Note: the XDR stream's op field must be set by the
          caller.

          Warning: this XDR stream implements an intermediate record stream.
          Therefore there are additional bytes in the stream to provide record
          boundary information.


          bool_t
          xdrrec_endofrecord(XDR *xdrs, bool_t sendnow)


          This routine can be invoked only on streams created by
          xdrrec_create().  The data in the output buffer is marked as a
          completed record, and the output buffer is optionally written out if
          sendnow is non-zero. This routine returns 1 if it succeeds, 0
          otherwise.


          bool_t
          xdrrec_eof(XDR *xdrs)


          This routine can be invoked only on streams created by
          xdrrec_create().  After consuming the rest of the current record in
          the stream, this routine returns 1 if the stream has no more input,
          0 otherwise.

          int
          xdrrec_readbytes(XDR *xdrs, caddr_t addr, u_int len)


          This routine reads data from the stream. It behaves like the read(2)
          system call against a pipe - it returns up to the number of bytes
          requested and a return of zero indicates end-of-record.  A -1 means
          something very bad happened.


          bool_t
          xdrrec_skiprecord(XDR *xdrs)


          This routine can be invoked only on streams created by
          xdrrec_create().  It tells the XDR implementation that the rest of
          the current record in the stream's input buffer should be discarded.
          This routine returns 1 if it succeeds, 0 otherwise.


          void
          xdrstdio_create(XDR *xdrs, FILE *file, enum xdr_op op)


          This routine initializes the XDR stream object pointed to by xdrs.
          The XDR stream data is written to, or read from, the Standard I/O
          stream file.  The parameter op determines the direction of the XDR
          stream (either XDR_ENCODE, XDR_DECODE, or XDR_FREE).

          Warning: the destroy routine associated with such XDR streams calls
          fflush(3S) on the file stream, but never fclose(3S).


SEE ALSO
     rpc(3R), IRIX Network Programming Guide.