version 1.1.1.1.2.8, 2010/06/23 17:29:07
|
version 1.1.1.1.2.14, 2010/07/07 09:29:42
|
Line 12
|
Line 12
|
static void * |
static void * |
rpc_srv_dispatchCall(void *arg) |
rpc_srv_dispatchCall(void *arg) |
{ |
{ |
rpc_cli_t cli, *c = arg; | rpc_cli_t *c = arg; |
rpc_srv_t *s; |
rpc_srv_t *s; |
rpc_val_t *vals, *v = NULL; | rpc_val_t *vals = NULL, *v = NULL; |
rpc_func_t *f; |
rpc_func_t *f; |
struct tagRPCCall *rpc; |
struct tagRPCCall *rpc; |
struct tagRPCRet rrpc; |
struct tagRPCRet rrpc; |
fd_set fds; |
fd_set fds; |
u_char buf[BUFSIZ], *data; |
u_char buf[BUFSIZ], *data; |
int ret, argc, Limit = 0; | int ret, argc = 0, Limit = 0; |
register int i; |
register int i; |
|
|
if (!arg) { |
if (!arg) { |
Line 57 rpc_srv_dispatchCall(void *arg)
|
Line 57 rpc_srv_dispatchCall(void *arg)
|
if (memcmp(&rpc->call_session, &s->srv_session, sizeof rpc->call_session)) { |
if (memcmp(&rpc->call_session, &s->srv_session, sizeof rpc->call_session)) { |
rpc_SetErr(EINVAL, "Error:: get invalid RPC session ...\n"); |
rpc_SetErr(EINVAL, "Error:: get invalid RPC session ...\n"); |
ret = -5; |
ret = -5; |
break; | goto makeReply; |
} |
} |
// RPC is OK! Go decapsulate variables ... |
// RPC is OK! Go decapsulate variables ... |
if (rpc->call_argc) { |
if (rpc->call_argc) { |
Line 75 rpc_srv_dispatchCall(void *arg)
|
Line 75 rpc_srv_dispatchCall(void *arg)
|
data += v[i].val_len + 1; |
data += v[i].val_len + 1; |
break; |
break; |
case blob: |
case blob: |
rpc_srv_getBLOBVar(&v[i], data); | if (s->srv_blob.state == disable) { |
data += sizeof(rpc_cli_t); | rpc_SetErr(ENOTSUP, "Error:: BLOB server is disabled\n"); |
break; | ret = -5; |
| goto makeReply; |
| } |
default: |
default: |
break; |
break; |
} |
} |
Line 90 rpc_srv_dispatchCall(void *arg)
|
Line 92 rpc_srv_dispatchCall(void *arg)
|
rpc_SetErr(EINVAL, "Error:: call not found into RPC server ...\n"); |
rpc_SetErr(EINVAL, "Error:: call not found into RPC server ...\n"); |
ret = -6; |
ret = -6; |
} else |
} else |
if ((ret = rpc_srv_execCall(s, f, rpc, v)) == -1) | if ((ret = rpc_srv_execCall(f, rpc, v)) == -1) |
ret = -6; |
ret = -6; |
else |
else |
argc = rpc_srv_getValsCall(f, &vals); |
argc = rpc_srv_getValsCall(f, &vals); |
|
|
|
makeReply: |
memcpy(&rrpc.ret_session, &rpc->call_session, sizeof rrpc.ret_session); |
memcpy(&rrpc.ret_session, &rpc->call_session, sizeof rrpc.ret_session); |
rrpc.ret_tag = rpc->call_tag; |
rrpc.ret_tag = rpc->call_tag; |
rrpc.ret_hash = rpc->call_hash; |
rrpc.ret_hash = rpc->call_hash; |
Line 136 rpc_srv_dispatchCall(void *arg)
|
Line 139 rpc_srv_dispatchCall(void *arg)
|
Limit += vals[i].val_len + 1; |
Limit += vals[i].val_len + 1; |
break; |
break; |
case blob: |
case blob: |
if (ret || Limit + sizeof(rpc_cli_t) > BUFSIZ) { | if (s->srv_blob.state == disable) { |
rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n"); | rpc_SetErr(ENOTSUP, "Error:: BLOB server is disabled\n"); |
rrpc.ret_retcode = ret = -7; | rrpc.ret_retcode = ret = -5; |
rrpc.ret_argc = 0; |
rrpc.ret_argc = 0; |
break; |
break; |
} |
} |
|
|
memcpy(data, &cli, sizeof(rpc_cli_t)); |
|
data += sizeof(rpc_cli_t); |
|
Limit += sizeof(rpc_cli_t); |
|
|
|
rpc_srv_setBLOBVar(&vals[i], &cli); |
|
break; |
|
default: |
default: |
break; |
break; |
} |
} |
Line 196 rpc_srv_dispatchVars(void *arg)
|
Line 192 rpc_srv_dispatchVars(void *arg)
|
|
|
cx = -1; |
cx = -1; |
do { |
do { |
|
// check for disable service at this moment? |
|
if (s->srv_blob.state == disable) { |
|
ret = 0; |
|
break; |
|
} |
|
|
FD_ZERO(&fds); |
FD_ZERO(&fds); |
FD_SET(c->cli_sock, &fds); |
FD_SET(c->cli_sock, &fds); |
ret = select(c->cli_sock + 1, &fds, NULL, NULL, NULL); |
ret = select(c->cli_sock + 1, &fds, NULL, NULL, NULL); |
Line 209 rpc_srv_dispatchVars(void *arg)
|
Line 211 rpc_srv_dispatchVars(void *arg)
|
ret = -3; |
ret = -3; |
break; |
break; |
} |
} |
if (!ret) { // receive EOF | if (!ret || s->srv_blob.state == disable) { // receive EOF or disable service |
ret = 0; |
ret = 0; |
break; |
break; |
} |
} |
Line 224 rpc_srv_dispatchVars(void *arg)
|
Line 226 rpc_srv_dispatchVars(void *arg)
|
blob->hdr_seq != cx) { |
blob->hdr_seq != cx) { |
rpc_SetErr(EINVAL, "Error:: get invalid BLOB session in seq=%d...\n", blob->hdr_seq); |
rpc_SetErr(EINVAL, "Error:: get invalid BLOB session in seq=%d...\n", blob->hdr_seq); |
ret = -5; |
ret = -5; |
break; | goto makeReply; |
} |
} |
// get requested BLOB object |
|
if (!(b = rpc_srv_getBLOB(s, blob->hdr_var))) |
|
if (blob->hdr_cmd != set) { |
|
rpc_SetErr(EINVAL, "Error:: var (%x) not found into BLOB server ...\n", blob->hdr_var); |
|
ret = -6; |
|
break; |
|
} |
|
// Go to proceed packet ... |
// Go to proceed packet ... |
switch (blob->hdr_cmd) { |
switch (blob->hdr_cmd) { |
case get: |
case get: |
|
if (!(b = rpc_srv_getBLOB(s, blob->hdr_var))) { |
|
rpc_SetErr(EINVAL, "Error:: var (%x) not found into BLOB server ...\n", |
|
blob->hdr_var); |
|
ret = -6; |
|
break; |
|
} |
|
|
if (rpc_srv_blobMap(s, b) != -1) { |
if (rpc_srv_blobMap(s, b) != -1) { |
ret = rpc_srv_sendBLOB(c, b); |
ret = rpc_srv_sendBLOB(c, b); |
rpc_srv_blobUnmap(b); |
rpc_srv_blobUnmap(b); |
Line 243 rpc_srv_dispatchVars(void *arg)
|
Line 245 rpc_srv_dispatchVars(void *arg)
|
ret = -7; |
ret = -7; |
break; |
break; |
case set: |
case set: |
if (b) { | if ((b = rpc_srv_registerBLOB(s, blob->hdr_len))) { |
rpc_SetErr(EINVAL, "Error:: Cannot set var into BLOB server, already exists ...\n"); | // set new BLOB variable for reply :) |
ret = -6; | blob->hdr_var = b->blob_var; |
break; | |
} | |
|
|
ret = rpc_srv_recvBLOB(c); | ret = rpc_srv_recvBLOB(c, b); |
if (ret == -1) | rpc_srv_blobUnmap(b); |
| } else |
ret = -7; |
ret = -7; |
break; |
break; |
case unset: |
case unset: |
ret = rpc_srv_blobFree(s, b); | ret = rpc_srv_unregisterBLOB(s, blob->hdr_var); |
if (ret == -1) |
if (ret == -1) |
ret = -7; |
ret = -7; |
break; |
break; |
Line 264 rpc_srv_dispatchVars(void *arg)
|
Line 265 rpc_srv_dispatchVars(void *arg)
|
ret = -7; |
ret = -7; |
} |
} |
|
|
|
makeReply: |
// Replay to client! |
// Replay to client! |
blob->hdr_cmd = ret < 0 ? error : ok; |
blob->hdr_cmd = ret < 0 ? error : ok; |
blob->hdr_seq = ret; |
blob->hdr_seq = ret; |
Line 362 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
Line 364 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
rpc_srv_registerCall(srv, NULL, CALL_BLOBSHUTDOWN, 0); |
rpc_srv_registerCall(srv, NULL, CALL_BLOBSHUTDOWN, 0); |
rpc_srv_registerCall(srv, NULL, CALL_BLOBCLIENTS, 0); |
rpc_srv_registerCall(srv, NULL, CALL_BLOBCLIENTS, 0); |
rpc_srv_registerCall(srv, NULL, CALL_BLOBVARS, 0); |
rpc_srv_registerCall(srv, NULL, CALL_BLOBVARS, 0); |
|
rpc_srv_registerCall(srv, NULL, CALL_BLOBSTATE, 1); |
pthread_mutex_unlock(&srv->srv_mtx); |
pthread_mutex_unlock(&srv->srv_mtx); |
|
|
srv->srv_blob.state = enable; // enable BLOB |
srv->srv_blob.state = enable; // enable BLOB |
Line 386 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
Line 389 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
} else |
} else |
srv->srv_blob.state = disable; |
srv->srv_blob.state = disable; |
|
|
|
rpc_srv_unregisterCall(srv, NULL, CALL_BLOBSHUTDOWN); |
|
rpc_srv_unregisterCall(srv, NULL, CALL_BLOBCLIENTS); |
|
rpc_srv_unregisterCall(srv, NULL, CALL_BLOBVARS); |
|
rpc_srv_unregisterCall(srv, NULL, CALL_BLOBSTATE); |
|
|
for (i = 0, c = srv->srv_blob.clients; i < srv->srv_numcli && c; i++, c++) |
for (i = 0, c = srv->srv_blob.clients; i < srv->srv_numcli && c; i++, c++) |
if (c->cli_sa.sa_family) |
if (c->cli_sa.sa_family) |
shutdown(c->cli_sock, SHUT_RDWR); |
shutdown(c->cli_sock, SHUT_RDWR); |
close(srv->srv_blob.server.cli_sock); |
close(srv->srv_blob.server.cli_sock); |
|
|
if (srv->srv_blob.clients) | if (srv->srv_blob.clients) { |
free(srv->srv_blob.clients); |
free(srv->srv_blob.clients); |
|
srv->srv_blob.clients = NULL; |
|
} |
|
|
pthread_mutex_lock(&srv->srv_blob.mtx); |
pthread_mutex_lock(&srv->srv_blob.mtx); |
while ((f = srv->srv_blob.blobs)) { |
while ((f = srv->srv_blob.blobs)) { |
srv->srv_blob.blobs = f->blob_next; |
srv->srv_blob.blobs = f->blob_next; |
|
rpc_srv_blobFree(srv, f); |
free(f); |
free(f); |
} |
} |
pthread_mutex_unlock(&srv->srv_blob.mtx); |
pthread_mutex_unlock(&srv->srv_blob.mtx); |
Line 419 rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
|
Line 430 rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
|
int ret; |
int ret; |
struct timeval tv = { DEF_RPC_TIMEOUT, 0 }; |
struct timeval tv = { DEF_RPC_TIMEOUT, 0 }; |
|
|
if (!srv || !srv->srv_blob.state) { | if (!srv || srv->srv_blob.state == disable) { |
rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t start BLOB server ...\n"); |
rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t start BLOB server ...\n"); |
return -1; |
return -1; |
} |
} |
Line 429 rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
|
Line 440 rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
|
return -1; |
return -1; |
} |
} |
|
|
while (!rpc_Kill) { | while (!blob_Kill && !rpc_Kill) { |
for (c = srv->srv_blob.clients, i = 0; i < srv->srv_numcli && c; i++, c++) |
for (c = srv->srv_blob.clients, i = 0; i < srv->srv_numcli && c; i++, c++) |
if (!c->cli_sa.sa_family) |
if (!c->cli_sa.sa_family) |
break; |
break; |
if (c && c->cli_sa.sa_family && c->cli_parent) { | if (i >= srv->srv_numcli) { |
usleep(1000000); |
usleep(1000000); |
continue; |
continue; |
} |
} |
Line 462 rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
|
Line 473 rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
|
} |
} |
} |
} |
|
|
|
srv->srv_blob.state = disable; |
|
|
return 0; |
return 0; |
} |
} |
|
|
Line 602 rpc_srv_endServer(rpc_srv_t * __restrict srv)
|
Line 615 rpc_srv_endServer(rpc_srv_t * __restrict srv)
|
|
|
if (srv->srv_clients) { |
if (srv->srv_clients) { |
free(srv->srv_clients); |
free(srv->srv_clients); |
|
srv->srv_clients = NULL; |
srv->srv_numcli = 0; |
srv->srv_numcli = 0; |
} |
} |
|
|
Line 647 rpc_srv_execServer(rpc_srv_t * __restrict srv)
|
Line 661 rpc_srv_execServer(rpc_srv_t * __restrict srv)
|
for (c = srv->srv_clients, i = 0; i < srv->srv_numcli && c; i++, c++) |
for (c = srv->srv_clients, i = 0; i < srv->srv_numcli && c; i++, c++) |
if (!c->cli_sa.sa_family) |
if (!c->cli_sa.sa_family) |
break; |
break; |
if (c && c->cli_sa.sa_family && c->cli_parent) { | if (i >= srv->srv_numcli) { |
usleep(1000000); |
usleep(1000000); |
continue; |
continue; |
} |
} |
Line 683 rpc_srv_execServer(rpc_srv_t * __restrict srv)
|
Line 697 rpc_srv_execServer(rpc_srv_t * __restrict srv)
|
|
|
/* |
/* |
* rpc_srv_execCall() Execute registered call from RPC server |
* rpc_srv_execCall() Execute registered call from RPC server |
* @data = RPC const data |
|
* @call = Register RPC call |
* @call = Register RPC call |
* @rpc = IN RPC call structure |
* @rpc = IN RPC call structure |
* @args = IN RPC call array of rpc values |
* @args = IN RPC call array of rpc values |
* return: -1 error, !=-1 ok |
* return: -1 error, !=-1 ok |
*/ |
*/ |
int |
int |
rpc_srv_execCall(void * const data, rpc_func_t * __restrict call, | rpc_srv_execCall(rpc_func_t * __restrict call, struct tagRPCCall * __restrict rpc, |
struct tagRPCCall * __restrict rpc, rpc_val_t * __restrict args) | rpc_val_t * __restrict args) |
{ |
{ |
void *dl; |
void *dl; |
rpc_callback_t func; |
rpc_callback_t func; |
int ret; |
int ret; |
|
|
if (!data || !call || !rpc) { | if (!call || !rpc || !call->func_parent) { |
rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t exec call from RPC server ...\n"); |
rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t exec call from RPC server ...\n"); |
return -1; |
return -1; |
} |
} |
Line 710 rpc_srv_execCall(void * const data, rpc_func_t * __res
|
Line 723 rpc_srv_execCall(void * const data, rpc_func_t * __res
|
|
|
func = dlsym(dl, (char*) call->func_name); |
func = dlsym(dl, (char*) call->func_name); |
if (func) |
if (func) |
ret = func(data, call, rpc->call_argc, args); | ret = func(call, rpc->call_argc, args); |
else { |
else { |
rpc_SetErr(ENOEXEC, "Error:: Can`t find function %s!\n", dlerror()); |
rpc_SetErr(ENOEXEC, "Error:: Can`t find function %s!\n", dlerror()); |
ret = -1; |
ret = -1; |