version 1.3.2.2, 2011/08/19 12:51:50
|
version 1.4.2.1, 2011/08/29 23:26:56
|
Line 264 rpc_cli_closeClient(rpc_cli_t * __restrict cli)
|
Line 264 rpc_cli_closeClient(rpc_cli_t * __restrict cli)
|
* @csModule = Module name, if NULL self binary |
* @csModule = Module name, if NULL self binary |
* @csFunc = Function name for execute |
* @csFunc = Function name for execute |
* @in_argc = IN count of arguments |
* @in_argc = IN count of arguments |
* @in_vals = IN RPC call array of rpc values | * @in_vars = IN RPC call array of rpc values |
* @out_argc = OUT returned count of arguments |
* @out_argc = OUT returned count of arguments |
* @out_vals = OUT returned array of rpc values, must be free after use (see rpc_cli_freeVals()) | * @out_vars = OUT returned array of rpc values, must be free after use (see rpc_cli_freeVals()) |
* return: -1 error or != -1 ok result |
* return: -1 error or != -1 ok result |
*/ |
*/ |
int |
int |
rpc_cli_execCall(rpc_cli_t *cli, const char *csModule, const char *csFunc, int in_argc, |
rpc_cli_execCall(rpc_cli_t *cli, const char *csModule, const char *csFunc, int in_argc, |
rpc_val_t * __restrict in_vals, int *out_argc, rpc_val_t ** __restrict out_vals) | ait_val_t * __restrict in_vars, int *out_argc, ait_val_t ** __restrict out_vars) |
{ |
{ |
fd_set fds; |
fd_set fds; |
u_char buf[BUFSIZ], str[MAXPATHLEN + UCHAR_MAX + 1], *data; |
u_char buf[BUFSIZ], str[MAXPATHLEN + UCHAR_MAX + 1], *data; |
Line 279 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
Line 279 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
struct tagRPCRet *rrpc = NULL; |
struct tagRPCRet *rrpc = NULL; |
int ret = 0, Limit = 0; |
int ret = 0, Limit = 0; |
register int i; |
register int i; |
rpc_val_t *v; | ait_val_t *v; |
struct timeval tv = { DEF_RPC_TIMEOUT, 0 }; |
struct timeval tv = { DEF_RPC_TIMEOUT, 0 }; |
|
|
FD_ZERO(&fds); |
FD_ZERO(&fds); |
memset(buf, 0, BUFSIZ); | memset(buf, 0, sizeof buf); |
memset(str, 0, MAXPATHLEN + UCHAR_MAX + 1); | memset(str, 0, sizeof str); |
if (!cli || !csFunc || (in_argc && !in_vals)) { | if (!cli || !csFunc || (in_argc && !in_vars)) { |
rpc_SetErr(EINVAL, "Error:: Can`t execute call because parameter is null or invalid!\n"); |
rpc_SetErr(EINVAL, "Error:: Can`t execute call because parameter is null or invalid!\n"); |
return -1; |
return -1; |
} |
} |
|
/* build RPC call string for hash */ |
if (csModule) |
if (csModule) |
strlcpy((char*) str, csModule, MAXPATHLEN + UCHAR_MAX + 1); | strlcpy((char*) str, csModule, sizeof str); |
strlcat((char*) str, "__", MAXPATHLEN + UCHAR_MAX + 1); | strlcat((char*) str, "__", sizeof str); |
strlcat((char*) str, csFunc, MAXPATHLEN + UCHAR_MAX + 1); | strlcat((char*) str, csFunc, sizeof str); |
|
|
|
/* prepare RPC call */ |
memcpy(&rpc->call_session, cli->cli_parent, sizeof rpc->call_session); |
memcpy(&rpc->call_session, cli->cli_parent, sizeof rpc->call_session); |
rpc->call_argc = in_argc; |
rpc->call_argc = in_argc; |
rpc->call_tag = crcFletcher16((u_short*) str, (MAXPATHLEN + UCHAR_MAX + 1) / 2); | rpc->call_tag = crcFletcher16((u_short*) str, sizeof str / 2); |
rpc->call_hash = hash_fnv((char*) str, MAXPATHLEN + UCHAR_MAX + 1); | rpc->call_hash = hash_fnv((char*) str, sizeof str); |
Limit = sizeof(struct tagRPCCall); |
Limit = sizeof(struct tagRPCCall); |
if (in_argc) { |
if (in_argc) { |
v = (rpc_val_t*) (buf + sizeof(struct tagRPCCall)); | v = (ait_val_t*) (buf + sizeof(struct tagRPCCall)); |
if (in_argc * sizeof(rpc_val_t) > BUFSIZ - Limit) { | if (in_argc * sizeof(ait_val_t) > sizeof buf - Limit) { |
rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet values (-7) ...\n"); |
rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet values (-7) ...\n"); |
return -7; |
return -7; |
} else |
} else |
Limit += in_argc * sizeof(rpc_val_t); | Limit += in_argc * sizeof(ait_val_t); |
memcpy(v, in_vals, in_argc * sizeof(rpc_val_t)); | memcpy(v, in_vars, in_argc * sizeof(ait_val_t)); |
data = (u_char*) v + in_argc * sizeof(rpc_val_t); | data = (u_char*) v + in_argc * sizeof(ait_val_t); |
for (i = 0; i < in_argc; i++) { | for (i = 0; i < in_argc && !ret; i++) { |
switch (in_vals[i].val_type) { | switch (in_vars[i].val_type) { |
case buffer: |
case buffer: |
if (Limit + in_vals[i].val_len > BUFSIZ) { | if (Limit + in_vars[i].val_len > sizeof buf) { |
ret = -7; |
ret = -7; |
break; |
break; |
} |
} |
|
|
memcpy(data, in_vals[i].val.buffer, in_vals[i].val_len); | memcpy(data, in_vars[i].val.buffer, in_vars[i].val_len); |
v[i].val.buffer = (uint8_t*) ((void*) data - (void*) v); |
v[i].val.buffer = (uint8_t*) ((void*) data - (void*) v); |
data += in_vals[i].val_len; | data += in_vars[i].val_len; |
Limit += in_vals[i].val_len; | Limit += in_vars[i].val_len; |
break; |
break; |
case string: |
case string: |
if (Limit + in_vals[i].val_len > BUFSIZ) { | if (Limit + in_vars[i].val_len > sizeof buf) { |
ret = -7; |
ret = -7; |
break; |
break; |
} |
} |
|
|
memcpy(data, in_vals[i].val.string, in_vals[i].val_len); | memcpy(data, in_vars[i].val.string, in_vars[i].val_len); |
v[i].val.string = (int8_t*) ((void*) data - (void*) v); |
v[i].val.string = (int8_t*) ((void*) data - (void*) v); |
data += in_vals[i].val_len; | data += in_vars[i].val_len; |
Limit += in_vals[i].val_len; | Limit += in_vars[i].val_len; |
break; |
break; |
default: |
default: |
break; |
break; |
Line 341 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
Line 343 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
return ret; |
return ret; |
} |
} |
} |
} |
|
|
if ((ret = send(cli->cli_sock, buf, Limit, 0)) == -1) { |
if ((ret = send(cli->cli_sock, buf, Limit, 0)) == -1) { |
LOGERR; |
LOGERR; |
return -1; |
return -1; |
Line 353 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
Line 356 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
|
|
FD_SET(cli->cli_sock, &fds); |
FD_SET(cli->cli_sock, &fds); |
if ((ret = select(cli->cli_sock + 1, &fds, NULL, NULL, &tv)) < 1) { |
if ((ret = select(cli->cli_sock + 1, &fds, NULL, NULL, &tv)) < 1) { |
if (ret) { | if (ret) |
LOGERR; |
LOGERR; |
} else | else |
rpc_SetErr(ETIMEDOUT, "Error:: timeout, no return from RPC server?\n"); |
rpc_SetErr(ETIMEDOUT, "Error:: timeout, no return from RPC server?\n"); |
|
|
return -1; |
return -1; |
} |
} |
memset(buf, 0, BUFSIZ); | memset(buf, 0, sizeof buf); |
if ((ret = recv(cli->cli_sock, buf, BUFSIZ, 0)) == -1) { | if ((ret = recv(cli->cli_sock, buf, sizeof buf, 0)) == -1) { |
LOGERR; |
LOGERR; |
return -3; |
return -3; |
} |
} |
Line 382 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
Line 386 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
rrpc->ret_retcode, strerror(rrpc->ret_errno)); |
rrpc->ret_retcode, strerror(rrpc->ret_errno)); |
return -6; |
return -6; |
} |
} |
if (rrpc->ret_argc * sizeof(rpc_val_t) > BUFSIZ - Limit) { | if (rrpc->ret_argc * sizeof(ait_val_t) > sizeof buf - Limit) { |
rpc_SetErr(EMSGSIZE, "Error:: reply RPC packet is too big ...\n"); | rpc_SetErr(EMSGSIZE, "Error:: reply RPC packet is too long ...\n"); |
return -7; |
return -7; |
} else |
} else |
Limit += rrpc->ret_argc * sizeof(rpc_val_t); | Limit += rrpc->ret_argc * sizeof(ait_val_t); |
/* RPC is OK! Go decapsulate variables ... */ |
/* RPC is OK! Go decapsulate variables ... */ |
if (rrpc->ret_argc) { |
if (rrpc->ret_argc) { |
*out_argc = rrpc->ret_argc; |
*out_argc = rrpc->ret_argc; |
*out_vals = calloc(rrpc->ret_argc, sizeof(rpc_val_t)); | *out_vars = calloc(rrpc->ret_argc, sizeof(ait_val_t)); |
if (!*out_vals) { | if (!*out_vars) { |
LOGERR; |
LOGERR; |
*out_argc = 0; |
*out_argc = 0; |
return -1; |
return -1; |
} else |
} else |
memcpy(*out_vals, buf + sizeof(struct tagRPCRet), Limit - sizeof(struct tagRPCRet)); | memcpy(*out_vars, buf + sizeof(struct tagRPCRet), Limit - sizeof(struct tagRPCRet)); |
/* RPC received variables types OK! */ |
/* RPC received variables types OK! */ |
data = (u_char*) buf + Limit; |
data = (u_char*) buf + Limit; |
for (i = 0; i < rrpc->ret_argc; i++) |
for (i = 0; i < rrpc->ret_argc; i++) |
switch ((*out_vals)[i].val_type) { | switch ((*out_vars)[i].val_type) { |
case buffer: |
case buffer: |
if ((*out_vals)[i].val_len > BUFSIZ - Limit) { | if ((*out_vars)[i].val_len > sizeof buf - Limit) { |
rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n"); | rpc_SetErr(EMSGSIZE, "Error:: Too long RPC packet ...\n"); |
free(*out_vals); | free(*out_vars); |
*out_vals = NULL; | *out_vars = NULL; |
*out_argc = 0; |
*out_argc = 0; |
return -7; |
return -7; |
} else |
} else |
Limit += (*out_vals)[i].val_len; | Limit += (*out_vars)[i].val_len; |
|
|
(*out_vals)[i].val.buffer = malloc((*out_vals)[i].val_len); | (*out_vars)[i].val.buffer = malloc((*out_vars)[i].val_len); |
if (!(*out_vals)[i].val.buffer) { | if (!(*out_vars)[i].val.buffer) { |
rpc_SetErr(errno, "Error:: in prepare RPC reply ...\n"); |
rpc_SetErr(errno, "Error:: in prepare RPC reply ...\n"); |
free(*out_vals); | free(*out_vars); |
*out_vals = NULL; | *out_vars = NULL; |
*out_argc = 0; |
*out_argc = 0; |
return -1; |
return -1; |
} else |
} else |
memcpy((*out_vals)[i].val.buffer, data, (*out_vals)[i].val_len); | memcpy((*out_vars)[i].val.buffer, data, (*out_vars)[i].val_len); |
data += (*out_vals)[i].val_len; | data += (*out_vars)[i].val_len; |
break; |
break; |
case string: |
case string: |
if ((*out_vals)[i].val_len > BUFSIZ - Limit) { | if ((*out_vars)[i].val_len > sizeof buf - Limit) { |
rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n"); | rpc_SetErr(EMSGSIZE, "Error:: Too long RPC packet ...\n"); |
free(*out_vals); | free(*out_vars); |
*out_vals = NULL; | *out_vars = NULL; |
*out_argc = 0; |
*out_argc = 0; |
return -7; |
return -7; |
} else |
} else |
Limit += (*out_vals)[i].val_len; | Limit += (*out_vars)[i].val_len; |
|
|
(*out_vals)[i].val.string = malloc((*out_vals)[i].val_len); | (*out_vars)[i].val.string = malloc((*out_vars)[i].val_len); |
if (!(*out_vals)[i].val.string) { | if (!(*out_vars)[i].val.string) { |
rpc_SetErr(errno, "Error:: in prepare RPC reply ...\n"); |
rpc_SetErr(errno, "Error:: in prepare RPC reply ...\n"); |
free(*out_vals); | free(*out_vars); |
*out_vals = NULL; | *out_vars = NULL; |
*out_argc = 0; |
*out_argc = 0; |
return -1; |
return -1; |
} else |
} else |
memcpy((*out_vals)[i].val.string, data, (*out_vals)[i].val_len); | memcpy((*out_vars)[i].val.string, data, (*out_vars)[i].val_len); |
data += (*out_vals)[i].val_len; | data += (*out_vars)[i].val_len; |
break; |
break; |
default: |
default: |
break; |
break; |
Line 449 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
Line 453 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
} else { |
} else { |
if (out_argc) |
if (out_argc) |
*out_argc = 0; |
*out_argc = 0; |
if (out_vals) | if (out_vars) |
*out_vals = NULL; | *out_vars = NULL; |
} |
} |
|
|
return rrpc->ret_retcode; |
return rrpc->ret_retcode; |
} |
} |
|
|
/* |
/* |
* rpc_cli_freeVals() Free rpc_val_t array returned from RPC call | * rpc_cli_freeVals() Free ait_val_t array returned from RPC call |
* @args = Number of arguments in array |
* @args = Number of arguments in array |
* @vals = Value elements | * @vars = Value elements |
* return: none |
* return: none |
*/ |
*/ |
inline void |
inline void |
rpc_cli_freeVals(int args, rpc_val_t *vals) | rpc_cli_freeVals(int args, ait_val_t * __restrict vars) |
{ |
{ |
register int i; |
register int i; |
|
|
if (!vals) | if (!vars) |
return; |
return; |
|
|
for (i = 0; i < args; i++) |
for (i = 0; i < args; i++) |
RPC_FREE_VAL(&vals[i]); | AIT_FREE_VAL(&vars[i]); |
|
|
free(vals); | free(vars); |
vals = NULL; | vars = NULL; |
} |
} |