Provided by: manpages-es_1.55-3_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)