version 1.9.2.6, 2012/05/15 20:49:25
|
version 1.9.2.11, 2012/05/16 07:54:49
|
Line 75 txPacket(sched_task_t *task)
|
Line 75 txPacket(sched_task_t *task)
|
u_char buf[USHRT_MAX] = { 0 }; |
u_char buf[USHRT_MAX] = { 0 }; |
struct tagRPCCall *rpc = (struct tagRPCCall*) buf; |
struct tagRPCCall *rpc = (struct tagRPCCall*) buf; |
int ret, wlen = sizeof(struct tagRPCCall); |
int ret, wlen = sizeof(struct tagRPCCall); |
array_t *arr = NULL; |
|
|
|
/* copy RPC header */ |
/* copy RPC header */ |
memcpy(buf, TASK_DATA(task), wlen); |
memcpy(buf, TASK_DATA(task), wlen); |
Line 87 txPacket(sched_task_t *task)
|
Line 86 txPacket(sched_task_t *task)
|
rpc->call_rep.ret = RPC_ERROR(-1); |
rpc->call_rep.ret = RPC_ERROR(-1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); |
} else { |
} else { |
rpc->call_argc = htons(rpc_srv_getVars(f, &arr)); | rpc->call_argc = htons(io_arraySize(f->func_vars)); |
/* Go Encapsulate variables */ |
/* Go Encapsulate variables */ |
ret = io_vars2buffer(buf + wlen, sizeof buf - wlen, arr); | ret = io_vars2buffer(buf + wlen, sizeof buf - wlen, f->func_vars); |
/* Free return values */ |
/* Free return values */ |
io_clrVars(f->func_vars); |
io_clrVars(f->func_vars); |
if (ret == -1) { |
if (ret == -1) { |
Line 141 execCall(sched_task_t *task)
|
Line 140 execCall(sched_task_t *task)
|
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); |
return NULL; |
return NULL; |
} |
} |
} | } else |
| arr = NULL; |
|
|
if (!(f = rpc_srv_getCall(s, ntohs(rpc->call_tag)))) { |
if (!(f = rpc_srv_getCall(s, ntohs(rpc->call_tag)))) { |
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
Line 161 execCall(sched_task_t *task)
|
Line 161 execCall(sched_task_t *task)
|
/* without reply */ |
/* without reply */ |
io_clrVars(f->func_vars); |
io_clrVars(f->func_vars); |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
} else | } else { |
rpc->call_argc = htons(rpc_srv_getVars(f, NULL)); | /* reply */ |
| rpc->call_argc = htons(io_arraySize(f->func_vars)); |
| } |
} |
} |
} |
} |
|
|
if (arr) | io_arrayDestroy(&arr); |
io_arrayDestroy(&arr); | |
return NULL; |
return NULL; |
} |
} |
|
|
Line 466 rpc_srv_dispatchVars(void *arg)
|
Line 467 rpc_srv_dispatchVars(void *arg)
|
free(buf); |
free(buf); |
return NULL; |
return NULL; |
} |
} |
|
#endif |
|
|
// ------------------------------------------------- |
|
|
|
/* |
/* |
* rpc_srv_initBLOBServer() - Init & create BLOB Server |
* rpc_srv_initBLOBServer() - Init & create BLOB Server |
Line 499 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
Line 500 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
} else |
} else |
AIT_SET_STR(&srv->srv_blob.dir, diskDir); |
AIT_SET_STR(&srv->srv_blob.dir, diskDir); |
|
|
srv->srv_blob.server.cli_tid = pthread_self(); | /* init blob list */ |
| TAILQ_INIT(&srv->srv_blob.blobs); |
| |
srv->srv_blob.server.cli_parent = srv; |
srv->srv_blob.server.cli_parent = srv; |
|
|
memcpy(&sa, &srv->srv_server.cli_sa, sizeof sa); | memcpy(&srv->srv_blob.server.cli_sa, &srv->srv_server.cli_sa, sizeof(io_sockaddr_t)); |
switch (sa.sa.sa_family) { |
switch (sa.sa.sa_family) { |
case AF_INET: |
case AF_INET: |
sa.sin.sin_port = htons(Port ? Port : ntohs(sa.sin.sin_port) + 1); |
sa.sin.sin_port = htons(Port ? Port : ntohs(sa.sin.sin_port) + 1); |
Line 517 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
Line 520 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
AIT_FREE_VAL(&srv->srv_blob.dir); |
AIT_FREE_VAL(&srv->srv_blob.dir); |
return -1; |
return -1; |
} |
} |
memcpy(&srv->srv_blob.server.cli_sa, &sa, sizeof sa); |
|
|
|
/* create BLOB server socket */ |
/* create BLOB server socket */ |
srv->srv_blob.server.cli_sock = socket(srv->srv_server.cli_sa.sa.sa_family, SOCK_STREAM, 0); |
srv->srv_blob.server.cli_sock = socket(srv->srv_server.cli_sa.sa.sa_family, SOCK_STREAM, 0); |
Line 553 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
Line 555 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
return -1; |
return -1; |
} |
} |
|
|
/* allocate pool for concurent clients */ | /* allocate pool for concurent blob clients */ |
srv->srv_blob.clients = calloc(srv->srv_numcli, sizeof(rpc_cli_t)); | srv->srv_blob.clients = io_arrayInit(io_arraySize(srv->srv_clients)); |
if (!srv->srv_blob.clients) { |
if (!srv->srv_blob.clients) { |
LOGERR; | rpc_SetErr(io_GetErrno(), "%s", io_GetError()); |
close(srv->srv_blob.server.cli_sock); |
close(srv->srv_blob.server.cli_sock); |
AIT_FREE_VAL(&srv->srv_blob.dir); |
AIT_FREE_VAL(&srv->srv_blob.dir); |
return -1; |
return -1; |
} else | } |
memset(srv->srv_blob.clients, 0, srv->srv_numcli * sizeof(rpc_cli_t)); | |
|
|
rpc_srv_registerCall(srv, NULL, CALL_BLOBSHUTDOWN, 0); |
|
rpc_srv_registerCall(srv, NULL, CALL_BLOBCLIENTS, 1); |
|
rpc_srv_registerCall(srv, NULL, CALL_BLOBVARS, 1); |
|
rpc_srv_registerCall(srv, NULL, CALL_BLOBSTATE, 0); |
|
|
|
srv->srv_blob.state = enable; /* enable BLOB */ |
srv->srv_blob.state = enable; /* enable BLOB */ |
return 0; |
return 0; |
} |
} |
Line 583 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
Line 579 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
{ |
{ |
rpc_cli_t *c; |
rpc_cli_t *c; |
register int i; |
register int i; |
rpc_blob_t *f; | rpc_blob_t *b, *tmp; |
|
|
if (!srv || srv->srv_blob.state == disable) |
if (!srv || srv->srv_blob.state == disable) |
return; |
return; |
else |
else |
srv->srv_blob.state = kill; |
srv->srv_blob.state = kill; |
|
|
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); |
|
|
|
/* close all clients connections & server socket */ |
/* close all clients connections & server socket */ |
for (i = 0, c = srv->srv_blob.clients; i < srv->srv_numcli && c; i++, c++) | for (i = 0; i < io_arraySize(srv->srv_blob.clients); i++) { |
if (c->cli_sa.sa.sa_family) | c = io_array(srv->srv_blob.clients, i, rpc_cli_t*); |
| if (c) { |
shutdown(c->cli_sock, SHUT_RDWR); |
shutdown(c->cli_sock, SHUT_RDWR); |
close(srv->srv_blob.server.cli_sock); | close(c->cli_sock); |
|
|
if (srv->srv_blob.clients) { | io_arrayDel(srv->srv_blob.clients, i, 42); |
free(srv->srv_blob.clients); | } |
srv->srv_blob.clients = NULL; | |
} |
} |
|
io_arrayDestroy(&srv->srv_blob.clients); |
|
|
|
close(srv->srv_blob.server.cli_sock); |
|
|
/* detach blobs */ |
/* detach blobs */ |
while ((f = srv->srv_blob.blobs)) { | TAILQ_FOREACH_SAFE(b, &srv->srv_blob.blobs, blob_node, tmp) { |
srv->srv_blob.blobs = f->blob_next; | TAILQ_REMOVE(&srv->srv_blob.blobs, b, blob_node); |
rpc_srv_blobFree(srv, f); | |
free(f); | rpc_srv_blobFree(srv, b); |
| free(b); |
} |
} |
|
|
AIT_FREE_VAL(&srv->srv_blob.dir); |
AIT_FREE_VAL(&srv->srv_blob.dir); |
Line 619 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
Line 614 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
srv->srv_blob.state = disable; |
srv->srv_blob.state = disable; |
} |
} |
|
|
|
#if 0 |
/* |
/* |
* rpc_srv_loopBLOB() - Execute Main BLOB server loop and wait for clients requests |
* rpc_srv_loopBLOB() - Execute Main BLOB server loop and wait for clients requests |
* |
* |
Line 825 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
|
Line 821 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
|
shutdown(c->cli_sock, SHUT_RDWR); |
shutdown(c->cli_sock, SHUT_RDWR); |
close(c->cli_sock); |
close(c->cli_sock); |
|
|
free(c); | io_arrayDel((*psrv)->srv_clients, i, 42); |
io_arrayDel((*psrv)->srv_clients, i, 0); | |
} |
} |
} |
} |
io_arrayDestroy(&(*psrv)->srv_clients); |
io_arrayDestroy(&(*psrv)->srv_clients); |
Line 835 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
|
Line 830 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
|
|
|
/* detach exported calls */ |
/* detach exported calls */ |
TAILQ_FOREACH_SAFE(f, &(*psrv)->srv_funcs, func_node, tmp) { |
TAILQ_FOREACH_SAFE(f, &(*psrv)->srv_funcs, func_node, tmp) { |
|
TAILQ_REMOVE(&(*psrv)->srv_funcs, f, func_node); |
|
|
io_freeVars(&f->func_vars); |
io_freeVars(&f->func_vars); |
AIT_FREE_VAL(&f->func_name); |
AIT_FREE_VAL(&f->func_name); |
free(f); |
free(f); |