--- libaitrpc/src/lists.c	2012/05/14 08:39:06	1.9
+++ libaitrpc/src/lists.c	2012/05/16 07:54:49	1.9.2.2
@@ -3,7 +3,7 @@
 *  by Michael Pounov <misho@openbsd-bg.org>
 *
 * $Author: misho $
-* $Id: lists.c,v 1.9 2012/05/14 08:39:06 misho Exp $
+* $Id: lists.c,v 1.9.2.2 2012/05/16 07:54:49 misho Exp $
 *
 **************************************************************************
 The ELWIX and AITNET software is distributed under the following
@@ -47,141 +47,78 @@ SUCH DAMAGE.
 
 
 /*
- * rpc_srv_allocVars() - Allocate array for call variables
- *
- * @call = RPC function call
- * @varnum = Number of variables, if ==0 return already allocated variables number
- * return: -1 error, !=-1 return varnum value
- */
-static inline int
-rpc_srv_allocVars(rpc_func_t * __restrict call, int varnum)
-{
-	if (!call || varnum < 0) {
-		rpc_SetErr(EINVAL, "Invalid parameter can`t allocate variables for RPC call");
-		return -1;
-	}
-
-	if (varnum) {
-		call->func_vars = io_allocVars(varnum);
-		if (!call->func_vars)
-			return -1;
-	}
-
-	return io_arraySize(call->func_vars);
-}
-
-/*
- * rpc_srv_getVars() - Get variables array for RPC call
- *
- * @call = RPC function call
- * @vars = Returned variables array, may be NULL
- * return: -1 error, !=-1 Number of returned variables
- */
-inline int
-rpc_srv_getVars(rpc_func_t * __restrict call, array_t ** __restrict vars)
-{
-	if (!call) {
-		rpc_SetErr(EINVAL, "Invalid parameter can`t get variables");
-		return -1;
-	}
-
-	if (vars)
-		*vars = call->func_vars;
-	return io_arraySize(call->func_vars);
-}
-
-/* --------------------------------------------------------- */
-
-/*
  * rpc_srv_registerCall() - Register call to RPC server
  *
  * @srv = RPC Server instance
- * @csModule = Module name, if NULL self binary
- * @csFunc = Function name
- * @args = Number of return function arguments, use for restriction case!
- * return: -1 error or 0 register ok
+ * @tag = Function tag
+ * @funcaddr = Function address
+ * @args = Number of return function arguments
+ * return: -1 error, 0 already registered tag or 1 register ok
  */
 int
-rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char *csModule, 
-		const char *csFunc, u_short args)
+rpc_srv_registerCall(rpc_srv_t * __restrict srv, u_short tag, void *funcaddr, u_short args)
 {
 	rpc_func_t *func;
 
-	if (!srv || !csFunc) {
+	if (!srv || !funcaddr) {
 		rpc_SetErr(EINVAL, "Invalid parameter can`t register function");
 		return -1;
+	} else {
+		/* search for duplicate */
+		TAILQ_FOREACH(func, &srv->srv_funcs, func_node)
+			if (AIT_KEY(&func->func_name) == tag)
+				return 0;
 	}
+
 	if (!(func = malloc(sizeof(rpc_func_t)))) {
 		LOGERR;
 		return -1;
-	} else
+	} else {
 		memset(func, 0, sizeof(rpc_func_t));
-
-	/* calculate hashes */
-	if (rpc_calcHashes(func, csModule, csFunc) == -1) {
-		AIT_FREE_VAL(&func->func_name);
-		AIT_FREE_VAL(&func->func_file);
-		free(func);
-		return -1;
+		func->func_parent = srv;
 	}
 
-	func->func_parent = srv;
+	AIT_KEY(&func->func_name) = tag;
+	AIT_SET_PTR(&func->func_name, funcaddr, 0);
 
 	/* allocate return variables */
-	if (args > 0 && rpc_srv_allocVars(func, args) == -1) {
+	if (args > 0 && !(func->func_vars = io_allocVars(args))) {
 		AIT_FREE_VAL(&func->func_name);
-		AIT_FREE_VAL(&func->func_file);
 		free(func);
 		return -1;
 	}
 
 	/* add to list of functions */
-	func->func_next = srv->srv_funcs;
-	srv->srv_funcs = func;
-	return 0;
+	TAILQ_INSERT_TAIL(&srv->srv_funcs, func, func_node);
+	return 1;
 }
 
 /*
  * rpc_srv_unregisterCall() - Unregister call from RPC server
  *
  * @srv = RPC Server instance
- * @csModule = Module name, if NULL self binary
- * @csFunc = Function name
+ * @tag = Function tag
  * return: -1 error, 0 not found call, 1 unregister ok
  */
 int
-rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc)
+rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, u_short tag)
 {
-	rpc_func_t func, *f, *curr;
+	rpc_func_t *f;
 
-	if (!srv || !csFunc) {
+	if (!srv) {
 		rpc_SetErr(EINVAL, "Invalid parameter can`t unregister function");
 		return -1;
-	} else
-		memset(&func, 0, sizeof func);
+	}
 
-	/* calculate hashes */
-	if (rpc_calcHashes(&func, csModule, csFunc) == -1)
-		return -1;
-
-	f = rpc_srv_getCall(srv, func.func_tag, func.func_hash);
-	AIT_FREE_VAL(&func.func_name);
-	AIT_FREE_VAL(&func.func_file);
+	f = rpc_srv_getCall(srv, tag);
 	if (!f) 		/* not found element for unregister */
 		return 0;
 
-	/* remove from list of functions */
-	if (srv->srv_funcs == f)	/* if is 1st element */
-		srv->srv_funcs = srv->srv_funcs->func_next;
-	else {
-		for (curr = srv->srv_funcs; curr->func_next != f; curr = curr->func_next);
-		curr->func_next = curr->func_next->func_next;
-	}
+	TAILQ_REMOVE(&srv->srv_funcs, f, func_node);
+
 	io_freeVars(&f->func_vars);
 	AIT_FREE_VAL(&f->func_name);
-	AIT_FREE_VAL(&f->func_file);
 	free(f);
-
 	return 1;
 }
 
@@ -190,58 +127,28 @@ rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con
  *
  * @srv = RPC Server instance
  * @tag = tag for function
- * @hash = hash for function
  * return: NULL not found call, !=NULL return call
  */
 inline rpc_func_t *
-rpc_srv_getCall(rpc_srv_t * __restrict srv, uint16_t tag, uint32_t hash)
+rpc_srv_getCall(rpc_srv_t * __restrict srv, uint16_t tag)
 {
-	rpc_func_t *f;
+	rpc_func_t *f, *tmp;
 
 	if (!srv) {
 		rpc_SetErr(EINVAL, "Invalid parameter can`t get function");
 		return NULL;
 	}
 
-	for (f = srv->srv_funcs; f; f = f->func_next)
-		if (f->func_tag == tag && f->func_hash == hash)
+	TAILQ_FOREACH_SAFE(f, &srv->srv_funcs, func_node, tmp)
+		if (AIT_KEY(&f->func_name) == tag)
 			break;
 
 	return f;
 }
 
-/*
- * rpc_srv_getFunc() - Get registered call from RPC server by Name
- *
- * @srv = RPC Server instance
- * @csModule = Module name, if NULL self binary
- * @csFunc = Function name
- * return: NULL not found call, !=NULL return call
- */
-rpc_func_t *
-rpc_srv_getFunc(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc)
-{
-	rpc_func_t func, *f = NULL;
+/* --------------------------------------------------------- */
 
-	if (!srv || !csFunc) {
-		rpc_SetErr(EINVAL, "Invalid parameter can`t get function");
-		return NULL;
-	} else
-		memset(&func, 0, sizeof(rpc_func_t));
-
-	/* calculate hashes */
-	if (rpc_calcHashes(&func, csModule, csFunc) == -1)
-		return NULL;
-
-	f = rpc_srv_getCall(srv, func.func_tag, func.func_hash);
-
-	AIT_FREE_VAL(&func.func_name);
-	AIT_FREE_VAL(&func.func_file);
-	return f;
-}
-
-// ---------------------------------------------------------
-
+#if 0
 /*
  * rpc_srv_getBLOB() - Get registered BLOB 
  *
@@ -328,51 +235,4 @@ rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uin
 
 	return 1;
 }
-
-/*
- * rpc_calcHashes() - Calculate hashes for RPC call
- *
- * @func = function
- * @csModule = Module name, if NULL self binary
- * @csFunc = Function name
- * return: -1 error or 0 ok
- */
-int
-rpc_calcHashes(rpc_func_t * __restrict func, const char *csModule, const char *csFunc)
-{
-	char *str = NULL;
-	int len = 0;
-
-	assert(func && csFunc);
-
-	/* set function name */
-	AIT_SET_STR(&func->func_name, csFunc);
-	len = strlen(csFunc) + 3;	/* extra 3 bytes, because add string "__" and 0 */
-	/* set module name if exists */
-	if (csModule) {
-		AIT_SET_STR(&func->func_file, csModule);
-		len += strlen(csModule);
-	}
-	/* align len to 2 */
-	len = io_align(len, 1);
-
-	/* prepare hash source string */
-	str = malloc(len);
-	if (!str) {
-		LOGERR;
-		return -1;
-	} else {
-		memset(str, 0, len);
-		if (csModule)
-			strlcpy((char*) str, csModule, len);
-		strlcat((char*) str, "__", len);
-		strlcat((char*) str, csFunc, len);
-	}
-
-	func->func_tag = crcFletcher16((u_short*) str, len / 2);
-	func->func_hash = hash_fnv((char*) str, len);
-
-	free(str);
-	return len;
-}
-
+#endif