--- libaitrpc/src/srv.c 2012/05/15 16:10:58 1.9.2.5 +++ libaitrpc/src/srv.c 2012/05/16 09:09:42 1.9.2.13 @@ -3,7 +3,7 @@ * by Michael Pounov * * $Author: misho $ -* $Id: srv.c,v 1.9.2.5 2012/05/15 16:10:58 misho Exp $ +* $Id: srv.c,v 1.9.2.13 2012/05/16 09:09:42 misho Exp $ * ************************************************************************** The ELWIX and AITNET software is distributed under the following @@ -52,7 +52,7 @@ closeClient(sched_task_t *task) rpc_cli_t *c = TASK_ARG(task); rpc_srv_t *s = c->cli_parent; - schedCancelby(s->srv_root, taskMAX, CRITERIA_FD, (void*) c->cli_sock, NULL); + schedCancelby(s->srv_root, taskMAX, CRITERIA_ARG, TASK_ARG(task), NULL); /* close client socket */ if (TASK_VAL(task)) @@ -75,21 +75,20 @@ txPacket(sched_task_t *task) u_char buf[USHRT_MAX] = { 0 }; struct tagRPCCall *rpc = (struct tagRPCCall*) buf; int ret, wlen = sizeof(struct tagRPCCall); - array_t *arr = NULL; /* copy RPC header */ memcpy(buf, TASK_DATA(task), wlen); if (rpc->call_argc) { - f = rpc_srv_getCall(s, ntohs(rpc->call_tag), ntohl(rpc->call_hash)); + f = rpc_srv_getCall(s, ntohs(rpc->call_tag)); if (!f) { rpc->call_argc ^= rpc->call_argc; rpc->call_rep.ret = RPC_ERROR(-1); rpc->call_rep.eno = RPC_ERROR(rpc_Errno); } else { - rpc->call_argc = htons(rpc_srv_getVars(f, &arr)); + rpc->call_argc = htons(io_arraySize(f->func_vars)); /* 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 */ io_clrVars(f->func_vars); if (ret == -1) { @@ -141,9 +140,10 @@ execCall(sched_task_t *task) rpc->call_rep.eno = RPC_ERROR(rpc_Errno); return NULL; } - } + } else + arr = NULL; - if (!(f = rpc_srv_getCall(s, ntohs(rpc->call_tag), ntohl(rpc->call_hash)))) { + if (!(f = rpc_srv_getCall(s, ntohs(rpc->call_tag)))) { rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); rpc->call_argc ^= rpc->call_argc; rpc->call_rep.ret = RPC_ERROR(-1); @@ -161,13 +161,14 @@ execCall(sched_task_t *task) /* without reply */ io_clrVars(f->func_vars); rpc->call_argc ^= rpc->call_argc; - } else - rpc->call_argc = htons(rpc_srv_getVars(f, NULL)); + } else { + /* reply */ + rpc->call_argc = htons(io_arraySize(f->func_vars)); + } } } - if (arr) - io_arrayDestroy(&arr); + io_arrayDestroy(&arr); return NULL; } @@ -256,7 +257,7 @@ acceptClients(sched_task_t *task) c = malloc(sizeof(rpc_cli_t)); if (!c) { LOGERR; - srv->srv_kill = kill; + srv->srv_kill = 1; return NULL; } else { memset(c, 0, sizeof(rpc_cli_t)); @@ -265,24 +266,27 @@ acceptClients(sched_task_t *task) c->cli_parent = srv; } + /* alloc empty buffer */ + AIT_SET_BUF2(&c->cli_buf, 0, srv->srv_netbuf); + /* 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) { LOGERR; + AIT_FREE_VAL(&c->cli_buf); io_arrayDel(srv->srv_clients, i, 42); goto end; } else fcntl(c->cli_sock, F_SETFL, fcntl(c->cli_sock, F_GETFL) | O_NONBLOCK); - /* alloc empty buffer */ - AIT_SET_BUF2(&c->cli_buf, 0, srv->srv_netbuf); - schedRead(TASK_ROOT(task), rxPacket, c, c->cli_sock, NULL, 0); end: schedReadSelf(task); return NULL; } +/* ------------------------------------------------------ */ + #if 0 static void * txBLOB(sched_task_t *task) @@ -421,52 +425,53 @@ end: TASK_DATA(task), TASK_DATLEN(task)); return NULL; } +#endif static void * -rpc_srv_dispatchVars(void *arg) +acceptBLOBClients(sched_task_t *task) { - rpc_cli_t *c = arg; - rpc_srv_t *s; - sched_root_task_t *root; - u_char *buf; - struct timespec ts = { DEF_RPC_TIMEOUT, 0 }; + rpc_srv_t *srv = TASK_ARG(task); + rpc_cli_t *c = NULL; + register int i; + socklen_t salen = sizeof(io_sockaddr_t); - if (!arg) { - rpc_SetErr(EINVAL, "Invalid parameter can`t procced BLOB"); - return NULL; - } else - s = c->cli_parent; - - /* allocate net buffer */ - buf = malloc(sizeof(struct tagBLOBHdr)); - if (!buf) { + /* check free slots for connect */ + for (i = 0; i < io_arraySize(srv->srv_blob.clients) && + (c = io_array(srv->srv_blob.clients, i, rpc_cli_t*)); i++); + if (c) /* no more free slots! */ + goto end; + c = malloc(sizeof(rpc_cli_t)); + if (!c) { LOGERR; + srv->srv_kill = srv->srv_blob.kill = 1; return NULL; - } - - root = schedBegin(); - if (!root) { - rpc_SetErr(sched_GetErrno(), "%s", sched_GetError()); - free(buf); - return NULL; } else { - schedTermCondition(root, kill); - schedPolling(root, &ts, NULL); + memset(c, 0, sizeof(rpc_cli_t)); + 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); - schedEnd(&root); + /* accept client */ + 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); - close(c->cli_sock); - memset(c, 0, sizeof(rpc_cli_t)); - free(buf); +// schedRead(TASK_ROOT(task), rxBLOB, c, c->cli_sock, NULL, 0); +end: + schedReadSelf(task); return NULL; } -// ------------------------------------------------- +/* ------------------------------------------------------ */ /* * rpc_srv_initBLOBServer() - Init & create BLOB Server @@ -482,14 +487,10 @@ rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s int n = 1; io_sockaddr_t sa; - if (!srv) { + if (!srv || srv->srv_kill) { rpc_SetErr(EINVAL, "Invalid parameters can`t init BLOB server"); 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); if (access(diskDir, R_OK | W_OK) == -1) { @@ -498,10 +499,12 @@ rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s } else 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; - 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) { case AF_INET: sa.sin.sin_port = htons(Port ? Port : ntohs(sa.sin.sin_port) + 1); @@ -516,7 +519,6 @@ rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s AIT_FREE_VAL(&srv->srv_blob.dir); return -1; } - memcpy(&srv->srv_blob.server.cli_sa, &sa, sizeof sa); /* create BLOB server socket */ srv->srv_blob.server.cli_sock = socket(srv->srv_server.cli_sa.sa.sa_family, SOCK_STREAM, 0); @@ -552,22 +554,25 @@ rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s return -1; } - /* allocate pool for concurent clients */ - srv->srv_blob.clients = calloc(srv->srv_numcli, sizeof(rpc_cli_t)); + /* allocate pool for concurent blob clients */ + srv->srv_blob.clients = io_arrayInit(io_arraySize(srv->srv_clients)); if (!srv->srv_blob.clients) { - LOGERR; + rpc_SetErr(io_GetErrno(), "%s", io_GetError()); close(srv->srv_blob.server.cli_sock); AIT_FREE_VAL(&srv->srv_blob.dir); 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); + /* init blob scheduler */ + srv->srv_blob.root = schedBegin(); + if (!srv->srv_blob.root) { + 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; } @@ -582,77 +587,68 @@ rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) { rpc_cli_t *c; register int i; - rpc_blob_t *f; + rpc_blob_t *b, *tmp; - if (!srv || srv->srv_blob.state == disable) + if (!srv) 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 */ - for (i = 0, c = srv->srv_blob.clients; i < srv->srv_numcli && c; i++, c++) - if (c->cli_sa.sa.sa_family) + for (i = 0; i < io_arraySize(srv->srv_blob.clients); i++) { + c = io_array(srv->srv_blob.clients, i, rpc_cli_t*); + if (c) { shutdown(c->cli_sock, SHUT_RDWR); - close(srv->srv_blob.server.cli_sock); + close(c->cli_sock); - if (srv->srv_blob.clients) { - free(srv->srv_blob.clients); - srv->srv_blob.clients = NULL; + io_arrayDel(srv->srv_blob.clients, i, 42); + } } + io_arrayDestroy(&srv->srv_blob.clients); + close(srv->srv_blob.server.cli_sock); + /* detach blobs */ - while ((f = srv->srv_blob.blobs)) { - srv->srv_blob.blobs = f->blob_next; - rpc_srv_blobFree(srv, f); - free(f); + TAILQ_FOREACH_SAFE(b, &srv->srv_blob.blobs, blob_node, tmp) { + TAILQ_REMOVE(&srv->srv_blob.blobs, b, blob_node); + + rpc_srv_blobFree(srv, b); + free(b); } + schedEnd(&srv->srv_blob.root); AIT_FREE_VAL(&srv->srv_blob.dir); - /* at final, save disable BLOB service state */ - srv->srv_blob.state = disable; + srv->srv_blob.kill = 1; } /* - * 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 * return: -1 error or 0 ok, infinite loop ... */ int -rpc_srv_loopBLOB(rpc_srv_t * __restrict srv) +rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) { - socklen_t salen = sizeof(io_sockaddr_t); - register int i; - rpc_cli_t *c; - int ret; - pthread_attr_t attr; - struct pollfd pfd; - - if (!srv || srv->srv_blob.state == kill) { + if (!srv || srv->srv_kill) { rpc_SetErr(EINVAL, "Invalid parameter can`t start BLOB server"); 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; 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); - pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + if (!schedRead(srv->srv_blob.root, acceptBLOBClients, srv, + 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; - pfd.events = POLLIN | POLLPRI; - /* main BLOB loop */ - while (srv->srv_blob.state != kill && srv->srv_kill != kill) { +#if 0 for (c = srv->srv_blob.clients, i = 0; i < srv->srv_numcli && c; i++, c++) if (!c->cli_sa.sa.sa_family) break; @@ -664,35 +660,19 @@ rpc_srv_loopBLOB(rpc_srv_t * __restrict srv) 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); if (c->cli_sock == -1) { LOGERR; continue; } else 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; - - pthread_attr_destroy(&attr); + /* main rpc loop */ + schedRun(srv->srv_blob.root, &srv->srv_blob.kill); return 0; } -#endif /* @@ -707,7 +687,7 @@ rpc_srv_loopBLOB(rpc_srv_t * __restrict srv) * return: NULL == error or !=NULL bind and created RPC server instance */ rpc_srv_t * -rpc_srv_initServer(u_int regProgID, u_int regProcID, int concurentClients, +rpc_srv_initServer(u_int regProgID, u_char regProcID, int concurentClients, int netBuf, const char *csHost, u_short Port) { int n = 1; @@ -736,7 +716,6 @@ rpc_srv_initServer(u_int regProgID, u_int regProcID, i srv->srv_netbuf = netBuf; srv->srv_session.sess_version = RPC_VERSION; - srv->srv_session.sess_timeout = DEF_RPC_TIMEOUT; srv->srv_session.sess_program = regProgID; srv->srv_session.sess_process = regProcID; @@ -818,14 +797,17 @@ rpc_srv_endServer(rpc_srv_t ** __restrict psrv) return; } + if (!(*psrv)->srv_blob.kill) + rpc_srv_endBLOBServer(*psrv); + /* close all clients connections & server socket */ for (i = 0; i < io_arraySize((*psrv)->srv_clients); i++) { c = io_array((*psrv)->srv_clients, i, rpc_cli_t*); if (c) { shutdown(c->cli_sock, SHUT_RDWR); close(c->cli_sock); - free(c); - io_arrayDel((*psrv)->srv_clients, i, 0); + + io_arrayDel((*psrv)->srv_clients, i, 42); } } io_arrayDestroy(&(*psrv)->srv_clients); @@ -834,9 +816,10 @@ rpc_srv_endServer(rpc_srv_t ** __restrict psrv) /* detach exported calls */ TAILQ_FOREACH_SAFE(f, &(*psrv)->srv_funcs, func_node, tmp) { + TAILQ_REMOVE(&(*psrv)->srv_funcs, f, func_node); + io_freeVars(&f->func_vars); AIT_FREE_VAL(&f->func_name); - AIT_FREE_VAL(&f->func_file); free(f); } @@ -854,21 +837,18 @@ rpc_srv_endServer(rpc_srv_t ** __restrict psrv) int rpc_srv_loopServer(rpc_srv_t * __restrict srv) { - /* - int ret; - */ - if (!srv) { rpc_SetErr(EINVAL, "Invalid parameter can`t start RPC server"); return -1; } + fcntl(srv->srv_server.cli_sock, F_SETFL, + fcntl(srv->srv_server.cli_sock, F_GETFL) | O_NONBLOCK); + if (listen(srv->srv_server.cli_sock, io_arraySize(srv->srv_clients)) == -1) { LOGERR; return -1; - } else - fcntl(srv->srv_server.cli_sock, F_SETFL, - fcntl(srv->srv_server.cli_sock, F_GETFL) | O_NONBLOCK); + } if (!schedRead(srv->srv_root, acceptClients, srv, srv->srv_server.cli_sock, NULL, 0)) { rpc_SetErr(sched_GetErrno(), "%s", sched_GetError()); @@ -893,29 +873,13 @@ int rpc_srv_execCall(rpc_func_t * __restrict call, struct tagRPCCall * __restrict rpc, array_t * __restrict args) { - void *dl; rpc_callback_t func; - int ret; - if (!call || !rpc || !call->func_parent) { + if (!call || !rpc || !call->func_parent || !AIT_ADDR(&call->func_name)) { rpc_SetErr(EINVAL, "Invalid parameter can`t exec function"); return -1; } - dl = dlopen(AIT_ADDR(&call->func_file), RTLD_LAZY | RTLD_GLOBAL); - if (!dl) { - rpc_SetErr(ENOENT, "Can`t attach module %s!", dlerror()); - return -1; - } - - func = dlsym(dl, (const char*) AIT_GET_STR(&call->func_name)); - if (func) - ret = func(call, ntohs(rpc->call_argc), args); - else { - rpc_SetErr(ENOEXEC, "Can`t find function %s!", dlerror()); - ret = -1; - } - - dlclose(dl); - return ret; + func = AIT_GET_LIKE(&call->func_name, rpc_callback_t); + return func(call, ntohs(rpc->call_argc), args); }