diff --git a/src/common/common.c b/src/common/common.c
index 03ce191b..10e22cb8 100644
--- a/src/common/common.c
+++ b/src/common/common.c
@@ -30,6 +30,7 @@
 #include <netinet/in.h>
 #include <netinet/ip.h>
 #include <poll.h>
+#include <limits.h>
 
 #include "common.h"
 
@@ -277,9 +278,11 @@ ssize_t recvmsg_timeout(int sockfd, struct msghdr * msg, int flags,
 }
 
 /* Sends message + socketfd */
+static
 int send_socket_msg(void *pool, int fd, uint8_t cmd,
-		    int socketfd,
-		    const void *msg, pack_size_func get_size, pack_func pack)
+		    int socketfd, const void *msg,
+		    pack_size_func get_size, pack_func pack,
+		    unsigned use_32bit)
 {
 	struct iovec iov[3];
 	struct msghdr hdr;
@@ -289,7 +292,9 @@ int send_socket_msg(void *pool, int fd, uint8_t cmd,
 	} control_un;
 	struct cmsghdr *cmptr;
 	void *packed = NULL;
-	uint16_t length;
+	uint16_t length16;
+	uint32_t length32;
+	size_t length;
 	int ret;
 
 	memset(&hdr, 0, sizeof(hdr));
@@ -299,8 +304,21 @@ int send_socket_msg(void *pool, int fd, uint8_t cmd,
 
 	length = get_size(msg);
 
-	iov[1].iov_base = &length;
-	iov[1].iov_len = 2;
+	if (use_32bit) {
+		if (length >= UINT32_MAX)
+			return -1;
+
+		length32 = length;
+		iov[1].iov_base = &length32;
+		iov[1].iov_len = 4;
+	} else {
+		if (length >= UINT16_MAX)
+			return -1;
+
+		length16 = length;
+		iov[1].iov_base = &length16;
+		iov[1].iov_len = 2;
+	}
 
 	hdr.msg_iov = iov;
 	hdr.msg_iovlen = 2;
@@ -349,16 +367,23 @@ int send_socket_msg(void *pool, int fd, uint8_t cmd,
  cleanup:
 	talloc_free(packed);
 	return ret;
-
 }
 
-int send_msg(void *pool, int fd, uint8_t cmd,
-	     const void *msg, pack_size_func get_size, pack_func pack)
+int send_socket_msg16(void *pool, int fd, uint8_t cmd,
+		      int socketfd, const void *msg,
+		      pack_size_func get_size, pack_func pack)
 {
-	return send_socket_msg(pool, fd, cmd, -1, msg, get_size, pack);
+	return send_socket_msg(pool, fd, cmd, socketfd, msg, get_size, pack, 0);
 }
 
-int recv_socket_msg(void *pool, int fd, uint8_t cmd,
+int send_socket_msg32(void *pool, int fd, uint8_t cmd,
+		      int socketfd, const void *msg,
+		      pack_size_func get_size, pack_func pack)
+{
+	return send_socket_msg(pool, fd, cmd, socketfd, msg, get_size, pack, 1);
+}
+
+int recv_socket_msg16(void *pool, int fd, uint8_t cmd,
 		    int *socketfd, void **msg, unpack_func unpack,
 		    unsigned timeout)
 {
@@ -463,12 +488,6 @@ int recv_socket_msg(void *pool, int fd, uint8_t cmd,
 	return ret;
 }
 
-int recv_msg(void *pool, int fd, uint8_t cmd,
-	     void **msg, unpack_func unpack, unsigned timeout)
-{
-	return recv_socket_msg(pool, fd, cmd, NULL, msg, unpack, timeout);
-}
-
 void _talloc_free2(void *ctx, void *ptr)
 {
 	talloc_free(ptr);
diff --git a/src/common/common.h b/src/common/common.h
index 76d3611b..b63d01a8 100644
--- a/src/common/common.h
+++ b/src/common/common.h
@@ -54,19 +54,39 @@ typedef void* (*unpack_func)(ProtobufCAllocator  *allocator,
                       size_t               len,
                       const uint8_t       *data);
 
-int send_msg(void *pool, int fd, uint8_t cmd, 
-	    const void* msg, pack_size_func get_size, pack_func pack);
+int send_socket_msg16(void *pool, int fd, uint8_t cmd, 
+		      int socketfd,
+		      const void* msg, pack_size_func get_size, pack_func pack);
 
-int send_socket_msg(void *pool, int fd, uint8_t cmd, 
-		    int socketfd,
-		    const void* msg, pack_size_func get_size, pack_func pack);
+int send_socket_msg32(void *pool, int fd, uint8_t cmd, 
+		      int socketfd,
+		      const void* msg, pack_size_func get_size, pack_func pack);
+
+inline static int send_msg16(void *pool, int fd, uint8_t cmd,
+	     const void *msg, pack_size_func get_size, pack_func pack)
+{
+	return send_socket_msg16(pool, fd, cmd, -1, msg, get_size, pack);
+}
+
+inline static
+int send_msg32(void *pool, int fd, uint8_t cmd,
+	     const void *msg, pack_size_func get_size, pack_func pack)
+{
+	return send_socket_msg32(pool, fd, cmd, -1, msg, get_size, pack);
+}
+
+
+int recv_socket_msg16(void *pool, int fd, uint8_t cmd, 
+  	    	      int *socketfd, void** msg, unpack_func, unsigned timeout);
 
 /* the timeout is in seconds */
-int recv_msg(void *pool, int fd, uint8_t cmd, 
-	     void** msg, unpack_func, unsigned timeout);
+inline static int recv_msg16(void *pool, int fd, uint8_t cmd,
+	     void **msg, unpack_func unpack, unsigned timeout)
+{
+	return recv_socket_msg16(pool, fd, cmd, NULL, msg, unpack, timeout);
+}
+
 
-int recv_socket_msg(void *pool, int fd, uint8_t cmd, 
-			int *socketfd, void** msg, unpack_func, unsigned timeout);
 
 const char* cmd_request_to_str(unsigned cmd);
 const char* discon_reason_to_str(unsigned reason);
diff --git a/src/main-ctl-unix.c b/src/main-ctl-unix.c
index 9575b887..37442667 100644
--- a/src/main-ctl-unix.c
+++ b/src/main-ctl-unix.c
@@ -183,7 +183,7 @@ static void method_status(method_ctx *ctx, int cfd, uint8_t * msg,
 	rep.stored_tls_sessions = ctx->s->tlsdb_entries;
 	rep.banned_ips = main_ban_db_elems(ctx->s);
 
-	ret = send_msg(ctx->pool, cfd, CTL_CMD_STATUS_REP, &rep,
+	ret = send_msg32(ctx->pool, cfd, CTL_CMD_STATUS_REP, &rep,
 		       (pack_size_func) status_rep__get_packed_size,
 		       (pack_func) status_rep__pack);
 	if (ret < 0) {
@@ -205,7 +205,7 @@ static void method_reload(method_ctx *ctx, int cfd, uint8_t * msg,
 
 	rep.status = 1;
 
-	ret = send_msg(ctx->pool, cfd, CTL_CMD_RELOAD_REP, &rep,
+	ret = send_msg32(ctx->pool, cfd, CTL_CMD_RELOAD_REP, &rep,
 		       (pack_size_func) bool_msg__get_packed_size,
 		       (pack_func) bool_msg__pack);
 	if (ret < 0) {
@@ -227,7 +227,7 @@ static void method_stop(method_ctx *ctx, int cfd, uint8_t * msg,
 
 	rep.status = 1;
 
-	ret = send_msg(ctx->pool, cfd, CTL_CMD_STOP_REP, &rep,
+	ret = send_msg32(ctx->pool, cfd, CTL_CMD_STOP_REP, &rep,
 		       (pack_size_func) bool_msg__get_packed_size,
 		       (pack_func) bool_msg__pack);
 	if (ret < 0) {
@@ -427,7 +427,7 @@ static void method_list_users(method_ctx *ctx, int cfd, uint8_t * msg,
 		}
 	}
 
-	ret = send_msg(ctx->pool, cfd, CTL_CMD_LIST_REP, &rep,
+	ret = send_msg32(ctx->pool, cfd, CTL_CMD_LIST_REP, &rep,
 		       (pack_size_func) user_list_rep__get_packed_size,
 		       (pack_func) user_list_rep__pack);
 	if (ret < 0) {
@@ -505,7 +505,7 @@ static void method_list_banned(method_ctx *ctx, int cfd, uint8_t * msg,
 		e = htable_next(db, &iter);
 	}
 
-	ret = send_msg(ctx->pool, cfd, CTL_CMD_LIST_BANNED_REP, &rep,
+	ret = send_msg32(ctx->pool, cfd, CTL_CMD_LIST_BANNED_REP, &rep,
 		       (pack_size_func) ban_list_rep__get_packed_size,
 		       (pack_func) ban_list_rep__pack);
 	if (ret < 0) {
@@ -561,7 +561,7 @@ static void single_info_common(method_ctx *ctx, int cfd, uint8_t * msg,
 			mslog(ctx->s, NULL, LOG_INFO, "could not find ID '%u'", id);
 	}
 
-	ret = send_msg(ctx->pool, cfd, CTL_CMD_LIST_REP, &rep,
+	ret = send_msg32(ctx->pool, cfd, CTL_CMD_LIST_REP, &rep,
 		       (pack_size_func) user_list_rep__get_packed_size,
 		       (pack_func) user_list_rep__pack);
 	if (ret < 0) {
@@ -633,7 +633,7 @@ static void method_unban_ip(method_ctx *ctx,
 
 	unban_req__free_unpacked(req, NULL);
 
-	ret = send_msg(ctx->pool, cfd, CTL_CMD_UNBAN_IP_REP, &rep,
+	ret = send_msg32(ctx->pool, cfd, CTL_CMD_UNBAN_IP_REP, &rep,
 		       (pack_size_func) bool_msg__get_packed_size,
 		       (pack_func) bool_msg__pack);
 	if (ret < 0) {
@@ -672,7 +672,7 @@ static void method_disconnect_user_name(method_ctx *ctx,
 
 	username_req__free_unpacked(req, NULL);
 
-	ret = send_msg(ctx->pool, cfd, CTL_CMD_DISCONNECT_NAME_REP, &rep,
+	ret = send_msg32(ctx->pool, cfd, CTL_CMD_DISCONNECT_NAME_REP, &rep,
 		       (pack_size_func) bool_msg__get_packed_size,
 		       (pack_func) bool_msg__pack);
 	if (ret < 0) {
@@ -712,7 +712,7 @@ static void method_disconnect_user_id(method_ctx *ctx, int cfd,
 	/* reply */
 	id_req__free_unpacked(req, NULL);
 
-	ret = send_msg(ctx->pool, cfd, CTL_CMD_DISCONNECT_ID_REP, &rep,
+	ret = send_msg32(ctx->pool, cfd, CTL_CMD_DISCONNECT_ID_REP, &rep,
 		       (pack_size_func) bool_msg__get_packed_size,
 		       (pack_func) bool_msg__pack);
 	if (ret < 0) {
@@ -887,7 +887,7 @@ void ctl_handler_notify (main_server_st* s, struct proc_st *proc, unsigned conne
 	}
 	rep.user = &list;
 
-	ret = send_msg(pool, s->top_fd, CTL_CMD_TOP_UPDATE_REP, &rep,
+	ret = send_msg32(pool, s->top_fd, CTL_CMD_TOP_UPDATE_REP, &rep,
 		       (pack_size_func) top_update_rep__get_packed_size,
 		       (pack_func) top_update_rep__pack);
 	if (ret < 0) {
diff --git a/src/main-sec-mod-cmd.c b/src/main-sec-mod-cmd.c
index 2baccd67..796ee13b 100644
--- a/src/main-sec-mod-cmd.c
+++ b/src/main-sec-mod-cmd.c
@@ -170,7 +170,7 @@ int handle_sec_mod_commands(main_server_st * s)
 
 			mslog(s, NULL, LOG_DEBUG, "sending msg %s to sec-mod", cmd_request_to_str(SM_CMD_AUTH_BAN_IP_REPLY));
 
-			ret = send_msg(NULL, s->sec_mod_fd, SM_CMD_AUTH_BAN_IP_REPLY,
+			ret = send_msg16(NULL, s->sec_mod_fd, SM_CMD_AUTH_BAN_IP_REPLY,
 				&reply, (pack_size_func)ban_ip_reply_msg__get_packed_size,
 				(pack_func)ban_ip_reply_msg__pack);
 			if (ret < 0) {
@@ -460,7 +460,7 @@ int session_open(main_server_st * s, struct proc_st *proc, const uint8_t *cookie
 
 	mslog(s, proc, LOG_DEBUG, "sending msg %s to sec-mod", cmd_request_to_str(SM_CMD_AUTH_SESSION_OPEN));
 
-	ret = send_msg(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_SESSION_OPEN,
+	ret = send_msg16(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_SESSION_OPEN,
 		&ireq, (pack_size_func)sec_auth_session_msg__get_packed_size,
 		(pack_func)sec_auth_session_msg__pack);
 	if (ret < 0) {
@@ -469,7 +469,7 @@ int session_open(main_server_st * s, struct proc_st *proc, const uint8_t *cookie
 		return -1;
 	}
 
-	ret = recv_msg(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_SESSION_REPLY,
+	ret = recv_msg16(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_SESSION_REPLY,
 	       (void *)&msg, (unpack_func) sec_auth_session_reply_msg__unpack, MAIN_SEC_MOD_TIMEOUT);
 	if (ret < 0) {
 		e = errno;
@@ -512,7 +512,7 @@ int session_close(main_server_st * s, struct proc_st *proc)
 
 	mslog(s, proc, LOG_DEBUG, "sending msg %s to sec-mod", cmd_request_to_str(SM_CMD_AUTH_SESSION_CLOSE));
 
-	ret = send_msg(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_SESSION_CLOSE,
+	ret = send_msg16(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_SESSION_CLOSE,
 		&ireq, (pack_size_func)sec_auth_session_msg__get_packed_size,
 		(pack_func)sec_auth_session_msg__pack);
 	if (ret < 0) {
@@ -521,7 +521,7 @@ int session_close(main_server_st * s, struct proc_st *proc)
 		return -1;
 	}
 
-	ret = recv_msg(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_CLI_STATS,
+	ret = recv_msg16(proc, s->sec_mod_fd_sync, SM_CMD_AUTH_CLI_STATS,
 	       (void *)&msg, (unpack_func) cli_stats_msg__unpack, MAIN_SEC_MOD_TIMEOUT);
 	if (ret < 0) {
 		e = errno;
diff --git a/src/main.h b/src/main.h
index 9a1bb32d..7feebc08 100644
--- a/src/main.h
+++ b/src/main.h
@@ -315,7 +315,7 @@ int send_msg_to_worker(main_server_st* s, struct proc_st* proc, uint8_t cmd,
 	    const void* msg, pack_size_func get_size, pack_func pack)
 {
 	mslog(s, proc, LOG_DEBUG, "sending message '%s' to worker", cmd_request_to_str(cmd));
-	return send_msg(proc, proc->fd, cmd, msg, get_size, pack);
+	return send_msg16(proc, proc->fd, cmd, msg, get_size, pack);
 }
 
 inline static
@@ -323,7 +323,7 @@ int send_socket_msg_to_worker(main_server_st* s, struct proc_st* proc, uint8_t c
 		int socketfd, const void* msg, pack_size_func get_size, pack_func pack)
 {
 	mslog(s, proc, LOG_DEBUG, "sending (socket) message %u to worker", (unsigned)cmd);
-	return send_socket_msg(proc, proc->fd, cmd, socketfd, msg, get_size, pack);
+	return send_socket_msg16(proc, proc->fd, cmd, socketfd, msg, get_size, pack);
 }
 
 void request_reload(int signo);
diff --git a/src/occtl/unix.c b/src/occtl/unix.c
index 7d3351da..5bbc0c31 100644
--- a/src/occtl/unix.c
+++ b/src/occtl/unix.c
@@ -95,26 +95,27 @@ int send_cmd(struct unix_ctx *ctx, unsigned cmd, const void *data,
 	struct iovec iov[2];
 	unsigned iov_len = 1;
 	int e, ret;
-	uint16_t length = 0;
+	uint16_t rlength = 0;
+	uint32_t length32 = 0;
 	void *packed = NULL;
 
 	if (get_size)
-		length = get_size(data);
+		rlength = get_size(data);
 
 	header[0] = cmd;
-	memcpy(&header[1], &length, 2);
+	memcpy(&header[1], &rlength, 2);
 
 	iov[0].iov_base = header;
 	iov[0].iov_len = 3;
 
 	if (data != NULL) {
-		packed = talloc_size(ctx, length);
+		packed = talloc_size(ctx, rlength);
 		if (packed == NULL) {
 			fprintf(stderr, "memory error\n");
 			return -1;
 		}
 		iov[1].iov_base = packed;
-		iov[1].iov_len = length;
+		iov[1].iov_len = rlength;
 		
 		ret = pack(data, packed);
 		if (ret == 0) {
@@ -134,7 +135,7 @@ int send_cmd(struct unix_ctx *ctx, unsigned cmd, const void *data,
 	}
 
 	if (rep != NULL) {
-		ret = force_read_timeout(ctx->fd, header, 3, DEFAULT_TIMEOUT);
+		ret = force_read_timeout(ctx->fd, header, 1+sizeof(length32), DEFAULT_TIMEOUT);
 		if (ret == -1) {
 			/*e = errno;
 			fprintf(stderr, "read: %s\n", strerror(e));*/
@@ -142,7 +143,7 @@ int send_cmd(struct unix_ctx *ctx, unsigned cmd, const void *data,
 			goto fail;
 		}
 
-		if (ret != 3) {
+		if (ret != 1+sizeof(length32)) {
 			fprintf(stderr, "short read %d\n", ret);
 			ret = -1;
 			goto fail;
@@ -156,17 +157,17 @@ int send_cmd(struct unix_ctx *ctx, unsigned cmd, const void *data,
 			goto fail;
 		}
 
-		memcpy(&length, &header[1], 2);
+		memcpy(&length32, &header[1], 4);
 
-		rep->data_size = length;
-		rep->data = talloc_size(ctx, length);
+		rep->data_size = length32;
+		rep->data = talloc_size(ctx, length32);
 		if (rep->data == NULL) {
 			fprintf(stderr, "memory error\n");
 			ret = -1;
 			goto fail;
 		}
 
-		ret = force_read_timeout(ctx->fd, rep->data, length, DEFAULT_TIMEOUT);
+		ret = force_read_timeout(ctx->fd, rep->data, length32, DEFAULT_TIMEOUT);
 		if (ret == -1) {
 			e = errno;
 			talloc_free(rep->data);
@@ -1063,7 +1064,7 @@ int handle_events_cmd(struct unix_ctx *ctx, const char *arg, cmd_params_st *para
 	struct cmd_reply_st raw;
 	UserListRep *rep1 = NULL;
 	TopUpdateRep *rep2 = NULL;
-	uint16_t length;
+	uint32_t slength;
 	unsigned data_size;
 	uint8_t *data = NULL;
 	char *groupname;
@@ -1113,7 +1114,7 @@ int handle_events_cmd(struct unix_ctx *ctx, const char *arg, cmd_params_st *para
 
 		if (ret == -1) {
 			int e = errno;
-			fprintf(stderr, "top: select: %s\n", strerror(e));
+			fprintf(stderr, "events: select: %s\n", strerror(e));
 			ret = -1;
 			break;
 		}
@@ -1129,46 +1130,46 @@ int handle_events_cmd(struct unix_ctx *ctx, const char *arg, cmd_params_st *para
 		if (!FD_ISSET(ctx->fd, &rfds))
 			continue;
 
-		ret = read(ctx->fd, header, 3);
+		ret = force_read_timeout(ctx->fd, header, 1+sizeof(slength), DEFAULT_TIMEOUT);
 		if (ret == -1) {
 			int e = errno;
-			fprintf(stderr, "top: read1: %s\n", strerror(e));
+			fprintf(stderr, "events: read1: %s\n", strerror(e));
 			ret = -1;
 			break;
 		}
 
 		if (ret == 0) {
-			fprintf(stderr, "top: server closed the connection\n");
+			fprintf(stderr, "events: server closed the connection\n");
 			ret = 0;
 			break;
 		}
 
-		if (ret != 3) {
-			fprintf(stderr, "top: short read %d\n", ret);
+		if (ret != 1+sizeof(slength)) {
+			fprintf(stderr, "events: short read %d\n", ret);
 			ret = -1;
 			break;
 		}
 
 		if (header[0] != CTL_CMD_TOP_UPDATE_REP) {
-			fprintf(stderr, "top: Unexpected message '%d', expected '%d'\n", (int)header[0], (int)CTL_CMD_TOP_UPDATE_REP);
+			fprintf(stderr, "events: Unexpected message '%d', expected '%d'\n", (int)header[0], (int)CTL_CMD_TOP_UPDATE_REP);
 			ret = -1;
 			break;
 		}
 
-		memcpy(&length, &header[1], 2);
+		memcpy(&slength, &header[1], sizeof(slength));
 
-		data_size = length;
-		data = talloc_size(ctx, length);
+		data_size = slength;
+		data = talloc_size(ctx, slength);
 		if (data == NULL) {
-			fprintf(stderr, "top: memory error\n");
+			fprintf(stderr, "events: memory error\n");
 			ret = -1;
 			break;
 		}
 
-		ret = read(ctx->fd, data, data_size);
+		ret = force_read(ctx->fd, data, data_size);
 		if (ret == -1) {
 			int e = errno;
-			fprintf(stderr, "top: read: %s\n", strerror(e));
+			fprintf(stderr, "events: read: %s\n", strerror(e));
 			ret = -1;
 			break;
 		}
diff --git a/src/sec-mod-auth.c b/src/sec-mod-auth.c
index eeba4549..65d0facd 100644
--- a/src/sec-mod-auth.c
+++ b/src/sec-mod-auth.c
@@ -94,7 +94,7 @@ void sec_mod_add_score_to_ip(sec_mod_st *sec, client_entry_st *e, const char *ip
 		return;
 	}
 
-	ret = send_msg(lpool, sec->cmd_fd, SM_CMD_AUTH_BAN_IP, &msg,
+	ret = send_msg16(lpool, sec->cmd_fd, SM_CMD_AUTH_BAN_IP, &msg,
 				(pack_size_func) ban_ip_msg__get_packed_size,
 				(pack_func) ban_ip_msg__pack);
 	if (ret < 0) {
@@ -178,7 +178,7 @@ int send_sec_auth_reply(int cfd, sec_mod_st * sec, client_entry_st * entry, AUTH
 		msg.dtls_session_id.data = entry->dtls_session_id;
 		msg.dtls_session_id.len = sizeof(entry->dtls_session_id);
 
-		ret = send_msg(entry, cfd, SM_CMD_AUTH_REP,
+		ret = send_msg16(entry, cfd, SM_CMD_AUTH_REP,
 			       &msg,
 			       (pack_size_func)
 			       sec_auth_reply_msg__get_packed_size,
@@ -186,7 +186,7 @@ int send_sec_auth_reply(int cfd, sec_mod_st * sec, client_entry_st * entry, AUTH
 	} else {
 		msg.reply = AUTH__REP__FAILED;
 
-		ret = send_msg(entry, cfd, SM_CMD_AUTH_REP,
+		ret = send_msg16(entry, cfd, SM_CMD_AUTH_REP,
 			       &msg,
 			       (pack_size_func)
 			       sec_auth_reply_msg__get_packed_size,
@@ -222,7 +222,7 @@ int send_sec_auth_reply_msg(int cfd, sec_mod_st * sec, client_entry_st * e)
 	msg.sid.data = e->sid;
 	msg.sid.len = sizeof(e->sid);
 
-	ret = send_msg(e, cfd, SM_CMD_AUTH_REP, &msg,
+	ret = send_msg16(e, cfd, SM_CMD_AUTH_REP, &msg,
 		       (pack_size_func) sec_auth_reply_msg__get_packed_size,
 		       (pack_func) sec_auth_reply_msg__pack);
 	if (ret < 0) {
@@ -389,7 +389,7 @@ int send_failed_session_open_reply(sec_mod_st *sec, int fd)
 		return ERR_BAD_COMMAND;
 	}
 
-	ret = send_msg(lpool, fd, SM_CMD_AUTH_SESSION_REPLY, &rep,
+	ret = send_msg16(lpool, fd, SM_CMD_AUTH_SESSION_REPLY, &rep,
 			(pack_size_func) sec_auth_session_reply_msg__get_packed_size,
 			(pack_func) sec_auth_session_reply_msg__pack);
 	if (ret < 0) {
@@ -476,7 +476,7 @@ int handle_sec_auth_session_open(sec_mod_st *sec, int fd, const SecAuthSessionMs
 		}
 	}
 
-	ret = send_msg(lpool, fd, SM_CMD_AUTH_SESSION_REPLY, &rep,
+	ret = send_msg16(lpool, fd, SM_CMD_AUTH_SESSION_REPLY, &rep,
 			(pack_size_func) sec_auth_session_reply_msg__get_packed_size,
 			(pack_func) sec_auth_session_reply_msg__pack);
 	if (ret < 0) {
@@ -510,14 +510,14 @@ int handle_sec_auth_session_close(sec_mod_st *sec, int fd, const SecAuthSessionM
 		char tmp[BASE64_ENCODE_RAW_LENGTH(SID_SIZE) + 1];
 		oc_base64_encode((char *)req->sid.data, req->sid.len, (char *)tmp, sizeof(tmp));
 		seclog(sec, LOG_INFO, "session close but with non-existing SID: %s", tmp);
-		return send_msg(e, fd, SM_CMD_AUTH_CLI_STATS, &rep,
+		return send_msg16(e, fd, SM_CMD_AUTH_CLI_STATS, &rep,
 		                (pack_size_func) cli_stats_msg__get_packed_size,
 		                (pack_func) cli_stats_msg__pack);
 	}
 
 	if (e->status < PS_AUTH_COMPLETED) {
 		seclog(sec, LOG_DEBUG, "session close received in unauthenticated client %s "SESSION_STR"!", e->acct_info.username, e->acct_info.psid);
-		return send_msg(e, fd, SM_CMD_AUTH_CLI_STATS, &rep,
+		return send_msg16(e, fd, SM_CMD_AUTH_CLI_STATS, &rep,
 		                (pack_size_func) cli_stats_msg__get_packed_size,
 		                (pack_func) cli_stats_msg__pack);
 	}
@@ -544,7 +544,7 @@ int handle_sec_auth_session_close(sec_mod_st *sec, int fd, const SecAuthSessionM
 	rep.secmod_tlsdb_entries = sec->tls_db.entries;
 	rep.has_secmod_tlsdb_entries = 1;
 
-	ret = send_msg(e, fd, SM_CMD_AUTH_CLI_STATS, &rep,
+	ret = send_msg16(e, fd, SM_CMD_AUTH_CLI_STATS, &rep,
 			(pack_size_func) cli_stats_msg__get_packed_size,
 			(pack_func) cli_stats_msg__pack);
 	if (ret < 0) {
diff --git a/src/sec-mod.c b/src/sec-mod.c
index 5601a884..b7094417 100644
--- a/src/sec-mod.c
+++ b/src/sec-mod.c
@@ -188,7 +188,7 @@ static int send_refresh_cookie_key(sec_mod_st * sec, void *key_data, unsigned ke
 	msg.key.data = key_data;
 	msg.key.len = key_size;
 
-	ret = send_msg(sec, sec->cmd_fd, SM_CMD_REFRESH_COOKIE_KEY, &msg,
+	ret = send_msg16(sec, sec->cmd_fd, SM_CMD_REFRESH_COOKIE_KEY, &msg,
 		       (pack_size_func) sec_refresh_cookie_key__get_packed_size,
 		       (pack_func) sec_refresh_cookie_key__pack);
 	if (ret < 0) {
@@ -207,7 +207,7 @@ static int handle_op(void *pool, int cfd, sec_mod_st * sec, uint8_t type, uint8_
 	msg.data.data = rep;
 	msg.data.len = rep_size;
 
-	ret = send_msg(pool, cfd, type, &msg,
+	ret = send_msg16(pool, cfd, type, &msg,
 		       (pack_size_func) sec_op_msg__get_packed_size,
 		       (pack_func) sec_op_msg__pack);
 	if (ret < 0) {
@@ -404,7 +404,7 @@ int process_packet(void *pool, int cfd, pid_t pid, sec_mod_st * sec, cmd_request
 			}
 
 			ret =
-			    send_msg(pool, cfd, RESUME_FETCH_REP, &msg,
+			    send_msg16(pool, cfd, RESUME_FETCH_REP, &msg,
 					       (pack_size_func)
 					       session_resume_reply_msg__get_packed_size,
 					       (pack_func)
diff --git a/src/tlslib.c b/src/tlslib.c
index c8428026..1f2f4c64 100644
--- a/src/tlslib.c
+++ b/src/tlslib.c
@@ -636,14 +636,14 @@ int key_cb_common_func (gnutls_privkey_t key, void* userdata, const gnutls_datum
 	msg.data.data = raw_data->data;
 	msg.data.len = raw_data->size;
 
-	ret = send_msg(userdata, sd, type, &msg,
+	ret = send_msg16(userdata, sd, type, &msg,
 			(pack_size_func)sec_op_msg__get_packed_size,
 			(pack_func)sec_op_msg__pack);
 	if (ret < 0) {
 		goto error;
 	}
 
-	ret = recv_msg(userdata, sd, type, (void*)&reply,
+	ret = recv_msg16(userdata, sd, type, (void*)&reply,
 		       (unpack_func)sec_op_msg__unpack,
 		       DEFAULT_SOCKET_TIMEOUT);
 	if (ret < 0) {
diff --git a/src/worker-auth.c b/src/worker-auth.c
index 6306d3bf..4dc77a82 100644
--- a/src/worker-auth.c
+++ b/src/worker-auth.c
@@ -533,7 +533,7 @@ static int recv_cookie_auth_reply(worker_st * ws)
 	AuthReplyMsg *msg = NULL;
 	PROTOBUF_ALLOCATOR(pa, ws);
 
-	ret = recv_socket_msg(ws, ws->cmd_fd, AUTH_COOKIE_REP, &socketfd,
+	ret = recv_socket_msg16(ws, ws->cmd_fd, AUTH_COOKIE_REP, &socketfd,
 			      (void *)&msg,
 			      (unpack_func) auth_reply_msg__unpack,
 			      DEFAULT_SOCKET_TIMEOUT);
@@ -674,7 +674,7 @@ static int recv_auth_reply(worker_st * ws, int sd, char **txt, unsigned *pcounte
 	SecAuthReplyMsg *msg = NULL;
 	PROTOBUF_ALLOCATOR(pa, ws);
 
-	ret = recv_msg(ws, sd, SM_CMD_AUTH_REP,
+	ret = recv_msg16(ws, sd, SM_CMD_AUTH_REP,
 		       (void *)&msg, (unpack_func) sec_auth_reply_msg__unpack,
 		       DEFAULT_SOCKET_TIMEOUT);
 	if (ret < 0) {
diff --git a/src/worker-resume.c b/src/worker-resume.c
index b38ea06c..14353892 100644
--- a/src/worker-resume.c
+++ b/src/worker-resume.c
@@ -47,7 +47,7 @@ static int recv_resume_fetch_reply(worker_st *ws, int sd, gnutls_datum_t *sdata)
 	SessionResumeReplyMsg *resp;
 	PROTOBUF_ALLOCATOR(pa, ws);
 
-	ret = recv_msg(ws, sd, RESUME_FETCH_REP, (void*)&resp, 
+	ret = recv_msg16(ws, sd, RESUME_FETCH_REP, (void*)&resp, 
 		(unpack_func)session_resume_reply_msg__unpack, DEFAULT_SOCKET_TIMEOUT);
 	if (ret < 0) {
 		oclog(ws, LOG_ERR, "error receiving resumption reply (fetch)");
diff --git a/src/worker-vpn.c b/src/worker-vpn.c
index 6206eabf..15df0448 100644
--- a/src/worker-vpn.c
+++ b/src/worker-vpn.c
@@ -283,7 +283,7 @@ void ws_add_score_to_ip(worker_st *ws, unsigned points, unsigned final)
 	msg.ip = ws->remote_ip_str;
 	msg.score = points;
 
-	ret = send_msg(ws, ws->cmd_fd, CMD_BAN_IP, &msg,
+	ret = send_msg16(ws, ws->cmd_fd, CMD_BAN_IP, &msg,
 				(pack_size_func) ban_ip_msg__get_packed_size,
 				(pack_func) ban_ip_msg__pack);
 	if (ret < 0) {
@@ -295,7 +295,7 @@ void ws_add_score_to_ip(worker_st *ws, unsigned points, unsigned final)
 	if (final != 0)
 		return;
 
-	ret = recv_msg(ws, ws->cmd_fd, CMD_BAN_IP_REPLY,
+	ret = recv_msg16(ws, ws->cmd_fd, CMD_BAN_IP_REPLY,
 		       (void *)&reply, (unpack_func) ban_ip_reply_msg__unpack, DEFAULT_SOCKET_TIMEOUT);
 	if (ret < 0) {
 		oclog(ws, LOG_ERR, "error receiving BAN IP reply message");
diff --git a/src/worker.h b/src/worker.h
index bd0ffc2f..5e7e7f74 100644
--- a/src/worker.h
+++ b/src/worker.h
@@ -348,7 +348,7 @@ int send_msg_to_secmod(worker_st * ws, int sd, uint8_t cmd,
 	oclog(ws, LOG_DEBUG, "sending message '%s' to secmod",
 	      cmd_request_to_str(cmd));
 
-	return send_msg(ws, sd, cmd, msg, get_size, pack);
+	return send_msg16(ws, sd, cmd, msg, get_size, pack);
 }
 
 inline static
@@ -356,7 +356,7 @@ int send_msg_to_main(worker_st *ws, uint8_t cmd,
 	    const void* msg, pack_size_func get_size, pack_func pack)
 {
 	oclog(ws, LOG_DEBUG, "sending message '%s' to main", cmd_request_to_str(cmd));
-	return send_msg(ws, ws->cmd_fd, cmd, msg, get_size, pack);
+	return send_msg16(ws, ws->cmd_fd, cmd, msg, get_size, pack);
 }
 
 int parse_proxy_proto_header(struct worker_st *ws, int fd);