--- libaitrpc/src/srv.c	2011/09/07 07:24:21	1.5
+++ libaitrpc/src/srv.c	2011/09/07 09:42:46	1.5.2.4
@@ -3,7 +3,7 @@
 *  by Michael Pounov <misho@openbsd-bg.org>
 *
 * $Author: misho $
-* $Id: srv.c,v 1.5 2011/09/07 07:24:21 misho Exp $
+* $Id: srv.c,v 1.5.2.4 2011/09/07 09:42:46 misho Exp $
 *
 **************************************************************************
 The ELWIX and AITNET software is distributed under the following
@@ -60,6 +60,8 @@ rpc_srv_dispatchCall(void *arg)
 	u_char *buf;
 	int ret, argc = 0, Limit = 0;
 	register int i;
+	uint16_t tag = 0;
+	uint32_t hash = 0;
 
 	if (!arg) {
 		rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t procced RPC client ...\n");
@@ -103,16 +105,20 @@ rpc_srv_dispatchCall(void *arg)
 		} else
 			rpc = (struct tagRPCCall*) buf;
 		/* check RPC packet session info */
-		if (memcmp(&rpc->call_session, &s->srv_session, sizeof rpc->call_session)) {
+		if (rpc_chkPktSession(&rpc->call_session, &s->srv_session)) {
 			rpc_SetErr(ERPCMISMATCH, "Error:: get invalid RPC session ...\n");
 			ret = -5;
 			goto makeReply;
 		} else
 			Limit = sizeof(struct tagRPCCall);
 
+		tag = rpc->call_tag;
+		hash = rpc->call_hash;
+
 		/* RPC is OK! Go decapsulate variables ... */
-		if (rpc->call_argc) {
-			arr = io_buffer2vals(buf + Limit, s->srv_netbuf - Limit, rpc->call_argc, 1);
+		if (ntohs(rpc->call_argc)) {
+			arr = io_buffer2vals(buf + Limit, s->srv_netbuf - Limit, 
+					ntohs(rpc->call_argc), 1);
 			if (!arr) {
 				ret = -5;
 				goto makeReply;
@@ -123,7 +129,7 @@ rpc_srv_dispatchCall(void *arg)
 		/* execute call */
 		argc = 0;
 		memcpy(&ses, &rpc->call_session, sizeof ses);
-		if (!(f = rpc_srv_getCall(s, rpc->call_tag, rpc->call_hash))) {
+		if (!(f = rpc_srv_getCall(s, ntohs(tag), ntohl(hash)))) {
 			rpc_SetErr(EPROGUNAVAIL, "Error:: call not found into RPC server ...\n");
 			ret = -6;
 		} else
@@ -146,11 +152,11 @@ makeReply:
 		Limit = sizeof(struct tagRPCRet);
 
 		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;
+		rrpc->ret_tag = tag;
+		rrpc->ret_hash = hash;
+		rrpc->ret_errno = htonl(rpc_Errno);
+		rrpc->ret_retcode = htonl(ret);
+		rrpc->ret_argc = htons(argc);
 
 		if (argc && arr) {
 			/* Go Encapsulate variables ... */
@@ -682,50 +688,50 @@ 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
+ * @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) {
+	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++)
+	for (i = 0, c = (*psrv)->srv_clients; i < (*psrv)->srv_numcli && c; i++, c++)
 		if (c->cli_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;
 		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;
 }
 
 /*
@@ -827,7 +833,7 @@ rpc_srv_execCall(rpc_func_t * __restrict call, struct 
 
 	func = dlsym(dl, (char*) 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());
 		ret = -1;