--- libaitrpc/src/cli.c	2011/05/02 23:12:08	1.2
+++ libaitrpc/src/cli.c	2011/09/07 07:24:21	1.5
@@ -3,7 +3,7 @@
 *  by Michael Pounov <misho@openbsd-bg.org>
 *
 * $Author: misho $
-* $Id: cli.c,v 1.2 2011/05/02 23:12:08 misho Exp $
+* $Id: cli.c,v 1.5 2011/09/07 07:24:21 misho Exp $
 *
 **************************************************************************
 The ELWIX and AITNET software is distributed under the following
@@ -56,10 +56,15 @@ rpc_cli_t *
 rpc_cli_openBLOBClient(rpc_cli_t * __restrict rpccli, u_short Port)
 {
 	rpc_cli_t *cli = NULL;
-	struct sockaddr_in sin;
-	struct sockaddr_in6 sin6;
+	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;
+	int n;
 
-	if (!rpccli || (rpccli->cli_sa.sa_family != AF_INET && rpccli->cli_sa.sa_family != AF_INET6)) {
+	if (!rpccli || 
+			(rpccli->cli_sa.sa_family != AF_INET && rpccli->cli_sa.sa_family != AF_INET6 && 
+			 rpccli->cli_sa.sa_family != AF_LOCAL)) {
 		rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t connect to BLOB server ...\n");
 		return NULL;
 	}
@@ -73,24 +78,45 @@ rpc_cli_openBLOBClient(rpc_cli_t * __restrict rpccli, 
 	} else
 		memcpy(cli, rpccli, sizeof(rpc_cli_t));
 
-	if (rpccli->cli_sa.sa_family == AF_INET) {
-		memcpy(&sin, &rpccli->cli_sa, sizeof sin);
-		sin.sin_port = htons(Port);
-		memcpy(&cli->cli_sa, &sin, sizeof(struct sockaddr));
-	} else {
-		memcpy(&sin6, &rpccli->cli_sa, sizeof sin6);
-		sin6.sin6_port = htons(Port);
-		memcpy(&cli->cli_sa, &sin6, sizeof(struct sockaddr));
+	memcpy(&sa, &rpccli->cli_sa, sizeof sa);
+	switch (rpccli->cli_sa.sa_family) {
+		case AF_INET:
+			sin->sin_port = htons(Port);
+			memcpy(&cli->cli_sa, sin, sizeof(struct sockaddr));
+			break;
+		case AF_INET6:
+			sin6->sin6_port = htons(Port);
+			memcpy(&cli->cli_sa, sin6, sizeof(struct sockaddr));
+			break;
+		case AF_LOCAL:
+			strlcat(sun->sun_path, ".blob", sizeof sun->sun_path);
+			memcpy(&cli->cli_sa, sun, sizeof(struct sockaddr));
+			break;
 	}
 
+	/* connect to BLOB server */
 	cli->cli_sock = socket(cli->cli_sa.sa_family, SOCK_STREAM, 0);
 	if (cli->cli_sock == -1) {
 		LOGERR;
 		free(cli);
 		return NULL;
 	}
+	n = cli->cli_netbuf;
+	if (setsockopt(cli->cli_sock, SOL_SOCKET, SO_SNDBUF, &n, sizeof n) == -1) {
+		LOGERR;
+		close(cli->cli_sock);
+		free(cli);
+		return NULL;
+	}
+	if (setsockopt(cli->cli_sock, SOL_SOCKET, SO_RCVBUF, &n, sizeof n) == -1) {
+		LOGERR;
+		close(cli->cli_sock);
+		free(cli);
+		return NULL;
+	}
 	if (connect(cli->cli_sock, &cli->cli_sa, sizeof cli->cli_sa) == -1) {
 		LOGERR;
+		close(cli->cli_sock);
 		free(cli);
 		return NULL;
 	}
@@ -124,49 +150,58 @@ rpc_cli_closeBLOBClient(rpc_cli_t * __restrict cli)
  * 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)
  * @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, u_short family, const char *csHost, u_short Port)
+rpc_cli_openClient(u_int ProgID, u_int ProcID, int netBuf, u_short family, const char *csHost, u_short Port)
 {
 	rpc_cli_t *cli = NULL;
 	struct hostent *host = NULL;
-	struct sockaddr_in sin;
-	struct sockaddr_in6 sin6;
+	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;
+	int n;
 
-	if (!csHost || (family != AF_INET && family != AF_INET6)) {
+	if (!csHost || (family != AF_INET && family != AF_INET6 && family != AF_LOCAL)) {
 		rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t connect to RPC server ...\n");
 		return NULL;
 	}
 	if (!Port)
 		Port = RPC_DEFPORT;
-	if (csHost) {
+	if (!netBuf)
+		netBuf = BUFSIZ;
+	if (csHost && family != AF_LOCAL) {
 		host = gethostbyname2(csHost, family);
 		if (!host) {
 			rpc_SetErr(h_errno, "Error:: %s\n", hstrerror(h_errno));
 			return NULL;
 		}
 	}
+	memset(&sa, 0, sizeof sa);
+	sa.sa_family = family;
 	switch (family) {
 		case AF_INET:
-			memset(&sin, 0, sizeof sin);
-			sin.sin_len = sizeof sin;
-			sin.sin_family = family;
-			sin.sin_port = htons(Port);
+			sin->sin_len = sizeof(struct sockaddr_in);
+			sin->sin_port = htons(Port);
 			if (csHost)
-				memcpy(&sin.sin_addr, host->h_addr, host->h_length);
+				memcpy(&sin->sin_addr, host->h_addr, host->h_length);
 			break;
 		case AF_INET6:
-			memset(&sin6, 0, sizeof sin6);
-			sin6.sin6_len = sizeof sin6;
-			sin6.sin6_family = family;
-			sin6.sin6_port = htons(Port);
+			sin6->sin6_len = sizeof(struct sockaddr_in6);
+			sin6->sin6_port = htons(Port);
 			if (csHost)
-				memcpy(&sin6.sin6_addr, host->h_addr, host->h_length);
+				memcpy(&sin6->sin6_addr, host->h_addr, host->h_length);
 			break;
+		case AF_LOCAL:
+			sun->sun_len = sizeof(struct sockaddr_un);
+			if (csHost)
+				strlcpy(sun->sun_path, csHost, sizeof sun->sun_path);
+			break;
 		default:
 			rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t connect to RPC server ...\n");
 			return NULL;
@@ -178,6 +213,8 @@ rpc_cli_openClient(u_int ProgID, u_int ProcID, u_short
 		return NULL;
 	} else
 		memset(cli, 0, sizeof(rpc_cli_t));
+
+	cli->cli_netbuf = netBuf;
 	cli->cli_parent = malloc(sizeof(rpc_sess_t));
 	if (!cli->cli_parent) {
 		LOGERR;
@@ -189,10 +226,19 @@ rpc_cli_openClient(u_int ProgID, u_int ProcID, u_short
 		((rpc_sess_t*) cli->cli_parent)->sess_process = ProcID;
 	}
 
-	if (family == AF_INET)
-		memcpy(&cli->cli_sa, &sin, sizeof cli->cli_sa);
-	else
-		memcpy(&cli->cli_sa, &sin6, sizeof cli->cli_sa);
+	switch (family) {
+		case AF_INET:
+			memcpy(&cli->cli_sa, sin, sizeof cli->cli_sa);
+			break;
+		case AF_INET6:
+			memcpy(&cli->cli_sa, sin6, sizeof cli->cli_sa);
+			break;
+		case AF_LOCAL:
+			memcpy(&cli->cli_sa, sun, sizeof cli->cli_sa);
+			break;
+	}
+
+	/* connect to RPC server */
 	cli->cli_sock = socket(family, SOCK_STREAM, 0);
 	if (cli->cli_sock == -1) {
 		LOGERR;
@@ -200,8 +246,24 @@ rpc_cli_openClient(u_int ProgID, u_int ProcID, u_short
 		free(cli);
 		return NULL;
 	}
+	n = cli->cli_netbuf;
+	if (setsockopt(cli->cli_sock, SOL_SOCKET, SO_SNDBUF, &n, sizeof n) == -1) {
+		LOGERR;
+		close(cli->cli_sock);
+		free(cli->cli_parent);
+		free(cli);
+		return NULL;
+	}
+	if (setsockopt(cli->cli_sock, SOL_SOCKET, SO_RCVBUF, &n, sizeof n) == -1) {
+		LOGERR;
+		close(cli->cli_sock);
+		free(cli->cli_parent);
+		free(cli);
+		return NULL;
+	}
 	if (connect(cli->cli_sock, &cli->cli_sa, sizeof cli->cli_sa) == -1) {
 		LOGERR;
+		close(cli->cli_sock);
 		free(cli->cli_parent);
 		free(cli);
 		return NULL;
@@ -238,214 +300,184 @@ rpc_cli_closeClient(rpc_cli_t * __restrict cli)
  * @cli = RPC Client session
  * @csModule = Module name, if NULL self binary
  * @csFunc = Function name for execute
- * @in_argc = IN count of arguments
- * @in_vals = IN RPC call array of rpc values
- * @out_argc = OUT returned count of arguments
- * @out_vals = OUT returned array of rpc values, must be free after use (see rpc_cli_freeVals())
+ * @in_vars = IN RPC call array of rpc values
+ * @out_vars = OUT returned array of rpc values, must be free after use with rpc_cli_freeVals()
  * return: -1 error or != -1 ok result
  */
 int
-rpc_cli_execCall(rpc_cli_t *cli, const char *csModule, const char *csFunc, int in_argc, 
-		rpc_val_t * __restrict in_vals, int *out_argc, rpc_val_t ** __restrict out_vals)
+rpc_cli_execCall(rpc_cli_t *cli, const char *csModule, const char *csFunc, 
+		array_t * __restrict in_vars, array_t ** __restrict out_vars)
 {
 	fd_set fds;
-	u_char buf[BUFSIZ], str[MAXPATHLEN + UCHAR_MAX + 1], *data;
-	struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
-	struct tagRPCRet *rrpc;
+	u_char *buf, str[MAXPATHLEN + UCHAR_MAX + 1];
+	struct tagRPCCall *rpc;
+	struct tagRPCRet *rrpc = NULL;
 	int ret = 0, Limit = 0;
-	register int i;
-	rpc_val_t *v;
 	struct timeval tv = { DEF_RPC_TIMEOUT, 0 };
 
-	FD_ZERO(&fds);
-	memset(buf, 0, BUFSIZ);
-	memset(str, 0, MAXPATHLEN + UCHAR_MAX + 1);
-	if (!cli || !csFunc || (in_argc && !in_vals)) {
+	if (!cli || !csFunc) {
 		rpc_SetErr(EINVAL, "Error:: Can`t execute call because parameter is null or invalid!\n");
 		return -1;
 	}
+	if (out_vars)
+		*out_vars = NULL;
+
+	buf = malloc(cli->cli_netbuf);
+	if (!buf) {
+		LOGERR;
+		return -1;
+	} else
+		memset(buf, 0, cli->cli_netbuf);
+
+	/* build RPC call string for hash */
+	memset(str, 0, sizeof str);
 	if (csModule)
-		strlcpy((char*) str, csModule, MAXPATHLEN + UCHAR_MAX + 1);
-	strlcat((char*) str, "__", MAXPATHLEN + UCHAR_MAX + 1);
-	strlcat((char*) str, csFunc, MAXPATHLEN + UCHAR_MAX + 1);
+		strlcpy((char*) str, csModule, sizeof str);
+	strlcat((char*) str, "__", sizeof str);
+	strlcat((char*) str, csFunc, sizeof str);
 
+	/* prepare RPC call */
+	rpc = (struct tagRPCCall*) buf;
 	memcpy(&rpc->call_session, cli->cli_parent, sizeof rpc->call_session);
-	rpc->call_argc = in_argc;
-	rpc->call_tag = crcFletcher16((u_short*) str, (MAXPATHLEN + UCHAR_MAX + 1) / 2);
-	rpc->call_hash = hash_fnv((char*) str, MAXPATHLEN + UCHAR_MAX + 1);
+	rpc->call_argc = in_vars ? io_arraySize(in_vars) : 0;
+	rpc->call_tag = crcFletcher16((u_short*) str, sizeof str / 2);
+	rpc->call_hash = hash_fnv((char*) str, sizeof str);
 	Limit = sizeof(struct tagRPCCall);
-	if (in_argc) {
-		v = (rpc_val_t*) (buf + sizeof(struct tagRPCCall));
-		memcpy(v, in_vals, in_argc * sizeof(rpc_val_t));
-		Limit += in_argc * sizeof(rpc_val_t);
-		data = (u_char*) v + in_argc * sizeof(rpc_val_t);
-		for (i = 0; i < in_argc; i++) {
-			switch (in_vals[i].val_type) {
-				case buffer:
-					if (Limit + in_vals[i].val_len > BUFSIZ) {
-						ret = -7;
-						break;
-					}
 
-					memcpy(data, in_vals[i].val.buffer, in_vals[i].val_len);
-					v[i].val.buffer = (uint8_t*) ((void*) data - (void*) v);
-					data += in_vals[i].val_len;
-					Limit += in_vals[i].val_len;
-					break;
-				case string:
-					if (Limit + in_vals[i].val_len + 1 > BUFSIZ) {
-						ret = -7;
-						break;
-					}
-
-					memcpy(data, in_vals[i].val.string, in_vals[i].val_len);
-					v[i].val.string = (int8_t*) ((void*) data - (void*) v);
-					data += in_vals[i].val_len + 1;
-					Limit += in_vals[i].val_len + 1;
-					break;
-				default:
-					break;
-			}
-		}
-		if (ret < 0) {
-			rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n");
-			return ret;
-		}
+	if (in_vars && io_arraySize(in_vars)) {
+		/* marshaling variables */
+		ret = io_vals2buffer(buf + Limit, cli->cli_netbuf - Limit, in_vars);
+		if (ret == -1) {
+			rpc_SetErr(EBADRPC, "Error:: in prepare RPC packet values (-7) ...\n");
+			free(buf);
+			return -7;
+		} else
+			Limit += ret;
 	}
+
 	if ((ret = send(cli->cli_sock, buf, Limit, 0)) == -1) {
 		LOGERR;
+		free(buf);
 		return -1;
 	}
 	if (ret != Limit) {
-		rpc_SetErr(ECANCELED, "Error:: in send RPC request, should be send %d bytes, really is %d\n", 
+		rpc_SetErr(EPROCUNAVAIL, "Error:: in send RPC request, should be send %d bytes, really is %d\n", 
 				Limit, ret);
+		free(buf);
 		return -9;
 	}
 
+	/* reply from RPC server */
+	FD_ZERO(&fds);
 	FD_SET(cli->cli_sock, &fds);
 	if ((ret = select(cli->cli_sock + 1, &fds, NULL, NULL, &tv)) < 1) {
-		if (ret) {
+		if (ret)
 			LOGERR;
-		} else
+		else
 			rpc_SetErr(ETIMEDOUT, "Error:: timeout, no return from RPC server?\n");
+
+		free(buf);
 		return -1;
 	}
-	memset(buf, 0, BUFSIZ);
-	if ((ret = recv(cli->cli_sock, buf, BUFSIZ, 0)) == -1) {
+	memset(buf, 0, cli->cli_netbuf);
+	if ((ret = recv(cli->cli_sock, buf, cli->cli_netbuf, 0)) == -1) {
 		LOGERR;
+		free(buf);
 		return -3;
 	}
-	if (!ret)	// receive EOF
+	if (!ret) {	/* receive EOF! */
+		free(buf);
 		return 0;
+	}
 	if (ret < sizeof(struct tagRPCRet)) {
-		rpc_SetErr(EMSGSIZE, "Error:: too short RPC packet ...\n");
+		rpc_SetErr(ERPCMISMATCH, "Error:: too short RPC packet ...\n");
+		free(buf);
 		return -4;
 	} else
 		rrpc = (struct tagRPCRet*) buf;
-	// check RPC packet session info
+	/* check RPC packet session info */
 	if (memcmp(&rrpc->ret_session, cli->cli_parent, sizeof rrpc->ret_session)) {
-		rpc_SetErr(EINVAL, "Error:: get invalid RPC session ...\n");
+		rpc_SetErr(ERPCMISMATCH, "Error:: get invalid RPC session ...\n");
+		free(buf);
 		return -5;
 	} else
 		Limit = sizeof(struct tagRPCRet);
 	if (rrpc->ret_retcode < 0 && rrpc->ret_errno) {
-		rpc_SetErr(rrpc->ret_errno, "Error::Server side: %d %s\n", 
-				rrpc->ret_retcode, strerror(rrpc->ret_errno));
+		rpc_SetErr(rrpc->ret_errno, "Error::Server side: retcode=%d #%d %s\n", 
+				rrpc->ret_retcode, rrpc->ret_errno, strerror(rrpc->ret_errno));
+		free(buf);
 		return -6;
 	}
-	if (rrpc->ret_argc * sizeof(rpc_val_t) > BUFSIZ - Limit) {
-		rpc_SetErr(EMSGSIZE, "Error:: reply RPC packet is too big ...\n");
+	if (rrpc->ret_argc * sizeof(ait_val_t) > cli->cli_netbuf - Limit) {
+		rpc_SetErr(EMSGSIZE, "Error:: reply RPC packet is too long ...\n");
+		free(buf);
 		return -7;
-	} else
-		Limit += rrpc->ret_argc * sizeof(rpc_val_t);
-	// RPC is OK! Go decapsulate variables ...
+	}
+
+	/* RPC is OK! Go de-marshaling variables ... */
 	if (rrpc->ret_argc) {
-		*out_argc = rrpc->ret_argc;
-		*out_vals = calloc(rrpc->ret_argc, sizeof(rpc_val_t));
-		if (!*out_vals) {
-			LOGERR;
-			*out_argc = 0;
+		*out_vars = io_buffer2vals(buf + Limit, cli->cli_netbuf - Limit, rrpc->ret_argc, 0);
+		if (!*out_vars) {
+			free(buf);
 			return -1;
-		} else
-			memcpy(*out_vals, buf + sizeof(struct tagRPCRet), Limit - sizeof(struct tagRPCRet));
-		// RPC received variables types OK!
-		data = (u_char*) buf + Limit;
-		for (i = 0; i < rrpc->ret_argc; i++)
-			switch ((*out_vals)[i].val_type) {
-				case buffer:
-					if ((*out_vals)[i].val_len > BUFSIZ - Limit) {
-						rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n");
-						free(*out_vals);
-						*out_vals = NULL;
-						*out_argc = 0;
-						return -7;
-					} else
-						Limit += (*out_vals)[i].val_len;
-
-					(*out_vals)[i].val.buffer = malloc((*out_vals)[i].val_len);
-					if (!(*out_vals)[i].val.buffer) {
-						rpc_SetErr(errno, "Error:: in prepare RPC reply ...\n");
-						free(*out_vals);
-						*out_vals = NULL;
-						*out_argc = 0;
-						return -1;
-					} else
-						memcpy((*out_vals)[i].val.buffer, data, (*out_vals)[i].val_len);
-				       	data += (*out_vals)[i].val_len;
-					break;
-				case string:
-					if ((*out_vals)[i].val_len + 1 > BUFSIZ - Limit) {
-						rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n");
-						free(*out_vals);
-						*out_vals = NULL;
-						*out_argc = 0;
-						return -7;
-					} else
-						Limit += (*out_vals)[i].val_len + 1;
-
-					(*out_vals)[i].val.string = (int8_t*) strdup((char*) data);
-					if (!(*out_vals)[i].val.string) {
-						rpc_SetErr(errno, "Error:: in prepare RPC reply ...\n");
-						free(*out_vals);
-						*out_vals = NULL;
-						*out_argc = 0;
-						return -1;
-					} else {
-						/* sanity check ... preserve null byte */
-						(*out_vals)[i].val.string[(*out_vals)[i].val_len] = 0;
-					}
-				       	data += (*out_vals)[i].val_len + 1;
-					break;
-				default:
-					break;
-			}
-	} else {
-		if (out_argc)
-			*out_argc = 0;
-		if (out_vals)
-			*out_vals = NULL;
+		}
 	}
 
-	return rrpc->ret_retcode;
+	ret = rrpc->ret_retcode;
+	free(buf);
+	return ret;
 }
 
 /*
- * rpc_cli_freeVals() Free rpc_val_t array returned from RPC call
- * @args = Number of arguments in array
- * @vals = Value elements
+ * rpc_cli_freeVals() Free ait_val_t array returned from RPC call
+ * @vars = Variable array
  * return: none
  */
 inline void
-rpc_cli_freeVals(int args, rpc_val_t *vals)
+rpc_cli_freeVals(array_t ** __restrict vars)
 {
 	register int i;
 
-	if (!vals)
+	if (!vars || !*vars)
 		return;
 
-	for (i = 0; i < args; i++)
-		RPC_FREE_VAL(&vals[i]);
+	for (i = 0; i < io_arraySize(*vars); i++)
+		if (io_arrayGet(*vars, i))
+			AIT_FREE_VAL(io_array(*vars, i, ait_val_t*));
 
-	free(vals);
-	vals = NULL;
+	io_arrayFree(*vars);
+	io_arrayDestroy(vars);
+}
+
+/*
+ * rpc_cli_allocVals() Allocate ait_val_t array for RPC call
+ * @args = Number of arguments
+ * return: =NULL error or !=NULL allocated array
+ */
+inline array_t *
+rpc_cli_allocVals(u_short args)
+{
+	array_t *arr;
+	register int i;
+	ait_val_t *v;
+
+	if (!args)
+		return NULL;
+
+	if (!(arr = io_arrayInit(args)))
+		return NULL;
+
+	for (i = 0; i < io_arraySize(arr); i++) {
+		v = malloc(sizeof(ait_val_t));
+		if (!v) {
+			LOGERR;
+			rpc_cli_freeVals(&arr);
+			return NULL;
+		} else {
+			memset(v, 0, sizeof(ait_val_t));
+			io_arraySet(arr, i, v);
+		}
+	}
+
+	return arr;
 }