[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[giFTcurs-devel] RPC protocol handling
|
From: |
Christian Häggström |
|
Subject: |
[giFTcurs-devel] RPC protocol handling |
|
Date: |
Mon, 23 Feb 2004 16:04:36 +0100 |
|
User-agent: |
Mutt/1.5.5.1+cvs20040105i |
Hi all!
The interface protocol are going RPC now. I have written a generator
which takes .x as input and generates template routines. The template
just queries the user for the values, and dumps the results on stdout.
I have successfully queried the rstatd with the template generated from
rstat.x, therefore the UDP transport code.
Of course much of the generated code is unused and can just be deleted
when we are going to glue this into giFTcurs.
Please tell me what you think!
Some advice how to name the variables in a smarter way would also be nice.
Here is the code generated from giftrpc.x:
--------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include <gnet.h>
/* gcc -Wall -O rpc_example.c `pkg-config --cflags --libs gnet-2.0 glib-2.0` */
/* Aligns to powers of two. */
#define ALIGN(x, n) (((x) + ((n) - 1)) & ~((n) - 1))
#define DEBUG(fmt, args...) printf(fmt "\n", ## args)
typedef int xdr_status_t;
GUdpSocket * local_sock;
GInetAddr * remote_addr;
const void * incoming_msg(const void *buf, int n);
int send_msg(GString *msg)
{
int n;
n = gnet_udp_socket_send(local_sock, msg->str, msg->len, remote_addr);
if (n) {
perror("gnet_udp_socket_send");
exit(1);
}
printf("%d bytes sent.\n", msg->len);
return 0;
}
typedef const void *(*callback_t) (const void *xdr_buf, int xdr_len);
struct {
callback_t callback;
int msg_xid;
} callbacks[1];
void register_callback(callback_t callback, int msg_xid)
{
callbacks[0].callback = callback;
callbacks[0].msg_xid = msg_xid;
}
callback_t lookup_callback(int msg_xid)
{
if (callbacks[0].msg_xid != msg_xid) {
g_message("Call number %d is unknown\n", msg_xid);
return NULL;
}
return callbacks[0].callback;
}
void xdr_prompt(const char *what, const char *fmt, void *addr)
{
printf("Enter the value of %s (format %s) ", what, fmt);
fflush(stdout);
scanf(fmt, addr);
getchar(); /* consume the newline
*/
}
gint32 xdr_get_integer(const void **buf)
{
gint32 ret = *((const gint32 *) *buf)++;
return GINT32_FROM_BE(ret);
}
guint32 xdr_get_uinteger(const void **buf)
{
guint32 ret = *((const guint32 *) *buf)++;
return GUINT32_FROM_BE(ret);
}
gint64 xdr_get_hyper(const void **buf)
{
gint64 ret = *((const gint64 *) *buf)++;
return GINT64_FROM_BE(ret);
}
guint64 xdr_get_uhyper(const void **buf)
{
guint64 ret = *((const guint64 *) *buf)++;
return GUINT64_FROM_BE(ret);
}
float xdr_get_float(const void **buf)
{
/* FIXME is this correct? */
guint32 ret = xdr_get_uinteger(buf);
return *(float*)&ret;
}
double xdr_get_double(const void **buf)
{
/* FIXME is this correct? */
guint64 ret = xdr_get_uhyper(buf);
return *(double*)&ret;
}
void xdr_put_integer(GString *buf, gint32 val)
{
val = GINT32_TO_BE(val);
g_string_append_len(buf, (char *) &val, 4);
}
void xdr_put_uinteger(GString *buf, guint64 val)
{
val = GUINT32_TO_BE(val);
g_string_append_len(buf, (char *) &val, 4);
}
void xdr_put_hyper(GString *buf, gint64 val)
{
val = GINT64_TO_BE(val);
g_string_append_len(buf, (char *) &val, 8);
}
void xdr_put_uhyper(GString *buf, guint64 val)
{
val = GUINT64_TO_BE(val);
g_string_append_len(buf, (char *) &val, 8);
}
void xdr_put_float(GString *buf, float val)
{
/* FIXME is this correct? */
xdr_put_uinteger(buf, *(guint32 *) &val);
}
void xdr_put_double(GString *buf, double val)
{
/* FIXME is this correct? */
xdr_put_uhyper(buf, *(guint64 *) &val);
}
static const void *xdr_decode_string(const void *buf, char **dest, int len)
{
*dest = g_new(char, len + 1);
memcpy(*dest, buf, len);
(*dest)[len] = '\0';
return (char *) buf + ALIGN(len, 4);
}
static char *xdr_prompt_string(const char *what)
{
char str[256];
printf("Enter value for %s (string): ", what);
fflush(stdout);
gets(str);
return g_strdup(str);
}
static void xdr_encode_string(GString *xdr_str, const gchar *data, guint32 len)
{
if (len == -1) {
len = strlen(data);
xdr_put_uinteger(xdr_str, len);
len = 3 - (len + 3) % 4;
} else {
len -= strlen(data);
g_assert(len >= 0);
}
g_string_append(xdr_str, data);
/* Add padding according to section 2, "BASIC BLOCK SIZE". */
while (len--)
g_string_append_c(xdr_str, '\0');
}
/* What follows is autogenerated templates for the RPC functions.
* You should probably make the call_* functions take some arguments,
* and replace all xdr_prompt with assignment to meaningful values.
* Do not remove this comment. Also try not to modify lines, this will
* help merging updates of the .x files.
* Generated Mon Feb 23 15:29:34 2004 by this command:
* rpcgen.py giftrpc_code.c rpc.x giftrpc.x -c GIFTSRV -s GIFTCLI
*/
enum auth_flavor {
AUTH_NONE, AUTH_SYS, AUTH_SHORT
};
enum msg_type {
CALL, REPLY
};
enum reply_stat {
MSG_ACCEPTED, MSG_DENIED
};
enum accept_stat {
SUCCESS, PROG_UNAVAIL, PROG_MISMATCH, PROC_UNAVAIL, GARBAGE_ARGS,
SYSTEM_ERR
};
enum reject_stat {
RPC_MISMATCH, AUTH_ERROR
};
enum auth_stat {
AUTH_OK, AUTH_BADCRED, AUTH_REJECTEDCRED, AUTH_BADVERF,
AUTH_REJECTEDVERF,
AUTH_TOOWEAK, AUTH_INVALIDRESP, AUTH_FAILED
};
#define GIFT_CURRENT_VERSION 1
#define GIFTSRV 20000000
enum GIFTSRV_version {
GIFTSRV_VERSION_1 = 1
};
#define GIFTCLI 20000001
enum GIFTCLI_version {
GIFTCLI_VERSION_1 = 1
};
/* Handler for call to GIFTCLI_Null version GIFTCLI_VERSION_1 */
GString *incoming_call_GIFTCLI_Null_1(const void *xdr_buf, int xdr_len)
{
return g_string_new("");
}
/* Handler for call to GIFTCLI_SearchResult version GIFTCLI_VERSION_1 */
GString *incoming_call_GIFTCLI_SearchResult_1(const void *xdr_buf, int xdr_len)
{
char *inparm0;
gint32 inparm0_len;
char *inparm1_type;
gint32 inparm1_type_len;
char *inparm1_data;
gint32 inparm1_data_len;
gint32 inparm2_i;
gint32 inparm2_len;
inparm0_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:inparm0_len = %d", inparm0_len);
xdr_len -= inparm0_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &inparm0, inparm0_len);
DEBUG(">>> RPC:inparm0 = %s", inparm0);
inparm1_type_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:inparm1_type_len = %d", inparm1_type_len);
if (inparm1_type_len > 16) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= inparm1_type_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &inparm1_type, inparm1_type_len);
DEBUG(">>> RPC:inparm1_type = %s", inparm1_type);
inparm1_data_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:inparm1_data_len = %d", inparm1_data_len);
xdr_len -= inparm1_data_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &inparm1_data, inparm1_data_len);
DEBUG(">>> RPC:inparm1_data = %s", inparm1_data);
inparm2_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:inparm2_len = %d", inparm2_len);
xdr_len -= 8 * inparm2_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
for (inparm2_i = 0; inparm2_i < inparm2_len; inparm2_i++) {
char *inparm2_key;
gint32 inparm2_key_len;
char *inparm2_value;
gint32 inparm2_value_len;
inparm2_key_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:inparm2_key_len = %d", inparm2_key_len);
if (inparm2_key_len > 64) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= inparm2_key_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &inparm2_key,
inparm2_key_len);
DEBUG(">>> RPC:inparm2_key = %s", inparm2_key);
inparm2_value_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:inparm2_value_len = %d", inparm2_value_len);
xdr_len -= inparm2_value_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf =
xdr_decode_string(xdr_buf, &inparm2_value,
inparm2_value_len);
DEBUG(">>> RPC:inparm2_value = %s", inparm2_value);
}
return g_string_new("");
}
int remote_call(int version, int procedure, const GString *body,
callback_t callback)
{
GString *xdr_str;
guint32 msg_xid;
enum msg_type msg_body_mtype;
guint32 cbody_rpcvers;
guint32 cbody_prog;
guint32 cbody_vers;
guint32 cbody_proc;
enum auth_flavor cbody_cred_flavor;
char *cbody_cred_body;
enum auth_flavor cbody_verf_flavor;
char *cbody_verf_body;
xdr_str = g_string_sized_new(20);
xdr_prompt("msg_xid", "%u", &msg_xid);
DEBUG("<<< RPC:msg_xid = %u", msg_xid);
xdr_put_uinteger(xdr_str, msg_xid);
msg_body_mtype = CALL;
DEBUG("<<< RPC:msg_body_mtype = %d", msg_body_mtype);
xdr_put_integer(xdr_str, msg_body_mtype);
cbody_rpcvers = 2;
DEBUG("<<< RPC:cbody_rpcvers = %u", cbody_rpcvers);
xdr_put_uinteger(xdr_str, cbody_rpcvers);
cbody_prog = GIFTSRV;
DEBUG("<<< RPC:cbody_prog = %u", cbody_prog);
xdr_put_uinteger(xdr_str, cbody_prog);
cbody_vers = version;
DEBUG("<<< RPC:cbody_vers = %d", cbody_vers);
xdr_put_integer(xdr_str, cbody_vers);
cbody_proc = procedure;
DEBUG("<<< RPC:cbody_proc = %u", cbody_proc);
xdr_put_uinteger(xdr_str, cbody_proc);
puts(" 0. AUTH_NONE\n 1. AUTH_SYS\n 2. AUTH_SHORT");
xdr_prompt("cbody_cred_flavor", "%d", &cbody_cred_flavor);
DEBUG("<<< RPC:cbody_cred_flavor = %d", cbody_cred_flavor);
xdr_put_integer(xdr_str, cbody_cred_flavor);
cbody_cred_body = xdr_prompt_string("cbody_cred_body");
xdr_encode_string(xdr_str, cbody_cred_body, -1);
DEBUG("<<< RPC:cbody_cred_body = %s", cbody_cred_body);
puts(" 0. AUTH_NONE\n 1. AUTH_SYS\n 2. AUTH_SHORT");
xdr_prompt("cbody_verf_flavor", "%d", &cbody_verf_flavor);
DEBUG("<<< RPC:cbody_verf_flavor = %d", cbody_verf_flavor);
xdr_put_integer(xdr_str, cbody_verf_flavor);
cbody_verf_body = xdr_prompt_string("cbody_verf_body");
xdr_encode_string(xdr_str, cbody_verf_body, -1);
DEBUG("<<< RPC:cbody_verf_body = %s", cbody_verf_body);
g_string_append_len(xdr_str, body->str, body->len);
register_callback(callback, msg_xid);
return send_msg(xdr_str);
}
/* Caller stub for call to GIFTSRV_Null version GIFTSRV_VERSION_1 */
int call_GIFTSRV_Null_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(0);
const void *GIFTSRV_Null_1_reply_callback(const void *xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 0, xdr_str,
GIFTSRV_Null_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_Null version GIFTSRV_VERSION_1 */
const void *GIFTSRV_Null_1_reply_callback(const void *xdr_buf, int xdr_len)
{
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_OpenSession version GIFTSRV_VERSION_1 */
int call_GIFTSRV_OpenSession_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(8);
char *name;
char *ver;
name = xdr_prompt_string("name");
xdr_encode_string(xdr_str, name, -1);
DEBUG("<<< RPC:name = %s", name);
ver = xdr_prompt_string("ver");
xdr_encode_string(xdr_str, ver, -1);
DEBUG("<<< RPC:ver = %s", ver);
const void *GIFTSRV_OpenSession_1_reply_callback(const void *xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 1, xdr_str,
GIFTSRV_OpenSession_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_OpenSession version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_OpenSession_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_CloseSession version GIFTSRV_VERSION_1 */
int call_GIFTSRV_CloseSession_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(0);
const void *GIFTSRV_CloseSession_1_reply_callback(const void *xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 2, xdr_str,
GIFTSRV_CloseSession_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_CloseSession version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_CloseSession_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_ProtocolStat version GIFTSRV_VERSION_1 */
int call_GIFTSRV_ProtocolStat_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(4);
char *inparam;
inparam = xdr_prompt_string("inparam");
xdr_encode_string(xdr_str, inparam, -1);
DEBUG("<<< RPC:inparam = %s", inparam);
const void *GIFTSRV_ProtocolStat_1_reply_callback(const void *xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 10, xdr_str,
GIFTSRV_ProtocolStat_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_ProtocolStat version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_ProtocolStat_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
char *ret_name;
gint32 ret_name_len;
char *ret_ver;
gint32 ret_ver_len;
gint32 ret_algos_i;
gint32 ret_algos_len;
xdr_len -= 12;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
ret_name_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_name_len = %d", ret_name_len);
if (ret_name_len > 64) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= ret_name_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &ret_name, ret_name_len);
DEBUG(">>> RPC:ret_name = %s", ret_name);
ret_ver_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_ver_len = %d", ret_ver_len);
if (ret_ver_len > 32) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= ret_ver_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &ret_ver, ret_ver_len);
DEBUG(">>> RPC:ret_ver = %s", ret_ver);
ret_algos_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_algos_len = %d", ret_algos_len);
xdr_len -= 8 * ret_algos_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
for (ret_algos_i = 0; ret_algos_i < ret_algos_len; ret_algos_i++) {
char *ret_algos_name;
gint32 ret_algos_name_len;
guint32 ret_algos_base;
ret_algos_name_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_algos_name_len = %d", ret_algos_name_len);
if (ret_algos_name_len > 16) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= ret_algos_name_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf =
xdr_decode_string(xdr_buf, &ret_algos_name,
ret_algos_name_len);
DEBUG(">>> RPC:ret_algos_name = %s", ret_algos_name);
ret_algos_base = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:ret_algos_base = %u", ret_algos_base);
}
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_ProtocolStatList version GIFTSRV_VERSION_1 */
int call_GIFTSRV_ProtocolStatList_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(0);
const void *GIFTSRV_ProtocolStatList_1_reply_callback(const void
*xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 11, xdr_str,
GIFTSRV_ProtocolStatList_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_ProtocolStatList version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_ProtocolStatList_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
gint32 ret_i;
gint32 ret_len;
xdr_len -= 4;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
ret_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_len = %d", ret_len);
xdr_len -= 12 * ret_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
for (ret_i = 0; ret_i < ret_len; ret_i++) {
char *ret_name;
gint32 ret_name_len;
char *ret_ver;
gint32 ret_ver_len;
gint32 ret_algos_i;
gint32 ret_algos_len;
ret_name_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_name_len = %d", ret_name_len);
if (ret_name_len > 64) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= ret_name_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &ret_name, ret_name_len);
DEBUG(">>> RPC:ret_name = %s", ret_name);
ret_ver_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_ver_len = %d", ret_ver_len);
if (ret_ver_len > 32) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= ret_ver_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &ret_ver, ret_ver_len);
DEBUG(">>> RPC:ret_ver = %s", ret_ver);
ret_algos_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_algos_len = %d", ret_algos_len);
xdr_len -= 8 * ret_algos_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
for (ret_algos_i = 0; ret_algos_i < ret_algos_len;
ret_algos_i++) {
char *ret_algos_name;
gint32 ret_algos_name_len;
guint32 ret_algos_base;
ret_algos_name_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_algos_name_len = %d",
ret_algos_name_len);
if (ret_algos_name_len > 16) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= ret_algos_name_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf =
xdr_decode_string(xdr_buf, &ret_algos_name,
ret_algos_name_len);
DEBUG(">>> RPC:ret_algos_name = %s", ret_algos_name);
ret_algos_base = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:ret_algos_base = %u", ret_algos_base);
}
}
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_ProtocolState version GIFTSRV_VERSION_1 */
int call_GIFTSRV_ProtocolState_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(4);
char *inparam;
inparam = xdr_prompt_string("inparam");
xdr_encode_string(xdr_str, inparam, -1);
DEBUG("<<< RPC:inparam = %s", inparam);
const void *GIFTSRV_ProtocolState_1_reply_callback(const void *xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 12, xdr_str,
GIFTSRV_ProtocolState_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_ProtocolState version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_ProtocolState_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
char *ret_name;
gint32 ret_name_len;
char *ret_state;
gint32 ret_state_len;
guint32 ret_nusers;
guint32 ret_nfiles;
double ret_tsize;
xdr_len -= 24;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
ret_name_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_name_len = %d", ret_name_len);
if (ret_name_len > 64) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= ret_name_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &ret_name, ret_name_len);
DEBUG(">>> RPC:ret_name = %s", ret_name);
ret_state_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_state_len = %d", ret_state_len);
if (ret_state_len > 64) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= ret_state_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &ret_state, ret_state_len);
DEBUG(">>> RPC:ret_state = %s", ret_state);
ret_nusers = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:ret_nusers = %u", ret_nusers);
ret_nfiles = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:ret_nfiles = %u", ret_nfiles);
ret_tsize = xdr_get_double(&xdr_buf);
DEBUG(">>> RPC:ret_tsize = %lf", ret_tsize);
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_ProtocolStateList version GIFTSRV_VERSION_1
*/
int call_GIFTSRV_ProtocolStateList_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(0);
const void *GIFTSRV_ProtocolStateList_1_reply_callback(const void
*xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 13, xdr_str,
GIFTSRV_ProtocolStateList_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_ProtocolStateList version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_ProtocolStateList_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
gint32 ret_i;
gint32 ret_len;
xdr_len -= 4;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
ret_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_len = %d", ret_len);
xdr_len -= 24 * ret_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
for (ret_i = 0; ret_i < ret_len; ret_i++) {
char *ret_name;
gint32 ret_name_len;
char *ret_state;
gint32 ret_state_len;
guint32 ret_nusers;
guint32 ret_nfiles;
double ret_tsize;
ret_name_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_name_len = %d", ret_name_len);
if (ret_name_len > 64) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= ret_name_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &ret_name, ret_name_len);
DEBUG(">>> RPC:ret_name = %s", ret_name);
ret_state_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_state_len = %d", ret_state_len);
if (ret_state_len > 64) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= ret_state_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &ret_state, ret_state_len);
DEBUG(">>> RPC:ret_state = %s", ret_state);
ret_nusers = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:ret_nusers = %u", ret_nusers);
ret_nfiles = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:ret_nfiles = %u", ret_nfiles);
ret_tsize = xdr_get_double(&xdr_buf);
DEBUG(">>> RPC:ret_tsize = %lf", ret_tsize);
}
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_PluginsLoaded version GIFTSRV_VERSION_1 */
int call_GIFTSRV_PluginsLoaded_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(0);
const void *GIFTSRV_PluginsLoaded_1_reply_callback(const void *xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 20, xdr_str,
GIFTSRV_PluginsLoaded_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_PluginsLoaded version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_PluginsLoaded_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
gint32 ret_i;
gint32 ret_len;
xdr_len -= 4;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
ret_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_len = %d", ret_len);
xdr_len -= 4 * ret_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
for (ret_i = 0; ret_i < ret_len; ret_i++) {
char *ret;
gint32 ret_len;
ret_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_len = %d", ret_len);
if (ret_len > 64) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= ret_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &ret, ret_len);
DEBUG(">>> RPC:ret = %s", ret);
}
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_PluginsAvaialble version GIFTSRV_VERSION_1 */
int call_GIFTSRV_PluginsAvaialble_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(0);
const void *GIFTSRV_PluginsAvaialble_1_reply_callback(const void
*xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 21, xdr_str,
GIFTSRV_PluginsAvaialble_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_PluginsAvaialble version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_PluginsAvaialble_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
gint32 ret_i;
gint32 ret_len;
xdr_len -= 4;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
ret_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_len = %d", ret_len);
xdr_len -= 4 * ret_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
for (ret_i = 0; ret_i < ret_len; ret_i++) {
char *ret;
gint32 ret_len;
ret_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_len = %d", ret_len);
if (ret_len > 64) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= ret_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &ret, ret_len);
DEBUG(">>> RPC:ret = %s", ret);
}
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_PluginLoad version GIFTSRV_VERSION_1 */
int call_GIFTSRV_PluginLoad_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(4);
char *inparam;
inparam = xdr_prompt_string("inparam");
xdr_encode_string(xdr_str, inparam, -1);
DEBUG("<<< RPC:inparam = %s", inparam);
const void *GIFTSRV_PluginLoad_1_reply_callback(const void *xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 22, xdr_str,
GIFTSRV_PluginLoad_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_PluginLoad version GIFTSRV_VERSION_1
*/
const void *GIFTSRV_PluginLoad_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
guint32 ret;
xdr_len -= 4;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
ret = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:ret = %u", ret);
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_PluginUnload version GIFTSRV_VERSION_1 */
int call_GIFTSRV_PluginUnload_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(4);
char *inparam;
inparam = xdr_prompt_string("inparam");
xdr_encode_string(xdr_str, inparam, -1);
DEBUG("<<< RPC:inparam = %s", inparam);
const void *GIFTSRV_PluginUnload_1_reply_callback(const void *xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 23, xdr_str,
GIFTSRV_PluginUnload_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_PluginUnload version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_PluginUnload_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
guint32 ret;
xdr_len -= 4;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
ret = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:ret = %u", ret);
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_SearchRequest version GIFTSRV_VERSION_1 */
int call_GIFTSRV_SearchRequest_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(4);
char *inparam;
inparam = xdr_prompt_string("inparam");
xdr_encode_string(xdr_str, inparam, -1);
DEBUG("<<< RPC:inparam = %s", inparam);
const void *GIFTSRV_SearchRequest_1_reply_callback(const void *xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 30, xdr_str,
GIFTSRV_SearchRequest_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_SearchRequest version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_SearchRequest_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
char *ret;
gint32 ret_len;
xdr_len -= 4;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
ret_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:ret_len = %d", ret_len);
xdr_len -= ret_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf = xdr_decode_string(xdr_buf, &ret, ret_len);
DEBUG(">>> RPC:ret = %s", ret);
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_SearchFilterProtocol version
GIFTSRV_VERSION_1 */
int call_GIFTSRV_SearchFilterProtocol_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(8);
char *inparm0;
char *inparm1;
inparm0 = xdr_prompt_string("inparm0");
xdr_encode_string(xdr_str, inparm0, -1);
DEBUG("<<< RPC:inparm0 = %s", inparm0);
inparm1 = xdr_prompt_string("inparm1");
xdr_encode_string(xdr_str, inparm1, -1);
DEBUG("<<< RPC:inparm1 = %s", inparm1);
const void *GIFTSRV_SearchFilterProtocol_1_reply_callback(const void
*xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 31, xdr_str,
GIFTSRV_SearchFilterProtocol_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_SearchFilterProtocol version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_SearchFilterProtocol_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_SearchFilterMeta version GIFTSRV_VERSION_1 */
int call_GIFTSRV_SearchFilterMeta_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(8);
char *inparm0;
gint32 inparm1_i;
gint32 inparm1_len;
inparm0 = xdr_prompt_string("inparm0");
xdr_encode_string(xdr_str, inparm0, -1);
DEBUG("<<< RPC:inparm0 = %s", inparm0);
xdr_prompt("inparm1_len", "%d", &inparm1_len);
DEBUG("<<< RPC:inparm1_len = %d", inparm1_len);
xdr_put_integer(xdr_str, inparm1_len);
for (inparm1_i = 0; inparm1_i < inparm1_len; inparm1_i++) {
char *inparm1_key;
char *inparm1_value;
inparm1_key = xdr_prompt_string("inparm1_key");
xdr_encode_string(xdr_str, inparm1_key, -1);
DEBUG("<<< RPC:inparm1_key = %s", inparm1_key);
inparm1_value = xdr_prompt_string("inparm1_value");
xdr_encode_string(xdr_str, inparm1_value, -1);
DEBUG("<<< RPC:inparm1_value = %s", inparm1_value);
}
const void *GIFTSRV_SearchFilterMeta_1_reply_callback(const void
*xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 32, xdr_str,
GIFTSRV_SearchFilterMeta_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_SearchFilterMeta version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_SearchFilterMeta_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_SearchExecute version GIFTSRV_VERSION_1 */
int call_GIFTSRV_SearchExecute_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(4);
char *inparam;
inparam = xdr_prompt_string("inparam");
xdr_encode_string(xdr_str, inparam, -1);
DEBUG("<<< RPC:inparam = %s", inparam);
const void *GIFTSRV_SearchExecute_1_reply_callback(const void *xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 33, xdr_str,
GIFTSRV_SearchExecute_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_SearchExecute version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_SearchExecute_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
guint32 ret;
xdr_len -= 4;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
ret = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:ret = %u", ret);
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_SearchCancel version GIFTSRV_VERSION_1 */
int call_GIFTSRV_SearchCancel_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(4);
char *inparam;
inparam = xdr_prompt_string("inparam");
xdr_encode_string(xdr_str, inparam, -1);
DEBUG("<<< RPC:inparam = %s", inparam);
const void *GIFTSRV_SearchCancel_1_reply_callback(const void *xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 34, xdr_str,
GIFTSRV_SearchCancel_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_SearchCancel version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_SearchCancel_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
return xdr_buf;
}
/* Caller stub for call to GIFTSRV_SearchFinish version GIFTSRV_VERSION_1 */
int call_GIFTSRV_SearchFinish_1(void)
{
int ret;
GString *xdr_str = g_string_sized_new(4);
char *inparam;
inparam = xdr_prompt_string("inparam");
xdr_encode_string(xdr_str, inparam, -1);
DEBUG("<<< RPC:inparam = %s", inparam);
const void *GIFTSRV_SearchFinish_1_reply_callback(const void *xdr_buf,
int xdr_len);
ret =
remote_call(GIFTSRV_VERSION_1, 35, xdr_str,
GIFTSRV_SearchFinish_1_reply_callback);
g_string_free(xdr_str, 1);
return ret;
}
/* Reply callback stub for call to GIFTSRV_SearchFinish version
GIFTSRV_VERSION_1 */
const void *GIFTSRV_SearchFinish_1_reply_callback(const void *xdr_buf,
int xdr_len)
{
return xdr_buf;
}
const void *incoming_msg(const void *xdr_buf, int xdr_len)
{
GString *xdr_str;
guint32 msg_xid;
enum msg_type msg_body_mtype;
guint32 reply_xid;
enum msg_type reply_body_mtype;
enum reply_stat rbody_stat;
xdr_len -= 20;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
msg_xid = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:msg_xid = %u", msg_xid);
msg_body_mtype = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:msg_body_mtype = %d", msg_body_mtype);
switch (msg_body_mtype) {
guint32 cbody_rpcvers;
guint32 cbody_prog;
guint32 cbody_vers;
guint32 cbody_proc;
enum auth_flavor cbody_cred_flavor;
char *cbody_cred_body;
gint32 cbody_cred_body_len;
enum auth_flavor cbody_verf_flavor;
char *cbody_verf_body;
gint32 cbody_verf_body_len;
enum reply_stat rbody_stat;
case CALL:
DEBUG(">>> RPC:msg_body_mtype = CALL");
xdr_len -= 20;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
cbody_rpcvers = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:cbody_rpcvers = %u", cbody_rpcvers);
if (cbody_rpcvers != 2) {
g_warning("RPC:cbody_rpcvers = %u, should be 2",
cbody_rpcvers);
return NULL;
}
cbody_prog = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:cbody_prog = %u", cbody_prog);
if (cbody_prog != GIFTCLI) {
g_warning("RPC:cbody_prog = %u, should be GIFTCLI (%u)",
cbody_prog, GIFTCLI);
return NULL;
}
cbody_vers = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:cbody_vers = %u", cbody_vers);
cbody_proc = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:cbody_proc = %u", cbody_proc);
cbody_cred_flavor = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:cbody_cred_flavor = %d", cbody_cred_flavor);
cbody_cred_body_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:cbody_cred_body_len = %d", cbody_cred_body_len);
if (cbody_cred_body_len > 400) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= cbody_cred_body_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf =
xdr_decode_string(xdr_buf, &cbody_cred_body,
cbody_cred_body_len);
DEBUG(">>> RPC:cbody_cred_body = %s", cbody_cred_body);
cbody_verf_flavor = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:cbody_verf_flavor = %d", cbody_verf_flavor);
cbody_verf_body_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:cbody_verf_body_len = %d", cbody_verf_body_len);
if (cbody_verf_body_len > 400) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= cbody_verf_body_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf =
xdr_decode_string(xdr_buf, &cbody_verf_body,
cbody_verf_body_len);
DEBUG(">>> RPC:cbody_verf_body = %s", cbody_verf_body);
switch (cbody_vers) {
case GIFTCLI_VERSION_1:
switch (cbody_proc) {
GString *ret;
case 0: /* GIFTCLI_Null */
ret = incoming_call_GIFTCLI_Null_1(xdr_buf,
xdr_len);
break;
case 1: /* GIFTCLI_SearchResult */
ret =
incoming_call_GIFTCLI_SearchResult_1(xdr_buf, xdr_len);
break;
}
break;
}
break;
case REPLY:
DEBUG(">>> RPC:msg_body_mtype = REPLY");
rbody_stat = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:rbody_stat = %d", rbody_stat);
switch (rbody_stat) {
enum auth_flavor areply_verf_flavor;
char *areply_verf_body;
gint32 areply_verf_body_len;
enum accept_stat areply_reply_data_stat;
enum reject_stat rreply_stat;
case MSG_ACCEPTED:
DEBUG(">>> RPC:rbody_stat = MSG_ACCEPTED");
xdr_len -= 4;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
areply_verf_flavor = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:areply_verf_flavor = %d",
areply_verf_flavor);
areply_verf_body_len = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:areply_verf_body_len = %d",
areply_verf_body_len);
if (areply_verf_body_len > 400) {
g_warning("%s", "Length too long");
return NULL;
}
xdr_len -= areply_verf_body_len;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
xdr_buf =
xdr_decode_string(xdr_buf, &areply_verf_body,
areply_verf_body_len);
DEBUG(">>> RPC:areply_verf_body = %s",
areply_verf_body);
areply_reply_data_stat = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:areply_reply_data_stat = %d",
areply_reply_data_stat);
switch (areply_reply_data_stat) {
guint32 mismatch_info_low;
guint32 mismatch_info_high;
case SUCCESS:
DEBUG(">>> RPC:areply_reply_data_stat =
SUCCESS");
{
callback_t callback = lookup_callback(msg_xid);
if (!callback) return NULL;
callback(xdr_buf, xdr_len);
}
break;
case PROG_MISMATCH:
DEBUG(">>> RPC:areply_reply_data_stat =
PROG_MISMATCH");
xdr_len -= 8;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
mismatch_info_low = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:mismatch_info_low = %u",
mismatch_info_low);
mismatch_info_high = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:mismatch_info_high = %u",
mismatch_info_high);
break;
default:
break;
}
break;
case MSG_DENIED:
DEBUG(">>> RPC:rbody_stat = MSG_DENIED");
rreply_stat = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:rreply_stat = %d", rreply_stat);
switch (rreply_stat) {
guint32 mismatch_info_low;
guint32 mismatch_info_high;
enum auth_stat stat;
case RPC_MISMATCH:
DEBUG(">>> RPC:rreply_stat = RPC_MISMATCH");
xdr_len -= 4;
if (xdr_len < 0) {
g_warning("%s", "Message too short");
return NULL;
}
mismatch_info_low = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:mismatch_info_low = %u",
mismatch_info_low);
mismatch_info_high = xdr_get_uinteger(&xdr_buf);
DEBUG(">>> RPC:mismatch_info_high = %u",
mismatch_info_high);
break;
case AUTH_ERROR:
DEBUG(">>> RPC:rreply_stat = AUTH_ERROR");
stat = xdr_get_integer(&xdr_buf);
DEBUG(">>> RPC:stat = %d", stat);
break;
default:
g_warning("%s", "Value not handled in switch");
return NULL;
break;
}
break;
default:
g_warning("%s", "Value not handled in switch");
return NULL;
break;
}
break;
default:
g_warning("%s", "Value not handled in switch");
return NULL;
break;
}
xdr_str = g_string_sized_new(20);
reply_xid = msg_xid;
DEBUG("<<< RPC:reply_xid = %u", reply_xid);
xdr_put_uinteger(xdr_str, reply_xid);
reply_body_mtype = REPLY;
DEBUG("<<< RPC:reply_body_mtype = %d", reply_body_mtype);
xdr_put_integer(xdr_str, reply_body_mtype);
puts(" 0. MSG_ACCEPTED\n 1. MSG_DENIED");
xdr_prompt("rbody_stat", "%d", &rbody_stat);
DEBUG("<<< RPC:rbody_stat = %d", rbody_stat);
xdr_put_integer(xdr_str, rbody_stat);
switch (rbody_stat) {
enum auth_flavor areply_verf_flavor;
char *areply_verf_body;
enum accept_stat areply_reply_data_stat;
enum reject_stat rreply_stat;
case MSG_ACCEPTED:
DEBUG(">>> RPC:rbody_stat = MSG_ACCEPTED");
puts(" 0. AUTH_NONE\n 1. AUTH_SYS\n 2. AUTH_SHORT");
xdr_prompt("areply_verf_flavor", "%d", &areply_verf_flavor);
DEBUG("<<< RPC:areply_verf_flavor = %d", areply_verf_flavor);
xdr_put_integer(xdr_str, areply_verf_flavor);
areply_verf_body = xdr_prompt_string("areply_verf_body");
xdr_encode_string(xdr_str, areply_verf_body, -1);
DEBUG("<<< RPC:areply_verf_body = %s", areply_verf_body);
puts(" 0. SUCCESS\n 1. PROG_UNAVAIL\n 2. PROG_MISMATCH\n 3.
PROC_UNAVAIL\n 4. GARBAGE_ARGS\n 5. SYSTEM_ERR");
xdr_prompt("areply_reply_data_stat", "%d",
&areply_reply_data_stat);
DEBUG("<<< RPC:areply_reply_data_stat = %d",
areply_reply_data_stat);
xdr_put_integer(xdr_str, areply_reply_data_stat);
switch (areply_reply_data_stat) {
char *results;
guint32 mismatch_info_low;
guint32 mismatch_info_high;
case SUCCESS:
DEBUG(">>> RPC:areply_reply_data_stat = SUCCESS");
results = xdr_prompt_string("results");
xdr_encode_string(xdr_str, results, 0);
DEBUG("<<< RPC:results = %s", results);
break;
case PROG_MISMATCH:
DEBUG(">>> RPC:areply_reply_data_stat = PROG_MISMATCH");
xdr_prompt("mismatch_info_low", "%u",
&mismatch_info_low);
DEBUG("<<< RPC:mismatch_info_low = %u",
mismatch_info_low);
xdr_put_uinteger(xdr_str, mismatch_info_low);
xdr_prompt("mismatch_info_high", "%u",
&mismatch_info_high);
DEBUG("<<< RPC:mismatch_info_high = %u",
mismatch_info_high);
xdr_put_uinteger(xdr_str, mismatch_info_high);
break;
default:
break;
}
break;
case MSG_DENIED:
DEBUG(">>> RPC:rbody_stat = MSG_DENIED");
puts(" 0. RPC_MISMATCH\n 1. AUTH_ERROR");
xdr_prompt("rreply_stat", "%d", &rreply_stat);
DEBUG("<<< RPC:rreply_stat = %d", rreply_stat);
xdr_put_integer(xdr_str, rreply_stat);
switch (rreply_stat) {
guint32 mismatch_info_low;
guint32 mismatch_info_high;
enum auth_stat stat;
case RPC_MISMATCH:
DEBUG(">>> RPC:rreply_stat = RPC_MISMATCH");
xdr_prompt("mismatch_info_low", "%u",
&mismatch_info_low);
DEBUG("<<< RPC:mismatch_info_low = %u",
mismatch_info_low);
xdr_put_uinteger(xdr_str, mismatch_info_low);
xdr_prompt("mismatch_info_high", "%u",
&mismatch_info_high);
DEBUG("<<< RPC:mismatch_info_high = %u",
mismatch_info_high);
xdr_put_uinteger(xdr_str, mismatch_info_high);
break;
case AUTH_ERROR:
DEBUG(">>> RPC:rreply_stat = AUTH_ERROR");
puts(" 0. AUTH_OK\n 1. AUTH_BADCRED\n 2.
AUTH_REJECTEDCRED\n 3. AUTH_BADVERF\n 4. AUTH_REJECTEDVERF\n 5. AUTH_TOOWEAK\n
6. AUTH_INVALIDRESP\n 7. AUTH_FAILED");
xdr_prompt("stat", "%d", &stat);
DEBUG("<<< RPC:stat = %d", stat);
xdr_put_integer(xdr_str, stat);
break;
}
break;
}
send_msg(xdr_str);
g_string_free(xdr_str, 1);
return xdr_buf;
}
int main(int argc, char *argv[])
{
char buf[512];
int n;
gnet_init();
local_sock = gnet_udp_socket_new();
if (!local_sock) {
perror("gnet_udp_socket_new");
return 1;
}
if (argc == 1) {
/* listen */
printf("Listening on UDP port: %d\n",
gnet_inetaddr_get_port(
gnet_udp_socket_get_local_inetaddr(local_sock)));
} else {
/* connect */
remote_addr = gnet_inetaddr_new("localhost", atoi(argv[1]));
if (!remote_addr) {
perror("gnet_inetaddr_new");
return 1;
}
n = call_GIFTSRV_PluginsAvaialble_1();
if (n < 0) {
printf("call failed.\n");
return 1;
}
printf("Waiting for answer...\n");
}
n = gnet_udp_socket_receive(local_sock, buf, sizeof buf, &remote_addr);
if (n < 0) {
perror("gnet_udp_socket_recieve");
return 1;
}
printf("%d bytes recieved.\n", n);
incoming_msg(buf, n);
return 0;
}
--
Christian
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [giFTcurs-devel] RPC protocol handling,
Christian Häggström <=