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

NOMBRE

       xdr - rutinas de biblioteca para la representacion externa de datos

SINOPSIS Y DESCRIPCI'ON

       Estas  rutinas  permiten a los programadores de C describir estructuras
       de datos arbitrarias de una forma  independiente  de  la  maquina.  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 parametro arrp es  la  direccion  del  puntero  al
              array,  mientras  que  sizep  es  la  direccion  del contador de
              elementos del array. Este contador de elementos no puede exceder
              maxsize.   El  parametro  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
              representacion externa.  Esta rutina devuelve uno si tiene exito
              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 exito 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 parametro sp es
              la direccion del puntero a la cadena. La longitud de  la  cadena
              se  encuentra  en la direccion sizep.  Las cadenas no pueden ser
              mas largas que maxsize.  Esta rutina devuelve uno si tiene exito
              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  exito  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 destruccion asociada con  el
              flujo   XDR,   xdrs.   Usualmente,  la  destruccion  implica  la
              liberacion de estructuras de datos  privadas  asociadas  con  el
              flujo.  El  uso  de  xdrs  despues  de llamar a xdr_destroy() es
              indefinido.

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

              Una primitiva de filtro que convierte numeros de precision doble
              de  C (double) a sus representaciones externas y viceversa. Esta
              rutina devuelve uno si tiene exito 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 exito  y  cero  en
              caso contrario.

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

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

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

              Rutina  generica de liberacion. 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 'el apunta (de forma recursiva).

       u_int
       xdr_getpos(xdrs)
       XDR *xdrs;

              Una macro que llama a la rutina "obtener posicion" asociada  con
              el  flujo XDR, xdrs.  La rutina devuelve un entero sin signo que
              indica  la  posicion  en   el   flujo   de   bytes   XDR.    Una
              caracterisitica  deseable de los flujos XDR es que la aritmetica
              simple funcione con este numero, 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 linea" asociada con el flujo
              XDR, xdrs.  La rutina devuelve un puntero a una porcion 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  porcion  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 exito 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 exito 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 porcion de
              memoria  en  la posicion addr cuya longitud no es mayor que size
              bytes.  El  op  determina  la  direccion  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 tamano
              fijo a sus representaciones externas y viceversa.  El  parametro
              cp es la direccion del objeto opaco y cnt es su tamano en bytes.
              Esta  rutina  devuelve  uno  si  tiene  exito  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 arboles
              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 tamano sendsize.
              Un valor cero indica que el sistema deberia usar  un  valor  por
              omision  adecuado.  Los  datos del flujo se leen de un buffer de
              tamano recvsize.  Un valor cero tambien indica que se le  asigne
              un valor por omision 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 esta vacio, 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 parametro.  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 informacion sobre limites de registros.

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

              Esta  rutina  solo  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
              exito y cero en caso contrario.

       xdrrec_eof(xdrs)
       XDR *xdrs;
       int empty;

              Solo  pueda  llamarse  a  esta  rutina  sobre flujos creados por
              xdrrec_create().  Despues de  consumir  el  resto  del  registro
              actual  en  el  flujo,  esta  rutina devuelve uno si el flujo no
              tiene mas datos de entrada y cero en caso contrario.

       xdrrec_skiprecord(xdrs)
       XDR *xdrs;

              Solo pueda llamarse a  esta  rutina  sobre  flujos  creados  por
              xdrrec_create().  Le dice a la implementacion XDR que se deberia
              descartar el resto del registro actual en el buffer  de  entrada
              del  flujo.  Esta  rutina  devuelve uno si tiene exito 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  parametro pp es la direccion 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 representacion externa.  Esta rutina  devuelve
              uno si tiene exito 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  posicion
              con el flujo XDR xdrs.  El parametro pos es el valor de posicion
              obtenido de xdr_getpos().  Esta rutina devuelve uno si se podria
              reposicionar el flujo XDR y cero en caso contrario.

              Cuidado:  es  dificil  reposicionar algunos tipos de flujos XDR,
              por lo que esta rutina puede fallar con un tipo de flujo y tener
              exito 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 exito 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  estandar  file.  El parametro op determina la direccion del
              flujo XDR (bien XDR_ENCODE, XDR_DECODE o XDR_FREE).

              Cuidado: la rutina de destruccion 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 mas largas de maxsize.  Nota: sp es la
              direccion del puntero a la cadena.  Esta rutina devuelve uno  si
              tiene exito 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  exito  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 exito 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 exito  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 exito 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  representacion  externa  y viceversa.
              Primero, convierte el discriminante de la  union  localizado  en
              dscmp.    Este   discriminante   siempre   es   un   enum_t.   A
              continuacion, se convierte  la  union  localizada  en  unp.   El
              parametro  choices  es  un  puntero  a  un  array de estructuras
              xdr_discrim().   Cada  estructura  contiene  un   par   ordenado
              [value,proc].  Si el discriminante de la union es igual al value
              asociado, se llama a proc para convertir la union. 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 exito 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
              parametro arrp es la direccion del puntero  al  array,  mientras
              que  size  es  el  numero  de  elementos del array. El parametro
              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 exito y cero en caso contrario.

       xdr_void()

              Esta  rutina  siempre devuelve uno. Se puede pasar a rutinas RPC
              que necesitan una parametro funcion 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 maximo de un entero sin signo.
              xdr_wrapstring() es adecuada  porque  el  paquete  RPC  pasa  un
              maximo de dos rutinas XDR como parametros y xdr_string(), una de
              las  primitivas  usadas  con  mas  frecuencia,  necesita   tres.
              Devuelve uno si tiene exito y cero en caso contrario.

V'EASE TAMBI'EN

       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)