--- libaitrpc/src/srv.c 2011/09/07 07:24:21 1.5 +++ libaitrpc/src/srv.c 2012/03/15 01:55:33 1.7 @@ -3,7 +3,7 @@ * by Michael Pounov * * $Author: misho $ -* $Id: srv.c,v 1.5 2011/09/07 07:24:21 misho Exp $ +* $Id: srv.c,v 1.7 2012/03/15 01:55:33 misho Exp $ * ************************************************************************** The ELWIX and AITNET software is distributed under the following @@ -12,7 +12,7 @@ terms: All of the documentation and software included in the ELWIX and AITNET Releases is copyrighted by ELWIX - Sofia/Bulgaria -Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 +Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 by Michael Pounov . All rights reserved. Redistribution and use in source and binary forms, with or without @@ -46,278 +46,427 @@ SUCH DAMAGE. #include "global.h" +static void *rxPacket(sched_task_t*); +static void *rxBLOB(sched_task_t*); + static void * +txPacket(sched_task_t *task) +{ + rpc_cli_t *c = TASK_ARG(task); + rpc_srv_t *s = c->cli_parent; + rpc_func_t *f = NULL; + u_char *buf = TASK_DATA(task); + struct tagRPCCall *rpc = (struct tagRPCCall*) buf; + int ret, wlen = sizeof(struct tagRPCCall); + array_t *arr = NULL; + + ioTRACE(RPC_TRACE_LEVEL); + + if (rpc->call_argc) { + f = rpc_srv_getCall(s, ntohs(rpc->call_tag), ntohl(rpc->call_hash)); + 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)); + /* Go Encapsulate variables */ + ret = io_vars2buffer(buf + wlen, TASK_DATLEN(task) - wlen, arr); + io_clrVars(f->func_vars); + if (ret == -1) { + rpc_SetErr(EBADRPC, "Prepare RPC packet failed"); + rpc->call_argc ^= rpc->call_argc; + rpc->call_rep.ret = RPC_ERROR(-1); + rpc->call_rep.eno = RPC_ERROR(rpc_Errno); + } else + wlen += ret; + } + } + + /* calculate CRC */ + rpc->call_crc ^= rpc->call_crc; + rpc->call_crc = htons(crcFletcher16((u_short*) buf, io_align(wlen, 1) / 2)); + + /* send reply */ + ret = send(TASK_FD(task), buf, wlen, 0); + if (ret == -1) + LOGERR; + else if (ret != wlen) + rpc_SetErr(EPROCUNAVAIL, "RPC reply, should be send %d bytes, " + "really sended %d bytes", wlen, ret); + else + ioDEBUG(RPC_DEBUG_LEVEL, "Sended %d bytes", ret); + + return NULL; +} + +static void * +execCall(sched_task_t *task) +{ + rpc_cli_t *c = TASK_ARG(task); + rpc_srv_t *s = c->cli_parent; + rpc_func_t *f = NULL; + array_t *arr = NULL; + u_char *buf = TASK_DATA(task); + struct tagRPCCall *rpc = (struct tagRPCCall*) buf; + int argc = ntohs(rpc->call_argc); + + ioTRACE(RPC_TRACE_LEVEL); + + /* Go decapsulate variables ... */ + if (!(rpc->call_req.flags & RPC_NOREPLY) && argc) { + arr = io_buffer2vars(buf + sizeof(struct tagRPCCall), + TASK_DATLEN(task) - sizeof(struct tagRPCCall), argc, 1); + if (!arr) { + rpc_SetErr(ERPCMISMATCH, "#%d - %s", io_GetErrno(), io_GetError()); + rpc->call_argc ^= rpc->call_argc; + rpc->call_rep.ret = RPC_ERROR(-1); + rpc->call_rep.eno = RPC_ERROR(rpc_Errno); + return NULL; + } + } + + if (!(f = rpc_srv_getCall(s, ntohs(rpc->call_tag), ntohl(rpc->call_hash)))) { + rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); + rpc->call_argc ^= rpc->call_argc; + rpc->call_rep.ret = RPC_ERROR(-1); + rpc->call_rep.eno = RPC_ERROR(rpc_Errno); + } else { + ioDEBUG(RPC_DEBUG_LEVEL, "RPC function %s from module %s", + AIT_GET_STR(&f->func_name), AIT_GET_LIKE(&f->func_file, char*)); + + rpc->call_rep.ret = RPC_ERROR(rpc_srv_execCall(f, rpc, arr)); + if (rpc->call_rep.ret == htonl(-1)) { + rpc->call_rep.eno = RPC_ERROR(errno); + rpc->call_argc ^= rpc->call_argc; + } else { + rpc->call_rep.eno ^= rpc->call_rep.eno; + rpc->call_argc = htons(rpc_srv_getVars(f, NULL)); + } + } + + if (arr) + io_arrayDestroy(&arr); + return NULL; +} + +static void * +rxPacket(sched_task_t *task) +{ + rpc_cli_t *c = TASK_ARG(task); + rpc_srv_t *s = c->cli_parent; + u_char *buf = TASK_DATA(task); + int rlen; + u_short crc; + struct tagRPCCall *rpc; + struct timespec ts; + + ioTRACE(RPC_TRACE_LEVEL); + + memset(buf, 0, TASK_DATLEN(task)); + rlen = recv(TASK_FD(task), buf, TASK_DATLEN(task), 0); + if (rlen == -1) { + LOGERR; + s->srv_kill = s->srv_blob.state = kill; + return NULL; + } else if (!rlen) { /* receive EOF */ + s->srv_kill = s->srv_blob.state = kill; + return NULL; + } else + ioDEBUG(RPC_DEBUG_LEVEL, "Readed %d bytes", rlen); + + if (rlen < sizeof(struct tagRPCCall)) { + rpc_SetErr(ERPCMISMATCH, "Too short RPC packet"); + + schedRead(TASK_ROOT(task), rxPacket, TASK_ARG(task), TASK_FD(task), + TASK_DATA(task), TASK_DATLEN(task)); + return NULL; + } else + rpc = (struct tagRPCCall*) buf; + + /* check integrity of packet */ + crc = ntohs(rpc->call_crc); + rpc->call_crc ^= rpc->call_crc; + if (crc != crcFletcher16((u_short*) buf, io_align(rlen, 1) / 2)) { + rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet"); + + schedRead(TASK_ROOT(task), rxPacket, TASK_ARG(task), TASK_FD(task), + TASK_DATA(task), TASK_DATLEN(task)); + return NULL; + } + + /* check RPC packet session info */ + if (rpc_chkPktSession(&rpc->call_session, &s->srv_session)) { + rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session"); + rpc->call_argc ^= rpc->call_argc; + rpc->call_rep.ret = RPC_ERROR(-1); + rpc->call_rep.eno = RPC_ERROR(errno); + goto end; + } else { + /* change socket timeout from last packet */ + ts.tv_sec = rpc->call_session.sess_timeout; + ts.tv_nsec = 0; + schedPolling(TASK_ROOT(task), &ts, NULL); + } + + /* execute RPC call */ + schedEvent(TASK_ROOT(task), execCall, TASK_ARG(task), 0, + TASK_DATA(task), TASK_DATLEN(task)); + +end: + /* send RPC reply */ + if (!(rpc->call_req.flags & RPC_NOREPLY)) + schedWrite(TASK_ROOT(task), txPacket, TASK_ARG(task), TASK_FD(task), + TASK_DATA(task), TASK_DATLEN(task)); + /* lets get next packet */ + schedRead(TASK_ROOT(task), rxPacket, TASK_ARG(task), TASK_FD(task), + TASK_DATA(task), TASK_DATLEN(task)); + return NULL; +} + +static void * rpc_srv_dispatchCall(void *arg) { rpc_cli_t *c = arg; rpc_srv_t *s; - rpc_func_t *f = NULL; - array_t *arr; - struct tagRPCCall *rpc; - struct tagRPCRet *rrpc; - rpc_sess_t ses = { 0 }; - fd_set fds; u_char *buf; - int ret, argc = 0, Limit = 0; - register int i; + sched_root_task_t *root; + struct timespec ts = { DEF_RPC_TIMEOUT, 0 }; + ioTRACE(RPC_TRACE_LEVEL); + if (!arg) { - rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t procced RPC client ...\n"); + rpc_SetErr(EINVAL, "Invalid parameter can`t procced RPC client"); return NULL; } else s = c->cli_parent; + /* allocate net buffer */ buf = malloc(s->srv_netbuf); if (!buf) { LOGERR; return NULL; } - do { - FD_ZERO(&fds); - FD_SET(c->cli_sock, &fds); - ret = select(c->cli_sock + 1, &fds, NULL, NULL, NULL); - if (ret == -1) { - if (errno == EINTR && s->srv_kill != kill) - continue; + root = schedBegin(); + if (!root) { + rpc_SetErr(sched_GetErrno(), "%s", sched_GetError()); + free(buf); + return NULL; + } else { + schedTermCondition(root, kill); + schedPolling(root, &ts, NULL); + } - LOGERR; - ret = -2; - break; - } - memset(buf, 0, s->srv_netbuf); - ret = recv(c->cli_sock, buf, s->srv_netbuf, 0); - if (ret == -1) { - LOGERR; - ret = -3; - break; - } - if (!ret) { /* receive EOF */ - ret = 0; - break; - } - if (ret < sizeof(struct tagRPCCall)) { - rpc_SetErr(ERPCMISMATCH, "Error:: too short RPC packet ...\n"); - ret = -4; - break; - } else - rpc = (struct tagRPCCall*) buf; - /* check RPC packet session info */ - if (memcmp(&rpc->call_session, &s->srv_session, sizeof rpc->call_session)) { - rpc_SetErr(ERPCMISMATCH, "Error:: get invalid RPC session ...\n"); - ret = -5; - goto makeReply; - } else - Limit = sizeof(struct tagRPCCall); + schedRead(root, rxPacket, c, c->cli_sock, buf, s->srv_netbuf); - /* RPC is OK! Go decapsulate variables ... */ - if (rpc->call_argc) { - arr = io_buffer2vals(buf + Limit, s->srv_netbuf - Limit, rpc->call_argc, 1); - if (!arr) { - ret = -5; - goto makeReply; - } - } else - arr = NULL; + schedRun(root, (void*) &s->srv_kill); + schedEnd(&root); - /* execute call */ - argc = 0; - memcpy(&ses, &rpc->call_session, sizeof ses); - if (!(f = rpc_srv_getCall(s, rpc->call_tag, rpc->call_hash))) { - rpc_SetErr(EPROGUNAVAIL, "Error:: call not found into RPC server ...\n"); - ret = -6; - } else - if ((ret = rpc_srv_execCall(f, rpc, arr)) == -1) - ret = -9; - else { - if (arr) - io_arrayDestroy(&arr); - argc = rpc_srv_getVars(f, &arr); - goto makeReply; /* Call finish OK */ - } + shutdown(c->cli_sock, SHUT_RDWR); + close(c->cli_sock); + memset(c, 0, sizeof(rpc_cli_t)); + free(buf); + return NULL; +} - if (arr) - io_arrayDestroy(&arr); -makeReply: - /* Made reply */ - memset(buf, 0, s->srv_netbuf); - rrpc = (struct tagRPCRet*) buf; - Limit = sizeof(struct tagRPCRet); +static void * +txBLOB(sched_task_t *task) +{ + u_char *buf = TASK_DATA(task); + struct tagBLOBHdr *blob = (struct tagBLOBHdr *) buf; + int wlen = sizeof(struct tagBLOBHdr); - memcpy(&rrpc->ret_session, &ses, sizeof(rpc_sess_t)); - rrpc->ret_tag = rpc->call_tag; - rrpc->ret_hash = rpc->call_hash; - rrpc->ret_errno = rpc_Errno; - rrpc->ret_retcode = ret; - rrpc->ret_argc = argc; + ioTRACE(RPC_TRACE_LEVEL); - if (argc && arr) { - /* Go Encapsulate variables ... */ - if ((i = io_vals2buffer(buf + Limit, s->srv_netbuf - Limit, arr)) == -1) { - rpc_srv_freeVals(f); - argc = 0; - ret = -7; - rpc_SetErr(EBADRPC, "Error:: in prepare RPC packet values (-7) ...\n"); - goto makeReply; - } else { - Limit += i; + /* calculate CRC */ + blob->hdr_crc ^= blob->hdr_crc; + blob->hdr_crc = htons(crcFletcher16((u_short*) buf, io_align(wlen, 1) / 2)); - rpc_srv_freeVals(f); + /* send reply */ + wlen = send(TASK_FD(task), buf, wlen, 0); + if (wlen == -1) + LOGERR; + else if (wlen != sizeof(struct tagBLOBHdr)) + rpc_SetErr(EPROCUNAVAIL, "RPC reply, should be send %d bytes, " + "really sended %d bytes", sizeof(struct tagBLOBHdr), wlen); + else + ioDEBUG(RPC_DEBUG_LEVEL, "Sended %d bytes", wlen); + + return NULL; +} + +static void * +rxBLOB(sched_task_t *task) +{ + rpc_cli_t *c = TASK_ARG(task); + rpc_srv_t *s = c->cli_parent; + rpc_blob_t *b; + u_char *buf = TASK_DATA(task); + struct tagBLOBHdr *blob = (struct tagBLOBHdr *) buf; + int rlen; + u_short crc; + struct timespec ts; + + ioTRACE(RPC_TRACE_LEVEL); + + /* check for disable service at this moment? */ + if (s->srv_blob.state == disable) { + usleep(100000); +#ifdef HAVE_PTHREAD_YIELD + pthread_yield(); +#endif + schedRead(TASK_ROOT(task), rxBLOB, TASK_ARG(task), TASK_FD(task), + TASK_DATA(task), TASK_DATLEN(task)); + return NULL; + } + + memset(buf, 0, TASK_DATLEN(task)); + rlen = recv(TASK_FD(task), buf, TASK_DATLEN(task), 0); + if (rlen == -1) { + LOGERR; + s->srv_blob.state = kill; + return NULL; + } else if (!rlen || s->srv_kill == kill) { /* receive EOF */ + s->srv_blob.state = kill; + return NULL; + } else + ioDEBUG(RPC_DEBUG_LEVEL, "Readed %d bytes", rlen); + + if (rlen < sizeof(struct tagBLOBHdr)) { + rpc_SetErr(ERPCMISMATCH, "Too short BLOB packet"); + schedRead(TASK_ROOT(task), rxBLOB, TASK_ARG(task), TASK_FD(task), + TASK_DATA(task), TASK_DATLEN(task)); + return NULL; + } + + /* check integrity of packet */ + crc = ntohs(blob->hdr_crc); + blob->hdr_crc ^= blob->hdr_crc; + if (crc != crcFletcher16((u_short*) buf, io_align(rlen, 1) / 2)) { + rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet"); + schedRead(TASK_ROOT(task), rxBLOB, TASK_ARG(task), TASK_FD(task), + TASK_DATA(task), TASK_DATLEN(task)); + return NULL; + } + + /* check RPC packet session info */ + if ((crc = rpc_chkPktSession(&blob->hdr_session, &s->srv_session))) { + rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session"); + blob->hdr_cmd = error; + goto end; + } else { + /* change socket timeout from last packet */ + ts.tv_sec = blob->hdr_session.sess_timeout; + ts.tv_nsec = 0; + schedPolling(TASK_ROOT(task), &ts, NULL); + } + + /* Go to proceed packet ... */ + switch (blob->hdr_cmd) { + case get: + if (!(b = rpc_srv_getBLOB(s, ntohl(blob->hdr_var)))) { + rpc_SetErr(EINVAL, "Var=%x not found", ntohl(blob->hdr_var)); + blob->hdr_cmd = no; + blob->hdr_ret = RPC_ERROR(-1); + break; + } else + blob->hdr_len = htonl(b->blob_len); + + if (rpc_srv_blobMap(s, b) != -1) { + /* deliver BLOB variable to client */ + blob->hdr_ret = htonl(rpc_srv_sendBLOB(c, b)); + rpc_srv_blobUnmap(b); + } else { + blob->hdr_cmd = error; + blob->hdr_ret = RPC_ERROR(-1); } - } + break; + case set: + if ((b = rpc_srv_registerBLOB(s, ntohl(blob->hdr_len)))) { + /* set new BLOB variable for reply :) */ + blob->hdr_var = htonl(b->blob_var); - ret = send(c->cli_sock, buf, Limit, 0); - if (ret == -1) { - LOGERR; - ret = -8; + /* receive BLOB from client */ + blob->hdr_ret = htonl(rpc_srv_recvBLOB(c, b)); + rpc_srv_blobUnmap(b); + } else { + blob->hdr_cmd = error; + blob->hdr_ret = RPC_ERROR(-1); + } break; - } - if (ret != Limit) { - rpc_SetErr(EPROCUNAVAIL, "Error:: in send RPC request, should be send %d bytes, " - "really is %d\n", Limit, ret); - ret = -9; + case unset: + if (rpc_srv_unregisterBLOB(s, blob->hdr_var) == -1) { + blob->hdr_cmd = error; + blob->hdr_ret = RPC_ERROR(-1); + } break; - } - } while (ret > -1 || s->srv_kill != kill); + default: + rpc_SetErr(EPROCUNAVAIL, "Unsupported BLOB command %d", blob->hdr_cmd); + blob->hdr_cmd = error; + blob->hdr_ret = RPC_ERROR(-1); + } - shutdown(c->cli_sock, SHUT_RDWR); - close(c->cli_sock); - memset(c, 0, sizeof(rpc_cli_t)); - free(buf); - return (void*) (long)ret; +end: + schedWrite(TASK_ROOT(task), txBLOB, TASK_ARG(task), TASK_FD(task), + TASK_DATA(task), TASK_DATLEN(task)); + schedRead(TASK_ROOT(task), rxBLOB, TASK_ARG(task), TASK_FD(task), + TASK_DATA(task), TASK_DATLEN(task)); + return NULL; } - static void * rpc_srv_dispatchVars(void *arg) { rpc_cli_t *c = arg; rpc_srv_t *s; - rpc_blob_t *b; - int ret = 0; - fd_set fds; - u_char buf[sizeof(struct tagBLOBHdr)]; - struct tagBLOBHdr *blob; + sched_root_task_t *root; + u_char *buf; + struct timespec ts = { DEF_RPC_TIMEOUT, 0 }; + ioTRACE(RPC_TRACE_LEVEL); + if (!arg) { - rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t procced BLOB client ...\n"); + rpc_SetErr(EINVAL, "Invalid parameter can`t procced BLOB"); return NULL; } else s = c->cli_parent; - do { - /* check for disable service at this moment? */ - if (s->srv_blob.state == disable && s->srv_kill != kill) { - usleep(100000); -#ifdef HAVE_PTHREAD_YIELD - pthread_yield(); -#endif - continue; - } + /* allocate net buffer */ + buf = malloc(sizeof(struct tagBLOBHdr)); + if (!buf) { + LOGERR; + return NULL; + } - FD_ZERO(&fds); - FD_SET(c->cli_sock, &fds); - ret = select(c->cli_sock + 1, &fds, NULL, NULL, NULL); - if (ret == -1) { - if (errno == EINTR && s->srv_kill != kill && s->srv_blob.state != kill) - continue; + root = schedBegin(); + if (!root) { + rpc_SetErr(sched_GetErrno(), "%s", sched_GetError()); + free(buf); + return NULL; + } else { + schedTermCondition(root, kill); + schedPolling(root, &ts, NULL); + } - LOGERR; - ret = -2; - break; - } + schedRead(root, rxBLOB, c, c->cli_sock, buf, sizeof(struct tagBLOBHdr)); - memset(buf, 0, sizeof buf); - ret = recv(c->cli_sock, buf, sizeof buf, 0); - if (ret == -1) { - LOGERR; - ret = -3; - break; - } - /* receive EOF, disable or kill service */ - if (!ret || s->srv_blob.state == kill || s->srv_kill == kill) { - ret = 0; - break; - } - if (ret < sizeof(struct tagBLOBHdr)) { - rpc_SetErr(ERPCMISMATCH, "Error:: too short BLOB packet ...\n"); - ret = -4; - break; - } else - blob = (struct tagBLOBHdr*) buf; - /* check BLOB packet session info */ - if (memcmp(&blob->hdr_session, &s->srv_session, sizeof blob->hdr_session)) { - rpc_SetErr(EINVAL, "Error:: get invalid BLOB session ...\n"); - ret = -5; - goto makeReply; - } - /* Go to proceed packet ... */ - switch (blob->hdr_cmd) { - 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; - } else - blob->hdr_len = b->blob_len; + schedRun(root, (void*) &s->srv_blob.state); + schedEnd(&root); - if (rpc_srv_blobMap(s, b) != -1) { - ret = rpc_srv_sendBLOB(c, b); - rpc_srv_blobUnmap(b); - } else - ret = -7; - break; - case set: - if ((b = rpc_srv_registerBLOB(s, blob->hdr_len))) { - /* set new BLOB variable for reply :) */ - blob->hdr_var = b->blob_var; - - ret = rpc_srv_recvBLOB(c, b); - rpc_srv_blobUnmap(b); - } else - ret = -7; - break; - case unset: - ret = rpc_srv_unregisterBLOB(s, blob->hdr_var); - if (ret == -1) - ret = -7; - break; - default: - rpc_SetErr(EPROCUNAVAIL, "Error:: unsupported BLOB command (%d)...\n", - blob->hdr_cmd); - ret = -7; - } - -makeReply: - /* Replay to client! */ - blob->hdr_cmd = ret < 0 ? error : ok; - blob->hdr_ret = ret; - ret = send(c->cli_sock, buf, sizeof buf, 0); - if (ret == -1) { - LOGERR; - ret = -8; - break; - } - if (ret != sizeof buf) { - rpc_SetErr(EPROCUNAVAIL, "Error:: in send BLOB reply, should be send %d bytes, " - "really is %d\n", sizeof buf, ret); - ret = -9; - break; - } - } while (ret > -1 || s->srv_kill != kill); - shutdown(c->cli_sock, SHUT_RDWR); close(c->cli_sock); memset(c, 0, sizeof(rpc_cli_t)); - return (void*) ((long)ret); + free(buf); + return NULL; } // ------------------------------------------------- /* - * rpc_srv_initBLOBServer() Init & create BLOB Server + * rpc_srv_initBLOBServer() - Init & create BLOB Server + * * @srv = RPC server instance * @Port = Port for bind server, if Port == 0 default port is selected * @diskDir = Disk place for BLOB file objects @@ -327,76 +476,77 @@ int rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_short Port, const char *diskDir) { int n = 1; - struct sockaddr sa; - struct sockaddr_in *sin = (struct sockaddr_in*) &sa; - struct sockaddr_in6 *sin6 = (struct sockaddr_in6*) &sa; - struct sockaddr_un *sun = (struct sockaddr_un*) &sa; + io_sockaddr_t sa; + ioTRACE(RPC_TRACE_LEVEL); + if (!srv) { - rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t init BLOB server ...\n"); + rpc_SetErr(EINVAL, "Invalid parameters can`t init BLOB server"); return -1; } if (srv->srv_blob.state) { - rpc_SetErr(EPERM, "Warning:: Already started BLOB server!\n"); + rpc_SetErr(EPERM, "Already started BLOB server!"); return 0; } - if (!Port) - Port = RPC_DEFPORT + 1; memset(&srv->srv_blob, 0, sizeof srv->srv_blob); if (access(diskDir, R_OK | W_OK) == -1) { LOGERR; return -1; } else - strlcpy(srv->srv_blob.dir, diskDir, UCHAR_MAX + 1); + AIT_SET_STR(&srv->srv_blob.dir, diskDir); srv->srv_blob.server.cli_tid = pthread_self(); srv->srv_blob.server.cli_parent = srv; memcpy(&sa, &srv->srv_server.cli_sa, sizeof sa); - switch (srv->srv_server.cli_sa.sa_family) { + switch (sa.sa.sa_family) { case AF_INET: - sin->sin_port = htons(Port); - memcpy(&srv->srv_blob.server.cli_sa, sin, sizeof(struct sockaddr)); + sa.sin.sin_port = htons(Port ? Port : ntohs(sa.sin.sin_port) + 1); break; case AF_INET6: - sin6->sin6_port = htons(Port); - memcpy(&srv->srv_blob.server.cli_sa, sin6, sizeof(struct sockaddr)); + sa.sin6.sin6_port = htons(Port ? Port : ntohs(sa.sin6.sin6_port) + 1); break; case AF_LOCAL: - strlcat(sun->sun_path, ".blob", sizeof sun->sun_path); - memcpy(&srv->srv_blob.server.cli_sa, sun, sizeof(struct sockaddr)); + strlcat(sa.sun.sun_path, ".blob", sizeof sa.sun.sun_path); break; default: + 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_family, SOCK_STREAM, 0); + srv->srv_blob.server.cli_sock = socket(srv->srv_server.cli_sa.sa.sa_family, SOCK_STREAM, 0); if (srv->srv_blob.server.cli_sock == -1) { LOGERR; + AIT_FREE_VAL(&srv->srv_blob.dir); return -1; } if (setsockopt(srv->srv_blob.server.cli_sock, SOL_SOCKET, SO_REUSEADDR, &n, sizeof n) == -1) { LOGERR; close(srv->srv_blob.server.cli_sock); + AIT_FREE_VAL(&srv->srv_blob.dir); return -1; } n = srv->srv_netbuf; if (setsockopt(srv->srv_blob.server.cli_sock, SOL_SOCKET, SO_SNDBUF, &n, sizeof n) == -1) { LOGERR; close(srv->srv_blob.server.cli_sock); + AIT_FREE_VAL(&srv->srv_blob.dir); return -1; } if (setsockopt(srv->srv_blob.server.cli_sock, SOL_SOCKET, SO_RCVBUF, &n, sizeof n) == -1) { LOGERR; close(srv->srv_blob.server.cli_sock); + AIT_FREE_VAL(&srv->srv_blob.dir); return -1; } - if (bind(srv->srv_blob.server.cli_sock, &srv->srv_blob.server.cli_sa, - sizeof srv->srv_blob.server.cli_sa) == -1) { + if (bind(srv->srv_blob.server.cli_sock, &srv->srv_blob.server.cli_sa.sa, + srv->srv_blob.server.cli_sa.sa.sa_len) == -1) { LOGERR; close(srv->srv_blob.server.cli_sock); + AIT_FREE_VAL(&srv->srv_blob.dir); return -1; } @@ -405,6 +555,7 @@ rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s if (!srv->srv_blob.clients) { LOGERR; 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)); @@ -421,7 +572,8 @@ rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s } /* - * rpc_srv_endBLOBServer() Destroy BLOB server, close all opened sockets and free resources + * rpc_srv_endBLOBServer() - Destroy BLOB server, close all opened sockets and free resources + * * @srv = RPC Server instance * return: none */ @@ -432,8 +584,10 @@ rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) register int i; rpc_blob_t *f; + ioTRACE(RPC_TRACE_LEVEL); + if (!srv) { - rpc_SetErr(EINVAL, "Error:: Can`t destroy server because parameter is null!\n"); + rpc_SetErr(EINVAL, "Can`t destroy server because parameter is null!"); return; } else srv->srv_blob.state = kill; @@ -445,7 +599,7 @@ rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) /* 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_family) + if (c->cli_sa.sa.sa_family) shutdown(c->cli_sock, SHUT_RDWR); close(srv->srv_blob.server.cli_sock); @@ -463,38 +617,50 @@ rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) } pthread_mutex_unlock(&srv->srv_blob.mtx); + AIT_FREE_VAL(&srv->srv_blob.dir); + while (pthread_mutex_trylock(&srv->srv_blob.mtx) == EBUSY); pthread_mutex_destroy(&srv->srv_blob.mtx); } /* - * 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 + * * @srv = RPC Server instance * return: -1 error or 0 ok, infinite loop ... */ int rpc_srv_loopBLOB(rpc_srv_t * __restrict srv) { - socklen_t salen = sizeof(struct sockaddr); + socklen_t salen = sizeof(io_sockaddr_t); register int i; rpc_cli_t *c; fd_set fds; int ret; struct timeval tv = { DEF_RPC_TIMEOUT, 0 }; + pthread_attr_t attr; + ioTRACE(RPC_TRACE_LEVEL); + if (!srv || srv->srv_blob.state == kill) { - rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t start BLOB server ...\n"); + rpc_SetErr(EINVAL, "Invalid parameter can`t start BLOB server"); return -1; } + tv.tv_sec = srv->srv_session.sess_timeout; + if (listen(srv->srv_blob.server.cli_sock, SOMAXCONN) == -1) { LOGERR; return -1; } + pthread_attr_init(&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + + /* 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++) - if (!c->cli_sa.sa_family) + if (!c->cli_sa.sa.sa_family) break; if (i >= srv->srv_numcli) { #ifdef HAVE_PTHREAD_YIELD @@ -516,28 +682,30 @@ rpc_srv_loopBLOB(rpc_srv_t * __restrict srv) if (!ret) continue; - c->cli_sock = accept(srv->srv_blob.server.cli_sock, &c->cli_sa, &salen); + 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; - if (pthread_create(&c->cli_tid, NULL, rpc_srv_dispatchVars, c)) { + /* spawn dispatch thread for BLOB client */ + if (pthread_create(&c->cli_tid, &attr, rpc_srv_dispatchVars, c)) { LOGERR; continue; - } else - pthread_detach(c->cli_tid); + } } srv->srv_blob.state = kill; + pthread_attr_destroy(&attr); return 0; } /* - * rpc_srv_initServer() Init & create RPC Server + * rpc_srv_initServer() - Init & create RPC Server + * * @regProgID = ProgramID for authentication & recognition * @regProcID = ProcessID for authentication & recognition * @concurentClients = Concurent clients at same time to this server @@ -554,11 +722,10 @@ rpc_srv_initServer(u_int regProgID, u_int regProcID, i rpc_srv_t *srv = NULL; int n = 1; struct hostent *host = NULL; - struct sockaddr sa; - struct sockaddr_in *sin = (struct sockaddr_in*) &sa; - struct sockaddr_in6 *sin6 = (struct sockaddr_in6*) &sa; - struct sockaddr_un *sun = (struct sockaddr_un*) &sa; + io_sockaddr_t sa; + ioTRACE(RPC_TRACE_LEVEL); + if (!concurentClients || !regProgID || (family != AF_INET && family != AF_INET6 && family != AF_LOCAL)) { rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t init RPC server ...\n"); @@ -568,6 +735,8 @@ rpc_srv_initServer(u_int regProgID, u_int regProcID, i Port = RPC_DEFPORT; if (!netBuf) netBuf = BUFSIZ; + else + netBuf = io_align(netBuf, 1); /* align netBuf length */ if (csHost && family != AF_LOCAL) { host = gethostbyname2(csHost, family); if (!host) { @@ -576,24 +745,25 @@ rpc_srv_initServer(u_int regProgID, u_int regProcID, i } } memset(&sa, 0, sizeof sa); - sa.sa_family = family; + sa.sa.sa_family = family; switch (family) { case AF_INET: - sin->sin_len = sizeof(struct sockaddr_in); - sin->sin_port = htons(Port); + sa.sin.sin_len = sizeof(struct sockaddr_in); + sa.sin.sin_port = htons(Port); if (csHost) - memcpy(&sin->sin_addr, host->h_addr, host->h_length); + memcpy(&sa.sin.sin_addr, host->h_addr, host->h_length); break; case AF_INET6: - sin6->sin6_len = sizeof(struct sockaddr_in6); - sin6->sin6_port = htons(Port); + sa.sin6.sin6_len = sizeof(struct sockaddr_in6); + sa.sin6.sin6_port = htons(Port); if (csHost) - memcpy(&sin6->sin6_addr, host->h_addr, host->h_length); + memcpy(&sa.sin6.sin6_addr, host->h_addr, host->h_length); break; case AF_LOCAL: - sun->sun_len = sizeof(struct sockaddr_un); + sa.sun.sun_len = sizeof(struct sockaddr_un); if (csHost) - strlcpy(sun->sun_path, csHost, sizeof sun->sun_path); + strlcpy(sa.sun.sun_path, csHost, sizeof sa.sun.sun_path); + unlink(sa.sun.sun_path); break; default: rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t start RPC server ...\n"); @@ -610,23 +780,13 @@ rpc_srv_initServer(u_int regProgID, u_int regProcID, i srv->srv_netbuf = netBuf; srv->srv_numcli = concurentClients; 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; srv->srv_server.cli_tid = pthread_self(); srv->srv_server.cli_parent = srv; - switch (family) { - case AF_INET: - memcpy(&srv->srv_server.cli_sa, sin, sizeof srv->srv_server.cli_sa); - break; - case AF_INET6: - memcpy(&srv->srv_server.cli_sa, sin6, sizeof srv->srv_server.cli_sa); - break; - case AF_LOCAL: - memcpy(&srv->srv_server.cli_sa, sun, sizeof srv->srv_server.cli_sa); - unlink(sun->sun_path); - break; - } + memcpy(&srv->srv_server.cli_sa, &sa, sizeof sa); /* create server socket */ srv->srv_server.cli_sock = socket(family, SOCK_STREAM, 0); @@ -654,7 +814,8 @@ rpc_srv_initServer(u_int regProgID, u_int regProcID, i free(srv); return NULL; } - if (bind(srv->srv_server.cli_sock, &srv->srv_server.cli_sa, sizeof srv->srv_server.cli_sa) == -1) { + if (bind(srv->srv_server.cli_sock, &srv->srv_server.cli_sa.sa, + srv->srv_server.cli_sa.sa.sa_len) == -1) { LOGERR; close(srv->srv_server.cli_sock); free(srv); @@ -681,73 +842,85 @@ rpc_srv_initServer(u_int regProgID, u_int regProcID, i } /* - * rpc_srv_endServer() Destroy RPC server, close all opened sockets and free resources - * @srv = RPC Server instance + * rpc_srv_endServer() - Destroy RPC server, close all opened sockets and free resources + * + * @psrv = RPC Server instance * return: none */ void -rpc_srv_endServer(rpc_srv_t * __restrict srv) +rpc_srv_endServer(rpc_srv_t ** __restrict psrv) { rpc_cli_t *c; register int i; rpc_func_t *f; - if (!srv) { + ioTRACE(RPC_TRACE_LEVEL); + + if (!psrv || !*psrv) { rpc_SetErr(EINVAL, "Error:: Can`t destroy server because parameter is null!\n"); return; } - rpc_srv_endBLOBServer(srv); + rpc_srv_endBLOBServer(*psrv); /* close all clients connections & server socket */ - for (i = 0, c = srv->srv_clients; i < srv->srv_numcli && c; i++, c++) - if (c->cli_sa.sa_family) { + for (i = 0, c = (*psrv)->srv_clients; i < (*psrv)->srv_numcli && c; i++, c++) + if (c->cli_sa.sa.sa_family) { shutdown(c->cli_sock, SHUT_RDWR); close(c->cli_sock); } - close(srv->srv_server.cli_sock); + close((*psrv)->srv_server.cli_sock); - if (srv->srv_clients) { - free(srv->srv_clients); - srv->srv_clients = NULL; - srv->srv_numcli = 0; + if ((*psrv)->srv_clients) { + free((*psrv)->srv_clients); + (*psrv)->srv_clients = NULL; + (*psrv)->srv_numcli = 0; } /* detach exported calls */ - pthread_mutex_lock(&srv->srv_mtx); - while ((f = srv->srv_funcs)) { - srv->srv_funcs = f->func_next; + pthread_mutex_lock(&(*psrv)->srv_mtx); + while ((f = (*psrv)->srv_funcs)) { + (*psrv)->srv_funcs = f->func_next; + io_freeVars(&f->func_vars); + AIT_FREE_VAL(&f->func_name); + AIT_FREE_VAL(&f->func_file); free(f); } - pthread_mutex_unlock(&srv->srv_mtx); + pthread_mutex_unlock(&(*psrv)->srv_mtx); - while (pthread_mutex_trylock(&srv->srv_mtx) == EBUSY); - pthread_mutex_destroy(&srv->srv_mtx); + while (pthread_mutex_trylock(&(*psrv)->srv_mtx) == EBUSY); + pthread_mutex_destroy(&(*psrv)->srv_mtx); - free(srv); - srv = NULL; + free(*psrv); + *psrv = NULL; } /* - * rpc_srv_loopServer() Execute Main server loop and wait for clients requests + * rpc_srv_loopServer() - Execute Main server loop and wait for clients requests + * * @srv = RPC Server instance * return: -1 error or 0 ok, infinite loop ... */ int rpc_srv_loopServer(rpc_srv_t * __restrict srv) { - socklen_t salen = sizeof(struct sockaddr); + socklen_t salen = sizeof(io_sockaddr_t); register int i; rpc_cli_t *c; fd_set fds; int ret; struct timeval tv = { DEF_RPC_TIMEOUT, 0 }; + pthread_attr_t attr; + ioTRACE(RPC_TRACE_LEVEL); + if (!srv) { rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t start RPC server ...\n"); return -1; } + tv.tv_sec = srv->srv_session.sess_timeout; + /* activate BLOB server worker if srv->srv_blob.state == enable */ rpc_srv_execBLOBServer(srv); @@ -756,9 +929,13 @@ rpc_srv_loopServer(rpc_srv_t * __restrict srv) return -1; } + pthread_attr_init(&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + + /* main rpc loop */ while (srv->srv_kill != kill) { 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.sa_family) break; if (i >= srv->srv_numcli) { #ifdef HAVE_PTHREAD_YIELD @@ -780,20 +957,21 @@ rpc_srv_loopServer(rpc_srv_t * __restrict srv) if (!ret) continue; - c->cli_sock = accept(srv->srv_server.cli_sock, &c->cli_sa, &salen); + c->cli_sock = accept(srv->srv_server.cli_sock, &c->cli_sa.sa, &salen); if (c->cli_sock == -1) { LOGERR; continue; } else c->cli_parent = srv; - if (pthread_create(&c->cli_tid, NULL, rpc_srv_dispatchCall, c)) { + /* spawn rpc client dispatcher */ + if (pthread_create(&c->cli_tid, &attr, rpc_srv_dispatchCall, c)) { LOGERR; continue; - } else - pthread_detach(c->cli_tid); + } } + pthread_attr_destroy(&attr); return 0; } @@ -801,6 +979,7 @@ rpc_srv_loopServer(rpc_srv_t * __restrict srv) /* * rpc_srv_execCall() Execute registered call from RPC server + * * @call = Register RPC call * @rpc = IN RPC call structure * @args = IN RPC calling arguments from RPC client @@ -814,22 +993,24 @@ rpc_srv_execCall(rpc_func_t * __restrict call, struct rpc_callback_t func; int ret; + ioTRACE(RPC_TRACE_LEVEL); + if (!call || !rpc || !call->func_parent) { - rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t exec call from RPC server ...\n"); + rpc_SetErr(EINVAL, "Invalid parameter can`t exec function"); return -1; } - dl = dlopen((char*) (*call->func_file ? call->func_file : NULL), RTLD_NOW); + dl = dlopen(AIT_VOID(&call->func_file), RTLD_NOW); if (!dl) { - rpc_SetErr(ENOENT, "Error:: Can`t attach module %s!\n", dlerror()); + rpc_SetErr(ENOENT, "Can`t attach module %s!", dlerror()); return -1; } - func = dlsym(dl, (char*) call->func_name); + func = dlsym(dl, (const char*) AIT_GET_STR(&call->func_name)); if (func) - ret = func(call, rpc->call_argc, args); + ret = func(call, ntohs(rpc->call_argc), args); else { - rpc_SetErr(ENOEXEC, "Error:: Can`t find function %s!\n", dlerror()); + rpc_SetErr(ENOEXEC, "Can`t find function %s!", dlerror()); ret = -1; }