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

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)