--- libaitrpc/src/cli.c 2011/11/03 15:32:21 1.6 +++ libaitrpc/src/cli.c 2012/03/15 00:44:24 1.6.2.3 @@ -3,7 +3,7 @@ * by Michael Pounov * * $Author: misho $ -* $Id: cli.c,v 1.6 2011/11/03 15:32:21 misho Exp $ +* $Id: cli.c,v 1.6.2.3 2012/03/15 00:44:24 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 @@ -47,7 +47,8 @@ SUCH DAMAGE. /* - * rpc_cli_openBLOBClient() Connect to BLOB Server + * rpc_cli_openBLOBClient() - Connect to BLOB Server + * * @rpccli = RPC Client session * @Port = Port for bind server, if Port == 0 default port is selected * return: NULL == error or !=NULL connection to BLOB server established @@ -62,7 +63,7 @@ rpc_cli_openBLOBClient(rpc_cli_t * __restrict rpccli, if (!rpccli || (rpccli->cli_sa.sa.sa_family != AF_INET && rpccli->cli_sa.sa.sa_family != AF_INET6 && rpccli->cli_sa.sa.sa_family != AF_LOCAL)) { - rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t connect to BLOB server ...\n"); + rpc_SetErr(EINVAL, "Invalid parameters can`t connect to BLOB server"); return NULL; } @@ -118,7 +119,8 @@ rpc_cli_openBLOBClient(rpc_cli_t * __restrict rpccli, } /* - * rpc_cli_closeBLOBClient() Close connection to BLOB server and free resources + * rpc_cli_closeBLOBClient() - Close connection to BLOB server and free resources + * * @cli = BLOB Client session * return: none */ @@ -126,7 +128,7 @@ void rpc_cli_closeBLOBClient(rpc_cli_t * __restrict cli) { if (!cli) { - rpc_SetErr(EINVAL, "Error:: Can`t close connection because parameter is null!\n"); + rpc_SetErr(EINVAL, "Can`t close connection because parameter is null!"); return; } @@ -140,17 +142,20 @@ rpc_cli_closeBLOBClient(rpc_cli_t * __restrict cli) // -------------------------------------------------------------- /* - * rpc_cli_openClient() Connect to RPC Server + * rpc_cli_openClient() - Connect to RPC Server + * * @ProgID = ProgramID for RPC session request * @ProcID = ProcessID for RPC session request * @netBuf = Network buffer length, if =0 == BUFSIZ (also meaning max RPC packet) + * @Timeout = RPC timeout in seconds, if =0 set default RPC timeout * @family = Family socket type, AF_INET or AF_INET6 * @csHost = Host name or IP address for bind server * @Port = Port for bind server, if Port == 0 default port is selected * return: NULL == error or !=NULL connection to RPC server established */ rpc_cli_t * -rpc_cli_openClient(u_int ProgID, u_int ProcID, int netBuf, u_short family, const char *csHost, u_short Port) +rpc_cli_openClient(u_int ProgID, u_int ProcID, int netBuf, u_char Timeout, + u_short family, const char *csHost, u_short Port) { rpc_cli_t *cli = NULL; struct hostent *host = NULL; @@ -165,6 +170,8 @@ rpc_cli_openClient(u_int ProgID, u_int ProcID, int net Port = RPC_DEFPORT; if (!netBuf) netBuf = BUFSIZ; + if (!Timeout) + Timeout = DEF_RPC_TIMEOUT; if (csHost && family != AF_LOCAL) { host = gethostbyname2(csHost, family); if (!host) { @@ -212,6 +219,7 @@ rpc_cli_openClient(u_int ProgID, u_int ProcID, int net return NULL; } else { ((rpc_sess_t*) cli->cli_parent)->sess_version = RPC_VERSION; + ((rpc_sess_t*) cli->cli_parent)->sess_timeout = Timeout; ((rpc_sess_t*) cli->cli_parent)->sess_program = ProgID; ((rpc_sess_t*) cli->cli_parent)->sess_process = ProcID; } @@ -253,7 +261,8 @@ rpc_cli_openClient(u_int ProgID, u_int ProcID, int net } /* - * rpc_cli_closeClient() Close connection to RPC server and free resources + * rpc_cli_closeClient() - Close connection to RPC server and free resources + * * @cli = RPC Client session * return: none */ @@ -261,7 +270,7 @@ void rpc_cli_closeClient(rpc_cli_t * __restrict cli) { if (!cli) { - rpc_SetErr(EINVAL, "Error:: Can`t close connection because parameter is null!\n"); + rpc_SetErr(EINVAL, "Can`t close connection because parameter is null!"); return; } @@ -276,7 +285,8 @@ rpc_cli_closeClient(rpc_cli_t * __restrict cli) /* - * rpc_cli_execCall() Execute RPC call + * rpc_cli_execCall() - Execute RPC call + * * @cli = RPC Client session * @csModule = Module name, if NULL self binary * @csFunc = Function name for execute @@ -289,16 +299,16 @@ rpc_cli_execCall(rpc_cli_t *cli, const char *csModule, array_t * __restrict in_vars, array_t ** __restrict out_vars) { fd_set fds; - u_char *buf, str[MAXPATHLEN + UCHAR_MAX + 1]; + u_char *buf; + rpc_func_t func; struct tagRPCCall *rpc; - struct tagRPCRet *rrpc = NULL; - int ret = 0, Limit = 0; + int ret = 0, wlen = sizeof(struct tagRPCCall); struct timeval tv = { DEF_RPC_TIMEOUT, 0 }; uint16_t tag; uint32_t hash; if (!cli || !csFunc) { - rpc_SetErr(EINVAL, "Error:: Can`t execute call because parameter is null or invalid!\n"); + rpc_SetErr(EINVAL, "Can`t execute call because parameter is null or invalid!"); return -1; } if (out_vars) @@ -311,42 +321,47 @@ rpc_cli_execCall(rpc_cli_t *cli, const char *csModule, } else memset(buf, 0, cli->cli_netbuf); - /* build RPC call string for hash */ - memset(str, 0, sizeof str); - if (csModule) - strlcpy((char*) str, csModule, sizeof str); - strlcat((char*) str, "__", sizeof str); - strlcat((char*) str, csFunc, sizeof str); + /* calculate hashes */ + if (rpc_calcHashes(&func, csModule, csFunc) == -1) + return -1; + else { + tag = htons(func.func_tag); + hash = htonl(func.func_hash); + AIT_FREE_VAL(&func.func_name); + AIT_FREE_VAL(&func.func_file); + } /* prepare RPC call */ rpc = (struct tagRPCCall*) buf; rpc_addPktSession(&rpc->call_session, cli->cli_parent); rpc->call_argc = htons(io_arraySize(in_vars)); - rpc->call_tag = tag = htons(crcFletcher16((u_short*) str, sizeof str / 2)); - rpc->call_hash = hash = htonl(hash_fnv((char*) str, sizeof str)); - Limit = sizeof(struct tagRPCCall); + rpc->call_tag = tag; + rpc->call_hash = hash; if (io_arraySize(in_vars)) { /* marshaling variables */ - ret = io_vars2buffer(buf + Limit, cli->cli_netbuf - Limit, in_vars); + ret = io_vars2buffer(buf + wlen, cli->cli_netbuf - wlen, in_vars); if (ret == -1) { - rpc_SetErr(EBADRPC, "Error:: in prepare RPC packet values (-7) ...\n"); + rpc_SetErr(EBADRPC, "Failed to prepare RPC packet values"); free(buf); - return -7; + return -1; } else - Limit += ret; + wlen += ret; } - if ((ret = send(cli->cli_sock, buf, Limit, 0)) == -1) { + /* calculate CRC */ + rpc->call_crc ^= rpc->call_crc; + rpc->call_crc = htons(crcFletcher16((u_short*) buf, io_align(wlen, 1) / 2)); + + if ((ret = send(cli->cli_sock, buf, wlen, 0)) == -1) { LOGERR; free(buf); return -1; - } - if (ret != Limit) { - rpc_SetErr(EPROCUNAVAIL, "Error:: in send RPC request, should be send %d bytes, really is %d\n", - Limit, ret); + } else if (ret != wlen) { + rpc_SetErr(EPROCUNAVAIL, "RPC request, should be send %d bytes, " + "really sended %d bytes", wlen, ret); free(buf); - return -9; + return -1; } /* reply from RPC server */ @@ -371,48 +386,47 @@ rpc_cli_execCall(rpc_cli_t *cli, const char *csModule, free(buf); return 0; } - if (ret < sizeof(struct tagRPCRet)) { + if (ret < sizeof(struct tagRPCCall)) { rpc_SetErr(ERPCMISMATCH, "Error:: too short RPC packet ...\n"); free(buf); return -4; - } else - rrpc = (struct tagRPCRet*) buf; + } /* check RPC packet session info */ - if (rpc_chkPktSession(&rrpc->ret_session, cli->cli_parent)) { + if (rpc_chkPktSession(&rpc->call_session, cli->cli_parent)) { rpc_SetErr(ERPCMISMATCH, "Error:: get invalid RPC session ...\n"); free(buf); return -5; } else - Limit = sizeof(struct tagRPCRet); - if (rrpc->ret_tag != tag || rrpc->ret_hash != hash) { + wlen = sizeof(struct tagRPCCall); + if (rpc->call_tag != tag || rpc->call_hash != hash) { rpc_SetErr(ERPCMISMATCH, "Error:: get wrong RPC reply ...\n"); free(buf); return -5; } - if (ntohl(rrpc->ret_retcode) < 0 && ntohl(rrpc->ret_errno)) { - rpc_SetErr(ntohl(rrpc->ret_errno), "Error::Server side: retcode=%d #%d %s\n", - ntohl(rrpc->ret_retcode), ntohl(rrpc->ret_errno), - strerror(ntohl(rrpc->ret_errno))); + if (ntohl(rpc->call_rep.ret) < 0 && ntohl(rpc->call_rep.eno)) { + rpc_SetErr(ntohl(rpc->call_rep.eno), "Error::Server side: retcode=%d #%d %s\n", + ntohl(rpc->call_rep.ret), ntohl(rpc->call_rep.eno), + strerror(ntohl(rpc->call_rep.eno))); free(buf); return -6; } - if (ntohs(rrpc->ret_argc) * sizeof(ait_val_t) > cli->cli_netbuf - Limit) { + if (ntohs(rpc->call_argc) * sizeof(ait_val_t) > cli->cli_netbuf - wlen) { rpc_SetErr(EMSGSIZE, "Error:: reply RPC packet is too long ...\n"); free(buf); return -7; } /* RPC is OK! Go de-marshaling variables ... */ - if (ntohs(rrpc->ret_argc)) { - *out_vars = io_buffer2vars(buf + Limit, cli->cli_netbuf - Limit, - ntohs(rrpc->ret_argc), 0); + if (ntohs(rpc->call_argc)) { + *out_vars = io_buffer2vars(buf + wlen, cli->cli_netbuf - wlen, + ntohs(rpc->call_argc), 0); if (!*out_vars) { free(buf); return -1; } } - ret = ntohl(rrpc->ret_retcode); + ret = ntohl(rpc->call_rep.ret); free(buf); return ret; }