--- libaitrpc/src/lists.c	2011/08/19 08:24:13	1.3.2.1
+++ libaitrpc/src/lists.c	2011/08/31 17:11:58	1.4.2.2
@@ -3,7 +3,7 @@
 *  by Michael Pounov <misho@openbsd-bg.org>
 *
 * $Author: misho $
-* $Id: lists.c,v 1.3.2.1 2011/08/19 08:24:13 misho Exp $
+* $Id: lists.c,v 1.4.2.2 2011/08/31 17:11:58 misho Exp $
 *
 **************************************************************************
 The ELWIX and AITNET software is distributed under the following
@@ -53,15 +53,13 @@ SUCH DAMAGE.
  * @varnum = Number of return variables
  * return: NULL error, !=NULL array with return values for RPC call with varnum items
  */
-inline rpc_val_t *
+inline array_t *
 rpc_srv_returnVars(rpc_func_t * __restrict call, int varnum)
 {
-	rpc_val_t *v = NULL;
+	array_t *v = NULL;
 
 	if (rpc_srv_allocVars(call, varnum) == -1)
 		return NULL;
-	else
-		rpc_srv_zeroVars(call);
 	if (rpc_srv_getVars(call, &v) == -1)
 		return NULL;
 
@@ -78,27 +76,38 @@ rpc_srv_returnVars(rpc_func_t * __restrict call, int v
 inline int
 rpc_srv_allocVars(rpc_func_t * __restrict call, int varnum)
 {
-	void *ptr;
+	register int i;
+	ait_val_t *v;
 
 	if (!call || varnum < 0) {
 		rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t allocate variables for RPC call...\n");
 		return -1;
-	} else
-		call->func_args = varnum;
+	}
 
-	if (!varnum) {
-		if (call->func_vars) {
-			free(call->func_vars);
-			call->func_vars = NULL;
-		}
-	} else {
-		ptr = realloc(call->func_vars, varnum * sizeof(rpc_val_t));
-		if (!ptr) {
-			LOGERR;
-			call->func_args = 0;
+	if (call->func_vars)
+		for (i = 0; i < io_arraySize(call->func_vars); i++)
+			if (io_arrayGet(call->func_vars, i))
+				AIT_FREE_VAL(io_array(call->func_vars, i, ait_val_t*));
+	io_arrayFree(call->func_vars);
+	io_arrayDestroy(&call->func_vars);
+
+	if (varnum) {
+		if (!(call->func_vars = io_arrayInit(varnum)))
 			return -1;
-		} else
-			call->func_vars = ptr;
+
+		for (i = 0; i < io_arraySize(call->func_vars); i++) {
+			v = malloc(sizeof(ait_val_t));
+			if (!v) {
+				LOGERR;
+				rpc_srv_freeVars(call);
+				return -1;
+			} else {
+				memset(v, 0, sizeof(ait_val_t));
+				io_arraySet(call->func_vars, i, v);
+			}
+		}
+
+		varnum = io_arraySize(call->func_vars);
 	}
 
 	return varnum;
@@ -117,8 +126,9 @@ rpc_srv_zeroVars(rpc_func_t * __restrict call)
 		return -1;
 	}
 
-	memset(call->func_vars, 0, call->func_args * sizeof(rpc_val_t));
-	return call->func_args;
+	io_arrayFree(call->func_vars);
+	io_arrayZero(call->func_vars);
+	return io_arraySize(call->func_vars);
 }
 
 /*
@@ -128,21 +138,17 @@ rpc_srv_zeroVars(rpc_func_t * __restrict call)
  * return: -1 error, !=-1 Returned number of copied RPC variables
  */
 inline int
-rpc_srv_copyVars(rpc_func_t * __restrict call, rpc_val_t ** __restrict newvars)
+rpc_srv_copyVars(rpc_func_t * __restrict call, array_t ** __restrict newvars)
 {
 	if (!call || !newvars) {
 		rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t copy variables to new array\n");
 		return -1;
 	}
 
-	*newvars = calloc(call->func_args, sizeof(rpc_val_t));
-	if (!*newvars) {
-		LOGERR;
+	if (io_arrayCopy(newvars, call->func_vars) == -1)
 		return -1;
-	} else
-		memcpy(*newvars, call->func_vars, call->func_args * sizeof(rpc_val_t));
 
-	return call->func_args;
+	return io_arraySize(*newvars);
 }
 
 /*
@@ -152,7 +158,7 @@ rpc_srv_copyVars(rpc_func_t * __restrict call, rpc_val
  * return: -1 error, !=-1 Number of returned variables
  */
 inline int
-rpc_srv_getVars(rpc_func_t * __restrict call, rpc_val_t ** __restrict vars)
+rpc_srv_getVars(rpc_func_t * __restrict call, array_t ** __restrict vars)
 {
 	if (!call) {
 		rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get variables ...\n");
@@ -161,7 +167,7 @@ rpc_srv_getVars(rpc_func_t * __restrict call, rpc_val_
 
 	if (vars)
 		*vars = call->func_vars;
-	return call->func_args;
+	return (call->func_vars ? io_arraySize(call->func_vars) : 0);
 }
 
 // ---------------------------------------------------------
@@ -175,12 +181,12 @@ rpc_srv_getVars(rpc_func_t * __restrict call, rpc_val_
  * return: -1 error or 0 register ok
  */
 int
-rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc, u_char args)
+rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc, u_short args)
 {
 	rpc_func_t *func;
 	u_char str[MAXPATHLEN + UCHAR_MAX + 1];
 
-	memset(str, 0, MAXPATHLEN + UCHAR_MAX + 1);
+	memset(str, 0, sizeof str);
 	if (!srv || !csFunc) {
 		rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t register function to RPC server ...\n");
 		return -1;
@@ -190,17 +196,17 @@ rpc_srv_registerCall(rpc_srv_t * __restrict srv, const
 		return -1;
 	} else {
 		memset(func, 0, sizeof(rpc_func_t));
-		strlcpy((char*) func->func_name, csFunc, UCHAR_MAX + 1);
+		strlcpy((char*) func->func_name, csFunc, sizeof func->func_name);
 	}
 	if (csModule) {
-		strlcpy((char*) func->func_file, csModule, MAXPATHLEN);
-		strlcpy((char*) str, csModule, MAXPATHLEN + UCHAR_MAX + 1);
+		strlcpy((char*) func->func_file, csModule, sizeof func->func_file);
+		strlcpy((char*) str, csModule, sizeof str);
 	}
-	strlcat((char*) str, "__", MAXPATHLEN + UCHAR_MAX + 1);
-	strlcat((char*) str, csFunc, MAXPATHLEN + UCHAR_MAX + 1);
+	strlcat((char*) str, "__", sizeof str);
+	strlcat((char*) str, csFunc, sizeof str);
 
-	func->func_tag = crcFletcher16((u_short*) str, (MAXPATHLEN + UCHAR_MAX + 1) / 2);
-	func->func_hash = hash_fnv((char*) str, MAXPATHLEN + UCHAR_MAX + 1);
+	func->func_tag = crcFletcher16((u_short*) str, sizeof str / 2);
+	func->func_hash = hash_fnv((char*) str, sizeof str);
 
 	func->func_parent = srv;
 
@@ -230,21 +236,21 @@ rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con
 	u_char str[MAXPATHLEN + UCHAR_MAX + 1];
 
 	memset(&func, 0, sizeof(rpc_func_t));
-	memset(str, 0, MAXPATHLEN + UCHAR_MAX + 1);
+	memset(str, 0, sizeof str);
 	if (!srv || !csFunc) {
 		rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t unregister function from RPC server ...\n");
 		return -1;
 	} else
-		strlcpy((char*) func.func_name, csFunc, UCHAR_MAX + 1);
+		strlcpy((char*) func.func_name, csFunc, sizeof func.func_name);
 	if (csModule) {
-		strlcpy((char*) func.func_file, csModule, MAXPATHLEN);
-		strlcpy((char*) str, csModule, MAXPATHLEN + UCHAR_MAX + 1);
+		strlcpy((char*) func.func_file, csModule, sizeof func.func_file);
+		strlcpy((char*) str, csModule, sizeof str);
 	}
-	strlcat((char*) str, "__", MAXPATHLEN + UCHAR_MAX + 1);
-	strlcat((char*) str, csFunc, MAXPATHLEN + UCHAR_MAX + 1);
+	strlcat((char*) str, "__", sizeof str);
+	strlcat((char*) str, csFunc, sizeof str);
 
-	func.func_tag = crcFletcher16((u_short*) str, (MAXPATHLEN + UCHAR_MAX + 1) / 2);
-	func.func_hash = hash_fnv((char*) str, MAXPATHLEN + UCHAR_MAX + 1);
+	func.func_tag = crcFletcher16((u_short*) str, sizeof str / 2);
+	func.func_hash = hash_fnv((char*) str, sizeof str);
 
 	f = rpc_srv_getCall(srv, func.func_tag, func.func_hash);
 	if (!f)				/* not found element for unregister */
@@ -308,21 +314,21 @@ rpc_srv_getFunc(rpc_srv_t * __restrict srv, const char
 	u_char str[MAXPATHLEN + UCHAR_MAX + 1];
 
 	memset(&func, 0, sizeof(rpc_func_t));
-	memset(str, 0, MAXPATHLEN + UCHAR_MAX + 1);
+	memset(str, 0, sizeof str);
 	if (!srv || !csFunc) {
 		rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get function from RPC server ...\n");
 		return NULL;
 	} else
-		strlcpy((char*) func.func_name, csFunc, UCHAR_MAX + 1);
+		strlcpy((char*) func.func_name, csFunc, sizeof func.func_name);
 	if (csModule) {
-		strlcpy((char*) func.func_file, csModule, MAXPATHLEN);
-		strlcpy((char*) str, csModule, MAXPATHLEN + UCHAR_MAX + 1);
+		strlcpy((char*) func.func_file, csModule, sizeof func.func_file);
+		strlcpy((char*) str, csModule, sizeof str);
 	}
-	strlcat((char*) str, "__", MAXPATHLEN + UCHAR_MAX + 1);
-	strlcat((char*) str, csFunc, MAXPATHLEN + UCHAR_MAX + 1);
+	strlcat((char*) str, "__", sizeof str);
+	strlcat((char*) str, csFunc, sizeof str);
 
-	func.func_tag = crcFletcher16((u_short*) str, (MAXPATHLEN + UCHAR_MAX + 1) / 2);
-	func.func_hash = hash_fnv((char*) str, MAXPATHLEN + UCHAR_MAX + 1);
+	func.func_tag = crcFletcher16((u_short*) str, sizeof str / 2);
+	func.func_hash = hash_fnv((char*) str, sizeof str);
 
 	return rpc_srv_getCall(srv, func.func_tag, func.func_hash);
 }