version 1.9.2.7, 2012/05/15 22:47:10
|
version 1.9.2.13, 2012/05/16 09:09:42
|
Line 140 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 160 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 { |
| /* reply */ |
rpc->call_argc = htons(io_arraySize(f->func_vars)); |
rpc->call_argc = htons(io_arraySize(f->func_vars)); |
|
} |
} |
} |
} |
} |
|
|
if (arr) | io_arrayDestroy(&arr); |
io_arrayDestroy(&arr); | |
return NULL; |
return NULL; |
} |
} |
|
|
Line 255 acceptClients(sched_task_t *task)
|
Line 257 acceptClients(sched_task_t *task)
|
c = malloc(sizeof(rpc_cli_t)); |
c = malloc(sizeof(rpc_cli_t)); |
if (!c) { |
if (!c) { |
LOGERR; |
LOGERR; |
srv->srv_kill = kill; | srv->srv_kill = 1; |
return NULL; |
return NULL; |
} else { |
} else { |
memset(c, 0, sizeof(rpc_cli_t)); |
memset(c, 0, sizeof(rpc_cli_t)); |
Line 268 acceptClients(sched_task_t *task)
|
Line 270 acceptClients(sched_task_t *task)
|
AIT_SET_BUF2(&c->cli_buf, 0, srv->srv_netbuf); |
AIT_SET_BUF2(&c->cli_buf, 0, srv->srv_netbuf); |
|
|
/* accept client */ |
/* accept client */ |
c->cli_sock = accept(srv->srv_server.cli_sock, &c->cli_sa.sa, &salen); | c->cli_sock = accept(TASK_FD(task), &c->cli_sa.sa, &salen); |
if (c->cli_sock == -1) { |
if (c->cli_sock == -1) { |
LOGERR; |
LOGERR; |
AIT_FREE_VAL(&c->cli_buf); |
AIT_FREE_VAL(&c->cli_buf); |
Line 283 end:
|
Line 285 end:
|
return NULL; |
return NULL; |
} |
} |
|
|
|
/* ------------------------------------------------------ */ |
|
|
#if 0 |
#if 0 |
static void * |
static void * |
txBLOB(sched_task_t *task) |
txBLOB(sched_task_t *task) |
Line 421 end:
|
Line 425 end:
|
TASK_DATA(task), TASK_DATLEN(task)); |
TASK_DATA(task), TASK_DATLEN(task)); |
return NULL; |
return NULL; |
} |
} |
|
#endif |
|
|
static void * |
static void * |
rpc_srv_dispatchVars(void *arg) | acceptBLOBClients(sched_task_t *task) |
{ |
{ |
rpc_cli_t *c = arg; | rpc_srv_t *srv = TASK_ARG(task); |
rpc_srv_t *s; | rpc_cli_t *c = NULL; |
sched_root_task_t *root; | register int i; |
u_char *buf; | socklen_t salen = sizeof(io_sockaddr_t); |
struct timespec ts = { DEF_RPC_TIMEOUT, 0 }; | |
|
|
if (!arg) { | /* check free slots for connect */ |
rpc_SetErr(EINVAL, "Invalid parameter can`t procced BLOB"); | for (i = 0; i < io_arraySize(srv->srv_blob.clients) && |
return NULL; | (c = io_array(srv->srv_blob.clients, i, rpc_cli_t*)); i++); |
} else | if (c) /* no more free slots! */ |
s = c->cli_parent; | goto end; |
| c = malloc(sizeof(rpc_cli_t)); |
/* allocate net buffer */ | if (!c) { |
buf = malloc(sizeof(struct tagBLOBHdr)); | |
if (!buf) { | |
LOGERR; |
LOGERR; |
|
srv->srv_kill = srv->srv_blob.kill = 1; |
return NULL; |
return NULL; |
} |
|
|
|
root = schedBegin(); |
|
if (!root) { |
|
rpc_SetErr(sched_GetErrno(), "%s", sched_GetError()); |
|
free(buf); |
|
return NULL; |
|
} else { |
} else { |
schedTermCondition(root, kill); | memset(c, 0, sizeof(rpc_cli_t)); |
schedPolling(root, &ts, NULL); | io_arraySet(srv->srv_blob.clients, i, c); |
| c->cli_id = i; |
| c->cli_parent = srv; |
} |
} |
|
|
schedRead(root, rxBLOB, c, c->cli_sock, buf, sizeof(struct tagBLOBHdr)); | /* alloc empty buffer */ |
| AIT_SET_BUF2(&c->cli_buf, 0, srv->srv_netbuf); |
|
|
schedRun(root, (void*) &c->cli_kill); | /* accept client */ |
schedEnd(&root); | c->cli_sock = accept(TASK_FD(task), &c->cli_sa.sa, &salen); |
| if (c->cli_sock == -1) { |
| LOGERR; |
| AIT_FREE_VAL(&c->cli_buf); |
| io_arrayDel(srv->srv_blob.clients, i, 42); |
| goto end; |
| } else |
| fcntl(c->cli_sock, F_SETFL, fcntl(c->cli_sock, F_GETFL) | O_NONBLOCK); |
|
|
shutdown(c->cli_sock, SHUT_RDWR); | // schedRead(TASK_ROOT(task), rxBLOB, c, c->cli_sock, NULL, 0); |
close(c->cli_sock); | end: |
memset(c, 0, sizeof(rpc_cli_t)); | schedReadSelf(task); |
free(buf); | |
return NULL; |
return NULL; |
} |
} |
|
|
// ------------------------------------------------- | /* ------------------------------------------------------ */ |
|
|
/* |
/* |
* rpc_srv_initBLOBServer() - Init & create BLOB Server |
* rpc_srv_initBLOBServer() - Init & create BLOB Server |
Line 482 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
Line 487 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
int n = 1; |
int n = 1; |
io_sockaddr_t sa; |
io_sockaddr_t sa; |
|
|
if (!srv) { | if (!srv || srv->srv_kill) { |
rpc_SetErr(EINVAL, "Invalid parameters can`t init BLOB server"); |
rpc_SetErr(EINVAL, "Invalid parameters can`t init BLOB server"); |
return -1; |
return -1; |
} |
} |
if (srv->srv_blob.state) { |
|
rpc_SetErr(EPERM, "Already started BLOB server!"); |
|
return 0; |
|
} |
|
|
|
memset(&srv->srv_blob, 0, sizeof srv->srv_blob); |
memset(&srv->srv_blob, 0, sizeof srv->srv_blob); |
if (access(diskDir, R_OK | W_OK) == -1) { |
if (access(diskDir, R_OK | W_OK) == -1) { |
Line 498 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
Line 499 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 516 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
Line 519 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 552 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
|
Line 554 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); | /* init blob scheduler */ |
rpc_srv_registerCall(srv, NULL, CALL_BLOBCLIENTS, 1); | srv->srv_blob.root = schedBegin(); |
rpc_srv_registerCall(srv, NULL, CALL_BLOBVARS, 1); | if (!srv->srv_blob.root) { |
rpc_srv_registerCall(srv, NULL, CALL_BLOBSTATE, 0); | rpc_SetErr(sched_GetErrno(), "%s", sched_GetError()); |
| io_arrayDestroy(&srv->srv_blob.clients); |
| close(srv->srv_blob.server.cli_sock); |
| AIT_FREE_VAL(&srv->srv_blob.dir); |
| return -1; |
| } |
|
|
srv->srv_blob.state = enable; /* enable BLOB */ |
|
return 0; |
return 0; |
} |
} |
|
|
Line 582 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
Line 587 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) |
return; |
return; |
else |
|
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); |
} |
} |
|
|
|
schedEnd(&srv->srv_blob.root); |
AIT_FREE_VAL(&srv->srv_blob.dir); |
AIT_FREE_VAL(&srv->srv_blob.dir); |
|
|
/* at final, save disable BLOB service state */ | srv->srv_blob.kill = 1; |
srv->srv_blob.state = disable; | |
} |
} |
|
|
/* |
/* |
* rpc_srv_loopBLOB() - Execute Main BLOB server loop and wait for clients requests | * rpc_srv_loopBLOBServer() - Execute Main BLOB server loop and wait for clients requests |
* |
* |
* @srv = RPC Server instance |
* @srv = RPC Server instance |
* return: -1 error or 0 ok, infinite loop ... |
* return: -1 error or 0 ok, infinite loop ... |
*/ |
*/ |
int |
int |
rpc_srv_loopBLOB(rpc_srv_t * __restrict srv) | rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) |
{ |
{ |
socklen_t salen = sizeof(io_sockaddr_t); | if (!srv || srv->srv_kill) { |
register int i; | |
rpc_cli_t *c; | |
int ret; | |
pthread_attr_t attr; | |
struct pollfd pfd; | |
| |
if (!srv || srv->srv_blob.state == kill) { | |
rpc_SetErr(EINVAL, "Invalid parameter can`t start BLOB server"); |
rpc_SetErr(EINVAL, "Invalid parameter can`t start BLOB server"); |
return -1; |
return -1; |
} |
} |
|
|
if (listen(srv->srv_blob.server.cli_sock, SOMAXCONN) == -1) { | fcntl(srv->srv_blob.server.cli_sock, F_SETFL, |
| fcntl(srv->srv_blob.server.cli_sock, F_GETFL) | O_NONBLOCK); |
| |
| if (listen(srv->srv_blob.server.cli_sock, io_arraySize(srv->srv_blob.clients)) == -1) { |
LOGERR; |
LOGERR; |
return -1; |
return -1; |
} else | } |
fcntl(srv->srv_blob.server.cli_sock, F_SETFL, | |
fcntl(srv->srv_blob.server.cli_sock, F_GETFL) | O_NONBLOCK); | |
|
|
pthread_attr_init(&attr); | if (!schedRead(srv->srv_blob.root, acceptBLOBClients, srv, |
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); | srv->srv_blob.server.cli_sock, NULL, 0)) { |
| rpc_SetErr(sched_GetErrno(), "%s", sched_GetError()); |
| return -1; |
| } |
|
|
pfd.fd = srv->srv_blob.server.cli_sock; | #if 0 |
pfd.events = POLLIN | POLLPRI; | |
/* main BLOB loop */ | |
while (srv->srv_blob.state != kill && srv->srv_kill != 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.sa_family) |
if (!c->cli_sa.sa.sa_family) |
break; |
break; |
Line 664 rpc_srv_loopBLOB(rpc_srv_t * __restrict srv)
|
Line 660 rpc_srv_loopBLOB(rpc_srv_t * __restrict srv)
|
continue; |
continue; |
} |
} |
|
|
if ((ret = poll(&pfd, 1, srv->srv_session.sess_timeout * 1000)) == -1 || |
|
pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) { |
|
LOGERR; |
|
ret = 1; |
|
break; |
|
} else if (!ret) |
|
continue; |
|
|
|
c->cli_sock = accept(srv->srv_blob.server.cli_sock, &c->cli_sa.sa, &salen); |
c->cli_sock = accept(srv->srv_blob.server.cli_sock, &c->cli_sa.sa, &salen); |
if (c->cli_sock == -1) { |
if (c->cli_sock == -1) { |
LOGERR; |
LOGERR; |
continue; |
continue; |
} else |
} else |
c->cli_parent = srv; |
c->cli_parent = srv; |
|
|
/* spawn dispatch thread for BLOB client */ |
|
c->cli_kill = enable; |
|
if (pthread_create(&c->cli_tid, &attr, rpc_srv_dispatchVars, c)) { |
|
LOGERR; |
|
continue; |
|
} |
|
} |
} |
|
#endif |
|
|
srv->srv_blob.state = kill; | /* main rpc loop */ |
| schedRun(srv->srv_blob.root, &srv->srv_blob.kill); |
pthread_attr_destroy(&attr); | |
return 0; |
return 0; |
} |
} |
#endif |
|
|
|
|
|
/* |
/* |
Line 817 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
|
Line 797 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
|
return; |
return; |
} |
} |
|
|
|
if (!(*psrv)->srv_blob.kill) |
|
rpc_srv_endBLOBServer(*psrv); |
|
|
/* close all clients connections & server socket */ |
/* close all clients connections & server socket */ |
for (i = 0; i < io_arraySize((*psrv)->srv_clients); i++) { |
for (i = 0; i < io_arraySize((*psrv)->srv_clients); i++) { |
c = io_array((*psrv)->srv_clients, i, rpc_cli_t*); |
c = io_array((*psrv)->srv_clients, i, rpc_cli_t*); |
Line 824 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
|
Line 807 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 834 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
|
Line 816 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); |