如何通过RPC发送数组？

Question

I have a bit of a difficulty sending arrays over the RPC using the libtirpc library. Sending primitives during a client-server session is as easy as:

// Client-side boilerplate
struct timeval tout = { 1, 0 };
int in = 42;
clnt_call (cln, 1, (xdrproc_t)xdr_int, (char*)&in,
    (xdrproc_t)xdr_void, NULL, tout);    

// Server-side boilerplate
int in;
svc_getargs (xprt, (xdrproc_t)xdr_int, (char*)&in);
assert (in == 42);

The xdrproc_t function signature is bool_t (*xdrproc_t) (XDR *, void *, ...); . The xdr_int(3) , xdr_long(3) and other primitive serializers have no variable arguments and so they can be used directly using the clnt_call(3) and svc_getargs(3) functions. The xdr_array(3) function used to serialize variable length arrays, however, takes much more arguments:

bool_t xdr_array(XDR *xdrs, char **arrp, unsigned int *sizep,
                 unsigned int maxsize, unsigned int elsize,
                 xdrproc_t elproc);

The clnt_call(3) and svc_getargs(3) functions can't really pass these arguments to the functions, so creating wrapper functions seemed like the cleanest solution to the problem:

// Client-side boilerplate
long a = 1, b = 2;
long * arr[] = { &a, &b };
unsigned int amount = sizeof(arr) / sizeof(long*);
bool_t xdr_array_wrapper (XDR * xdr, void * ptr) {
    return xdr_array (xdr, ptr, &amount, amount,
        sizeof(long), (xdrproc_t)xdr_long);
}

struct timeval tout = { 1, 0 };
long out;
clnt_call (cln, 1, (xdrproc_t)xdr_array_wrapper,
    (char*)arr, (xdrproc_t)xdr_long, (char*)&out, tout);

// Server-side boilerplate
long * arr[2];
unsigned int amount = sizeof(arr) / sizeof(long*);
bool_t xdr_array_wrapper (XDR * xdr, void * ptr) {
    return xdr_array (xdr, ptr, &amount, amount,
        sizeof(long), (xdrproc_t)xdr_long);
}
svc_getargs (xprt, (xdrproc_t)xdr_array_wrapper, (char*)arr);
long a = *arr[0], b = *arr[1];

However, for some unknown reason, only the first element of the array (the variable a ) is transferred and the other one contains garbage. What am I doing wrong?

Answer 1

You are using xdr_array incorrectly for two reasons.

1. It can only handle dynamically allocated arrays.
2. You are trying to send an array of int* as if it were an array of int .

The correct way of using it goes like this (stolen from IBM and simplified, refer to the link for a more complete treatment):

typedef struct xarray
{
        int size;
        int *p_array;
} xarray ;

bool_t xdr_xarray(XDR *xdrs, xarray *p_xarray )
{
    return xdr_array(
                 xdrs,
                 (char**)(&(p_xarray->p_array)),
                 &(p_xarray->size),
                 MAX_INT,
                 sizeof(int),
                 (xdrproc_t)xdr_int)) 
}

Note these thinsg:

1. p_array is a pointer to a dynamically allocated array.
2. It is an array of int , not of pointers.
3. We are passing an address of p_array to xdr_array so that on decoding it can allocate an array of the required size and assign it to p_array .

If you want fixed-size arrays you need to use xdr_vector .

typedef struct xvector
{
        int vector[42];
} xarray ;

bool_t xdr_xvector(XDR *xdrs, xarray *p_xvector )
{
    return xdr_vector(
                 xdrs,
                 (char*)p_xvector->vector,
                 42,
                 sizeof(int),
                 (xdrproc_t)xdr_int)) 
}

Note you still should not use an array of pointers here.

An RPC compiler generates XDR procedures automatically from your data structures, so consider using one.