version 1.4.2.1, 2011/08/29 23:26:56
|
version 1.4.2.3, 2011/08/30 12:59:02
|
Line 60 rpc_cli_openBLOBClient(rpc_cli_t * __restrict rpccli,
|
Line 60 rpc_cli_openBLOBClient(rpc_cli_t * __restrict rpccli,
|
struct sockaddr_in *sin = (struct sockaddr_in*) &sa; |
struct sockaddr_in *sin = (struct sockaddr_in*) &sa; |
struct sockaddr_in6 *sin6 = (struct sockaddr_in6*) &sa; |
struct sockaddr_in6 *sin6 = (struct sockaddr_in6*) &sa; |
struct sockaddr_un *sun = (struct sockaddr_un*) &sa; |
struct sockaddr_un *sun = (struct sockaddr_un*) &sa; |
|
int n; |
|
|
if (!rpccli || |
if (!rpccli || |
(rpccli->cli_sa.sa_family != AF_INET && rpccli->cli_sa.sa_family != AF_INET6 && |
(rpccli->cli_sa.sa_family != AF_INET && rpccli->cli_sa.sa_family != AF_INET6 && |
Line 100 rpc_cli_openBLOBClient(rpc_cli_t * __restrict rpccli,
|
Line 101 rpc_cli_openBLOBClient(rpc_cli_t * __restrict rpccli,
|
free(cli); |
free(cli); |
return NULL; |
return NULL; |
} |
} |
|
n = cli->cli_netbuf; |
|
if (setsockopt(cli->cli_sock, SOL_SOCKET, SO_SNDBUF, &n, sizeof n) == -1) { |
|
LOGERR; |
|
close(cli->cli_sock); |
|
free(cli->cli_parent); |
|
free(cli); |
|
return NULL; |
|
} |
|
if (setsockopt(cli->cli_sock, SOL_SOCKET, SO_RCVBUF, &n, sizeof n) == -1) { |
|
LOGERR; |
|
close(cli->cli_sock); |
|
free(cli->cli_parent); |
|
free(cli); |
|
return NULL; |
|
} |
if (connect(cli->cli_sock, &cli->cli_sa, sizeof cli->cli_sa) == -1) { |
if (connect(cli->cli_sock, &cli->cli_sa, sizeof cli->cli_sa) == -1) { |
LOGERR; |
LOGERR; |
free(cli); |
free(cli); |
Line 135 rpc_cli_closeBLOBClient(rpc_cli_t * __restrict cli)
|
Line 151 rpc_cli_closeBLOBClient(rpc_cli_t * __restrict cli)
|
* rpc_cli_openClient() Connect to RPC Server |
* rpc_cli_openClient() Connect to RPC Server |
* @ProgID = ProgramID for RPC session request |
* @ProgID = ProgramID for RPC session request |
* @ProcID = ProcessID for RPC session request |
* @ProcID = ProcessID for RPC session request |
|
* @netBuf = Network buffer length, if =0 == BUFSIZ (also meaning max RPC packet) |
* @family = Family socket type, AF_INET or AF_INET6 |
* @family = Family socket type, AF_INET or AF_INET6 |
* @csHost = Host name or IP address for bind server |
* @csHost = Host name or IP address for bind server |
* @Port = Port for bind server, if Port == 0 default port is selected |
* @Port = Port for bind server, if Port == 0 default port is selected |
* return: NULL == error or !=NULL connection to RPC server established |
* return: NULL == error or !=NULL connection to RPC server established |
*/ |
*/ |
rpc_cli_t * |
rpc_cli_t * |
rpc_cli_openClient(u_int ProgID, u_int ProcID, u_short family, const char *csHost, u_short Port) | rpc_cli_openClient(u_int ProgID, u_int ProcID, int netBuf, u_short family, const char *csHost, u_short Port) |
{ |
{ |
rpc_cli_t *cli = NULL; |
rpc_cli_t *cli = NULL; |
struct hostent *host = NULL; |
struct hostent *host = NULL; |
Line 149 rpc_cli_openClient(u_int ProgID, u_int ProcID, u_short
|
Line 166 rpc_cli_openClient(u_int ProgID, u_int ProcID, u_short
|
struct sockaddr_in *sin = (struct sockaddr_in*) &sa; |
struct sockaddr_in *sin = (struct sockaddr_in*) &sa; |
struct sockaddr_in6 *sin6 = (struct sockaddr_in6*) &sa; |
struct sockaddr_in6 *sin6 = (struct sockaddr_in6*) &sa; |
struct sockaddr_un *sun = (struct sockaddr_un*) &sa; |
struct sockaddr_un *sun = (struct sockaddr_un*) &sa; |
|
int n; |
|
|
if (!csHost || (family != AF_INET && family != AF_INET6 && family != AF_LOCAL)) { |
if (!csHost || (family != AF_INET && family != AF_INET6 && family != AF_LOCAL)) { |
rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t connect to RPC server ...\n"); |
rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t connect to RPC server ...\n"); |
Line 156 rpc_cli_openClient(u_int ProgID, u_int ProcID, u_short
|
Line 174 rpc_cli_openClient(u_int ProgID, u_int ProcID, u_short
|
} |
} |
if (!Port) |
if (!Port) |
Port = RPC_DEFPORT; |
Port = RPC_DEFPORT; |
|
if (!netBuf) |
|
netBuf = BUFSIZ; |
if (csHost && family != AF_LOCAL) { |
if (csHost && family != AF_LOCAL) { |
host = gethostbyname2(csHost, family); |
host = gethostbyname2(csHost, family); |
if (!host) { |
if (!host) { |
Line 194 rpc_cli_openClient(u_int ProgID, u_int ProcID, u_short
|
Line 214 rpc_cli_openClient(u_int ProgID, u_int ProcID, u_short
|
return NULL; |
return NULL; |
} else |
} else |
memset(cli, 0, sizeof(rpc_cli_t)); |
memset(cli, 0, sizeof(rpc_cli_t)); |
|
|
|
cli->cli_netbuf = netBuf; |
cli->cli_parent = malloc(sizeof(rpc_sess_t)); |
cli->cli_parent = malloc(sizeof(rpc_sess_t)); |
if (!cli->cli_parent) { |
if (!cli->cli_parent) { |
LOGERR; |
LOGERR; |
Line 225 rpc_cli_openClient(u_int ProgID, u_int ProcID, u_short
|
Line 247 rpc_cli_openClient(u_int ProgID, u_int ProcID, u_short
|
free(cli); |
free(cli); |
return NULL; |
return NULL; |
} |
} |
|
n = cli->cli_netbuf; |
|
if (setsockopt(cli->cli_sock, SOL_SOCKET, SO_SNDBUF, &n, sizeof n) == -1) { |
|
LOGERR; |
|
close(cli->cli_sock); |
|
free(cli->cli_parent); |
|
free(cli); |
|
return NULL; |
|
} |
|
if (setsockopt(cli->cli_sock, SOL_SOCKET, SO_RCVBUF, &n, sizeof n) == -1) { |
|
LOGERR; |
|
close(cli->cli_sock); |
|
free(cli->cli_parent); |
|
free(cli); |
|
return NULL; |
|
} |
if (connect(cli->cli_sock, &cli->cli_sa, sizeof cli->cli_sa) == -1) { |
if (connect(cli->cli_sock, &cli->cli_sa, sizeof cli->cli_sa) == -1) { |
LOGERR; |
LOGERR; |
|
close(cli->cli_sock); |
free(cli->cli_parent); |
free(cli->cli_parent); |
free(cli); |
free(cli); |
return NULL; |
return NULL; |
Line 274 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
Line 312 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
ait_val_t * __restrict in_vars, int *out_argc, ait_val_t ** __restrict out_vars) |
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, str[MAXPATHLEN + UCHAR_MAX + 1], *data; |
struct tagRPCCall *rpc = (struct tagRPCCall*) buf; | struct tagRPCCall *rpc; |
struct tagRPCRet *rrpc = NULL; |
struct tagRPCRet *rrpc = NULL; |
int ret = 0, Limit = 0; |
int ret = 0, Limit = 0; |
register int i; |
register int i; |
ait_val_t *v; |
ait_val_t *v; |
struct timeval tv = { DEF_RPC_TIMEOUT, 0 }; |
struct timeval tv = { DEF_RPC_TIMEOUT, 0 }; |
|
|
FD_ZERO(&fds); |
|
memset(buf, 0, sizeof buf); |
|
memset(str, 0, sizeof str); |
|
if (!cli || !csFunc || (in_argc && !in_vars)) { |
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; |
} |
} |
|
|
|
buf = malloc(cli->cli_netbuf); |
|
if (!buf) { |
|
LOGERR; |
|
return -1; |
|
} else |
|
memset(buf, 0, cli->cli_netbuf); |
|
|
/* build RPC call string for hash */ |
/* build RPC call string for hash */ |
|
memset(str, 0, sizeof str); |
if (csModule) |
if (csModule) |
strlcpy((char*) str, csModule, sizeof str); |
strlcpy((char*) str, csModule, sizeof str); |
strlcat((char*) str, "__", sizeof str); |
strlcat((char*) str, "__", sizeof str); |
strlcat((char*) str, csFunc, sizeof str); |
strlcat((char*) str, csFunc, sizeof str); |
|
|
/* prepare RPC call */ |
/* prepare RPC call */ |
|
rpc = (struct tagRPCCall*) buf; |
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, sizeof str / 2); |
rpc->call_tag = crcFletcher16((u_short*) str, sizeof str / 2); |
rpc->call_hash = hash_fnv((char*) str, sizeof str); |
rpc->call_hash = hash_fnv((char*) str, sizeof str); |
Limit = sizeof(struct tagRPCCall); |
Limit = sizeof(struct tagRPCCall); |
|
|
if (in_argc) { |
if (in_argc) { |
|
/* marshaling variables */ |
v = (ait_val_t*) (buf + sizeof(struct tagRPCCall)); |
v = (ait_val_t*) (buf + sizeof(struct tagRPCCall)); |
if (in_argc * sizeof(ait_val_t) > sizeof buf - Limit) { | if (in_argc * sizeof(ait_val_t) > cli->cli_netbuf - Limit) { |
rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet values (-7) ...\n"); |
rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet values (-7) ...\n"); |
|
free(buf); |
return -7; |
return -7; |
} else |
} else |
Limit += in_argc * sizeof(ait_val_t); |
Limit += in_argc * sizeof(ait_val_t); |
memcpy(v, in_vars, in_argc * sizeof(ait_val_t)); |
memcpy(v, in_vars, in_argc * sizeof(ait_val_t)); |
|
|
|
/* adding additional data */ |
data = (u_char*) v + in_argc * sizeof(ait_val_t); |
data = (u_char*) v + in_argc * sizeof(ait_val_t); |
for (i = 0; i < in_argc && !ret; i++) { |
for (i = 0; i < in_argc && !ret; i++) { |
switch (in_vars[i].val_type) { | switch (AIT_TYPE(&in_vars[i])) { |
case buffer: |
case buffer: |
if (Limit + in_vars[i].val_len > sizeof buf) { | if (Limit + AIT_LEN(&in_vars[i]) > cli->cli_netbuf) { |
ret = -7; |
ret = -7; |
break; |
break; |
} |
} |
|
|
memcpy(data, in_vars[i].val.buffer, in_vars[i].val_len); | memcpy(data, in_vars[i].val.buffer, AIT_LEN(&in_vars[i])); |
v[i].val.buffer = (uint8_t*) ((void*) data - (void*) v); |
v[i].val.buffer = (uint8_t*) ((void*) data - (void*) v); |
data += in_vars[i].val_len; | data += AIT_LEN(&in_vars[i]); |
Limit += in_vars[i].val_len; | Limit += AIT_LEN(&in_vars[i]); |
break; |
break; |
case string: |
case string: |
if (Limit + in_vars[i].val_len > sizeof buf) { | if (Limit + AIT_LEN(&in_vars[i]) > cli->cli_netbuf) { |
ret = -7; |
ret = -7; |
break; |
break; |
} |
} |
|
|
memcpy(data, in_vars[i].val.string, in_vars[i].val_len); | memcpy(data, in_vars[i].val.string, AIT_LEN(&in_vars[i])); |
v[i].val.string = (int8_t*) ((void*) data - (void*) v); |
v[i].val.string = (int8_t*) ((void*) data - (void*) v); |
data += in_vars[i].val_len; | data += AIT_LEN(&in_vars[i]); |
Limit += in_vars[i].val_len; | Limit += AIT_LEN(&in_vars[i]); |
break; |
break; |
default: |
default: |
break; |
break; |
Line 340 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
Line 390 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
} |
} |
if (ret < 0) { |
if (ret < 0) { |
rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n"); |
rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n"); |
|
free(buf); |
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; |
|
free(buf); |
return -1; |
return -1; |
} |
} |
if (ret != Limit) { |
if (ret != Limit) { |
rpc_SetErr(ECANCELED, "Error:: in send RPC request, should be send %d bytes, really is %d\n", |
rpc_SetErr(ECANCELED, "Error:: in send RPC request, should be send %d bytes, really is %d\n", |
Limit, ret); |
Limit, ret); |
|
free(buf); |
return -9; |
return -9; |
} |
} |
|
|
|
/* reply from RPC server */ |
|
FD_ZERO(&fds); |
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) |
Line 361 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
Line 416 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
else |
else |
rpc_SetErr(ETIMEDOUT, "Error:: timeout, no return from RPC server?\n"); |
rpc_SetErr(ETIMEDOUT, "Error:: timeout, no return from RPC server?\n"); |
|
|
|
free(buf); |
return -1; |
return -1; |
} |
} |
memset(buf, 0, sizeof buf); | memset(buf, 0, cli->cli_netbuf); |
if ((ret = recv(cli->cli_sock, buf, sizeof buf, 0)) == -1) { | if ((ret = recv(cli->cli_sock, buf, cli->cli_netbuf, 0)) == -1) { |
LOGERR; |
LOGERR; |
|
free(buf); |
return -3; |
return -3; |
} |
} |
if (!ret) /* receive EOF! */ | if (!ret) { /* receive EOF! */ |
| free(buf); |
return 0; |
return 0; |
|
} |
if (ret < sizeof(struct tagRPCRet)) { |
if (ret < sizeof(struct tagRPCRet)) { |
rpc_SetErr(EMSGSIZE, "Error:: too short RPC packet ...\n"); |
rpc_SetErr(EMSGSIZE, "Error:: too short RPC packet ...\n"); |
|
free(buf); |
return -4; |
return -4; |
} else |
} else |
rrpc = (struct tagRPCRet*) buf; |
rrpc = (struct tagRPCRet*) buf; |
/* check RPC packet session info */ |
/* check RPC packet session info */ |
if (memcmp(&rrpc->ret_session, cli->cli_parent, sizeof rrpc->ret_session)) { |
if (memcmp(&rrpc->ret_session, cli->cli_parent, sizeof rrpc->ret_session)) { |
rpc_SetErr(EINVAL, "Error:: get invalid RPC session ...\n"); |
rpc_SetErr(EINVAL, "Error:: get invalid RPC session ...\n"); |
|
free(buf); |
return -5; |
return -5; |
} else |
} else |
Limit = sizeof(struct tagRPCRet); |
Limit = sizeof(struct tagRPCRet); |
if (rrpc->ret_retcode < 0 && rrpc->ret_errno) { |
if (rrpc->ret_retcode < 0 && rrpc->ret_errno) { |
rpc_SetErr(rrpc->ret_errno, "Error::Server side: %d %s\n", |
rpc_SetErr(rrpc->ret_errno, "Error::Server side: %d %s\n", |
rrpc->ret_retcode, strerror(rrpc->ret_errno)); |
rrpc->ret_retcode, strerror(rrpc->ret_errno)); |
|
free(buf); |
return -6; |
return -6; |
} |
} |
if (rrpc->ret_argc * sizeof(ait_val_t) > sizeof buf - Limit) { | if (rrpc->ret_argc * sizeof(ait_val_t) > cli->cli_netbuf - Limit) { |
rpc_SetErr(EMSGSIZE, "Error:: reply RPC packet is too long ...\n"); |
rpc_SetErr(EMSGSIZE, "Error:: reply RPC packet is too long ...\n"); |
|
free(buf); |
return -7; |
return -7; |
} else |
} else |
Limit += rrpc->ret_argc * sizeof(ait_val_t); |
Limit += rrpc->ret_argc * sizeof(ait_val_t); |
Line 398 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
Line 461 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
if (!*out_vars) { |
if (!*out_vars) { |
LOGERR; |
LOGERR; |
*out_argc = 0; |
*out_argc = 0; |
|
free(buf); |
return -1; |
return -1; |
} else |
} else |
memcpy(*out_vars, 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_vars)[i].val_type) { | switch (AIT_TYPE(&(*out_vars)[i])) { |
case buffer: |
case buffer: |
if ((*out_vars)[i].val_len > sizeof buf - Limit) { | if (AIT_LEN(&(*out_vars)[i]) > cli->cli_netbuf - Limit) { |
rpc_SetErr(EMSGSIZE, "Error:: Too long RPC packet ...\n"); |
rpc_SetErr(EMSGSIZE, "Error:: Too long RPC packet ...\n"); |
free(*out_vars); |
free(*out_vars); |
*out_vars = NULL; |
*out_vars = NULL; |
*out_argc = 0; |
*out_argc = 0; |
|
free(buf); |
return -7; |
return -7; |
} else |
} else |
Limit += (*out_vars)[i].val_len; | Limit += AIT_LEN(&(*out_vars)[i]); |
|
|
(*out_vars)[i].val.buffer = malloc((*out_vars)[i].val_len); | (*out_vars)[i].val.buffer = malloc(AIT_LEN(&(*out_vars)[i])); |
if (!(*out_vars)[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_vars); |
free(*out_vars); |
*out_vars = NULL; |
*out_vars = NULL; |
*out_argc = 0; |
*out_argc = 0; |
|
free(buf); |
return -1; |
return -1; |
} else |
} else |
memcpy((*out_vars)[i].val.buffer, data, (*out_vars)[i].val_len); | memcpy((*out_vars)[i].val.buffer, data, AIT_LEN(&(*out_vars)[i])); |
data += (*out_vars)[i].val_len; | data += AIT_LEN(&(*out_vars)[i]); |
break; |
break; |
case string: |
case string: |
if ((*out_vars)[i].val_len > sizeof buf - Limit) { | if (AIT_LEN(&(*out_vars)[i]) > cli->cli_netbuf - Limit) { |
rpc_SetErr(EMSGSIZE, "Error:: Too long RPC packet ...\n"); |
rpc_SetErr(EMSGSIZE, "Error:: Too long RPC packet ...\n"); |
free(*out_vars); |
free(*out_vars); |
*out_vars = NULL; |
*out_vars = NULL; |
*out_argc = 0; |
*out_argc = 0; |
|
free(buf); |
return -7; |
return -7; |
} else |
} else |
Limit += (*out_vars)[i].val_len; | Limit += AIT_LEN(&(*out_vars)[i]); |
|
|
(*out_vars)[i].val.string = malloc((*out_vars)[i].val_len); | (*out_vars)[i].val.string = malloc(AIT_LEN(&(*out_vars)[i])); |
if (!(*out_vars)[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_vars); |
free(*out_vars); |
*out_vars = NULL; |
*out_vars = NULL; |
*out_argc = 0; |
*out_argc = 0; |
|
free(buf); |
return -1; |
return -1; |
} else |
} else |
memcpy((*out_vars)[i].val.string, data, (*out_vars)[i].val_len); | memcpy((*out_vars)[i].val.string, data, AIT_LEN(&(*out_vars)[i])); |
data += (*out_vars)[i].val_len; | data += AIT_LEN(&(*out_vars)[i]); |
break; |
break; |
default: |
default: |
break; |
break; |
Line 457 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
Line 526 rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
|
*out_vars = NULL; |
*out_vars = NULL; |
} |
} |
|
|
return rrpc->ret_retcode; | ret = rrpc->ret_retcode; |
| free(buf); |
| return ret; |
} |
} |
|
|
/* |
/* |