Provided by: manpages-es_1.55-10_all bug

NOMBRE

       xdr - rutinas de biblioteca para la representación externa de datos

SINOPSIS Y DESCRIPCIÓN

       Estas rutinas permiten a los programadores de C describir estructuras de datos arbitrarias
       de una forma independiente de la máquina. Los datos para  las  llamadas  a  procedimientos
       remotos se transmiten usando estas rutinas.

       xdr_array(xdrs, arrp, sizep, maxsize, elsize, elproc)
       XDR *xdrs;
       char **arrp;
       u_int *sizep, maxsize, elsize;
       xdrproc_t elproc;

              Una   primitiva  de  filtro  que  convierte  arrays  de  longitud  variable  a  sus
              correspondientes representaciones externas y viceversa. El  parámetro  arrp  es  la
              dirección  del puntero al array, mientras que sizep es la dirección del contador de
              elementos del array. Este contador de  elementos  no  puede  exceder  maxsize.   El
              parámetro  elsize  es el sizeof de cada uno de los elementos del array, y elproc es
              un filtro XDR que convierte entre el formato en C de los elementos del array  y  su
              representación  externa.   Esta  rutina  devuelve uno si tiene éxito y cero en caso
              contrario.

       xdr_bool(xdrs, bp)
       XDR *xdrs;
       bool_t *bp;

              Una  primitiva  de  filtro  que  convierte  booleanos  (enteros   de   C)   a   sus
              representaciones  externas  y  viceversa.  Cuando  se condifican datos, este filtro
              produce valores de uno o de cero.  Esta rutina devuelve uno si tiene éxito  y  cero
              en caso contrario.

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

              Una   primitiva   de   filtro  que  convierte  cadenas  de  bytes  contadas  a  sus
              representaciones externas y viceversa.  El parámetro sp es la dirección del puntero
              a  la  cadena.  La  longitud  de la cadena se encuentra en la dirección sizep.  Las
              cadenas no pueden ser más largas que maxsize.  Esta rutina devuelve  uno  si  tiene
              éxito y cero en caso contrario.

       xdr_char(xdrs, cp)
       XDR *xdrs;
       char *cp;

              Una  primitiva  de  filtro  que  convierte  caracteres  de C a sus representaciones
              externas y viceversa. Esta rutina devuelve uno  si  tiene  éxito  y  cero  en  caso
              contrario.  Nota:  los  caracteres  codificados no se empaquetan y cada uno ocupa 4
              bytes. Para arrays de caracteres, vale la pena considerar xdr_bytes(), xdr_opaque()
              o xdr_string().

       void
       xdr_destroy(xdrs)
       XDR *xdrs;

              Una  macro  que  invoca a la rutina de destrucción asociada con el flujo XDR, xdrs.
              Usualmente, la destrucción implica la liberación de estructuras de  datos  privadas
              asociadas  con  el  flujo.  El  uso  de  xdrs  después de llamar a xdr_destroy() es
              indefinido.

       xdr_double(xdrs, dp)
       XDR *xdrs;
       double *dp;

              Una primitiva de filtro que convierte números de precisión doble de  C  (double)  a
              sus  representaciones externas y viceversa. Esta rutina devuelve uno si tiene éxito
              y cero en caso contrario.

       xdr_enum(xdrs, ep)
       XDR *xdrs;
       enum_t *ep;

              Una primitiva de filtro que convierte enumerados de C (enums) (enteros en realidad)
              a  sus  representaciones  externas  y viceversa.  Esta rutina devuelve uno si tiene
              éxito y cero en caso contrario.

       xdr_float(xdrs, fp)
       XDR *xdrs;
       float *fp;

              Una primitiva de filtro que  convierte  números  flotantes  de  C  (floats)  a  sus
              representaciones  externas  y viceversa.  Esta rutina devuelve uno si tiene éxito y
              cero en caso contrario.

       void
       xdr_free(proc, objp)
       xdrproc_t proc;
       char *objp;

              Rutina genérica de liberación. El primer argumento es la rutina XDR para que libera
              el  objeto. El segundo argumento es un puntero al propio objeto. Nota: no se libera
              el puntero pasado a esta rutina, sino a lo que él apunta (de forma recursiva).

       u_int
       xdr_getpos(xdrs)
       XDR *xdrs;

              Una macro que llama a la rutina "obtener posición" asociada con el flujo XDR, xdrs.
              La  rutina devuelve un entero sin signo que indica la posición en el flujo de bytes
              XDR.  Una caracterísitica deseable de los flujos XDR es que  la  aritmética  simple
              funcione  con  este  número,  aunque  las  instancias  de  flujos  XDR no necesitan
              garantizar esto.

       long *
       xdr_inline(xdrs, len)
       XDR *xdrs;
       int len;

              Una macro que llama a la rutina "en línea" asociada con el  flujo  XDR,  xdrs.   La
              rutina  devuelve un puntero a una porción contigua del buffer del flujo.  len es la
              longitud en bytes del buffer deseado.  Nota: el puntero se convierte al  tipo  long
              *.

              Cuidado:  xdr_inline()  puede  devolver  NULL  (0) si no puede reservar una porción
              contigua de buffer. Por lo tanto, el comportamiento puede varias  entre  instancias
              de flujo.  Existe por el bien de la eficiencia.

       xdr_int(xdrs, ip)
       XDR *xdrs;
       int *ip;

              Una  primitiva de filtro que convierte enteros de C a sus representaciones externas
              y viceversa. Esta rutina devuelve uno si tiene éxito y cero en caso contrario.

       xdr_long(xdrs, lp)
       XDR *xdrs;
       long *lp;

              Una  primitiva  de  filtro  que  convierte  enteros  largos  de  C  (long)  a   sus
              representaciones  externas  y viceversa.  Esta rutina devuelve uno si tiene éxito y
              cero en caso contrario.

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

              Esta rutina inicializa el objeto de flujo XDR apuntado por  xdrs.   Los  datos  del
              flujo se escriben en, o se leen de, una porción de memoria en la posición addr cuya
              longitud no es mayor que size bytes.  El op determina la dirección  del  flujo  XDR
              (bien XDR_ENCODE, XDR_DECODE o XDR_FREE).

       xdr_opaque(xdrs, cp, cnt)
       XDR *xdrs;
       char *cp;
       u_int cnt;

              Una  primitiva  de  filtro  que  convierte  datos  opacos  de  tamaño  fijo  a  sus
              representaciones externas y viceversa.  El parámetro cp es la dirección del  objeto
              opaco  y cnt es su tamaño en bytes.  Esta rutina devuelve uno si tiene éxito y cero
              en caso contrario.

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

              Como  xdr_reference()   salvo   que   serializa   punteros   NULL,   mientras   que
              xdr_reference()  no lo hace. Por tanto, xdr_pointer() puede representar estructuras
              de datos recursivas, tales como árboles binarios o listas enlazadas.

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

              Esta rutina inicializa el objeto de flujo XDR apuntado por  xdrs.   Los  datos  del
              flujo  se  escriben  en  un buffer de tamaño sendsize.  Un valor cero indica que el
              sistema debería usar un valor por omisión adecuado. Los datos del flujo se leen  de
              un  buffer  de  tamaño  recvsize.  Un valor cero también indica que se le asigne un
              valor por omisión adecuado.  Cuando un buffer de salida de un flujo  se  llena,  se
              llama  a  writeit.   De  igual  forma, cuando un buffer de entrada de un flujo está
              vacío, se llama a readit.  El comportamiento de estas rutinas es similar al de  las
              llamadas  al  sistema  read  y  write,  excepto  que  handle  se pasa a las rutinas
              anteriores como primer parámetro.  Nota:  el  campo  op  del  flujo  XDR  debe  ser
              asignado por el invocador.

              Cuidado:  este  flujo  XDR implanta un flujo de registros intermedio. Por lo tanto,
              existen bytes adicionales en el flujo para proporcionar información  sobre  límites
              de registros.

       xdrrec_endofrecord(xdrs, sendnow)
       XDR *xdrs;
       int sendnow;

              Esta  rutina  sólo  puede  llamarse  sobre flujos creados por xdrrec_create().  Los
              datos del buffer de salida se marcan como un registro terminado  y,  opcionalmente,
              se  escribe  el buffer de salida si sendnow no es cero. Esta rutina devuelve uno si
              tiene éxito y cero en caso contrario.

       xdrrec_eof(xdrs)
       XDR *xdrs;
       int empty;

              Sólo pueda llamarse  a  esta  rutina  sobre  flujos  creados  por  xdrrec_create().
              Después  de consumir el resto del registro actual en el flujo, esta rutina devuelve
              uno si el flujo no tiene más datos de entrada y cero en caso contrario.

       xdrrec_skiprecord(xdrs)
       XDR *xdrs;

              Sólo pueda llamarse a esta rutina sobre flujos  creados  por  xdrrec_create().   Le
              dice  a la implementación XDR que se debería descartar el resto del registro actual
              en el buffer de entrada del flujo. Esta rutina devuelve uno si tiene éxito  y  cero
              en caso contrario.

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

              Una primitiva que proporciona un seguimiento de punteros dentro de estructuras.  El
              parámetro pp es la dirección del puntero.  size es el sizeof de la estructura a  la
              que  apunta  *pp,  y proc es un procedimiento XDR que filtra la estructura entre su
              formato en C y su representación externa.  Esta rutina devuelve uno si tiene  éxito
              y cero en caso contrario.

              Cuidado: esta rutina no entiende punteros NULL.  Use xdr_pointer() en su lugar.

       xdr_setpos(xdrs, pos)
       XDR *xdrs;
       u_int pos;

              Una  macro  que  llama  a la rutina de establecimiento de posición con el flujo XDR
              xdrs.  El parámetro pos es el valor de posición  obtenido  de  xdr_getpos().   Esta
              rutina  devuelve  uno  si  se  podría  reposicionar  el  flujo  XDR  y cero en caso
              contrario.

              Cuidado: es difícil reposicionar algunos tipos de  flujos  XDR,  por  lo  que  esta
              rutina puede fallar con un tipo de flujo y tener éxito con otro.

       xdr_short(xdrs, sp)
       XDR *xdrs;
       short *sp;

              Una  primitiva  de  filtro  que  convierte  enteros  cortos  de  C  (short)  a  sus
              representaciones externas y viceversa.  Esta rutina devuelve uno si tiene  éxito  y
              cero en caso contrario.

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

              Esta  rutina inicializa el flujo XDR apuntado por xdrs.  Los datos del flujo XDR se
              escriben en, o se leen de,  el  flujo  de  E/S  estándar  file.   El  parámetro  op
              determina la dirección del flujo XDR (bien XDR_ENCODE, XDR_DECODE o XDR_FREE).

              Cuidado:  la  rutina  de destrucción asociada con tales flujos XDR llama a fflush()
              sobre el flujo file, pero nunca a fclose().

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

              Una primitiva de  filtro  que  convierte  cadenas  de  C  en  sus  correspondientes
              representaciones  externas  y  viceversa.  Las candenas no pueden ser más largas de
              maxsize.  Nota: sp es la dirección del puntero a la cadena.  Esta  rutina  devuelve
              uno si tiene éxito y cero en caso contrario.

       xdr_u_char(xdrs, ucp)
       XDR *xdrs;
       unsigned char *ucp;

              Una  primitiva  de filtro que convierte caracteres sin signo de C (unsigned char) a
              sus representaciones externas y viceversa.  Esta rutina devuelve uno si tiene éxito
              y cero en caso contrario.

       xdr_u_int(xdrs, up)
       XDR *xdrs;
       unsigned *up;

              Una  primitiva  de  filtro  que  convierte  enteros sin signo de C (unsigned) a sus
              representaciones externas y viceversa.  Esta rutina devuelve uno si tiene  éxito  y
              cero en caso contrario.

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

              Una primitiva de filtro que convierte enteros largos sin signo de C (unsigned long)
              a sus representaciones externas y viceversa.  Esta rutina  devuelve  uno  si  tiene
              éxito y cero en caso contrario.

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

              Una  primitiva  de  filtro  que  convierte  enteros cortos sin signo de C (unsigned
              short) a sus representaciones externas y viceversa.  Esta rutina  devuelve  uno  si
              tiene éxito y cero en caso contrario.

       xdr_union(xdrs, dscmp, unp, choices, dfault)
       XDR *xdrs;
       int *dscmp;
       char *unp;
       struct xdr_discrim *choices;
       bool_t (*defaultarm) ();  /* may equal NULL */

              Una   primitiva  de  filtro  que  convierte  una  union  discriminada  de  C  a  su
              correspondiente  representación  externa  y  viceversa.   Primero,   convierte   el
              discriminante  de  la  unión localizado en dscmp.  Este discriminante siempre es un
              enum_t.  A continuación, se convierte la unión localizada  en  unp.   El  parámetro
              choices  es  un  puntero  a un array de estructuras xdr_discrim().  Cada estructura
              contiene un par ordenado [value,proc].  Si el discriminante de la unión es igual al
              value  asociado,  se  llama  a  proc para convertir la unión. El final del array de
              estructuras xdr_discrim() se denota con  una  rutina  de  valor  NULL.   Si  no  se
              encuentra  el  discriminante  en  el  array  choices,  se  llama  al  procedimiento
              defaultarm (si no es NULL).  Devuelve uno si tiene éxito y cero en caso contrario.

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

              Una  primitiva  de  filtro  que  convierte  arrays   de   longitud   fija   a   sus
              correspondientes  representaciones  externas  y  viceversa. El parámetro arrp es la
              dirección del puntero al array, mientras que size es el  número  de  elementos  del
              array.  El  parámetro  elsize es el sizeof de cada uno de los elementos del array y
              elproc es un flitro XDR que traduce entre el formato en  C  de  los  elementos  del
              array  y  sus representaciones externas.  Esta rutina devuelve uno si tiene éxito y
              cero en caso contrario.

       xdr_void()

              Esta rutina siempre devuelve uno. Se puede pasar a rutinas RPC  que  necesitan  una
              parámetro función donde no se va a hacer nada.

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

              Una primitiva que llama a xdr_string(xdrs, sp,MAXUN.UNSIGNED); donde MAXUN.UNSIGNED
              es el valor máximo de un entero sin signo.  xdr_wrapstring() es adecuada porque  el
              paquete  RPC  pasa un máximo de dos rutinas XDR como parámetros y xdr_string(), una
              de las primitivas usadas con más frecuencia, necesita tres.  Devuelve uno si  tiene
              éxito y cero en caso contrario.

VÉASE TAMBIÉN

       rpc(3)

       Los siguientes manuales:
              eXternal Data Representation Standard: Protocol Specification
              eXternal Data Representation: Sun Technical Notes
              XDR:  External  Data Representation Standard, RFC1014, Sun Microsystems, Inc., USC-
              ISI.

                                         16 febrero 1988                                  XDR(3N)