--- libaitrpc/src/srv.c	2015/05/18 15:09:59	1.26
+++ libaitrpc/src/srv.c	2015/07/02 22:28:15	1.27
@@ -3,7 +3,7 @@
 *  by Michael Pounov <misho@openbsd-bg.org>
 *
 * $Author: misho $
-* $Id: srv.c,v 1.26 2015/05/18 15:09:59 misho Exp $
+* $Id: srv.c,v 1.27 2015/07/02 22:28:15 misho Exp $
 *
 **************************************************************************
 The ELWIX and AITNET software is distributed under the following
@@ -70,19 +70,18 @@ static void *rxEXTPacket(sched_task_t *);
 static void *txEXTPacket(sched_task_t *);
 
 static sched_task_func_t cbProto[SOCK_MAX_SUPPORT][4] = {
-	{ acceptClients, closeClient, rxPacket, txPacket },	/* SOCK_STREAM */
-	{ acceptClients, closeClient, rxPacket, txPacket },	/* SOCK_STREAM */
-	{ rxUDPPacket, freeClient, rxUDPPacket, txUDPPacket }, 	/* SOCK_DGRAM */
-	{ rxRAWPacket, freeClient, rxRAWPacket, txRAWPacket },	/* SOCK_RAW */
-	{ rxBPFPacket, freeClient, rxBPFPacket, txBPFPacket }, 	/* SOCK_BPF */
-	{ rxEXTPacket, freeClient, rxEXTPacket, txEXTPacket }	/* SOCK_EXT */
+	{ acceptClients, closeClient, rxPacket, txPacket },		/* SOCK_STREAM */
+	{ acceptClients, closeClient, rxPacket, txPacket },		/* SOCK_STREAM */
+	{ rxUDPPacket, freeClient, NULL /*rxUDPPacket*/, txUDPPacket },	/* SOCK_DGRAM */
+	{ rxRAWPacket, freeClient, NULL /*rxRAWPacket*/, txRAWPacket },	/* SOCK_RAW */
+	{ rxBPFPacket, freeClient, NULL /*rxBPFPacket*/, txBPFPacket },	/* SOCK_BPF */
+	{ rxEXTPacket, freeClient, NULL /*rxEXTPacket*/, txEXTPacket }	/* SOCK_EXT */
 };
 
 /* Global Signal Argument when kqueue support disabled */
 
 static volatile uintptr_t _glSigArg = 0;
 
-
 void
 rpc_freeCli(rpc_cli_t * __restrict c)
 {
@@ -158,7 +157,7 @@ freeClient(sched_task_t *task)
 {
 	rpc_freeCli(TASK_ARG(task));
 
-	return NULL;
+	taskExit(task, NULL);
 }
 
 static void *
@@ -171,7 +170,7 @@ closeClient(sched_task_t *task)
 	/* close client socket */
 	shutdown(sock, SHUT_RDWR);
 	close(sock);
-	return NULL;
+	taskExit(task, NULL);
 }
 
 static void *
@@ -182,8 +181,7 @@ txPacket(sched_task_t *task)
 	rpc_func_t *f = NULL;
 	u_char *buf = AIT_GET_BUF(&c->cli_buf);
 	struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
-	int ret, estlen, wlen = sizeof(struct tagRPCCall);
-	struct pollfd pfd;
+	int ret, wlen = sizeof(struct tagRPCCall);
 #ifdef TCP_SESSION_TIMEOUT
 	struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
 
@@ -198,33 +196,33 @@ txPacket(sched_task_t *task)
 			rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
 
 			rpc->call_argc ^= rpc->call_argc;
-			rpc->call_rep.ret = RPC_ERROR(-1);
-			rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
-		} else {
-			/* calc estimated length */
-			estlen = ait_resideVars(RPC_RETVARS(c)) + wlen;
-			if (estlen > AIT_LEN(&c->cli_buf))
-				AIT_RE_BUF(&c->cli_buf, estlen);
-			buf = AIT_GET_BUF(&c->cli_buf);
-			rpc = (struct tagRPCCall*) buf;
+			RPC_SET_RETURN(rpc, -1);
+			RPC_SET_ERRNO(rpc, rpc_Errno);
+		} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
+			rpc_SetErr(EMSGSIZE, "Message too long");
 
+			rpc->call_argc ^= rpc->call_argc;
+			RPC_SET_RETURN(rpc, -1);
+			RPC_SET_ERRNO(rpc, rpc_Errno);
+		} else {
 			rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
 			/* Go Encapsulate variables */
 			ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen, 
 					RPC_RETVARS(c));
-			/* Free return values */
-			ait_freeVars(&c->cli_vars);
 			if (ret == -1) {
 				rpc_SetErr(EBADRPC, "Prepare RPC packet failed");
 
 				rpc->call_argc ^= rpc->call_argc;
-				rpc->call_rep.ret = RPC_ERROR(-1);
-				rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
+				RPC_SET_RETURN(rpc, -1);
+				RPC_SET_ERRNO(rpc, rpc_Errno);
 			} else
 				wlen += ret;
 		}
 	}
 
+	/* Free return values */
+	ait_freeVars(&c->cli_vars);
+
 	rpc->call_len = htonl(wlen);
 	rpc->call_io = RPC_ACK;
 
@@ -235,30 +233,14 @@ txPacket(sched_task_t *task)
 #endif
 
 	/* send reply */
-	pfd.fd = TASK_FD(task);
-	pfd.events = POLLOUT;
-	for (; wlen > 0; wlen -= ret, buf += ret) {
-		if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
-				pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
-			if (ret)
-				LOGERR;
-			else
-				rpc_SetErr(ETIMEDOUT, "Timeout reached! Client not respond");
-			/* close connection */
-			schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
-					TASK_ARG(task), 0, NULL, 0);
-			return NULL;
-		}
-		ret = send(TASK_FD(task), buf, MIN(wlen, s->srv_netbuf), MSG_NOSIGNAL);
-		if (ret == -1) {
-			/* close connection */
-			schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
-					TASK_ARG(task), 0, NULL, 0);
-			return NULL;
-		}
+	ret = send(TASK_FD(task), buf, wlen, MSG_NOSIGNAL);
+	if (ret == -1) {
+		/* close connection */
+		schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
+				TASK_ARG(task), 0, NULL, 0);
 	}
 
-	return NULL;
+	taskExit(task, NULL);
 }
 
 static void *
@@ -280,9 +262,9 @@ execCall(sched_task_t *task)
 			rpc_SetErr(ERPCMISMATCH, "#%d - %s", elwix_GetErrno(), elwix_GetError());
 
 			rpc->call_argc ^= rpc->call_argc;
-			rpc->call_rep.ret = RPC_ERROR(-1);
-			rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
-			return NULL;
+			RPC_SET_RETURN(rpc, -1);
+			RPC_SET_ERRNO(rpc, rpc_Errno);
+			taskExit(task, NULL);
 		}
 	} else
 		arr = NULL;
@@ -291,24 +273,24 @@ execCall(sched_task_t *task)
 		rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
 
 		rpc->call_argc ^= rpc->call_argc;
-		rpc->call_rep.ret = RPC_ERROR(-1);
-		rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
+		RPC_SET_RETURN(rpc, -1);
+		RPC_SET_ERRNO(rpc, rpc_Errno);
 	} else {
 		/* if client doesn't want reply */
-		argc = RPC_CHK_NOREPLY(rpc);
-		rpc->call_rep.ret = RPC_ERROR(rpc_srv_execCall(c, rpc, f->func_name, arr));
+		RPC_SET_RETURN(rpc, rpc_srv_execCall(c, rpc, f->func_name, arr));
 		if (rpc->call_rep.ret == htonl(-1)) {
 			if (!rpc->call_rep.eno) {
 				LOGERR;
-				rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
+				RPC_SET_ERRNO(rpc, rpc_Errno);
 			}
 			rpc->call_argc ^= rpc->call_argc;
+			ait_freeVars(&c->cli_vars);
 		} else {
 			rpc->call_rep.eno ^= rpc->call_rep.eno;
-			if (argc) {
+			rpc->call_argc ^= rpc->call_argc;
+			if (TASK_VAL(task)) {
 				/* without reply */
 				ait_freeVars(&c->cli_vars);
-				rpc->call_argc ^= rpc->call_argc;
 			} else {
 				/* reply */
 				rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
@@ -317,7 +299,7 @@ execCall(sched_task_t *task)
 	}
 
 	array_Destroy(&arr);
-	return NULL;
+	taskExit(task, NULL);
 }
 
 static void *
@@ -325,13 +307,13 @@ rxPacket(sched_task_t *task)
 {
 	rpc_cli_t *c = TASK_ARG(task);
 	rpc_srv_t *s = c->cli_parent;
-	int len, rlen, noreply, estlen;
+	int len, noreply = 0, rlen = AIT_LEN(&c->cli_buf);
 #if 0
 	u_short crc;
 #endif
 	u_char *buf = AIT_GET_BUF(&c->cli_buf);
+	u_char b[sizeof(struct tagRPCCall)];
 	struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
-	struct pollfd pfd;
 #ifdef TCP_SESSION_TIMEOUT
 	struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
 
@@ -340,51 +322,40 @@ rxPacket(sched_task_t *task)
 			 TASK_ARG(task), ts, TASK_ARG(task), 0);
 #endif
 
-	memset(buf, 0, sizeof(struct tagRPCCall));
-	rlen = recv(TASK_FD(task), rpc, sizeof(struct tagRPCCall), MSG_PEEK);
-	if (rlen < sizeof(struct tagRPCCall)) {
+	/* prepare rx */
+	len = recv(TASK_FD(task), b, sizeof b, MSG_PEEK);
+	if (len == sizeof b)
+		rlen = ntohl(((struct tagRPCCall*) b)->call_len);
+
+	rlen = recv(TASK_FD(task), buf, rlen, 0);
+	if (rlen == -1) {
 		/* close connection */
 		schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
 				TASK_ARG(task), 0, NULL, 0);
-		return NULL;
-	} else {
-		estlen = ntohl(rpc->call_len);
-		if (estlen > AIT_LEN(&c->cli_buf))
-			AIT_RE_BUF(&c->cli_buf, estlen);
-		rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);
-		buf = AIT_GET_BUF(&c->cli_buf);
-		len = estlen;
+		taskExit(task, NULL);
 	}
+	if (rlen < sizeof(struct tagRPCCall)) {
+		rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
 
-	/* get next part of packet */
-	memset(buf, 0, len);
-	pfd.fd = TASK_FD(task);
-	pfd.events = POLLIN | POLLPRI;
-	for (; len > 0; len -= rlen, buf += rlen) {
-		if ((rlen = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
-				pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
-			if (rlen)
-				LOGERR;
-			else
-				rpc_SetErr(ETIMEDOUT, "Timeout reached! Client not respond");
-			schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
-					TASK_ARG(task), 0, NULL, 0);
-			return NULL;
-		}
-		rlen = recv(TASK_FD(task), buf, len, 0);
-		if (rlen == -1) {
-			/* close connection */
-			schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
-					TASK_ARG(task), 0, NULL, 0);
-			return NULL;
-		}
+		rpc->call_argc ^= rpc->call_argc;
+		RPC_SET_RETURN(rpc, -1);
+		RPC_SET_ERRNO(rpc, rpc_Errno);
+		goto err;
+	} else
+		len = ntohl(rpc->call_len);
+	if (rlen < len || len > AIT_LEN(&c->cli_buf)) {
+		rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
+
+		rpc->call_argc ^= rpc->call_argc;
+		RPC_SET_RETURN(rpc, -1);
+		RPC_SET_ERRNO(rpc, rpc_Errno);
+		goto err;
 	}
-	len = estlen;
 
 	/* skip loop packet */
 	if (rpc->call_io & RPC_ACK) {
 		schedReadSelf(task);
-		return NULL;
+		taskExit(task, NULL);
 	}
 
 #if 0
@@ -393,24 +364,29 @@ rxPacket(sched_task_t *task)
 	rpc->call_crc ^= rpc->call_crc;
 	if (crc != crcFletcher16((u_short*) rpc, len / 2)) {
 		rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
-		return NULL;
+
+		rpc->call_argc ^= rpc->call_argc;
+		RPC_SET_RETURN(rpc, -1);
+		RPC_SET_ERRNO(rpc, rpc_Errno);
+		goto err;
 	}
 #endif
 
-	noreply = RPC_CHK_NOREPLY(rpc);
-
 	/* check RPC packet session info */
 	if (rpc_chkPktSession(&rpc->call_session, &s->srv_session)) {
 		rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");
 
 		rpc->call_argc ^= rpc->call_argc;
-		rpc->call_rep.ret = RPC_ERROR(-1);
-		rpc->call_rep.eno = RPC_ERROR(errno);
-	} else {
-		/* execute RPC call */
-		schedEvent(TASK_ROOT(task), execCall, TASK_ARG(task), (int) noreply, rpc, len);
+		RPC_SET_RETURN(rpc, -1);
+		RPC_SET_ERRNO(rpc, rpc_Errno);
+		goto err;
 	}
 
+	noreply = RPC_CHK_NOREPLY(rpc);
+
+	/* execute RPC call */
+	schedEvent(TASK_ROOT(task), execCall, TASK_ARG(task), (int) noreply, rpc, len);
+err:
 	/* send RPC reply */
 	if (!noreply)
 		schedWrite(TASK_ROOT(task), cbProto[s->srv_proto][CB_TXPACKET], 
@@ -418,7 +394,7 @@ rxPacket(sched_task_t *task)
 
 	/* lets get next packet */
 	schedReadSelf(task);
-	return NULL;
+	taskExit(task, NULL);
 }
 
 static void *
@@ -462,7 +438,7 @@ acceptClients(sched_task_t *task)
 			c->cli_sock, NULL, 0);
 end:
 	schedReadSelf(task);
-	return NULL;
+	taskExit(task, NULL);
 }
 
 
@@ -474,9 +450,8 @@ txUDPPacket(sched_task_t *task)
 	rpc_func_t *f = NULL;
 	u_char *buf = AIT_GET_BUF(&c->cli_buf);
 	struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
-	int ret, estlen, wlen = sizeof(struct tagRPCCall);
+	int ret, wlen = sizeof(struct tagRPCCall);
 	struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
-	struct pollfd pfd;
 
 	schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, TASK_ARG(task), NULL);
 	schedTimer(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
@@ -486,33 +461,35 @@ txUDPPacket(sched_task_t *task)
 		f = rpc_srv_getCall(s, ntohs(rpc->call_tag));
 		if (!f) {
 			rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
+
 			rpc->call_argc ^= rpc->call_argc;
-			rpc->call_rep.ret = RPC_ERROR(-1);
-			rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
-		} else {
-			/* calc estimated length */
-			estlen = ait_resideVars(RPC_RETVARS(c)) + wlen;
-			if (estlen > AIT_LEN(&c->cli_buf))
-				AIT_RE_BUF(&c->cli_buf, estlen);
-			buf = AIT_GET_BUF(&c->cli_buf);
-			rpc = (struct tagRPCCall*) buf;
+			RPC_SET_RETURN(rpc, -1);
+			RPC_SET_ERRNO(rpc, rpc_Errno);
+		} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
+			rpc_SetErr(EMSGSIZE, "Message too long");
 
+			rpc->call_argc ^= rpc->call_argc;
+			RPC_SET_RETURN(rpc, -1);
+			RPC_SET_ERRNO(rpc, rpc_Errno);
+		} else {
 			rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
 			/* Go Encapsulate variables */
 			ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen, 
 					RPC_RETVARS(c));
-			/* Free return values */
-			ait_freeVars(&c->cli_vars);
 			if (ret == -1) {
 				rpc_SetErr(EBADRPC, "Prepare RPC packet failed");
+
 				rpc->call_argc ^= rpc->call_argc;
-				rpc->call_rep.ret = RPC_ERROR(-1);
-				rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
+				RPC_SET_RETURN(rpc, -1);
+				RPC_SET_ERRNO(rpc, rpc_Errno);
 			} else
 				wlen += ret;
 		}
 	}
 
+	/* Free return values */
+	ait_freeVars(&c->cli_vars);
+
 	rpc->call_len = htonl(wlen);
 	rpc->call_io = RPC_ACK;
 
@@ -521,31 +498,15 @@ txUDPPacket(sched_task_t *task)
 	rpc->call_crc = htons(crcFletcher16((u_short*) buf, wlen / 2));
 
 	/* send reply */
-	pfd.fd = TASK_FD(task);
-	pfd.events = POLLOUT;
-	for (; wlen > 0; wlen -= ret, buf += ret) {
-		if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
-				pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
-			if (ret)
-				LOGERR;
-			else
-				rpc_SetErr(ETIMEDOUT, "Timeout reached! Client not respond");
-			/* close connection */
-			schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
-					TASK_ARG(task), 0, NULL, 0);
-			return NULL;
-		}
-		ret = sendto(TASK_FD(task), buf, MIN(wlen, s->srv_netbuf), MSG_NOSIGNAL, 
-				&c->cli_sa.sa, c->cli_sa.sa.sa_len);
-		if (ret == -1) {
-			/* close connection */
-			schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
-					TASK_ARG(task), 0, NULL, 0);
-			return NULL;
-		}
+	ret = sendto(TASK_FD(task), buf, wlen, MSG_NOSIGNAL, 
+			&c->cli_sa.sa, c->cli_sa.sa.sa_len);
+	if (ret == -1) {
+		/* close connection */
+		schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
+				TASK_ARG(task), 0, NULL, 0);
 	}
 
-	return NULL;
+	taskExit(task, NULL);
 }
 
 static void *
@@ -553,35 +514,48 @@ rxUDPPacket(sched_task_t *task)
 {
 	rpc_srv_t *srv = TASK_ARG(task);
 	rpc_cli_t *c = NULL;
-	int len, rlen, noreply, estlen;
+	int len, noreply = 0, rlen;
 	u_short crc;
-	u_char *buf, b[sizeof(struct tagRPCCall)];
-	struct tagRPCCall *rpc = (struct tagRPCCall*) b;
+	struct tagRPCCall *rpc;
 	sockaddr_t sa;
 	socklen_t salen;
 	struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
-	struct pollfd pfd;
+	ait_val_t b = AIT_VAL_INIT;
 
 	/* receive connect packet */
+	AIT_SET_BUF(&b, NULL, srv->srv_netbuf);
 	salen = sa.ss.ss_len = sizeof(sockaddr_t);
-	rlen = recvfrom(TASK_FD(task), b, sizeof b, MSG_PEEK, &sa.sa, &salen);
-	if (rlen < sizeof(struct tagRPCCall)) {
-		rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
+	rlen = recvfrom(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b), 0, &sa.sa, &salen);
+	rpc = (struct tagRPCCall*) AIT_GET_BUF(&b);
+	if (rlen < sizeof(struct tagRPCCall))
 		goto end;
-	}
+	else
+		len = ntohl(rpc->call_len);
+	if (rlen < len || len > srv->srv_netbuf)
+		goto end;
 
+	/* skip loop packet */
+	if (rpc->call_io & RPC_ACK)
+		goto end;
+
+	/* check integrity of packet */
+	crc = ntohs(rpc->call_crc);
+	rpc->call_crc ^= rpc->call_crc;
+	if (crc != crcFletcher16((u_short*) rpc, len / 2))
+		goto end;
+
+	/* check RPC packet session info */
+	if (rpc_chkPktSession(&rpc->call_session, &srv->srv_session))
+		goto end;
+
 	c = _allocClient(srv, &sa);
 	if (!c) {
 		EVERBOSE(1, "RPC client quota exceeded! Connection will be shutdown!\n");
 		usleep(2000);	/* blocked client delay */
 		goto end;
 	} else {
-		estlen = ntohl(rpc->call_len);
-		if (estlen > AIT_LEN(&c->cli_buf))
-			AIT_RE_BUF(&c->cli_buf, estlen);
+		memcpy(AIT_GET_BUF(&c->cli_buf), AIT_GET_BUF(&b), len);
 		rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);
-		buf = AIT_GET_BUF(&c->cli_buf);
-		len = estlen;
 
 		c->cli_sock = TASK_FD(task);
 		memcpy(&c->cli_sa, &sa, sizeof c->cli_sa);
@@ -592,70 +566,19 @@ rxUDPPacket(sched_task_t *task)
 				c, ts, c, 0);
 	}
 
-	/* get next part of packet */
-	memset(buf, 0, len);
-	pfd.fd = TASK_FD(task);
-	pfd.events = POLLIN | POLLPRI;
-	for (; len > 0; len -= rlen, buf += rlen) {
-		if ((rlen = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
-				pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
-			if (rlen)
-				LOGERR;
-			else
-				rpc_SetErr(ETIMEDOUT, "Timeout reached! Client not respond");
-			schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
-					c, 0, NULL, 0);
-			goto end;
-		}
-		salen = sa.ss.ss_len = sizeof(sockaddr_t);
-		rlen = recvfrom(TASK_FD(task), buf, len, 0, &sa.sa, &salen);
-		if (rlen == -1) {
-			/* close connection */
-			schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
-					c, 0, NULL, 0);
-			goto end;
-		}
-		if (e_addrcmp(&c->cli_sa, &sa, 42))
-			rlen ^= rlen;	/* skip if arrive from different address */
-	}
-	len = estlen;
-
-	/* skip loop packet */
-	if (rpc->call_io & RPC_ACK)
-		goto end;
-
-	/* check integrity of packet */
-	crc = ntohs(rpc->call_crc);
-	rpc->call_crc ^= rpc->call_crc;
-	if (crc != crcFletcher16((u_short*) rpc, len / 2)) {
-		rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
-		/* close connection */
-		schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
-				c, 0, NULL, 0);
-		goto end;
-	}
-
 	noreply = RPC_CHK_NOREPLY(rpc);
 
-	/* check RPC packet session info */
-	if (rpc_chkPktSession(&rpc->call_session, &srv->srv_session)) {
-		rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");
+	/* execute RPC call */
+	schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);
 
-		rpc->call_argc ^= rpc->call_argc;
-		rpc->call_rep.ret = RPC_ERROR(-1);
-		rpc->call_rep.eno = RPC_ERROR(errno);
-	} else {
-		/* execute RPC call */
-		schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);
-	}
-
 	/* send RPC reply */
 	if (!noreply)
 		schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET], 
 				c, TASK_FD(task), rpc, len);
 end:
+	AIT_FREE_VAL(&b);
 	schedReadSelf(task);
-	return NULL;
+	taskExit(task, NULL);
 }
 
 
@@ -667,9 +590,8 @@ txRAWPacket(sched_task_t *task)
 	rpc_func_t *f = NULL;
 	u_char *buf = AIT_GET_BUF(&c->cli_buf);
 	struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
-	int ret, estlen, wlen = sizeof(struct tagRPCCall);
+	int ret, wlen = sizeof(struct tagRPCCall);
 	struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
-	struct pollfd pfd;
 
 	schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, TASK_ARG(task), NULL);
 	schedTimer(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
@@ -679,33 +601,35 @@ txRAWPacket(sched_task_t *task)
 		f = rpc_srv_getCall(s, ntohs(rpc->call_tag));
 		if (!f) {
 			rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
+
 			rpc->call_argc ^= rpc->call_argc;
-			rpc->call_rep.ret = RPC_ERROR(-1);
-			rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
-		} else {
-			/* calc estimated length */
-			estlen = ait_resideVars(RPC_RETVARS(c)) + wlen;
-			if (estlen > AIT_LEN(&c->cli_buf))
-				AIT_RE_BUF(&c->cli_buf, estlen);
-			buf = AIT_GET_BUF(&c->cli_buf);
-			rpc = (struct tagRPCCall*) buf;
+			RPC_SET_RETURN(rpc, -1);
+			RPC_SET_ERRNO(rpc, rpc_Errno);
+		} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
+			rpc_SetErr(EMSGSIZE, "Message too long");
 
+			rpc->call_argc ^= rpc->call_argc;
+			RPC_SET_RETURN(rpc, -1);
+			RPC_SET_ERRNO(rpc, rpc_Errno);
+		} else {
 			rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
 			/* Go Encapsulate variables */
 			ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen, 
 					RPC_RETVARS(c));
-			/* Free return values */
-			ait_freeVars(&c->cli_vars);
 			if (ret == -1) {
 				rpc_SetErr(EBADRPC, "Prepare RPC packet failed");
+
 				rpc->call_argc ^= rpc->call_argc;
-				rpc->call_rep.ret = RPC_ERROR(-1);
-				rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
+				RPC_SET_RETURN(rpc, -1);
+				RPC_SET_ERRNO(rpc, rpc_Errno);
 			} else
 				wlen += ret;
 		}
 	}
 
+	/* Free return values */
+	ait_freeVars(&c->cli_vars);
+
 	rpc->call_len = htonl(wlen);
 	rpc->call_io = RPC_ACK;
 
@@ -714,31 +638,15 @@ txRAWPacket(sched_task_t *task)
 	rpc->call_crc = htons(crcFletcher16((u_short*) buf, wlen / 2));
 
 	/* send reply */
-	pfd.fd = TASK_FD(task);
-	pfd.events = POLLOUT;
-	for (; wlen > 0; wlen -= ret, buf += ret) {
-		if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
-				pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
-			if (ret)
-				LOGERR;
-			else
-				rpc_SetErr(ETIMEDOUT, "Timeout reached! Client not respond");
-			/* close connection */
-			schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
-					TASK_ARG(task), 0, NULL, 0);
-			return NULL;
-		}
-		ret = sendto(TASK_FD(task), buf, MIN(wlen, s->srv_netbuf), MSG_NOSIGNAL, 
-				&c->cli_sa.sa, c->cli_sa.sa.sa_len);
-		if (ret == -1) {
-			/* close connection */
-			schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
-					TASK_ARG(task), 0, NULL, 0);
-			return NULL;
-		}
+	ret = sendto(TASK_FD(task), buf, wlen, MSG_NOSIGNAL, 
+			&c->cli_sa.sa, c->cli_sa.sa.sa_len);
+	if (ret == -1) {
+		/* close connection */
+		schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
+				TASK_ARG(task), 0, NULL, 0);
 	}
 
-	return NULL;
+	taskExit(task, NULL);
 }
 
 static void *
@@ -746,40 +654,67 @@ rxRAWPacket(sched_task_t *task)
 {
 	rpc_srv_t *srv = TASK_ARG(task);
 	rpc_cli_t *c = NULL;
-	int len, rlen, noreply, estlen;
+	int len, noreply = 0, rlen;
 	u_short crc;
-	u_char *buf, b[sizeof(struct ip6_hdr) + sizeof(struct tagRPCCall)];
 	struct tagRPCCall *rpc;
 	sockaddr_t sa;
 	socklen_t salen;
 	struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
-	struct pollfd pfd;
+	ait_val_t b = AIT_VAL_INIT;
 
 	/* receive connect packet */
+	AIT_SET_BUF(&b, NULL, srv->srv_netbuf);
 	salen = sa.ss.ss_len = sizeof(sockaddr_t);
-	rlen = recvfrom(TASK_FD(task), b, sizeof b, MSG_PEEK, &sa.sa, &salen);
-	if (rlen < sizeof(struct ip) + sizeof(struct tagRPCCall)) {
-		rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
-		goto end;
+	rlen = recvfrom(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b), 0, &sa.sa, &salen);
+	if (sa.sa.sa_family == AF_INET) {
+		struct ip *h;
+		h = (struct ip*) AIT_GET_BUF(&b);
+		if (rlen < ntohs(h->ip_len) || h->ip_p != IPPROTO_ERPC)
+			goto end;
+		else {
+			rlen -= sizeof(struct ip);
+			rpc = (struct tagRPCCall*) (h + 1);
+		}
+	} else {
+		struct ip6_hdr *h;
+		h = (struct ip6_hdr*) AIT_GET_BUF(&b);
+		if (rlen < (ntohs(h->ip6_plen) + sizeof(struct ip6_hdr)) || 
+				h->ip6_nxt != IPPROTO_ERPC)
+			goto end;
+		else {
+			rlen -= sizeof(struct ip6_hdr);
+			rpc = (struct tagRPCCall*) (h + 1);
+		}
 	}
+	if (rlen < sizeof(struct tagRPCCall))
+		goto end;
+	else
+		len = ntohl(rpc->call_len);
+	if (rlen < len || len > srv->srv_netbuf)
+		goto end;
 
+	/* skip loop packet */
+	if (rpc->call_io & RPC_ACK)
+		goto end;
+
+	/* check integrity of packet */
+	crc = ntohs(rpc->call_crc);
+	rpc->call_crc ^= rpc->call_crc;
+	if (crc != crcFletcher16((u_short*) rpc, len / 2))
+		goto end;
+
+	/* check RPC packet session info */
+	if (rpc_chkPktSession(&rpc->call_session, &srv->srv_session))
+		goto end;
+
 	c = _allocClient(srv, &sa);
 	if (!c) {
 		EVERBOSE(1, "RPC client quota exceeded! Connection will be shutdown!\n");
 		usleep(2000);	/* blocked client delay */
 		goto end;
 	} else {
-		estlen = sa.sa.sa_family == AF_INET ? 
-			sizeof(struct ip) : sizeof(struct ip6_hdr);
-		rpc = (struct tagRPCCall*) (b + estlen);
-		estlen += ntohl(rpc->call_len);
-		if (estlen > AIT_LEN(&c->cli_buf))
-			AIT_RE_BUF(&c->cli_buf, estlen);
-		rpc = (struct tagRPCCall*) (AIT_GET_BUF(&c->cli_buf) + 
-			(sa.sa.sa_family == AF_INET ? 
-			sizeof(struct ip) : sizeof(struct ip6_hdr)));
-		buf = AIT_GET_BUF(&c->cli_buf);
-		len = estlen;
+		memcpy(AIT_GET_BUF(&c->cli_buf), rpc, len);
+		rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);
 
 		c->cli_sock = TASK_FD(task);
 		memcpy(&c->cli_sa, &sa, sizeof c->cli_sa);
@@ -790,74 +725,19 @@ rxRAWPacket(sched_task_t *task)
 				c, ts, c, 0);
 	}
 
-	/* get next part of packet */
-	memset(buf, 0, len);
-	pfd.fd = TASK_FD(task);
-	pfd.events = POLLIN | POLLPRI;
-	for (; len > 0; len -= rlen, buf += rlen) {
-		if ((rlen = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
-				pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
-			if (rlen)
-				LOGERR;
-			else
-				rpc_SetErr(ETIMEDOUT, "Timeout reached! Client not respond");
-			schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
-					c, 0, NULL, 0);
-			goto end;
-		}
-		salen = sa.ss.ss_len = sizeof(sockaddr_t);
-		rlen = recvfrom(TASK_FD(task), buf, len, 0, &sa.sa, &salen);
-		if (rlen == -1) {
-			/* close connection */
-			schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
-					c, 0, NULL, 0);
-			goto end;
-		}
-		if (e_addrcmp(&c->cli_sa, &sa, 42))
-			rlen ^= rlen;	/* skip if arrive from different address */
-	}
-	len = estlen;
-	len -= sa.sa.sa_family == AF_INET ? 
-		sizeof(struct ip) : sizeof(struct ip6_hdr);
-	memmove(AIT_GET_BUF(&c->cli_buf), rpc, len);
-	rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);
-
-	/* skip loop packet */
-	if (rpc->call_io & RPC_ACK)
-		goto end;
-
-	/* check integrity of packet */
-	crc = ntohs(rpc->call_crc);
-	rpc->call_crc ^= rpc->call_crc;
-	if (crc != crcFletcher16((u_short*) rpc, len / 2)) {
-		rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
-		/* close connection */
-		schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
-				c, 0, NULL, 0);
-		goto end;
-	}
-
 	noreply = RPC_CHK_NOREPLY(rpc);
 
-	/* check RPC packet session info */
-	if (rpc_chkPktSession(&rpc->call_session, &srv->srv_session)) {
-		rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");
+	/* execute RPC call */
+	schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);
 
-		rpc->call_argc ^= rpc->call_argc;
-		rpc->call_rep.ret = RPC_ERROR(-1);
-		rpc->call_rep.eno = RPC_ERROR(errno);
-	} else {
-		/* execute RPC call */
-		schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);
-	}
-
 	/* send RPC reply */
 	if (!noreply)
 		schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET], 
 				c, TASK_FD(task), rpc, len);
 end:
+	AIT_FREE_VAL(&b);
 	schedReadSelf(task);
-	return NULL;
+	taskExit(task, NULL);
 }
 
 
@@ -869,7 +749,7 @@ txBPFPacket(sched_task_t *task)
 	rpc_func_t *f = NULL;
 	u_char *buf = AIT_GET_BUF(&c->cli_buf);
 	struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
-	int ret, len, wlen = sizeof(struct tagRPCCall);
+	int ret, wlen = sizeof(struct tagRPCCall);
 	struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
 	struct ether_header *eh;
 	ait_val_t b = AIT_VAL_INIT;
@@ -882,33 +762,35 @@ txBPFPacket(sched_task_t *task)
 		f = rpc_srv_getCall(s, ntohs(rpc->call_tag));
 		if (!f) {
 			rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
+
 			rpc->call_argc ^= rpc->call_argc;
-			rpc->call_rep.ret = RPC_ERROR(-1);
-			rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
-		} else {
-			/* calc estimated length */
-			len = ait_resideVars(RPC_RETVARS(c)) + wlen;
-			if (len > AIT_LEN(&c->cli_buf))
-				AIT_RE_BUF(&c->cli_buf, len);
-			buf = AIT_GET_BUF(&c->cli_buf);
-			rpc = (struct tagRPCCall*) buf;
+			RPC_SET_RETURN(rpc, -1);
+			RPC_SET_ERRNO(rpc, rpc_Errno);
+		} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
+			rpc_SetErr(EMSGSIZE, "Message too long");
 
+			rpc->call_argc ^= rpc->call_argc;
+			RPC_SET_RETURN(rpc, -1);
+			RPC_SET_ERRNO(rpc, rpc_Errno);
+		} else {
 			rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
 			/* Go Encapsulate variables */
 			ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen, 
 					RPC_RETVARS(c));
-			/* Free return values */
-			ait_freeVars(&RPC_RETVARS(c));
 			if (ret == -1) {
 				rpc_SetErr(EBADRPC, "Prepare RPC packet failed");
+
 				rpc->call_argc ^= rpc->call_argc;
-				rpc->call_rep.ret = RPC_ERROR(-1);
-				rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
+				RPC_SET_RETURN(rpc, -1);
+				RPC_SET_ERRNO(rpc, rpc_Errno);
 			} else
 				wlen += ret;
 		}
 	}
 
+	/* Free return values */
+	ait_freeVars(&RPC_RETVARS(c));
+
 	rpc->call_len = htonl(wlen);
 	rpc->call_io = RPC_ACK;
 
@@ -917,11 +799,11 @@ txBPFPacket(sched_task_t *task)
 	rpc->call_crc = htons(crcFletcher16((u_short*) buf, wlen / 2));
 
 	/* send reply */
-	AIT_SET_BUF(&b, NULL, MIN(wlen, s->srv_netbuf) + ETHER_HDR_LEN);
+	AIT_SET_BUF(&b, NULL, wlen + ETHER_HDR_LEN);
 	eh = (struct ether_header*) AIT_GET_BUF(&b);
 	memcpy(eh->ether_dhost, LLADDR(&c->cli_sa.sdl), ETHER_ADDR_LEN);
 	eh->ether_type = htons(RPC_DEFPORT);
-	memcpy(eh + 1, buf, MIN(wlen, s->srv_netbuf));
+	memcpy(eh + 1, buf, wlen);
 
 	ret = write(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b));
 	AIT_FREE_VAL(&b);
@@ -929,10 +811,9 @@ txBPFPacket(sched_task_t *task)
 		/* close connection */
 		schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
 				TASK_ARG(task), 0, NULL, 0);
-		return NULL;
 	}
 
-	return NULL;
+	taskExit(task, NULL);
 }
 
 static void *
@@ -955,37 +836,49 @@ rxBPFPacket(sched_task_t *task)
 	h = (struct bpf_hdr*) AIT_GET_BUF(&b);
 	rlen -= h->bh_hdrlen;
 	if (rlen < h->bh_datalen || h->bh_caplen != h->bh_datalen || 
-			rlen < ETHER_HDR_LEN + sizeof(struct tagRPCCall)) {
-		rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
+			rlen < ETHER_HDR_LEN + sizeof(struct tagRPCCall))
 		goto end;
-	} else {
+	else {
 		rlen = h->bh_caplen;
 		eh = (struct ether_header*) (AIT_GET_BUF(&b) + h->bh_hdrlen);
 		rlen -= ETHER_HDR_LEN;
 		rpc = (struct tagRPCCall*) (eh + 1);
 
-#if 0
-		/* skip loop packet */
-		if (rpc->call_io & RPC_ACK)
-			goto end;
-#endif
-
 		if (eh->ether_type != ntohs(RPC_DEFPORT))
 			goto end;
 		else
 			e_getlinkbymac((const ether_addr_t*) eh->ether_shost, &sa);
 	}
+	if (rlen < sizeof(struct tagRPCCall))
+		goto end;
+	else
+		len = ntohl(rpc->call_len);
+	if (rlen < len || len > srv->srv_netbuf)
+		goto end;
 
+#ifdef CHECK_ETHACK
+	/* skip loop packet */
+	if (rpc->call_io & RPC_ACK)
+		goto end;
+#endif
+
+	/* check integrity of packet */
+	crc = ntohs(rpc->call_crc);
+	rpc->call_crc ^= rpc->call_crc;
+	if (crc != crcFletcher16((u_short*) rpc, len / 2))
+		goto end;
+
+	/* check RPC packet session info */
+	if (rpc_chkPktSession(&rpc->call_session, &srv->srv_session))
+		goto end;
+
 	c = _allocClient(srv, &sa);
 	if (!c) {
 		EVERBOSE(1, "RPC client quota exceeded! Connection will be shutdown!\n");
 		usleep(2000);	/* blocked client delay */
 		goto end;
 	} else {
-		len = ntohl(rpc->call_len);
-		if (len > AIT_LEN(&c->cli_buf))
-			AIT_RE_BUF(&c->cli_buf, len);
-		memcpy(AIT_GET_BUF(&c->cli_buf), rpc, AIT_LEN(&c->cli_buf));
+		memcpy(AIT_GET_BUF(&c->cli_buf), rpc, len);
 		rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);
 
 		c->cli_sock = TASK_FD(task);
@@ -997,31 +890,11 @@ rxBPFPacket(sched_task_t *task)
 				c, ts, c, 0);
 	}
 
-	/* check integrity of packet */
-	crc = ntohs(rpc->call_crc);
-	rpc->call_crc ^= rpc->call_crc;
-	if (crc != crcFletcher16((u_short*) rpc, len / 2)) {
-		rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
-		/* close connection */
-		schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
-				c, 0, NULL, 0);
-		goto end;
-	}
-
 	noreply = RPC_CHK_NOREPLY(rpc);
 
-	/* check RPC packet session info */
-	if (rpc_chkPktSession(&rpc->call_session, &srv->srv_session)) {
-		rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");
+	/* execute RPC call */
+	schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);
 
-		rpc->call_argc ^= rpc->call_argc;
-		rpc->call_rep.ret = RPC_ERROR(-1);
-		rpc->call_rep.eno = RPC_ERROR(errno);
-	} else {
-		/* execute RPC call */
-		schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);
-	}
-
 	/* send RPC reply */
 	if (!noreply)
 		schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET], 
@@ -1029,7 +902,7 @@ rxBPFPacket(sched_task_t *task)
 end:
 	AIT_FREE_VAL(&b);
 	schedReadSelf(task);
-	return NULL;
+	taskExit(task, NULL);
 }
 
 
@@ -1041,7 +914,7 @@ txEXTPacket(sched_task_t *task)
 	rpc_func_t *f = NULL;
 	u_char *buf = AIT_GET_BUF(&c->cli_buf);
 	struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
-	int ret, len, wlen = sizeof(struct tagRPCCall);
+	int ret, wlen = sizeof(struct tagRPCCall);
 	struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
 
 	schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, TASK_ARG(task), NULL);
@@ -1052,46 +925,47 @@ txEXTPacket(sched_task_t *task)
 		f = rpc_srv_getCall(s, ntohs(rpc->call_tag));
 		if (!f) {
 			rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
+
 			rpc->call_argc ^= rpc->call_argc;
-			rpc->call_rep.ret = RPC_ERROR(-1);
-			rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
-		} else {
-			/* calc estimated length */
-			len = ait_resideVars(RPC_RETVARS(c)) + wlen;
-			if (len > AIT_LEN(&c->cli_buf))
-				AIT_RE_BUF(&c->cli_buf, len);
-			buf = AIT_GET_BUF(&c->cli_buf);
-			rpc = (struct tagRPCCall*) buf;
+			RPC_SET_RETURN(rpc, -1);
+			RPC_SET_ERRNO(rpc, rpc_Errno);
+		} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
+			rpc_SetErr(EMSGSIZE, "Message too long");
 
+			rpc->call_argc ^= rpc->call_argc;
+			RPC_SET_RETURN(rpc, -1);
+			RPC_SET_ERRNO(rpc, rpc_Errno);
+		} else {
 			rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
 			/* Go Encapsulate variables */
 			ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen, 
 					RPC_RETVARS(c));
-			/* Free return values */
-			ait_freeVars(&RPC_RETVARS(c));
 			if (ret == -1) {
 				rpc_SetErr(EBADRPC, "Prepare RPC packet failed");
+
 				rpc->call_argc ^= rpc->call_argc;
-				rpc->call_rep.ret = RPC_ERROR(-1);
-				rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
+				RPC_SET_RETURN(rpc, -1);
+				RPC_SET_ERRNO(rpc, rpc_Errno);
 			} else
 				wlen += ret;
 		}
 	}
 
+	/* Free return values */
+	ait_freeVars(&RPC_RETVARS(c));
+
 	rpc->call_len = htonl(wlen);
 	rpc->call_io = RPC_ACK;
 
 	/* send reply */
-	ret = write(TASK_FD(task), buf, MIN(wlen, s->srv_netbuf));
+	ret = write(TASK_FD(task), buf, wlen);
 	if (ret == -1) {
 		/* close connection */
 		schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
 				TASK_ARG(task), 0, NULL, 0);
-		return NULL;
 	}
 
-	return NULL;
+	taskExit(task, NULL);
 }
 
 static void *
@@ -1099,37 +973,39 @@ rxEXTPacket(sched_task_t *task)
 {
 	rpc_srv_t *srv = TASK_ARG(task);
 	rpc_cli_t *c = NULL;
-	int len, rlen, noreply;
+	int len, noreply = 0, rlen = AIT_LEN(&c->cli_buf);
 	struct tagRPCCall *rpc;
 	struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
-	ait_val_t b = AIT_VAL_INIT;
 	sockaddr_t sa;
+	ait_val_t b = AIT_VAL_INIT;
 
 	memset(&sa, 0, sizeof sa);
 	/* receive connect packet */
 	AIT_SET_BUF(&b, NULL, srv->srv_netbuf);
 	rlen = read(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b));
-	if (rlen < sizeof(struct tagRPCCall)) {
-		rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
+	rpc = (struct tagRPCCall*) AIT_GET_BUF(&b);
+	if (rlen < sizeof(struct tagRPCCall))
 		goto end;
-	} else {
-		rpc = (struct tagRPCCall*) AIT_GET_BUF(&b);
+	else
+		len = ntohl(rpc->call_len);
+	if (rlen < len || len > srv->srv_netbuf)
+		goto end;
 
-		/* skip loop packet */
-		if (rpc->call_io & RPC_ACK)
-			goto end;
-	}
+	/* skip loop packet */
+	if (rpc->call_io & RPC_ACK)
+		goto end;
 
+	/* check RPC packet session info */
+	if (rpc_chkPktSession(&rpc->call_session, &srv->srv_session))
+		goto end;
+
 	c = _allocClient(srv, &sa);
 	if (!c) {
 		EVERBOSE(1, "RPC client quota exceeded! Connection will be shutdown!\n");
 		usleep(2000);	/* blocked client delay */
 		goto end;
 	} else {
-		len = ntohl(rpc->call_len);
-		if (len > AIT_LEN(&c->cli_buf))
-			AIT_RE_BUF(&c->cli_buf, len);
-		memcpy(AIT_GET_BUF(&c->cli_buf), rpc, AIT_LEN(&c->cli_buf));
+		memcpy(AIT_GET_BUF(&c->cli_buf), AIT_GET_BUF(&b), len);
 		rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);
 
 		c->cli_sock = TASK_FD(task);
@@ -1142,18 +1018,9 @@ rxEXTPacket(sched_task_t *task)
 
 	noreply = RPC_CHK_NOREPLY(rpc);
 
-	/* check RPC packet session info */
-	if (rpc_chkPktSession(&rpc->call_session, &srv->srv_session)) {
-		rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");
+	/* execute RPC call */
+	schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);
 
-		rpc->call_argc ^= rpc->call_argc;
-		rpc->call_rep.ret = RPC_ERROR(-1);
-		rpc->call_rep.eno = RPC_ERROR(errno);
-	} else {
-		/* execute RPC call */
-		schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);
-	}
-
 	/* send RPC reply */
 	if (!noreply)
 		schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET], 
@@ -1161,7 +1028,7 @@ rxEXTPacket(sched_task_t *task)
 end:
 	AIT_FREE_VAL(&b);
 	schedReadSelf(task);
-	return NULL;
+	taskExit(task, NULL);
 }
 
 /* ------------------------------------------------------ */
@@ -1192,7 +1059,7 @@ closeBLOBClient(sched_task_t *task)
 	/* close client socket */
 	shutdown(sock, SHUT_RDWR);
 	close(sock);
-	return NULL;
+	taskExit(task, NULL);
 }
 
 static void *
@@ -1209,7 +1076,7 @@ txBLOB(sched_task_t *task)
 		schedEvent(TASK_ROOT(task), closeBLOBClient, c, 42, NULL, 0);
 	}
 
-	return NULL;
+	taskExit(task, NULL);
 }
 
 static void *
@@ -1226,7 +1093,7 @@ rxBLOB(sched_task_t *task)
 	if (rlen < 1) {
 		/* close blob connection */
 		schedEvent(TASK_ROOT(task), closeBLOBClient, c, 42, NULL, 0);
-		return NULL;
+		taskExit(task, NULL);
 	}
 
 	/* check BLOB packet */
@@ -1234,7 +1101,7 @@ rxBLOB(sched_task_t *task)
 		rpc_SetErr(ERPCMISMATCH, "Short BLOB packet");
 
 		schedReadSelf(task);
-		return NULL;
+		taskExit(task, NULL);
 	}
 
 	/* check RPC packet session info */
@@ -1250,7 +1117,7 @@ rxBLOB(sched_task_t *task)
 			if (!(b = rpc_srv_getBLOB(s, ntohl(blob.hdr_var)))) {
 				rpc_SetErr(EINVAL, "Var=%x not found", ntohl(blob.hdr_var));
 				blob.hdr_cmd = no;
-				blob.hdr_ret = RPC_ERROR(-1);
+				RPC_SET_BLOB_RET(&blob, -1);
 				break;
 			} else
 				blob.hdr_len = htonl(b->blob_len);
@@ -1261,7 +1128,7 @@ rxBLOB(sched_task_t *task)
 				rpc_srv_blobUnmap(b);
 			} else {
 				blob.hdr_cmd = error;
-				blob.hdr_ret = RPC_ERROR(-1);
+				RPC_SET_BLOB_RET(&blob, -1);
 			}
 			break;
 		case set:
@@ -1275,26 +1142,26 @@ rxBLOB(sched_task_t *task)
 				rpc_srv_blobUnmap(b);
 			} else {
 				blob.hdr_cmd = error;
-				blob.hdr_ret = RPC_ERROR(-1);
+				RPC_SET_BLOB_RET(&blob, -1);
 			}
 			break;
 		case unset:
 			if (rpc_srv_unregisterBLOB(s, ntohl(blob.hdr_var)) == -1) {
 				blob.hdr_cmd = error;
-				blob.hdr_ret = RPC_ERROR(-1);
+				RPC_SET_BLOB_RET(&blob, -1);
 			}
 			break;
 		default:
 			rpc_SetErr(EPROCUNAVAIL, "Unsupported BLOB command %d", blob.hdr_cmd);
 			blob.hdr_cmd = error;
-			blob.hdr_ret = RPC_ERROR(-1);
+			RPC_SET_BLOB_RET(&blob, -1);
 	}
 
 end:
 	memcpy(AIT_ADDR(&c->cli_buf), &blob, sizeof blob);
 	schedWrite(TASK_ROOT(task), txBLOB, TASK_ARG(task), TASK_FD(task), NULL, 0);
 	schedReadSelf(task);
-	return NULL;
+	taskExit(task, NULL);
 }
 
 static void *
@@ -1322,7 +1189,7 @@ flushBLOB(sched_task_t *task)
 		sigaction(SIGFBLOB, &sa, NULL);
 	}
 
-	return NULL;
+	taskExit(task, NULL);
 }
 
 static void *
@@ -1353,7 +1220,7 @@ acceptBLOBClients(sched_task_t *task)
 	if (!c) {
 		LOGERR;
 		srv->srv_kill = srv->srv_blob.kill = 1;
-		return NULL;
+		taskExit(task, NULL);
 	} else {
 		memset(c, 0, sizeof(rpc_cli_t));
 		array_Set(srv->srv_blob.clients, i, c);
@@ -1381,7 +1248,7 @@ acceptBLOBClients(sched_task_t *task)
 	schedRead(TASK_ROOT(task), rxBLOB, c, c->cli_sock, NULL, 0);
 end:
 	schedReadSelf(task);
-	return NULL;
+	taskExit(task, NULL);
 }
 
 /* ------------------------------------------------------ */
@@ -1509,6 +1376,9 @@ rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
 	srv->srv_blob.kill = 1;
 
 	schedEnd(&srv->srv_blob.root);
+
+	if (srv->srv_blob.server.cli_sa.sa.sa_family == AF_LOCAL)
+		unlink(srv->srv_blob.server.cli_sa.sun.sun_path);
 }
 
 /*
@@ -1610,10 +1480,10 @@ rpc_srv_initServer(u_char InstID, int concurentClients
 		rpc_SetErr(EINVAL, "Invalid parameters can`t init RPC server");
 		return NULL;
 	}
+	if (!Port && proto < SOCK_RAW)
+		Port = RPC_DEFPORT;
 	if (!e_gethostbyname(csHost, Port, &sa))
 		return NULL;
-	if (!Port)
-		Port = RPC_DEFPORT;
 	if (!proto)
 		proto = SOCK_STREAM;
 	if (netBuf < RPC_MIN_BUFSIZ)
@@ -1683,6 +1553,8 @@ rpc_srv_initServer(u_char InstID, int concurentClients
 		LOGERR;
 		goto err;
 	}
+	if (srv->srv_proto == SOCK_STREAM)
+		setsockopt(srv->srv_server.cli_sock, IPPROTO_TCP, TCP_NODELAY, &n, sizeof n);
 	n = srv->srv_netbuf;
 	if (setsockopt(srv->srv_server.cli_sock, SOL_SOCKET, SO_SNDBUF, &n, sizeof n) == -1) {
 		LOGERR;
@@ -1731,6 +1603,9 @@ rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
 	sleep(RPC_SCHED_POLLING);
 
 	schedEnd(&(*psrv)->srv_root);
+
+	if ((*psrv)->srv_server.cli_sa.sa.sa_family == AF_LOCAL)
+		unlink((*psrv)->srv_server.cli_sa.sun.sun_path);
 
 	pthread_mutex_destroy(&(*psrv)->srv_funcs.mtx);
 	e_free(*psrv);