diff --git a/libknet/tests/api_knet_get_compress_list.c b/libknet/tests/api_knet_get_compress_list.c
index 47828874..58562ba2 100644
--- a/libknet/tests/api_knet_get_compress_list.c
+++ b/libknet/tests/api_knet_get_compress_list.c
@@ -1,70 +1,68 @@
 /*
  * Copyright (C) 2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	struct knet_compress_info compress_list[16];
 	size_t compress_list_entries;
 	size_t compress_list_entries1;
 	size_t i;
 
 	memset(compress_list, 0, sizeof(compress_list));
 
 	printf("Test knet_get_compress_list with no entries_list\n");
 
 	if ((!knet_get_compress_list(compress_list, NULL)) || (errno != EINVAL)) {
 		printf("knet_get_compress_list accepted invalid list_entries or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_get_compress_list with no compress_list (get number of entries)\n");
 
 	if (knet_get_compress_list(NULL, &compress_list_entries) < 0) {
 		printf("knet_handle_get_compress_list returned error instead of number of entries: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_get_compress_list with valid data\n");
 
 	if (knet_get_compress_list(compress_list, &compress_list_entries1) < 0) {
 		printf("knet_get_compress_list failed: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (compress_list_entries != compress_list_entries1) {
 		printf("knet_get_compress_list returned a different number of entries: %d, %d\n",
 		       (int)compress_list_entries, (int)compress_list_entries1);
 		exit(FAIL);
 	}
 
 	for (i=0; i<compress_list_entries; i++) {
 		printf("Detected compress: %s\n", compress_list[i].name);
 	}
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_get_crypto_list.c b/libknet/tests/api_knet_get_crypto_list.c
index b4ab2da4..4a55af3c 100644
--- a/libknet/tests/api_knet_get_crypto_list.c
+++ b/libknet/tests/api_knet_get_crypto_list.c
@@ -1,70 +1,68 @@
 /*
  * Copyright (C) 2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	struct knet_crypto_info crypto_list[16];
 	size_t crypto_list_entries;
 	size_t crypto_list_entries1;
 	size_t i;
 
 	memset(crypto_list, 0, sizeof(crypto_list));
 
 	printf("Test knet_handle_get_crypto_list with no entries_list\n");
 
 	if ((!knet_get_crypto_list(crypto_list, NULL)) || (errno != EINVAL)) {
 		printf("knet_get_crypto_list accepted invalid list_entries or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_get_crypto_list with no crypto_list (get number of entries)\n");
 
 	if (knet_get_crypto_list(NULL, &crypto_list_entries) < 0) {
 		printf("knet_handle_get_crypto_list returned error instead of number of entries: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_get_crypto_list with valid data\n");
 
 	if (knet_get_crypto_list(crypto_list, &crypto_list_entries1) < 0) {
 		printf("knet_get_crypto_list failed: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (crypto_list_entries != crypto_list_entries1) {
 		printf("knet_get_crypto_list returned a different number of entries: %d, %d\n",
 		       (int)crypto_list_entries, (int)crypto_list_entries1);
 		exit(FAIL);
 	}
 
 	for (i=0; i<crypto_list_entries; i++) {
 		printf("Detected crypto: %s\n", crypto_list[i].name);
 	}
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_get_transport_id_by_name.c b/libknet/tests/api_knet_get_transport_id_by_name.c
index feaed822..f2d7a571 100644
--- a/libknet/tests/api_knet_get_transport_id_by_name.c
+++ b/libknet/tests/api_knet_get_transport_id_by_name.c
@@ -1,56 +1,54 @@
 /*
  * Copyright (C) 2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	uint8_t id;
 
 	printf("Test knet_get_transport_id_by_name with no name\n");
 
 	if ((knet_get_transport_id_by_name(NULL) != KNET_MAX_TRANSPORTS) || (errno != EINVAL)) {
 		printf("knet_get_transport_id_by_name accepted invalid transport or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_get_transport_id_by_name with incorrect name\n");
 
 	if ((knet_get_transport_id_by_name("ARP") != KNET_MAX_TRANSPORTS) || (errno != EINVAL)) {
 		printf("knet_get_transport_id_by_name accepted invalid transport or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_get_transport_id_by_name with correct values\n");
 
 	id = knet_get_transport_id_by_name("UDP");
 	if (id != KNET_TRANSPORT_UDP) {
 		printf("knet_handle_get_transport_id_by_name failed: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_get_transport_list.c b/libknet/tests/api_knet_get_transport_list.c
index 35b98a4d..2496f8a7 100644
--- a/libknet/tests/api_knet_get_transport_list.c
+++ b/libknet/tests/api_knet_get_transport_list.c
@@ -1,71 +1,69 @@
 /*
  * Copyright (C) 2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	struct knet_transport_info transport_list[KNET_MAX_TRANSPORTS];
 	size_t transport_list_entries;
 	size_t transport_list_entries1;
 	size_t i;
 
 	memset(transport_list, 0, sizeof(transport_list));
 
 	printf("Test knet_handle_get_transport_list with no entries_list\n");
 
 	if ((!knet_get_transport_list(transport_list, NULL)) || (errno != EINVAL)) {
 		printf("knet_get_transport_list accepted invalid list_entries or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_get_transport_list with no transport_list (get number of entries)\n");
 
 	if (knet_get_transport_list(NULL, &transport_list_entries) < 0) {
 		printf("knet_get_transport_list returned error instead of number of entries: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_get_transport_list with valid data\n");
 
 	if (knet_get_transport_list(transport_list, &transport_list_entries1) < 0) {
 		printf("knet_get_transport_list failed: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (transport_list_entries != transport_list_entries1) {
 		printf("knet_get_transport_list returned a different number of entries: %d, %d\n",
 		       (int)transport_list_entries, (int)transport_list_entries1);
 		exit(FAIL);
 	}
 
 	for (i=0; i<transport_list_entries; i++) {
 		printf("Detected transport: %s id: %d properties: %u\n",
 			transport_list[i].name, transport_list[i].id, transport_list[i].properties);
 	}
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_get_transport_name_by_id.c b/libknet/tests/api_knet_get_transport_name_by_id.c
index 58e01bc9..e502213b 100644
--- a/libknet/tests/api_knet_get_transport_name_by_id.c
+++ b/libknet/tests/api_knet_get_transport_name_by_id.c
@@ -1,54 +1,52 @@
 /*
  * Copyright (C) 2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	const char *name = NULL;
 
 	printf("Test knet_handle_get_transport_name_by_id with incorrect transport\n");
 
 	if ((knet_get_transport_name_by_id(KNET_MAX_TRANSPORTS) != NULL) || (errno != EINVAL)) {
 		printf("knet_get_transport_name_by_id accepted invalid transport or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_get_transport_name_by_id with correct values\n");
 
 	name = knet_get_transport_name_by_id(KNET_TRANSPORT_UDP);
 	if (!name) {
 		printf("knet_get_transport_name_by_id failed: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (strcmp(name, "UDP")) {
 		printf("knet_get_transport_name_by_id failed to get UDP transport name\n");
 		exit(FAIL);
 	}
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_add_datafd.c b/libknet/tests/api_knet_handle_add_datafd.c
index a9199cfe..ef83446a 100644
--- a/libknet/tests/api_knet_handle_add_datafd.c
+++ b/libknet/tests/api_knet_handle_add_datafd.c
@@ -1,224 +1,222 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static int private_data;
 
 static void sock_notify(void *pvt_data,
 			int datafd,
 			int8_t channel,
 			uint8_t tx_rx,
 			int error,
 			int errorno)
 {
 	return;
 }
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	int datafd = 0, i;
 	int8_t channel = 0;
 	int datafdmax[KNET_DATAFD_MAX];
 	int8_t channels[KNET_DATAFD_MAX];
 
 	printf("Test knet_handle_add_datafd incorrect knet_h\n");
 
 	if ((!knet_handle_add_datafd(NULL, &datafd, &channel)) || (errno != EINVAL)) {
 		printf("knet_handle_add_datafd accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_handle_add_datafd with no datafd\n");
 
 	if ((!knet_handle_add_datafd(knet_h, NULL, &channel)) || (errno != EINVAL)) {
 		printf("knet_handle_add_datafd accepted invalid datafd or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_add_datafd with no channel\n");
 
 	if ((!knet_handle_add_datafd(knet_h, &datafd, NULL)) || (errno != EINVAL)) {
 		printf("knet_handle_add_datafd accepted invalid channel or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_add_datafd with invalid channel\n");
 
 	channel = KNET_DATAFD_MAX;
 
 	if ((!knet_handle_add_datafd(knet_h, &datafd, &channel)) || (errno != EINVAL)) {
 		printf("knet_handle_add_datafd accepted invalid channel or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_add_datafd with no socknotify\n");
 
 	datafd = 0;
 	channel = -1;
 
 	if ((!knet_handle_add_datafd(knet_h, &datafd, &channel)) || (errno != EINVAL)) {
 		printf("knet_handle_add_datafd accepted invalid channel or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_add_datafd with automatic config values\n");
 
 	if (knet_handle_enable_sock_notify(knet_h, &private_data, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	datafd = 0;
 	channel = -1;
 
 	if (knet_handle_add_datafd(knet_h, &datafd, &channel) < 0) {
 		printf("knet_handle_add_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("got datafd: %d channel: %d\n", datafd, channel);
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_add_datafd with duplicated datafd\n");
 
 	if ((!knet_handle_add_datafd(knet_h, &datafd, &channel)) || (errno != EEXIST)) {
 		printf("knet_handle_add_datafd accepted duplicated datafd or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_add_datafd with busy channel\n");
 
 	datafd = datafd + 1;
 
 	if ((!knet_handle_add_datafd(knet_h, &datafd, &channel)) || (errno != EBUSY)) {
 		printf("knet_handle_add_datafd accepted duplicated datafd or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	datafd = datafd - 1;
 
 	if (knet_handle_remove_datafd(knet_h, datafd) < 0) {
 		printf("knet_handle_remove_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_add_datafd with no available channels\n");
 
 	for (i = 0; i < KNET_DATAFD_MAX; i++) {
 		datafdmax[i] = 0;
 		channels[i] = -1;
 		if (knet_handle_add_datafd(knet_h, &datafdmax[i], &channels[i]) < 0) {
 			printf("knet_handle_add_datafd failed: %s\n", strerror(errno));
 			knet_handle_free(knet_h);
 			flush_logs(logfds[0], stdout);
 			close_logpipes(logfds);
 			exit(FAIL);
 		}
 	}
 
 	datafd = 0;
 	channel = -1;
 
 	if ((!knet_handle_add_datafd(knet_h, &datafd, &channel)) || (errno != EBUSY)) {
 		printf("knet_handle_add_datafd accepted entry with no available channels or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	for (i = 0; i < KNET_DATAFD_MAX; i++) {
 		if (knet_handle_remove_datafd(knet_h, datafdmax[i]) < 0) {
 			printf("knet_handle_remove_datafd failed: %s\n", strerror(errno));
 			knet_handle_free(knet_h);
 			flush_logs(logfds[0], stdout);
 			close_logpipes(logfds);
 			exit(FAIL);
 		}
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_clear_stats.c b/libknet/tests/api_knet_handle_clear_stats.c
index cd51196c..8e3db4f1 100644
--- a/libknet/tests/api_knet_handle_clear_stats.c
+++ b/libknet/tests/api_knet_handle_clear_stats.c
@@ -1,297 +1,295 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <inttypes.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static int private_data;
 
 static void sock_notify(void *pvt_data,
 			int datafd,
 			int8_t channel,
 			uint8_t tx_rx,
 			int error,
 			int errorno)
 {
 	return;
 }
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	int datafd = 0;
 	int8_t channel = 0;
 	struct knet_link_status link_status;
 	char send_buff[KNET_MAX_PACKET_SIZE];
 	char recv_buff[KNET_MAX_PACKET_SIZE];
 	ssize_t send_len = 0;
 	int recv_len = 0;
 	int savederrno;
 	struct sockaddr_storage lo;
 
 	if (make_local_sockaddr(&lo, 0) < 0) {
 		printf("Unable to convert loopback to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	memset(send_buff, 0, sizeof(send_buff));
 
 	printf("Test knet_handle_clear_stats incorrect knet_h\n");
 
 	if (!knet_handle_clear_stats(NULL, 0) || (errno != EINVAL)) {
 		printf("knet_handle_clear_stats accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_send with valid data\n");
 
 	if (knet_handle_enable_sock_notify(knet_h, &private_data, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
         }
 
 	datafd = 0;
 	channel = -1;
 
 	if (knet_handle_add_datafd(knet_h, &datafd, &channel) < 0) {
 		printf("knet_handle_add_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("knet_host_add failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &lo, &lo, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_enable(knet_h, 1, 0, 1) < 0) {
 		printf("knet_link_set_enable failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_handle_setfwd(knet_h, 1) < 0) {
 		printf("knet_handle_setfwd failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (wait_for_host(knet_h, 1, 10, logfds[0], stdout) < 0) {
 		printf("timeout waiting for host to be reachable");
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	send_len = knet_send(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel);
 	if (send_len <= 0) {
 		printf("knet_send failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (send_len != sizeof(send_buff)) {
 		printf("knet_send sent only %zd bytes: %s\n", send_len, strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	if (wait_for_packet(knet_h, 10, datafd)) {
 		printf("Error waiting for packet: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	recv_len = knet_recv(knet_h, recv_buff, KNET_MAX_PACKET_SIZE, channel);
 	savederrno = errno;
 	if (recv_len != send_len) {
 		printf("knet_recv received only %d bytes: %s (errno: %d)\n", recv_len, strerror(errno), errno);
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		if ((is_helgrind()) && (recv_len == -1) && (savederrno == EAGAIN)) {
 			printf("helgrind exception. this is normal due to possible timeouts\n");
 			exit(PASS);
 		}
 		exit(FAIL);
 	}
 
 	if (memcmp(recv_buff, send_buff, KNET_MAX_PACKET_SIZE)) {
 		printf("recv and send buffers are different!\n");
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	/* A sanity check on the stats */
 	if (knet_link_get_status(knet_h, 1, 0, &link_status, sizeof(link_status)) < 0) {
 		printf("knet_link_get_status failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (link_status.stats.tx_data_packets != 2 ||
 	    link_status.stats.rx_data_packets != 2 ||
 	    link_status.stats.tx_data_bytes < KNET_MAX_PACKET_SIZE ||
 	    link_status.stats.rx_data_bytes < KNET_MAX_PACKET_SIZE ||
 	    link_status.stats.tx_data_bytes > KNET_MAX_PACKET_SIZE*2 ||
 	    link_status.stats.rx_data_bytes > KNET_MAX_PACKET_SIZE*2) {
 	    printf("stats look wrong: tx_packets: %" PRIu64 " (%" PRIu64 " bytes), rx_packets: %" PRIu64 " (%" PRIu64 " bytes)\n",
 		   link_status.stats.tx_data_packets,
 		   link_status.stats.tx_data_bytes,
 		   link_status.stats.rx_data_packets,
 		   link_status.stats.rx_data_bytes);
 	}
 
 	printf("Test knet_clear_stats (link)\n");
 	if (knet_handle_clear_stats(knet_h, KNET_CLEARSTATS_HANDLE_AND_LINK) < 0) {
 		printf("knet_link_clear_stats failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 
 /* Check they've been cleared */
 	if (knet_link_get_status(knet_h, 1, 0, &link_status, sizeof(link_status)) < 0) {
 		printf("knet_link_get_status failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (link_status.stats.tx_data_packets != 0 ||
 	    link_status.stats.rx_data_packets != 0 ||
 	    link_status.stats.tx_data_bytes != 0 ||
 	    link_status.stats.rx_data_bytes != 0 ||
 	    link_status.stats.tx_data_bytes != 0 ||
 	    link_status.stats.rx_data_bytes != 0) {
 		printf("stats not cleared: tx_packets: %" PRIu64 " (%" PRIu64 " bytes), rx_packets: %" PRIu64 " (%" PRIu64 " bytes)\n",
 		       link_status.stats.tx_data_packets,
 		       link_status.stats.tx_data_bytes,
 		       link_status.stats.rx_data_packets,
 		       link_status.stats.rx_data_bytes);
 
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_link_set_enable(knet_h, 1, 0, 0);
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_compress.c b/libknet/tests/api_knet_handle_compress.c
index 00eeceb3..628f683c 100644
--- a/libknet/tests/api_knet_handle_compress.c
+++ b/libknet/tests/api_knet_handle_compress.c
@@ -1,175 +1,173 @@
 /*
  * Copyright (C) 2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct knet_handle_compress_cfg knet_handle_compress_cfg;
 
 	memset(&knet_handle_compress_cfg, 0, sizeof(struct knet_handle_compress_cfg));
 
 	printf("Test knet_handle_compress incorrect knet_h\n");
 
 	if ((!knet_handle_compress(NULL, &knet_handle_compress_cfg)) || (errno != EINVAL)) {
 		printf("knet_handle_compress accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_compress with invalid cfg\n");
 
 	if ((!knet_handle_compress(knet_h, NULL)) || (errno != EINVAL)) {
 		printf("knet_handle_compress accepted invalid cfg or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_compress with un-initialized cfg\n");
 
 	memset(&knet_handle_compress_cfg, 0, sizeof(struct knet_handle_compress_cfg));
 
 	if ((!knet_handle_compress(knet_h, &knet_handle_compress_cfg)) || (errno != EINVAL)) {
 		printf("knet_handle_compress accepted invalid un-initialized cfg\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_compress with none compress model (disable compress)\n");
 
 	memset(&knet_handle_compress_cfg, 0, sizeof(struct knet_handle_compress_cfg));
 	strncpy(knet_handle_compress_cfg.compress_model, "none", sizeof(knet_handle_compress_cfg.compress_model) - 1);
 
 	if (knet_handle_compress(knet_h, &knet_handle_compress_cfg) != 0) {
 		printf("knet_handle_compress did not accept none compress mode cfg\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 #ifdef BUILDCOMPZLIB
 	printf("Test knet_handle_compress with zlib compress and negative level\n");
 
 	memset(&knet_handle_compress_cfg, 0, sizeof(struct knet_handle_compress_cfg));
 	strncpy(knet_handle_compress_cfg.compress_model, "zlib", sizeof(knet_handle_compress_cfg.compress_model) - 1);
 	knet_handle_compress_cfg.compress_level = -1;
 
 	if ((!knet_handle_compress(knet_h, &knet_handle_compress_cfg)) || (errno != EINVAL)) {
 		printf("knet_handle_compress accepted invalid (-1) compress level for zlib\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_compress with zlib compress and excessive compress level\n");
 
 	memset(&knet_handle_compress_cfg, 0, sizeof(struct knet_handle_compress_cfg));
 	strncpy(knet_handle_compress_cfg.compress_model, "zlib", sizeof(knet_handle_compress_cfg.compress_model) - 1);
 	knet_handle_compress_cfg.compress_level = 10;
 
 	if ((!knet_handle_compress(knet_h, &knet_handle_compress_cfg)) || (errno != EINVAL)) {
 		printf("knet_handle_compress accepted invalid (10) compress level for zlib\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_compress with zlib compress and excessive compress threshold\n");
 
 	memset(&knet_handle_compress_cfg, 0, sizeof(struct knet_handle_compress_cfg));
 	strncpy(knet_handle_compress_cfg.compress_model, "zlib", sizeof(knet_handle_compress_cfg.compress_model) - 1);
 	knet_handle_compress_cfg.compress_level = 1;
 	knet_handle_compress_cfg.compress_threshold = KNET_MAX_PACKET_SIZE +1;
 
 	if ((!knet_handle_compress(knet_h, &knet_handle_compress_cfg)) || (errno != EINVAL)) {
 		printf("knet_handle_compress accepted invalid compress threshold\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_compress with zlib compress model normal compress level and threshold\n");
 
 	memset(&knet_handle_compress_cfg, 0, sizeof(struct knet_handle_compress_cfg));
 	strncpy(knet_handle_compress_cfg.compress_model, "zlib", sizeof(knet_handle_compress_cfg.compress_model) - 1);
 	knet_handle_compress_cfg.compress_level = 1;
 	knet_handle_compress_cfg.compress_threshold = 64;
 
 	if (knet_handle_compress(knet_h, &knet_handle_compress_cfg) != 0) {
 		printf("knet_handle_compress did not accept zlib compress mode with compress level 1 cfg\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 #endif
 	flush_logs(logfds[0], stdout);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 #ifdef BUILDCOMPZLIB
 	return PASS;
 #else
 	printf("WARNING: zlib support not builtin the library. Unable to test/verify internal compress API calls\n");
 	return SKIP;
 #endif
 }
diff --git a/libknet/tests/api_knet_handle_crypto.c b/libknet/tests/api_knet_handle_crypto.c
index 84ad0765..81ceb874 100644
--- a/libknet/tests/api_knet_handle_crypto.c
+++ b/libknet/tests/api_knet_handle_crypto.c
@@ -1,272 +1,270 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct knet_handle_crypto_cfg knet_handle_crypto_cfg;
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 
 	printf("Test knet_handle_crypto incorrect knet_h\n");
 
 	if ((!knet_handle_crypto(NULL, &knet_handle_crypto_cfg)) || (errno != EINVAL)) {
 		printf("knet_handle_crypto accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_crypto with invalid cfg\n");
 
 	if ((!knet_handle_crypto(knet_h, NULL)) || (errno != EINVAL)) {
 		printf("knet_handle_crypto accepted invalid cfg or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_crypto with un-initialized cfg\n");
 
 	if ((!knet_handle_crypto(knet_h, &knet_handle_crypto_cfg)) || (errno != EINVAL)) {
 		printf("knet_handle_crypto accepted invalid un-initialized cfg\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_crypto with none crypto model (disable crypto)\n");
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 	strncpy(knet_handle_crypto_cfg.crypto_model, "none", sizeof(knet_handle_crypto_cfg.crypto_model) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_cipher_type, "aes128", sizeof(knet_handle_crypto_cfg.crypto_cipher_type) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_hash_type, "sha1", sizeof(knet_handle_crypto_cfg.crypto_hash_type) - 1);
 
 	if (knet_handle_crypto(knet_h, &knet_handle_crypto_cfg) != 0) {
 		printf("knet_handle_crypto did not accept none crypto mode cfg\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_crypto with none crypto cipher and hash (disable crypto)\n");
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 	strncpy(knet_handle_crypto_cfg.crypto_model, "nss", sizeof(knet_handle_crypto_cfg.crypto_model) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_cipher_type, "none", sizeof(knet_handle_crypto_cfg.crypto_cipher_type) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_hash_type, "none", sizeof(knet_handle_crypto_cfg.crypto_hash_type) - 1);
 
 	if (knet_handle_crypto(knet_h, &knet_handle_crypto_cfg) != 0) {
 		printf("knet_handle_crypto did not accept none crypto cipher and hash cfg\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_crypto with nss/aes128/sha1 and too short key\n");
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 	strncpy(knet_handle_crypto_cfg.crypto_model, "nss", sizeof(knet_handle_crypto_cfg.crypto_model) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_cipher_type, "aes128", sizeof(knet_handle_crypto_cfg.crypto_cipher_type) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_hash_type, "sha1", sizeof(knet_handle_crypto_cfg.crypto_hash_type) - 1);
 	knet_handle_crypto_cfg.private_key_len = 10;
 
 	if ((!knet_handle_crypto(knet_h, &knet_handle_crypto_cfg)) || (errno != EINVAL)) {
 		printf("knet_handle_crypto accepted too short private key\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_crypto with nss/aes128/sha1 and too long key\n");
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 	strncpy(knet_handle_crypto_cfg.crypto_model, "nss", sizeof(knet_handle_crypto_cfg.crypto_model) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_cipher_type, "aes128", sizeof(knet_handle_crypto_cfg.crypto_cipher_type) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_hash_type, "sha1", sizeof(knet_handle_crypto_cfg.crypto_hash_type) - 1);
 	knet_handle_crypto_cfg.private_key_len = 10000;
 
 	if ((!knet_handle_crypto(knet_h, &knet_handle_crypto_cfg)) || (errno != EINVAL)) {
 		printf("knet_handle_crypto accepted too long private key\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 #ifdef BUILDCRYPTONSS
 	printf("Test knet_handle_crypto with nss/aes128/sha1 and normal key\n");
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 	strncpy(knet_handle_crypto_cfg.crypto_model, "nss", sizeof(knet_handle_crypto_cfg.crypto_model) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_cipher_type, "aes128", sizeof(knet_handle_crypto_cfg.crypto_cipher_type) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_hash_type, "sha1", sizeof(knet_handle_crypto_cfg.crypto_hash_type) - 1);
 	knet_handle_crypto_cfg.private_key_len = 2000;
 
 	if (knet_handle_crypto(knet_h, &knet_handle_crypto_cfg)) {
 		printf("knet_handle_crypto failed with correct config: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_crypto (nss specific test) with nss/aes128/none and normal key\n");
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 	strncpy(knet_handle_crypto_cfg.crypto_model, "nss", sizeof(knet_handle_crypto_cfg.crypto_model) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_cipher_type, "aes128", sizeof(knet_handle_crypto_cfg.crypto_cipher_type) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_hash_type, "none", sizeof(knet_handle_crypto_cfg.crypto_hash_type) - 1);
 	knet_handle_crypto_cfg.private_key_len = 2000;
 
 	if (!knet_handle_crypto(knet_h, &knet_handle_crypto_cfg)) {
 		printf("knet_handle_crypto (nss) accepted crypto without hashing\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Shutdown crypto\n");
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 	strncpy(knet_handle_crypto_cfg.crypto_model, "none", sizeof(knet_handle_crypto_cfg.crypto_model) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_cipher_type, "none", sizeof(knet_handle_crypto_cfg.crypto_cipher_type) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_hash_type, "none", sizeof(knet_handle_crypto_cfg.crypto_hash_type) - 1);
 	knet_handle_crypto_cfg.private_key_len = 2000;
 
 	if (knet_handle_crypto(knet_h, &knet_handle_crypto_cfg) < 0) {
 		printf("Unable to shutdown crypto: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 #endif
 
 #ifdef BUILDCRYPTOOPENSSL
 	printf("Test knet_handle_crypto with openssl/aes128/sha1 and normal key\n");
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 	strncpy(knet_handle_crypto_cfg.crypto_model, "openssl", sizeof(knet_handle_crypto_cfg.crypto_model) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_cipher_type, "aes128", sizeof(knet_handle_crypto_cfg.crypto_cipher_type) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_hash_type, "sha1", sizeof(knet_handle_crypto_cfg.crypto_hash_type) - 1);
 	knet_handle_crypto_cfg.private_key_len = 2000;
 
 	if (knet_handle_crypto(knet_h, &knet_handle_crypto_cfg)) {
 		printf("knet_handle_crypto failed with correct config: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_crypto (nss specific test) with openssl/aes128/none and normal key\n");
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 	strncpy(knet_handle_crypto_cfg.crypto_model, "openssl", sizeof(knet_handle_crypto_cfg.crypto_model) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_cipher_type, "aes128", sizeof(knet_handle_crypto_cfg.crypto_cipher_type) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_hash_type, "none", sizeof(knet_handle_crypto_cfg.crypto_hash_type) - 1);
 	knet_handle_crypto_cfg.private_key_len = 2000;
 
 	if (!knet_handle_crypto(knet_h, &knet_handle_crypto_cfg)) {
 		printf("knet_handle_crypto (nss) accepted crypto without hashing\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Shutdown crypto\n");
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 	strncpy(knet_handle_crypto_cfg.crypto_model, "none", sizeof(knet_handle_crypto_cfg.crypto_model) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_cipher_type, "none", sizeof(knet_handle_crypto_cfg.crypto_cipher_type) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_hash_type, "none", sizeof(knet_handle_crypto_cfg.crypto_hash_type) - 1);
 	knet_handle_crypto_cfg.private_key_len = 2000;
 
 	if (knet_handle_crypto(knet_h, &knet_handle_crypto_cfg) < 0) {
 		printf("Unable to shutdown crypto: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 #endif
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 #if defined(BUILDCRYPTONSS) || defined(BUILDCRYPTOOPENSSL)
 	return PASS;
 #else
 	printf("WARNING: nss support not builtin the library. Unable to test/verify internal crypto API calls\n");
 	return SKIP;
 #endif
 }
diff --git a/libknet/tests/api_knet_handle_enable_filter.c b/libknet/tests/api_knet_handle_enable_filter.c
index 0f1580ac..3dc73f0d 100644
--- a/libknet/tests/api_knet_handle_enable_filter.c
+++ b/libknet/tests/api_knet_handle_enable_filter.c
@@ -1,158 +1,156 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static int private_data;
 
 static int dhost_filter(void *pvt_data,
 			const unsigned char *outdata,
 			ssize_t outdata_len,
 			uint8_t tx_rx,
 			knet_node_id_t this_host_id,
 			knet_node_id_t src_host_id,
 			int8_t *dst_channel,
 			knet_node_id_t *dst_host_ids,
 			size_t *dst_host_ids_entries)
 {
 	return 0;
 }
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 
 	printf("Test knet_handle_enable_filter incorrect knet_h\n");
 
 	if ((!knet_handle_enable_filter(NULL, NULL, dhost_filter)) || (errno != EINVAL)) {
 		printf("knet_handle_enable_filter accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_handle_enable_filter with no private_data\n");
 
 	if (knet_handle_enable_filter(knet_h, NULL, dhost_filter) < 0) {
 		printf("knet_handle_enable_filter failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->dst_host_filter_fn_private_data != NULL) {
 		printf("knet_handle_enable_filter failed to unset private_data");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_enable_filter with private_data\n");
 
 	if (knet_handle_enable_filter(knet_h, &private_data, NULL) < 0) {
 		printf("knet_handle_enable_filter failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->dst_host_filter_fn_private_data != &private_data) {
 		printf("knet_handle_enable_filter failed to set private_data");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_enable_filter with no dhost_filter fn\n");
 
 	if (knet_handle_enable_filter(knet_h, NULL, NULL) < 0) {
 		printf("knet_handle_enable_filter failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->dst_host_filter_fn != NULL) {
 		printf("knet_handle_enable_filter failed to unset dhost_filter fn");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_enable_filter with dhost_filter fn\n");
 
 	if (knet_handle_enable_filter(knet_h, NULL, dhost_filter) < 0) {
 		printf("knet_handle_enable_filter failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->dst_host_filter_fn != &dhost_filter) {
 		printf("knet_handle_enable_filter failed to set dhost_filter fn");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_enable_pmtud_notify.c b/libknet/tests/api_knet_handle_enable_pmtud_notify.c
index 818c0541..64116ab2 100644
--- a/libknet/tests/api_knet_handle_enable_pmtud_notify.c
+++ b/libknet/tests/api_knet_handle_enable_pmtud_notify.c
@@ -1,149 +1,147 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static int private_data;
 
 static void pmtud_notify(void *priv_data,
 			 unsigned int data_mtu)
 {
 	return;
 }
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 
 	printf("Test knet_handle_enable_pmtud_notify incorrect knet_h\n");
 
 	if ((!knet_handle_enable_pmtud_notify(NULL, NULL, pmtud_notify)) || (errno != EINVAL)) {
 		printf("knet_handle_enable_pmtud_notify accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_handle_enable_pmtud_notify with no private_data\n");
 
 	if (knet_handle_enable_pmtud_notify(knet_h, NULL, pmtud_notify) < 0) {
 		printf("knet_handle_enable_pmtud_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->pmtud_notify_fn_private_data != NULL) {
 		printf("knet_handle_enable_pmtud_notify failed to unset private_data");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_enable_pmtud_notify with private_data\n");
 
 	if (knet_handle_enable_pmtud_notify(knet_h, &private_data, NULL) < 0) {
 		printf("knet_handle_enable_pmtud_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->pmtud_notify_fn_private_data != &private_data) {
 		printf("knet_handle_enable_pmtud_notify failed to set private_data");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_enable_pmtud_notify with no pmtud_notify fn\n");
 
 	if (knet_handle_enable_pmtud_notify(knet_h, NULL, NULL) < 0) {
 		printf("knet_handle_enable_pmtud_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->pmtud_notify_fn != NULL) {
 		printf("knet_handle_enable_pmtud_notify failed to unset pmtud_notify fn");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_enable_pmtud_notify with pmtud_notify fn\n");
 
 	if (knet_handle_enable_pmtud_notify(knet_h, NULL, pmtud_notify) < 0) {
 		printf("knet_handle_enable_pmtud_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->pmtud_notify_fn != &pmtud_notify) {
 		printf("knet_handle_enable_pmtud_notify failed to set pmtud_notify fn");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_enable_sock_notify.c b/libknet/tests/api_knet_handle_enable_sock_notify.c
index a545dcd1..ff1836f7 100644
--- a/libknet/tests/api_knet_handle_enable_sock_notify.c
+++ b/libknet/tests/api_knet_handle_enable_sock_notify.c
@@ -1,144 +1,142 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static int private_data;
 
 static void sock_notify(void *pvt_data,
 			int datafd,
 			int8_t channel,
 			uint8_t tx_rx,
 			int error,
 			int errorno)
 {
 	return;
 }
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 
 	printf("Test knet_handle_enable_sock_notify incorrect knet_h\n");
 
 	if ((!knet_handle_enable_sock_notify(NULL, NULL, sock_notify)) || (errno != EINVAL)) {
 		printf("knet_handle_enable_sock_notify accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_handle_enable_sock_notify with no private_data\n");
 
 	if (knet_handle_enable_sock_notify(knet_h, NULL, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->sock_notify_fn_private_data != NULL) {
 		printf("knet_handle_enable_sock_notify failed to unset private_data");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_enable_sock_notify with private_data\n");
 
 	if (knet_handle_enable_sock_notify(knet_h, &private_data, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->sock_notify_fn_private_data != &private_data) {
 		printf("knet_handle_enable_sock_notify failed to set private_data");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_enable_sock_notify with no sock_notify fn\n");
 
 	if ((!knet_handle_enable_sock_notify(knet_h, NULL, NULL)) || (errno != EINVAL)) {
 		printf("knet_handle_enable_sock_notify accepted invalid sock_notify or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_enable_sock_notify with sock_notify fn\n");
 
 	if (knet_handle_enable_sock_notify(knet_h, NULL, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->sock_notify_fn != &sock_notify) {
 		printf("knet_handle_enable_sock_notify failed to set sock_notify fn");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_free.c b/libknet/tests/api_knet_handle_free.c
index 54dfe552..8e38da4e 100644
--- a/libknet/tests/api_knet_handle_free.c
+++ b/libknet/tests/api_knet_handle_free.c
@@ -1,90 +1,88 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 #include "internals.h"
 
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 
 	setup_logpipes(logfds);
 
 	printf("Test knet_handle_free with invalid knet_h\n");
 
 	if ((!knet_handle_free(NULL)) || (errno != EINVAL)) {
 		printf("knet_handle_free failed to detect invalid parameter\n");
 		exit(FAIL);
 	}
 
 	printf("Test knet_handle_free with one host configured\n");
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add new knet_host: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_handle_free(knet_h)) || (errno != EBUSY)) {
 		printf("knet_handle_free didn't return error or correct errno with one host configured: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	if (knet_host_remove(knet_h, 1) < 0) {
 		printf("Unable to remove knet_host: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_handle_free(knet_h) < 0) {
 		printf("knet_handle_free failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_get_channel.c b/libknet/tests/api_knet_handle_get_channel.c
index 8f6089c3..b8aaa7af 100644
--- a/libknet/tests/api_knet_handle_get_channel.c
+++ b/libknet/tests/api_knet_handle_get_channel.c
@@ -1,152 +1,150 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static int private_data;
 
 static void sock_notify(void *pvt_data,
 			int datafd,
 			int8_t channel,
 			uint8_t tx_rx,
 			int error,
 			int errorno)
 {
 	return;
 }
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	int datafd = 0;
 	int8_t channel = 0, old_channel = 0;
 
 	printf("Test knet_handle_get_channel incorrect knet_h\n");
 
 	if ((!knet_handle_get_channel(NULL, datafd, &channel)) || (errno != EINVAL)) {
 		printf("knet_handle_get_channel accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_handle_get_channel with invalid datafd\n");
 
 	datafd = 0;
 
 	if ((!knet_handle_get_channel(knet_h, datafd, &channel)) || (errno != EINVAL)) {
 		printf("knet_handle_get_channel accepted invalid datafd or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_get_channel with invalid channel\n");
 
 	datafd = 10;
 
 	if ((!knet_handle_get_channel(knet_h, datafd, NULL)) || (errno != EINVAL)) {
 		printf("knet_handle_get_channel accepted invalid channel or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_get_channel with unconfigured datafd/channel\n");
 
 	datafd = 10;
 
 	if ((!knet_handle_get_channel(knet_h, datafd, &channel)) || (errno != EINVAL)) {
 		printf("knet_handle_get_channel accepted invalid channel or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_get_channel with valid datafd\n");
 
 	if (knet_handle_enable_sock_notify(knet_h, &private_data, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
         }
 
 	datafd = 0;
 	old_channel = -1;
 
 	if (knet_handle_add_datafd(knet_h, &datafd, &old_channel) < 0) {
 		printf("knet_handle_add_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_handle_get_channel(knet_h, datafd, &channel) < 0) {
 		printf("knet_handle_get_channel failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (old_channel != channel) {
 		printf("knet_handle_get_channel got incorrect channel\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_get_datafd.c b/libknet/tests/api_knet_handle_get_datafd.c
index 674662d7..0835e601 100644
--- a/libknet/tests/api_knet_handle_get_datafd.c
+++ b/libknet/tests/api_knet_handle_get_datafd.c
@@ -1,152 +1,150 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static int private_data;
 
 static void sock_notify(void *pvt_data,
 			int datafd,
 			int8_t channel,
 			uint8_t tx_rx,
 			int error,
 			int errorno)
 {
 	return;
 }
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	int datafd = 0, old_datafd;
 	int8_t channel = 0;
 
 	printf("Test knet_handle_get_datafd incorrect knet_h\n");
 
 	if ((!knet_handle_get_datafd(NULL, channel, &datafd)) || (errno != EINVAL)) {
 		printf("knet_handle_get_datafd accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_handle_get_datafd with invalid channel (< 0)\n");
 
 	channel = 0;
 
 	if ((!knet_handle_get_datafd(knet_h, channel, &datafd)) || (errno != EINVAL)) {
 		printf("knet_handle_get_datafd accepted invalid channel or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_get_datafd with invalid channel (KNET_DATAFD_MAX)\n");
 
 	channel = KNET_DATAFD_MAX;
 
 	if ((!knet_handle_get_datafd(knet_h, channel, &datafd)) || (errno != EINVAL)) {
 		printf("knet_handle_get_datafd accepted invalid channel or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_get_datafd with unconfigured datafd/channel\n");
 
 	channel = 10;
 
 	if ((!knet_handle_get_datafd(knet_h, channel, &datafd)) || (errno != EINVAL)) {
 		printf("knet_handle_get_datafd accepted unconfigured channel or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_get_datafd with valid datafd\n");
 
 	if (knet_handle_enable_sock_notify(knet_h, &private_data, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
         }
 
 	old_datafd = 0;
 	channel = -1;
 
 	if (knet_handle_add_datafd(knet_h, &old_datafd, &channel) < 0) {
 		printf("knet_handle_add_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_handle_get_datafd(knet_h, channel, &datafd) < 0) {
 		printf("knet_handle_get_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (old_datafd != datafd) {
 		printf("knet_handle_get_datafd got incorrect channel\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_get_stats.c b/libknet/tests/api_knet_handle_get_stats.c
index 8b455593..d48efcc3 100644
--- a/libknet/tests/api_knet_handle_get_stats.c
+++ b/libknet/tests/api_knet_handle_get_stats.c
@@ -1,110 +1,108 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "link.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct knet_handle_stats test_byte_array[2];
 	struct knet_handle_stats ref_byte_array[2];
 	struct knet_handle_stats stats;
 
 	printf("Test knet_handle_get_stats incorrect knet_h\n");
 
 	memset(&stats, 0, sizeof(struct knet_handle_stats));
 
 	if ((!knet_handle_get_stats(NULL, &stats, sizeof(struct knet_handle_stats))) || (errno != EINVAL)) {
 		printf("knet_handle_get_stats accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_handle_get_stats with NULL structure pointer\n");
 
 	if ((!knet_handle_get_stats(knet_h, NULL, 0) || (errno != EINVAL))) {
 		printf("knet_handle_get_stats accepted invalid stats address or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_get_stats with small structure size\n");
 
 	memset(test_byte_array, 0x55, sizeof(struct knet_handle_stats) * 2);
 	memset(ref_byte_array, 0x55, sizeof(struct knet_handle_stats) * 2);
 	if (knet_handle_get_stats(knet_h, (struct knet_handle_stats *)test_byte_array, sizeof(size_t)) < 0) {
 		printf("knet_handle_get_stats failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (memcmp(&test_byte_array[1], ref_byte_array, sizeof(struct knet_handle_stats))) {
 		printf("knet_handle_get_stats corrupted memory after stats structure\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_get_stats with valid input\n");
 
 	if (knet_handle_get_stats(knet_h, &stats, sizeof(struct knet_handle_stats)) < 0) {
 		printf("knet_handle_get_stats failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_get_transport_reconnect_interval.c b/libknet/tests/api_knet_handle_get_transport_reconnect_interval.c
index b77ddad7..5a566297 100644
--- a/libknet/tests/api_knet_handle_get_transport_reconnect_interval.c
+++ b/libknet/tests/api_knet_handle_get_transport_reconnect_interval.c
@@ -1,90 +1,88 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	uint32_t msecs = 0;
 
 	printf("Test knet_handle_get_transport_reconnect_interval with incorrect knet_h\n");
 
 	if ((!knet_handle_get_transport_reconnect_interval(NULL, &msecs)) || (errno != EINVAL)) {
 		printf("knet_handle_get_transport_reconnect_interval accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_handle_get_transport_reconnect_interval with incorrect msecs\n");
 
 	if ((!knet_handle_get_transport_reconnect_interval(knet_h, NULL)) || (errno != EINVAL)) {
 		printf("knet_handle_get_transport_reconnect_interval accepted invalid msecs or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_get_transport_reconnect_interval with correct values\n");
 
 	if (knet_handle_get_transport_reconnect_interval(knet_h, &msecs) < 0) {
 		printf("knet_handle_get_transport_reconnect_interval failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	if (msecs != KNET_TRANSPORT_DEFAULT_RECONNECT_INTERVAL) {
 		printf("knet_handle_get_transport_reconnect_interval failed to set correct value\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_new.c b/libknet/tests/api_knet_handle_new.c
index edebb449..aea969c5 100644
--- a/libknet/tests/api_knet_handle_new.c
+++ b/libknet/tests/api_knet_handle_new.c
@@ -1,139 +1,137 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 
 #include "libknet.h"
 #include "internals.h"
 
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	struct rlimit cur;
 	int logfds[2];
 
 	printf("Test knet_handle_new hostid 1, no logging\n");
 
 	knet_h = knet_handle_new(1, 0, 0);
 	if (!knet_h) {
 		printf("Unable to init knet_handle! err: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (knet_handle_free(knet_h) != 0) {
 		printf("Unable to free knet_handle\n");
 		exit(FAIL);
 	}
 
 	printf("Test knet_handle_new hostid -1, no logging\n");
 
 	knet_h = knet_handle_new(-1, 0, 0);
 	if (!knet_h) {
 		printf("Unable to init knet_handle! err: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	/*
 	 * -1 == knet_node_id_t 65535
 	 */
 
 	if (knet_h->host_id != 65535) {
 		printf("host_id size might have changed!\n");
 		knet_handle_free(knet_h);
 		exit(FAIL);
 	}
 
 	if (knet_handle_free(knet_h) != 0) {
 		printf("Unable to free knet_handle\n");
 		exit(FAIL);
 	}
 
 	if (getrlimit(RLIMIT_NOFILE, &cur) < 0) {
 		printf("Unable to get current fd limit: %s\n", strerror(errno));
 		exit(SKIP);
 	}
 
 	/*
 	 * passing a bad fd and it should fail
 	 */
 	printf("Test knet_handle_new hostid 1, incorrect log_fd (-1)\n");
 
 	knet_h = knet_handle_new(1, -1, 0);
 
 	if ((!knet_h) && (errno != EINVAL)) {
 		printf("knet_handle_new returned incorrect errno on incorrect log_fd\n");
 		exit(FAIL);
 	}
 
 	if (knet_h) {
 		printf("knet_handle_new accepted an incorrect (-1) log_fd\n");
 		knet_handle_free(knet_h);
 		exit(FAIL);
 	}
 
 	/*
 	 * passing a bad fd and it should fail
 	 */
 	printf("Test knet_handle_new hostid 1, incorrect log_fd (max_fd + 1)\n");
 
 	knet_h = knet_handle_new(1, (int) cur.rlim_max, 0);
 
 	if ((knet_h) || (errno != EINVAL)) {
 		printf("knet_handle_new accepted an incorrect (max_fd + 1) log_fd or returned incorrect errno on incorrect log_fd: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	printf("Test knet_handle_new hostid 1, proper log_fd, invalid log level (DEBUG + 1)\n");
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG + 1);
 
 	if ((knet_h) || (errno != EINVAL)) {
 		printf("knet_handle_new accepted an incorrect log level or returned incorrect errno on incorrect log level: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_handle_new hostid 1, proper log_fd, proper log level (DEBUG)\n");
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_new_limit.c b/libknet/tests/api_knet_handle_new_limit.c
index 4b203849..5beb33e0 100644
--- a/libknet/tests/api_knet_handle_new_limit.c
+++ b/libknet/tests/api_knet_handle_new_limit.c
@@ -1,72 +1,70 @@
 /*
  * Copyright (C) 2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 
 #include "libknet.h"
 #include "internals.h"
 
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h[UINT8_MAX + 1];
 	int logfds[2];
 	int idx;
 
 	setup_logpipes(logfds);
 
 	for (idx = 0; idx < UINT8_MAX; idx++) {
 		printf("Allocating %d\n", idx);
 		knet_h[idx] = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 		if (!knet_h[idx]) {
 			printf("knet_handle_new[%d] failed: %s\n", idx, strerror(errno));
 			flush_logs(logfds[0], stdout);
 			close_logpipes(logfds);
 			exit(FAIL);
 		}
 		flush_logs(logfds[0], stdout);
 	}
 
 	printf("forcing UINT8_T MAX\n");
 	knet_h[UINT8_MAX] = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 	if (knet_h[UINT8_MAX]) {
 		printf("off by one somewhere\n");
 		knet_handle_free(knet_h[UINT8_MAX]);
 	}
 	flush_logs(logfds[0], stdout);
 
 	for (idx = 0; idx < UINT8_MAX; idx++) {
 		printf("Freeing %d\n", idx);
 		knet_handle_free(knet_h[idx]);
 		flush_logs(logfds[0], stdout);
 	}
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
 	if ((is_memcheck()) || (is_helgrind())) {
 		return SKIP;
 	}
 
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_pmtud_get.c b/libknet/tests/api_knet_handle_pmtud_get.c
index bb476e0c..01c28fc7 100644
--- a/libknet/tests/api_knet_handle_pmtud_get.c
+++ b/libknet/tests/api_knet_handle_pmtud_get.c
@@ -1,87 +1,85 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	unsigned int data_mtu;
 
 	printf("Test knet_handle_pmtud_get incorrect knet_h\n");
 
 	if ((!knet_handle_pmtud_get(NULL, &data_mtu)) || (errno != EINVAL)) {
 		printf("knet_handle_pmtud_get accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_pmtud_get with no data_mtu\n");
 	if ((!knet_handle_pmtud_get(knet_h, NULL)) || (errno != EINVAL)) {
 		printf("knet_handle_pmtud_get accepted invalid data_mtu or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	if (knet_handle_pmtud_get(knet_h, &data_mtu) < 0) {
 		printf("knet_handle_pmtud_get failed error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->data_mtu != data_mtu) {
 		printf("knet_handle_pmtud_get failed to set the value\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_pmtud_getfreq.c b/libknet/tests/api_knet_handle_pmtud_getfreq.c
index 2fa4d64a..38d5e853 100644
--- a/libknet/tests/api_knet_handle_pmtud_getfreq.c
+++ b/libknet/tests/api_knet_handle_pmtud_getfreq.c
@@ -1,87 +1,85 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	unsigned int interval;
 
 	printf("Test knet_handle_pmtud_getfreq incorrect knet_h\n");
 
 	if ((!knet_handle_pmtud_getfreq(NULL, &interval)) || (errno != EINVAL)) {
 		printf("knet_handle_pmtud_getfreq accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_pmtud_getfreq with no interval\n");
 	if ((!knet_handle_pmtud_getfreq(knet_h, NULL)) || (errno != EINVAL)) {
 		printf("knet_handle_pmtud_getfreq accepted invalid interval or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	if (knet_handle_pmtud_getfreq(knet_h, &interval) < 0) {
 		printf("knet_handle_pmtud_getfreq failed error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->pmtud_interval != interval) {
 		printf("knet_handle_pmtud_getfreq failed to set the value\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_pmtud_setfreq.c b/libknet/tests/api_knet_handle_pmtud_setfreq.c
index 759c4f13..5b113dd7 100644
--- a/libknet/tests/api_knet_handle_pmtud_setfreq.c
+++ b/libknet/tests/api_knet_handle_pmtud_setfreq.c
@@ -1,98 +1,96 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 
 	printf("Test knet_handle_pmtud_setfreq incorrect knet_h\n");
 
 	if ((!knet_handle_pmtud_setfreq(NULL, 1)) || (errno != EINVAL)) {
 		printf("knet_handle_pmtud_setfreq accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_pmtud_setfreq with 0 (incorrect)\n");
 	if ((!knet_handle_pmtud_setfreq(NULL, 0)) || (errno != EINVAL)) {
 		printf("knet_handle_pmtud_setfreq accepted invalid PTMUd freq or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_pmtud_setfreq with 86401 (incorrect)\n");
 	if ((!knet_handle_pmtud_setfreq(NULL, 86401)) || (errno != EINVAL)) {
 		printf("knet_handle_pmtud_setfreq accepted invalid PTMUd freq or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_pmtud_setfreq with 1 (correct)\n");
 	if (knet_handle_pmtud_setfreq(knet_h, 1) < 0) {
 		printf("knet_handle_pmtud_setfreq failed error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->pmtud_interval != 1) {
 		printf("knet_handle_pmtud_setfreq failed to set the value\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_remove_datafd.c b/libknet/tests/api_knet_handle_remove_datafd.c
index 51285c6b..161d87e8 100644
--- a/libknet/tests/api_knet_handle_remove_datafd.c
+++ b/libknet/tests/api_knet_handle_remove_datafd.c
@@ -1,130 +1,128 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static int private_data;
 
 static void sock_notify(void *pvt_data,
 			int datafd,
 			int8_t channel,
 			uint8_t tx_rx,
 			int error,
 			int errorno)
 {
 	return;
 }
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	int datafd = 0;
 	int8_t channel = 0;
 
 	printf("Test knet_handle_remove_datafd incorrect knet_h\n");
 
 	if ((!knet_handle_remove_datafd(NULL, datafd)) || (errno != EINVAL)) {
 		printf("knet_handle_remove_datafd accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_handle_remove_datafd with no datafd\n");
 
 	datafd = 0;
 
 	if ((!knet_handle_remove_datafd(knet_h, datafd)) || (errno != EINVAL)) {
 		printf("knet_handle_remove_datafd accepted invalid datafd or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_remove_datafd with invalid datafd\n");
 
 	datafd = 10;
 
 	if ((!knet_handle_remove_datafd(knet_h, datafd)) || (errno != EINVAL)) {
 		printf("knet_handle_remove_datafd accepted invalid channel or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_remove_datafd with valid datafd\n");
 
 	if (knet_handle_enable_sock_notify(knet_h, &private_data, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
         }
 
 	datafd = 0;
 	channel = -1;
 
 	if (knet_handle_add_datafd(knet_h, &datafd, &channel) < 0) {
 		printf("knet_handle_add_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_handle_remove_datafd(knet_h, datafd) < 0) {
 		printf("knet_handle_remove_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_set_transport_reconnect_interval.c b/libknet/tests/api_knet_handle_set_transport_reconnect_interval.c
index e5296f24..68bc8976 100644
--- a/libknet/tests/api_knet_handle_set_transport_reconnect_interval.c
+++ b/libknet/tests/api_knet_handle_set_transport_reconnect_interval.c
@@ -1,89 +1,87 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 
 	printf("Test knet_handle_set_transport_reconnect_interval with incorrect knet_h\n");
 
 	if ((!knet_handle_set_transport_reconnect_interval(NULL, 1000)) || (errno != EINVAL)) {
 		printf("knet_handle_set_transport_reconnect_interval accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_handle_set_transport_reconnect_interval with incorrect msecs\n");
 
 	if ((!knet_handle_set_transport_reconnect_interval(knet_h, 0)) || (errno != EINVAL)) {
 		printf("knet_handle_set_transport_reconnect_interval accepted invalid msecs or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_set_transport_reconnect_interval with correct values\n");
 
 	if (knet_handle_set_transport_reconnect_interval(knet_h, 2000) < 0) {
 		printf("knet_handle_set_transport_reconnect_interval failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	if (knet_h->reconnect_int != 2000) {
 		printf("knet_handle_set_transport_reconnect_interval failed to set correct value\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_handle_setfwd.c b/libknet/tests/api_knet_handle_setfwd.c
index f0a177ee..cbddafa4 100644
--- a/libknet/tests/api_knet_handle_setfwd.c
+++ b/libknet/tests/api_knet_handle_setfwd.c
@@ -1,109 +1,107 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 #include "internals.h"
 
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 
 	printf("Test knet_handle_setfwd with invalid knet_h\n");
 
 	if ((!knet_handle_setfwd(NULL, 0)) || (errno != EINVAL)) {
 		printf("knet_handle_setfwd accepted invalid knet_h parameter\n");
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	printf("Test knet_handle_setfwd with invalid param (2) \n");
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_handle_setfwd(knet_h, 2)) || (errno != EINVAL)) {
 		printf("knet_handle_setfwd accepted invalid param for enabled: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_setfwd with valid param (1) \n");
 
 	if (knet_handle_setfwd(knet_h, 1) < 0) {
 		printf("knet_handle_setfwd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->enabled != 1) {
 		printf("knet_handle_setfwd failed to set correct value");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_setfwd with valid param (0) \n");
 
 	if (knet_handle_setfwd(knet_h, 0) < 0) {
 		printf("knet_handle_setfwd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->enabled != 0) {
 		printf("knet_handle_setfwd failed to set correct value");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_host_add.c b/libknet/tests/api_knet_host_add.c
index 6ad25be0..86b13fab 100644
--- a/libknet/tests/api_knet_host_add.c
+++ b/libknet/tests/api_knet_host_add.c
@@ -1,114 +1,112 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	knet_node_id_t host_ids[KNET_MAX_HOST];
 	size_t host_ids_entries;
 
 	printf("Test knet_host_add incorrect knet_h\n");
 
 	if ((!knet_host_add(NULL, 1)) || (errno != EINVAL)) {
 		printf("knet_host_add accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_add with hostid 1\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("knet_host_add failed error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test verify host_id 1 is in the host list\n");
 
 	if (knet_host_get_host_list(knet_h, host_ids, &host_ids_entries) < 0) {
 		printf("Unable to get host list: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (host_ids_entries != 1) {
 		printf("Too many hosts?\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (host_ids[0] != 1) {
 		printf("Unable to find host id 1 in host list\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_add adding host 1 again\n");
 
 	if ((!knet_host_add(knet_h, 1)) || (errno != EEXIST)) {
 		printf("knet_host_add accepted duplicated host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_host_remove(knet_h, 1);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_host_enable_status_change_notify.c b/libknet/tests/api_knet_host_enable_status_change_notify.c
index 95d931f7..148b081d 100644
--- a/libknet/tests/api_knet_host_enable_status_change_notify.c
+++ b/libknet/tests/api_knet_host_enable_status_change_notify.c
@@ -1,152 +1,150 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static int private_data;
 
 static void host_notify(void *priv_data,
 			knet_node_id_t host_id,
 			uint8_t reachable,
 			uint8_t remote,
 			uint8_t external)
 {
 	return;
 }
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 
 	printf("Test knet_host_enable_status_change_notify incorrect knet_h\n");
 
 	if ((!knet_host_enable_status_change_notify(NULL, NULL, host_notify)) || (errno != EINVAL)) {
 		printf("knet_host_enable_status_change_notify accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_host_enable_status_change_notify with no private_data\n");
 
 	if (knet_host_enable_status_change_notify(knet_h, NULL, host_notify) < 0) {
 		printf("knet_host_enable_status_change_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->host_status_change_notify_fn_private_data != NULL) {
 		printf("knet_host_enable_status_change_notify failed to unset private_data");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_enable_status_change_notify with private_data\n");
 
 	if (knet_host_enable_status_change_notify(knet_h, &private_data, NULL) < 0) {
 		printf("knet_host_enable_status_change_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->host_status_change_notify_fn_private_data != &private_data) {
 		printf("knet_host_enable_status_change_notify failed to set private_data");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_enable_status_change_notify with no host_notify fn\n");
 
 	if (knet_host_enable_status_change_notify(knet_h, NULL, NULL) < 0) {
 		printf("knet_host_enable_status_change_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->host_status_change_notify_fn != NULL) {
 		printf("knet_host_enable_status_change_notify failed to unset host_notify fn");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_enable_status_change_notify with host_notify fn\n");
 
 	if (knet_host_enable_status_change_notify(knet_h, NULL, host_notify) < 0) {
 		printf("knet_host_enable_status_change_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->host_status_change_notify_fn != &host_notify) {
 		printf("knet_host_enable_status_change_notify failed to set host_notify fn");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_host_get_host_list.c b/libknet/tests/api_knet_host_get_host_list.c
index 84305f40..7f08c9d0 100644
--- a/libknet/tests/api_knet_host_get_host_list.c
+++ b/libknet/tests/api_knet_host_get_host_list.c
@@ -1,148 +1,146 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	knet_node_id_t host_ids[KNET_MAX_HOST];
 	size_t host_ids_entries;
 
 	printf("Test knet_host_get_host_list incorrect knet_h\n");
 
 	if ((!knet_host_get_host_list(NULL, host_ids, &host_ids_entries)) || (errno != EINVAL)) {
 		printf("knet_host_get_host_list accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_host_list incorrect host_ids\n");
 
 	if ((!knet_host_get_host_list(knet_h, NULL, &host_ids_entries)) || (errno != EINVAL)) {
 		printf("knet_host_get_host_list accepted invalid host_ids or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_host_list incorrect host_ids_entries\n");
 
 	if ((!knet_host_get_host_list(knet_h, host_ids, NULL)) || (errno != EINVAL)) {
 		printf("knet_host_get_host_list accepted invalid host_ids or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_host_list with one host\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("knet_host_add failed error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_host_get_host_list(knet_h, host_ids, &host_ids_entries) < 0) {
 		printf("Unable to get host list: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (host_ids_entries != 1) {
 		printf("Too many hosts?\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (host_ids[0] != 1) {
 		printf("Unable to find host id 1 in host list\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_host_list with zero hosts\n");
 
 	if (knet_host_remove(knet_h, 1) < 0) {
 		printf("knet_host_remove failed error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_host_get_host_list(knet_h, host_ids, &host_ids_entries) < 0) {
 		printf("Unable to get host list: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (host_ids_entries != 0) {
 		printf("Too many hosts?\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_host_get_id_by_host_name.c b/libknet/tests/api_knet_host_get_id_by_host_name.c
index 1e50418b..00fe525d 100644
--- a/libknet/tests/api_knet_host_get_id_by_host_name.c
+++ b/libknet/tests/api_knet_host_get_id_by_host_name.c
@@ -1,120 +1,118 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	knet_node_id_t host_id;
 
 	printf("Test knet_host_get_id_by_host_name incorrect knet_h\n");
 
 	if ((!knet_host_get_id_by_host_name(NULL, "1", &host_id)) || (errno != EINVAL)) {
 		printf("knet_host_get_id_by_host_name accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_id_by_host_name with incorrect name 1\n");
 
 	if ((!knet_host_get_id_by_host_name(knet_h, NULL, &host_id)) || (errno != EINVAL)) {
 		printf("knet_host_get_id_by_host_name accepted invalid name or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_id_by_host_name with incorrect host_id\n");
 
 	if ((!knet_host_get_id_by_host_name(knet_h, "1", NULL)) || (errno != EINVAL)) {
 		printf("knet_host_get_id_by_host_name accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_id_by_host_name with incorrect values for name\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("knet_host_add failed error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_host_get_id_by_host_name(knet_h, "test", &host_id)) || (errno != ENOENT)) {
 		printf("knet_host_get_id_by_host_name returned invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_id_by_host_name with correct values\n");
 
 	if (knet_host_get_id_by_host_name(knet_h, "1", &host_id) < 0) {
 		printf("knet_host_get_id_by_host_name could not get id for known name: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_host_remove(knet_h, 1);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_host_get_name_by_host_id.c b/libknet/tests/api_knet_host_get_name_by_host_id.c
index 4988a962..3385fc98 100644
--- a/libknet/tests/api_knet_host_get_name_by_host_id.c
+++ b/libknet/tests/api_knet_host_get_name_by_host_id.c
@@ -1,109 +1,107 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	char name[KNET_MAX_HOST_LEN];
 
 	printf("Test knet_host_get_name_by_host_id incorrect knet_h\n");
 
 	if ((!knet_host_get_name_by_host_id(NULL, 1, name)) || (errno != EINVAL)) {
 		printf("knet_host_get_name_by_host_id accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_name_by_host_id with incorrect hostid 1\n");
 
 	if ((!knet_host_get_name_by_host_id(knet_h, 1, name)) || (errno != EINVAL)) {
 		printf("knet_host_get_name_by_host_id accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_name_by_host_id with incorrect name\n");
 
 	if ((!knet_host_get_name_by_host_id(knet_h, 1, NULL)) || (errno != EINVAL)) {
 		printf("knet_host_get_name_by_host_id accepted invalid name or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_name_by_host_id with correct values for hostid 1: ");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("knet_host_add failed error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_host_get_name_by_host_id(knet_h, 1, name) < 0) {
 		printf("knet_host_get_name_by_host_id faild to retrive name: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("%s\n", name);
 
 	flush_logs(logfds[0], stdout);
 
 	knet_host_remove(knet_h, 1);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_host_get_policy.c b/libknet/tests/api_knet_host_get_policy.c
index 0e9f6d1e..d69ddd4c 100644
--- a/libknet/tests/api_knet_host_get_policy.c
+++ b/libknet/tests/api_knet_host_get_policy.c
@@ -1,125 +1,123 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	uint8_t policy;
 
 	printf("Test knet_host_get_policy incorrect knet_h\n");
 
 	if ((!knet_host_get_policy(NULL, 1, &policy)) || (errno != EINVAL)) {
 		printf("knet_host_get_policy accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_policy incorrect host_id\n");
 
 	if ((!knet_host_get_policy(knet_h, 1, &policy)) || (errno != EINVAL)) {
 		printf("knet_host_get_policy accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_policy incorrect policy\n");
 
 	if ((!knet_host_get_policy(knet_h, 1, NULL)) || (errno != EINVAL)) {
 		printf("knet_host_get_policy accepted invalid policy or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_policy correct policy\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("knet_host_add failed error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_host_set_policy(knet_h, 1, KNET_LINK_POLICY_RR) < 0) {
 		printf("knet_host_set_policy failed to set RR policy for host 1: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_host_get_policy(knet_h, 1, &policy) < 0) {
 		printf("knet_host_get_policy failed for host 1: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (policy != KNET_LINK_POLICY_RR) {
 		printf("knet_host_get_policy policy for host 1 does not appear to be correct\n");
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_host_remove(knet_h, 1);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_host_get_status.c b/libknet/tests/api_knet_host_get_status.c
index 3c88ec97..e8d0b178 100644
--- a/libknet/tests/api_knet_host_get_status.c
+++ b/libknet/tests/api_knet_host_get_status.c
@@ -1,108 +1,106 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "host.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct knet_host_status status;
 
 	printf("Test knet_host_get_status incorrect knet_h\n");
 
 	memset(&status, 0, sizeof(struct knet_host_status));
 
 	if ((!knet_host_get_status(NULL, 1, &status)) || (errno != EINVAL)) {
 		printf("knet_host_get_status accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_host_get_status with unconfigured host_id\n");
 
 	if ((!knet_host_get_status(knet_h, 1, &status)) || (errno != EINVAL)) {
 		printf("knet_host_get_status accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_status with incorrect status\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("knet_host_add failed error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_host_get_status(knet_h, 1, NULL)) || (errno != EINVAL)) {
 		printf("knet_host_get_status accepted invalid status or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_get_status with correct values\n");
 
 	if (knet_host_get_status(knet_h, 1, &status) < 0) {
 		printf("knet_host_get_status failed: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_host_remove.c b/libknet/tests/api_knet_host_remove.c
index 783971b1..9f124209 100644
--- a/libknet/tests/api_knet_host_remove.c
+++ b/libknet/tests/api_knet_host_remove.c
@@ -1,167 +1,165 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "netutils.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	knet_node_id_t host_ids[KNET_MAX_HOST];
 	size_t host_ids_entries;
 	struct sockaddr_storage ss;
 
 	printf("Test knet_host_add incorrect knet_h\n");
 
 	if ((!knet_host_remove(NULL, 1)) || (errno != EINVAL)) {
 		printf("knet_host_remove accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_remove with unconfigured host_id\n");
 
 	if ((!knet_host_remove(knet_h, 1)) || (errno != EINVAL)) {
 		printf("knet_host_remove accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_remove with configured host_id and links\n");
 
 	if (make_local_sockaddr(&ss, 0) < 0) {
 		printf("Unable to convert str to sockaddr: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &ss, NULL, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_enable(knet_h, 1, 0, 1) < 0) {
 		printf("Unable to enable link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_host_remove(knet_h, 1)) || (errno != EBUSY)) {
 		printf("knet_host_remove accepted invalid request to remove host with link enabled or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_enable(knet_h, 1, 0, 0) < 0) {
 		printf("Unable to disable link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_clear_config(knet_h, 1, 0) < 0) {
 		printf("Unable to clear link config: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_remove with configured host_id (no links)\n");
 
 	if (knet_host_remove(knet_h, 1) < 0) {
 		printf("knet_host_remove didn't remove host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_host_get_host_list(knet_h, host_ids, &host_ids_entries) < 0) {
 		printf("Unable to get host list: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (host_ids_entries) {
 		printf("Too many hosts?\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_host_set_name.c b/libknet/tests/api_knet_host_set_name.c
index c21eda3f..50f9d335 100644
--- a/libknet/tests/api_knet_host_set_name.c
+++ b/libknet/tests/api_knet_host_set_name.c
@@ -1,179 +1,177 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	char longhostname[KNET_MAX_HOST_LEN+2];
 
 	printf("Test knet_host_set_name incorrect knet_h\n");
 
 	if ((!knet_host_set_name(NULL, 1, "test")) || (errno != EINVAL)) {
 		printf("knet_host_set_name accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_set_name with incorrect hostid 1\n");
 
 	if ((!knet_host_set_name(knet_h, 2, "test")) || (errno != EINVAL)) {
 		printf("knet_host_set_name accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_set_name with correct values\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("knet_host_add failed error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_host_set_name(knet_h, 1, "test") < 0) {
 		printf("knet_host_set_name failed: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (strcmp("test", knet_h->host_index[1]->name)) {
 		printf("knet_host_set_name failed to copy name\n");
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_set_name with correct values (name change)\n");
 
 	if (knet_host_set_name(knet_h, 1, "tes") < 0) {
 		printf("knet_host_set_name failed: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (strcmp("tes", knet_h->host_index[1]->name)) {
 		printf("knet_host_set_name failed to change name\n");
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_set_name with NULL name\n");
 
 	if ((!knet_host_set_name(knet_h, 1, NULL)) || (errno != EINVAL)) {
 		printf("knet_host_set_name accepted invalid name or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_set_name with duplicate name\n");
 
 	if (knet_host_add(knet_h, 2) < 0) {
 		printf("knet_host_add failed error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_host_set_name(knet_h, 2, "tes")) || (errno != EEXIST)) {
 		printf("knet_host_set_name accepted duplicated name or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 2);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_host_remove(knet_h, 2);
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_set_name with (too) long name\n");
 
 	memset(longhostname, 'a', sizeof(longhostname));
 	longhostname[KNET_MAX_HOST_LEN] = '\0';
 
 	if ((!knet_host_set_name(knet_h, 1, longhostname)) || (errno != EINVAL)) {
 		printf("knet_host_set_name accepted invalid (too long) name or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_host_remove(knet_h, 1);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_host_set_policy.c b/libknet/tests/api_knet_host_set_policy.c
index e7e481cf..3624bfa4 100644
--- a/libknet/tests/api_knet_host_set_policy.c
+++ b/libknet/tests/api_knet_host_set_policy.c
@@ -1,115 +1,113 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 
 	printf("Test knet_host_set_policy incorrect knet_h\n");
 
 	if ((!knet_host_set_policy(NULL, 1, KNET_LINK_POLICY_PASSIVE)) || (errno != EINVAL)) {
 		printf("knet_host_set_policy accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_set_policy incorrect host_id\n");
 
 	if ((!knet_host_set_policy(knet_h, 1, KNET_LINK_POLICY_PASSIVE)) || (errno != EINVAL)) {
 		printf("knet_host_set_policy accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_set_policy incorrect policy\n");
 
 	if ((!knet_host_set_policy(knet_h, 1, KNET_LINK_POLICY_RR + 1)) || (errno != EINVAL)) {
 		printf("knet_host_set_policy accepted invalid policy or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_host_set_policy correct policy\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("knet_host_add failed error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_host_set_policy(knet_h, 1, KNET_LINK_POLICY_RR) < 0) {
 		printf("knet_host_set_policy failed to set RR policy for host 1: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->host_index[1]->link_handler_policy != KNET_LINK_POLICY_RR) {
 		printf("knet_host_set_policy failed to set RR policy for host 1: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_host_remove(knet_h, 1);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_link_clear_config.c b/libknet/tests/api_knet_link_clear_config.c
index f56de055..1b5bc7b6 100644
--- a/libknet/tests/api_knet_link_clear_config.c
+++ b/libknet/tests/api_knet_link_clear_config.c
@@ -1,174 +1,172 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "link.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct sockaddr_storage src, dst;
 
 	if (make_local_sockaddr(&src, 0) < 0) {
 		printf("Unable to convert src to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (make_local_sockaddr(&dst, 1) < 0) {
 		printf("Unable to convert dst to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_clear_config incorrect knet_h\n");
 
 	if ((!knet_link_clear_config(NULL, 1, 0)) || (errno != EINVAL)) {
 		printf("knet_link_clear_config accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_clear_config with unconfigured host_id\n");
 
 	if ((!knet_link_clear_config(knet_h, 1, 0)) || (errno != EINVAL)) {
 		printf("knet_link_clear_config accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_clear_config with incorrect linkid\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_clear_config(knet_h, 1, KNET_MAX_LINK)) || (errno != EINVAL)) {
 		printf("knet_link_clear_config accepted invalid linkid or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_clear_config with unconfigured linkid\n");
 
 	if ((!knet_link_clear_config(knet_h, 1, 0)) || (errno != EINVAL)) {
 		printf("knet_link_clear_config accepted unconfigured linkid or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_clear_config with enabled linkid\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_enable(knet_h, 1, 0, 1) < 0) {
 		printf("Unable to enable link: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_clear_config(knet_h, 1, 0) || (errno != EBUSY))) {
 		printf("knet_link_clear_config accepted invalid enabled link or returned incorrect error: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_clear_config with correct data\n");
 
 	if (knet_link_set_enable(knet_h, 1, 0, 0) < 0) {
 		printf("Unable to disable link: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_clear_config(knet_h, 1, 0) < 0) {
 		printf("Unable to clear link config: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_link_get_config.c b/libknet/tests/api_knet_link_get_config.c
index f120c456..87baaf1f 100644
--- a/libknet/tests/api_knet_link_get_config.c
+++ b/libknet/tests/api_knet_link_get_config.c
@@ -1,334 +1,332 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "link.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct sockaddr_storage src, dst, get_src, get_dst;
 	uint8_t dynamic = 0, transport = 0;
 	uint64_t flags;
 
 	if (make_local_sockaddr(&src, 0) < 0) {
 		printf("Unable to convert src to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (make_local_sockaddr(&dst, 1) < 0) {
 		printf("Unable to convert dst to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_config incorrect knet_h\n");
 
 	memset(&get_src, 0, sizeof(struct sockaddr_storage));
 	memset(&get_dst, 0, sizeof(struct sockaddr_storage));
 
 	if ((!knet_link_get_config(NULL, 1, 0, &transport, &get_src, &get_dst, &dynamic, &flags)) || (errno != EINVAL)) {
 		printf("knet_link_get_config accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_config with unconfigured host_id\n");
 
 	memset(&get_src, 0, sizeof(struct sockaddr_storage));
 	memset(&get_dst, 0, sizeof(struct sockaddr_storage));
 
 	if ((!knet_link_get_config(knet_h, 1, 0, &transport, &get_src, &get_dst, &dynamic, &flags)) || (errno != EINVAL)) {
 		printf("knet_link_get_config accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_config with incorrect linkid\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	memset(&get_src, 0, sizeof(struct sockaddr_storage));
 	memset(&get_dst, 0, sizeof(struct sockaddr_storage));
 
 	if ((!knet_link_get_config(knet_h, 1, KNET_MAX_LINK, &transport, &get_src, &get_dst, &dynamic, &flags)) || (errno != EINVAL)) {
 		printf("knet_link_get_config accepted invalid linkid or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_config with incorrect src_addr\n");
 
 	memset(&get_src, 0, sizeof(struct sockaddr_storage));
 	memset(&get_dst, 0, sizeof(struct sockaddr_storage));
 
 	if ((!knet_link_get_config(knet_h, 1, 0, &transport, NULL, &get_dst, &dynamic, &flags)) || (errno != EINVAL)) {
 		printf("knet_link_get_config accepted invalid src_addr or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_config with incorrect dynamic\n");
 
 	memset(&get_src, 0, sizeof(struct sockaddr_storage));
 	memset(&get_dst, 0, sizeof(struct sockaddr_storage));
 
 	if ((!knet_link_get_config(knet_h, 1, 0, &transport, &get_src, &get_dst, NULL, &flags)) || (errno != EINVAL)) {
 		printf("knet_link_get_config accepted invalid dynamic or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_config with unconfigured link\n");
 
 	memset(&get_src, 0, sizeof(struct sockaddr_storage));
 	memset(&get_dst, 0, sizeof(struct sockaddr_storage));
 
 	if ((!knet_link_get_config(knet_h, 1, 0, &transport, &get_src, &get_dst, &dynamic, &flags)) || (errno != EINVAL)) {
 		printf("knet_link_get_config accepted unconfigured link or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_config with incorrect dst_addr\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	memset(&get_src, 0, sizeof(struct sockaddr_storage));
 	memset(&get_dst, 0, sizeof(struct sockaddr_storage));
 
 	if ((!knet_link_get_config(knet_h, 1, 0, &transport, &get_src, NULL, &dynamic, &flags)) || (errno != EINVAL)) {
 		printf("knet_link_get_config accepted invalid dst_addr or returned incorrect error: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (dynamic) {
 		printf("knet_link_get_config returned invalid dynamic status\n");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_config with correct parameters for static link\n");
 
 	memset(&get_src, 0, sizeof(struct sockaddr_storage));
 	memset(&get_dst, 0, sizeof(struct sockaddr_storage));
 
 	if (knet_link_get_config(knet_h, 1, 0, &transport, &get_src, &get_dst, &dynamic, &flags) < 0) {
 		printf("knet_link_get_config failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (transport != KNET_TRANSPORT_UDP) {
 		printf("knet_link_get_config returned incorrect transport: %d\n", transport);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((dynamic) ||
 	    (memcmp(&src, &get_src, sizeof(struct sockaddr_storage))) ||
 	    (memcmp(&dst, &get_dst, sizeof(struct sockaddr_storage)))) {
 		printf("knet_link_get_config returned invalid data\n");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_config with correct parameters for dynamic link\n");
 
 	if (knet_link_clear_config(knet_h, 1, 0) < 0) {
 		printf("Unable to deconfigure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, NULL, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	memset(&get_src, 0, sizeof(struct sockaddr_storage));
 	memset(&get_dst, 0, sizeof(struct sockaddr_storage));
 
 	if (knet_link_get_config(knet_h, 1, 0, &transport, &get_src, &get_dst, &dynamic, &flags) < 0) {
 		printf("knet_link_get_config failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!dynamic) ||
 	    (memcmp(&src, &get_src, sizeof(struct sockaddr_storage)))) {
 		printf("knet_link_get_config returned invalid data\n");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_config NULL transport ptr\n");
 
 	if ((!knet_link_get_config(knet_h, 1, 0, NULL, &get_src, &get_dst, &dynamic, &flags)) || (errno != EINVAL)) {
 		printf("knet_link_get_config accepted NULL &transport or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_config with flags\n");
 
 	if (knet_link_clear_config(knet_h, 1, 0) < 0) {
 		printf("Unable to deconfigure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, NULL, KNET_LINK_FLAG_TRAFFICHIPRIO) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_get_config(knet_h, 1, 0, &transport, &get_src, &get_dst, &dynamic, &flags) < 0) {
 		printf("knet_link_get_config failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (flags != KNET_LINK_FLAG_TRAFFICHIPRIO) {
 		printf("knet_link_get_config returned no flags\n");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_link_get_enable.c b/libknet/tests/api_knet_link_get_enable.c
index 0aed9aca..cb3e9969 100644
--- a/libknet/tests/api_knet_link_get_enable.c
+++ b/libknet/tests/api_knet_link_get_enable.c
@@ -1,201 +1,199 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "link.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct sockaddr_storage src, dst;
 	unsigned int enabled;
 
 	if (make_local_sockaddr(&src, 0) < 0) {
 		printf("Unable to convert src to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (make_local_sockaddr(&dst, 1) < 0) {
 		printf("Unable to convert dst to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_enable incorrect knet_h\n");
 
 	if ((!knet_link_get_enable(NULL, 1, 0, &enabled)) || (errno != EINVAL)) {
 		printf("knet_link_get_enable accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_enable with unconfigured host_id\n");
 
 	if ((!knet_link_get_enable(knet_h, 1, 0, &enabled)) || (errno != EINVAL)) {
 		printf("knet_link_get_enable accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_enable with incorrect linkid\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_get_enable(knet_h, 1, KNET_MAX_LINK, &enabled)) || (errno != EINVAL)) {
 		printf("knet_link_get_enable accepted invalid linkid or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_enable with unconfigured link\n");
 
 	if ((!knet_link_get_enable(knet_h, 1, 0, &enabled)) || (errno != EINVAL)) {
 		printf("knet_link_get_enable accepted unconfigured link or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_enable without enabled\n");
 
 	if ((!knet_link_get_enable(knet_h, 1, 0, NULL)) || (errno != EINVAL)) {
 		printf("knet_link_get_enable accepted NULL enabled or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_enable with disabled link\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_get_enable(knet_h, 1, 0, &enabled) < 0) {
 		printf("knet_link_get_enable failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (enabled) {
 		printf("knet_link_get_enable returned incorrect value");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_enable with enabled link\n");
 
 	if (knet_link_set_enable(knet_h, 1, 0, 1) < 0) {
 		printf("knet_link_get_enable failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_get_enable(knet_h, 1, 0, &enabled) < 0) {
 		printf("knet_link_get_enable failed: %s\n", strerror(errno));
 		knet_link_get_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (!enabled) {
 		printf("knet_link_get_enable returned incorrect value");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_link_set_enable(knet_h, 1, 0, 0);
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_link_get_link_list.c b/libknet/tests/api_knet_link_get_link_list.c
index e7d81cda..4b923482 100644
--- a/libknet/tests/api_knet_link_get_link_list.c
+++ b/libknet/tests/api_knet_link_get_link_list.c
@@ -1,178 +1,176 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "link.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct sockaddr_storage src, dst;
 	uint8_t link_ids[KNET_MAX_LINK];
 	size_t link_ids_entries = 0;
 
 	if (make_local_sockaddr(&src, 0) < 0) {
 		printf("Unable to convert src to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (make_local_sockaddr(&dst, 1) < 0) {
 		printf("Unable to convert dst to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	memset(&link_ids, 1, sizeof(link_ids));
 
 	printf("Test knet_link_get_link_list incorrect knet_h\n");
 
 	if ((!knet_link_get_link_list(NULL, 1, link_ids, &link_ids_entries)) || (errno != EINVAL)) {
 		printf("knet_link_get_link_list accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_link_list with unconfigured host_id\n");
 
 	if ((!knet_link_get_link_list(knet_h, 1, link_ids, &link_ids_entries)) || (errno != EINVAL)) {
 		printf("knet_link_get_link_list accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_link_list with incorrect link_id\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_get_link_list(knet_h, 1, NULL, &link_ids_entries)) || (errno != EINVAL)) {
 		printf("knet_link_get_link_list accepted invalid link_ids or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_link_list with incorrect link_ids_entries\n");
 
 	if ((!knet_link_get_link_list(knet_h, 1, link_ids, NULL)) || (errno != EINVAL)) {
 		printf("knet_link_get_link_list accepted invalid link_ids_entries or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_link_list with no links\n");
 
 	if (knet_link_get_link_list(knet_h, 1, link_ids, &link_ids_entries) < 0) {
 		printf("knet_link_get_link_list failed: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (link_ids_entries != 0) {
 		printf("knet_link_get_link_list returned incorrect number of links");
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_link_list with 1 link\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_get_link_list(knet_h, 1, link_ids, &link_ids_entries) < 0) {
 		printf("knet_link_get_link_list failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((link_ids_entries != 1) || (link_ids[0] != 0)) {
 		printf("knet_link_get_link_list returned incorrect values");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_link_get_ping_timers.c b/libknet/tests/api_knet_link_get_ping_timers.c
index b3de92bb..e4a22d99 100644
--- a/libknet/tests/api_knet_link_get_ping_timers.c
+++ b/libknet/tests/api_knet_link_get_ping_timers.c
@@ -1,196 +1,194 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "link.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct sockaddr_storage src, dst;
 	time_t interval = 0, timeout = 0;
 	unsigned int precision = 0;
 
 	if (make_local_sockaddr(&src, 0) < 0) {
 		printf("Unable to convert src to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (make_local_sockaddr(&dst, 1) < 0) {
 		printf("Unable to convert dst to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_ping_timers incorrect knet_h\n");
 
 	if ((!knet_link_get_ping_timers(NULL, 1, 0, &interval, &timeout, &precision)) || (errno != EINVAL)) {
 		printf("knet_link_get_ping_timers accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_ping_timers with unconfigured host_id\n");
 
 	if ((!knet_link_get_ping_timers(knet_h, 1, 0, &interval, &timeout, &precision)) || (errno != EINVAL)) {
 		printf("knet_link_get_ping_timers accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_ping_timers with incorrect linkid\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_get_ping_timers(knet_h, 1, KNET_MAX_LINK, &interval, &timeout, &precision)) || (errno != EINVAL)) {
 		printf("knet_link_get_ping_timers accepted invalid linkid or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_ping_timers with incorrect interval\n");
 
 	if ((!knet_link_get_ping_timers(knet_h, 1, 0, NULL, &timeout, &precision)) || (errno != EINVAL)) {
 		printf("knet_link_get_ping_timers accepted invalid interval or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_ping_timers with incorrect timeout\n");
 
 	if ((!knet_link_get_ping_timers(knet_h, 1, 0, &interval, NULL, &precision)) || (errno != EINVAL)) {
 		printf("knet_link_get_ping_timers accepted invalid timeout or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_ping_timers with incorrect interval\n");
 
 	if ((!knet_link_get_ping_timers(knet_h, 1, 0, &interval, &timeout, NULL)) || (errno != EINVAL)) {
 		printf("knet_link_get_ping_timers accepted invalid interval or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_ping_timers with unconfigured link\n");
 
 	if ((!knet_link_get_ping_timers(knet_h, 1, 0, &interval, &timeout, &precision)) || (errno != EINVAL)) {
 		printf("knet_link_get_ping_timers accepted unconfigured link or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_ping_timers with correct values\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_get_ping_timers(knet_h, 1, 0, &interval, &timeout, &precision) < 0) {
 		printf("knet_link_get_ping_timers failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("DEFAULT: int: %ld timeout: %ld prec: %u\n", (long int)interval, (long int)timeout, precision);
 
 	if ((interval != KNET_LINK_DEFAULT_PING_INTERVAL) ||
 	    (timeout != KNET_LINK_DEFAULT_PING_TIMEOUT) ||
 	    (precision != KNET_LINK_DEFAULT_PING_PRECISION)) {
 		printf("knet_link_get_ping_timers failed to set values\n");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_link_get_pong_count.c b/libknet/tests/api_knet_link_get_pong_count.c
index 8afafabe..eceaacc9 100644
--- a/libknet/tests/api_knet_link_get_pong_count.c
+++ b/libknet/tests/api_knet_link_get_pong_count.c
@@ -1,173 +1,171 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "link.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct sockaddr_storage src, dst;
 	uint8_t pong_count = 0;
 
 	if (make_local_sockaddr(&src, 0) < 0) {
 		printf("Unable to convert src to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (make_local_sockaddr(&dst, 1) < 0) {
 		printf("Unable to convert dst to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_pong_count incorrect knet_h\n");
 
 	if ((!knet_link_get_pong_count(NULL, 1, 0, &pong_count)) || (errno != EINVAL)) {
 		printf("knet_link_get_pong_count accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_pong_count with unconfigured host_id\n");
 
 	if ((!knet_link_get_pong_count(knet_h, 1, 0, &pong_count)) || (errno != EINVAL)) {
 		printf("knet_link_get_pong_count accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_pong_count with incorrect linkid\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_get_pong_count(knet_h, 1, KNET_MAX_LINK, &pong_count)) || (errno != EINVAL)) {
 		printf("knet_link_get_pong_count accepted invalid linkid or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_pong_count with incorrect pong count\n");
 
 	if ((!knet_link_get_pong_count(knet_h, 1, 0, NULL)) || (errno != EINVAL)) {
 		printf("knet_link_get_pong_count accepted invalid pong count or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_pong_count with unconfigured link\n");
 
 	if ((!knet_link_get_pong_count(knet_h, 1, 0, &pong_count)) || (errno != EINVAL)) {
 		printf("knet_link_get_pong_count accepted unconfigured link or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_pong_count with correct values\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_pong_count(knet_h, 1, 0, 3) < 0) {
 		printf("knet_link_set_pong_count failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_get_pong_count(knet_h, 1, 0, &pong_count) < 0) {
 		printf("knet_link_get_pong_count failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (pong_count != 3) {
 		printf("knet_link_get_pong_count failed to get correct values\n");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_link_get_priority.c b/libknet/tests/api_knet_link_get_priority.c
index 5dde209e..224b3565 100644
--- a/libknet/tests/api_knet_link_get_priority.c
+++ b/libknet/tests/api_knet_link_get_priority.c
@@ -1,173 +1,171 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "link.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct sockaddr_storage src, dst;
 	uint8_t priority = 0;
 
 	if (make_local_sockaddr(&src, 0) < 0) {
 		printf("Unable to convert src to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (make_local_sockaddr(&dst, 1) < 0) {
 		printf("Unable to convert dst to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_priority incorrect knet_h\n");
 
 	if ((!knet_link_get_priority(NULL, 1, 0, &priority)) || (errno != EINVAL)) {
 		printf("knet_link_get_priority accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_priority with unconfigured host_id\n");
 
 	if ((!knet_link_get_priority(knet_h, 1, 0, &priority)) || (errno != EINVAL)) {
 		printf("knet_link_get_priority accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_priority with incorrect linkid\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_get_priority(knet_h, 1, KNET_MAX_LINK, &priority)) || (errno != EINVAL)) {
 		printf("knet_link_get_priority accepted invalid linkid or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_priority with unconfigured link\n");
 
 	if ((!knet_link_get_priority(knet_h, 1, 0, &priority)) || (errno != EINVAL)) {
 		printf("knet_link_get_priority accepted unconfigured link or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_priority with incorrect priority\n");
 
 	if ((!knet_link_get_priority(knet_h, 1, 0, NULL)) || (errno != EINVAL)) {
 		printf("knet_link_get_priority accepted incorrect priority or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_priority with correct values\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_priority(knet_h, 1, 0, 1) < 0) {
 		printf("knet_link_set_priority failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_get_priority(knet_h, 1, 0, &priority) < 0) {
 		printf("knet_link_get_priority failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (priority != 1) {
 		printf("knet_link_get_priority failed to get correct values\n");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_link_get_status.c b/libknet/tests/api_knet_link_get_status.c
index 7c7bfb75..d98dccdc 100644
--- a/libknet/tests/api_knet_link_get_status.c
+++ b/libknet/tests/api_knet_link_get_status.c
@@ -1,157 +1,155 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "link.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct sockaddr_storage src, dst;
 	struct knet_link_status status;
 
 	if (make_local_sockaddr(&src, 0) < 0) {
 		printf("Unable to convert src to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (make_local_sockaddr(&dst, 1) < 0) {
 		printf("Unable to convert dst to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_status incorrect knet_h\n");
 
 	memset(&status, 0, sizeof(struct knet_link_status));
 
 	if ((!knet_link_get_status(NULL, 1, 0, &status, sizeof(struct knet_link_status))) || (errno != EINVAL)) {
 		printf("knet_link_get_status accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_get_status with unconfigured host_id\n");
 
 	if ((!knet_link_get_status(knet_h, 1, 0, &status, sizeof(struct knet_link_status))) || (errno != EINVAL)) {
 		printf("knet_link_get_status accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_status with incorrect linkid\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_get_status(knet_h, 1, KNET_MAX_LINK, &status, sizeof(struct knet_link_status))) || (errno != EINVAL)) {
 		printf("knet_link_get_status accepted invalid linkid or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_status with incorrect status\n");
 
 	if ((!knet_link_get_status(knet_h, 1, 0, NULL, 0)) || (errno != EINVAL)) {
 		printf("knet_link_get_status accepted invalid status or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_status with unconfigured link\n");
 
 	if ((!knet_link_get_status(knet_h, 1, 0, &status, sizeof(struct knet_link_status))) || (errno != EINVAL)) {
 		printf("knet_link_get_status accepted unconfigured link or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_get_status with correct values\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_get_status(knet_h, 1, 0, &status, sizeof(struct knet_link_status)) < 0) {
 		printf("knet_link_get_status failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_link_set_config.c b/libknet/tests/api_knet_link_set_config.c
index d55899cd..b49541ee 100644
--- a/libknet/tests/api_knet_link_set_config.c
+++ b/libknet/tests/api_knet_link_set_config.c
@@ -1,273 +1,271 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "links.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	char src_portstr[32];
 	char dst_portstr[32];
 	struct sockaddr_storage src, dst;
 	struct sockaddr_in *src_in = (struct sockaddr_in *)&src;
 	struct sockaddr_in *dst_in = (struct sockaddr_in *)&dst;
 	struct knet_link_status link_status;
 
 	if (make_local_sockaddr(&src, 0) < 0) {
 		printf("Unable to convert src to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 	sprintf(src_portstr, "%d", ntohs(src_in->sin_port));
 
 	if (make_local_sockaddr(&dst, 1) < 0) {
 		printf("Unable to convert dst to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 	sprintf(dst_portstr, "%d", ntohs(dst_in->sin_port));
 
 	printf("Test knet_link_set_config incorrect knet_h\n");
 
 	if ((!knet_link_set_config(NULL, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0)) || (errno != EINVAL)) {
 		printf("knet_link_set_config accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_config with unconfigured host_id\n");
 
 	if ((!knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0)) || (errno != EINVAL)) {
 		printf("knet_link_set_config accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_config with bad transport type\n");
 
 	if ((!knet_link_set_config(knet_h, 1, 0, KNET_MAX_TRANSPORTS, &src, &dst, 0)) || (errno != EINVAL)) {
 		printf("knet_link_set_config accepted invalid transport or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_config with incorrect linkid\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_set_config(knet_h, 1, KNET_MAX_LINK, KNET_TRANSPORT_UDP, &src, &dst, 0)) || (errno != EINVAL)) {
 		printf("knet_link_set_config accepted invalid linkid or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_config with incorrect src_addr\n");
 
 	if ((!knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, NULL, &dst, 0)) || (errno != EINVAL)) {
 		printf("knet_link_set_config accepted invalid src_addr or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_config with dynamic dst_addr\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, NULL, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_get_status(knet_h, 1, 0, &link_status, sizeof(struct knet_link_status)) < 0) {
 		printf("Unable to get link status: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((link_status.enabled != 0) ||
 	    (strcmp(link_status.src_ipaddr, "127.0.0.1")) ||
 	    (strcmp(link_status.src_port, src_portstr)) ||
 	    (knet_h->host_index[1]->link[0].dynamic != KNET_LINK_DYNIP)) {
 		printf("knet_link_set_config failed to set configuration. enabled: %d src_addr %s src_port %s dynamic %u\n",
 		       link_status.enabled, link_status.src_ipaddr, link_status.src_port, knet_h->host_index[1]->link[0].dynamic);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_config with already configured link\n");
 	if ((!knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, NULL, 0) || (errno != EBUSY))) {
 		printf("knet_link_set_config accepted request while link configured or returned incorrect error: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_config with link enabled\n");
 
 	if (knet_link_set_enable(knet_h, 1, 0, 1) < 0) {
 		printf("Unable to enable link: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_get_status(knet_h, 1, 0, &link_status, sizeof(struct knet_link_status)) < 0) {
 		printf("Unable to get link status: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, NULL, 0)) || (errno != EBUSY)) {
 		printf("knet_link_set_config accepted request while link enabled or returned incorrect error: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_enable(knet_h, 1, 0, 0) < 0) {
 		printf("Unable to disable link: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_clear_config(knet_h, 1, 0) < 0) {
 		printf("Unable to clear link config: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_config with static dst_addr\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_get_status(knet_h, 1, 0, &link_status, sizeof(struct knet_link_status)) < 0) {
 		printf("Unable to get link status: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((link_status.enabled != 0) ||
 	    (strcmp(link_status.src_ipaddr, "127.0.0.1")) ||
 	    (strcmp(link_status.src_port, src_portstr)) ||
 	    (strcmp(link_status.dst_ipaddr, "127.0.0.1")) ||
 	    (strcmp(link_status.dst_port, dst_portstr)) || 
 	    (knet_h->host_index[1]->link[0].dynamic != KNET_LINK_STATIC)) {
 		printf("knet_link_set_config failed to set configuration. enabled: %d src_addr %s src_port %s dst_addr %s dst_port %s dynamic %u\n",
 		       link_status.enabled, link_status.src_ipaddr, link_status.src_port, link_status.dst_ipaddr, link_status.dst_port, knet_h->host_index[1]->link[0].dynamic);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_link_set_enable.c b/libknet/tests/api_knet_link_set_enable.c
index c31ac0c0..13b9ecdd 100644
--- a/libknet/tests/api_knet_link_set_enable.c
+++ b/libknet/tests/api_knet_link_set_enable.c
@@ -1,360 +1,358 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "link.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static void test_udp(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct sockaddr_storage src, dst;
 
 	if (make_local_sockaddr(&src, 0) < 0) {
 		printf("Unable to convert src to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (make_local_sockaddr(&dst, 1) < 0) {
 		printf("Unable to convert dst to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_enable incorrect knet_h\n");
 
 	if ((!knet_link_set_enable(NULL, 1, 0, 1)) || (errno != EINVAL)) {
 		printf("knet_link_set_enable accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_enable with unconfigured host_id\n");
 
 	if ((!knet_link_set_enable(knet_h, 1, 0, 1)) || (errno != EINVAL)) {
 		printf("knet_link_set_enable accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_enable with incorrect linkid\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_set_enable(knet_h, 1, KNET_MAX_LINK, 1)) || (errno != EINVAL)) {
 		printf("knet_link_set_enable accepted invalid linkid or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_enable with unconfigured link\n");
 
 	if ((!knet_link_set_enable(knet_h, 1, 0, 1)) || (errno != EINVAL)) {
 		printf("knet_link_set_enable accepted unconfigured link or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_enable with incorrect values\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_set_enable(knet_h, 1, 0, 2)) || (errno != EINVAL)) {
 		printf("knet_link_set_enable accepted incorrect value for enabled or returned incorrect error: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_enable with correct values (1)\n");
 
 	if (knet_link_set_enable(knet_h, 1, 0, 1) < 0) {
 		printf("knet_link_set_enable failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->host_index[1]->link[0].status.enabled != 1) {
 		printf("knet_link_set_enable failed to set correct values\n");
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_enable with correct values (0)\n");
 
 	if (knet_link_set_enable(knet_h, 1, 0, 0) < 0) {
 		printf("knet_link_set_enable failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->host_index[1]->link[0].status.enabled != 0) {
 		printf("knet_link_set_enable failed to set correct values\n");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_link_set_enable(knet_h, 1, 0, 0);
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 #ifdef HAVE_NETINET_SCTP_H
 static void test_sctp(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct sockaddr_storage src, dst;
 
 	if (make_local_sockaddr(&src, 0) < 0) {
 		printf("Unable to convert src to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (make_local_sockaddr(&dst, 1) < 0) {
 		printf("Unable to convert dst to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_enable incorrect knet_h\n");
 
 	if ((!knet_link_set_enable(NULL, 1, 0, 1)) || (errno != EINVAL)) {
 		printf("knet_link_set_enable accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_enable with unconfigured host_id\n");
 
 	if ((!knet_link_set_enable(knet_h, 1, 0, 1)) || (errno != EINVAL)) {
 		printf("knet_link_set_enable accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_enable with incorrect linkid\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_set_enable(knet_h, 1, KNET_MAX_LINK, 1)) || (errno != EINVAL)) {
 		printf("knet_link_set_enable accepted invalid linkid or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_enable with unconfigured link\n");
 
 	if ((!knet_link_set_enable(knet_h, 1, 0, 1)) || (errno != EINVAL)) {
 		printf("knet_link_set_enable accepted unconfigured link or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_enable with incorrect values\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_SCTP, &src, &dst, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_set_enable(knet_h, 1, 0, 2)) || (errno != EINVAL)) {
 		printf("knet_link_set_enable accepted incorrect value for enabled or returned incorrect error: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_enable with correct values (1)\n");
 
 	if (knet_link_set_enable(knet_h, 1, 0, 1) < 0) {
 		printf("knet_link_set_enable failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->host_index[1]->link[0].status.enabled != 1) {
 		printf("knet_link_set_enable failed to set correct values\n");
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Wait 2 seconds for sockets to connect\n");
 	sleep(2);
 
 	printf("Test knet_link_set_enable with correct values (0)\n");
 
 	if (knet_link_set_enable(knet_h, 1, 0, 0) < 0) {
 		printf("knet_link_set_enable failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->host_index[1]->link[0].status.enabled != 0) {
 		printf("knet_link_set_enable failed to set correct values\n");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_link_set_enable(knet_h, 1, 0, 0);
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 #endif
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	printf("Testing with UDP\n");
 
 	test_udp();
 
 #ifdef HAVE_NETINET_SCTP_H
 	printf("Testing with SCTP\n");
 
 	test_sctp();
 #else
 	printf("Skipping SCTP test. Protocol not supported in this build\n");
 #endif
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_link_set_ping_timers.c b/libknet/tests/api_knet_link_set_ping_timers.c
index eedd0f6c..e3d9fb71 100644
--- a/libknet/tests/api_knet_link_set_ping_timers.c
+++ b/libknet/tests/api_knet_link_set_ping_timers.c
@@ -1,192 +1,190 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "link.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct sockaddr_storage src, dst;
 
 	if (make_local_sockaddr(&src, 0) < 0) {
 		printf("Unable to convert src to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (make_local_sockaddr(&dst, 1) < 0) {
 		printf("Unable to convert dst to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_ping_timers incorrect knet_h\n");
 
 	if ((!knet_link_set_ping_timers(NULL, 1, 0, 1000, 2000, 2048)) || (errno != EINVAL)) {
 		printf("knet_link_set_ping_timers accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_ping_timers with unconfigured host_id\n");
 
 	if ((!knet_link_set_ping_timers(knet_h, 1, 0, 1000, 2000, 2048)) || (errno != EINVAL)) {
 		printf("knet_link_set_ping_timers accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_ping_timers with incorrect linkid\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_set_ping_timers(knet_h, 1, KNET_MAX_LINK, 1000, 2000, 2048)) || (errno != EINVAL)) {
 		printf("knet_link_set_ping_timers accepted invalid linkid or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_ping_timers with incorrect interval\n");
 
 	if ((!knet_link_set_ping_timers(knet_h, 1, 0, 0, 2000, 2048)) || (errno != EINVAL)) {
 		printf("knet_link_set_ping_timers accepted invalid interval or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_ping_timers with 0 timeout\n");
 
 	if ((!knet_link_set_ping_timers(knet_h, 1, 0, 1000, 0, 2048)) || (errno != ENOSYS)) {
 		printf("knet_link_set_ping_timers accepted invalid timeout or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_ping_timers with incorrect interval\n");
 
 	if ((!knet_link_set_ping_timers(knet_h, 1, 0, 1000, 2000, 0)) || (errno != EINVAL)) {
 		printf("knet_link_set_ping_timers accepted invalid interval or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_ping_timers with unconfigured link\n");
 
 	if ((!knet_link_set_ping_timers(knet_h, 1, 0, 1000, 2000, 2048)) || (errno != EINVAL)) {
 		printf("knet_link_set_ping_timers accepted unconfigured link or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_ping_timers with correct values\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_ping_timers(knet_h, 1, 0, 1000, 2000, 2048) < 0) {
 		printf("knet_link_set_ping_timers failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((knet_h->host_index[1]->link[0].ping_interval != 1000000) ||
 	    (knet_h->host_index[1]->link[0].pong_timeout != 2000000) ||
 	    (knet_h->host_index[1]->link[0].latency_fix != 2048)) {
 		printf("knet_link_set_ping_timers failed to set values\n");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_link_set_pong_count.c b/libknet/tests/api_knet_link_set_pong_count.c
index eec1b22f..d29dbf44 100644
--- a/libknet/tests/api_knet_link_set_pong_count.c
+++ b/libknet/tests/api_knet_link_set_pong_count.c
@@ -1,162 +1,160 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "link.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct sockaddr_storage src, dst;
 
 	if (make_local_sockaddr(&src, 0) < 0) {
 		printf("Unable to convert src to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (make_local_sockaddr(&dst, 1) < 0) {
 		printf("Unable to convert dst to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_pong_count incorrect knet_h\n");
 
 	if ((!knet_link_set_pong_count(NULL, 1, 0, 2)) || (errno != EINVAL)) {
 		printf("knet_link_set_pong_count accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_pong_count with unconfigured host_id\n");
 
 	if ((!knet_link_set_pong_count(knet_h, 1, 0, 2)) || (errno != EINVAL)) {
 		printf("knet_link_set_pong_count accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_pong_count with incorrect linkid\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_set_pong_count(knet_h, 1, KNET_MAX_LINK, 2)) || (errno != EINVAL)) {
 		printf("knet_link_set_pong_count accepted invalid linkid or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_pong_count with incorrect pong count\n");
 
 	if ((!knet_link_set_pong_count(knet_h, 1, 0, 0)) || (errno != EINVAL)) {
 		printf("knet_link_set_pong_count accepted invalid pong count or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_pong_count with unconfigured link\n");
 
 	if ((!knet_link_set_pong_count(knet_h, 1, 0, 2)) || (errno != EINVAL)) {
 		printf("knet_link_set_pong_count accepted unconfigured link or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_pong_count with correct values\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_pong_count(knet_h, 1, 0, 3) < 0) {
 		printf("knet_link_set_pong_count failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->host_index[1]->link[0].pong_count != 3) {
 		printf("knet_link_set_pong_count failed to set correct values\n");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_link_set_priority.c b/libknet/tests/api_knet_link_set_priority.c
index 29ac6112..9326ca34 100644
--- a/libknet/tests/api_knet_link_set_priority.c
+++ b/libknet/tests/api_knet_link_set_priority.c
@@ -1,149 +1,147 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "link.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct sockaddr_storage src, dst;
 
 	if (make_local_sockaddr(&src, 0) < 0) {
 		printf("Unable to convert src to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (make_local_sockaddr(&dst, 1) < 0) {
 		printf("Unable to convert dst to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_priority incorrect knet_h\n");
 
 	if ((!knet_link_set_priority(NULL, 1, 0, 1)) || (errno != EINVAL)) {
 		printf("knet_link_set_priority accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_link_set_priority with unconfigured host_id\n");
 
 	if ((!knet_link_set_priority(knet_h, 1, 0, 1)) || (errno != EINVAL)) {
 		printf("knet_link_set_priority accepted invalid host_id or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_priority with incorrect linkid\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("Unable to add host_id 1: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_link_set_priority(knet_h, 1, KNET_MAX_LINK, 2)) || (errno != EINVAL)) {
 		printf("knet_link_set_priority accepted invalid linkid or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_priority with unconfigured link\n");
 
 	if ((!knet_link_set_priority(knet_h, 1, 0, 1)) || (errno != EINVAL)) {
 		printf("knet_link_set_priority accepted unconfigured link or returned incorrect error: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_link_set_priority with correct values\n");
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &src, &dst, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_priority(knet_h, 1, 0, 3) < 0) {
 		printf("knet_link_set_priority failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->host_index[1]->link[0].priority != 3) {
 		printf("knet_link_set_priority failed to set correct values\n");
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_log_get_loglevel.c b/libknet/tests/api_knet_log_get_loglevel.c
index 02bdc0af..15468885 100644
--- a/libknet/tests/api_knet_log_get_loglevel.c
+++ b/libknet/tests/api_knet_log_get_loglevel.c
@@ -1,102 +1,100 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 
 #include "libknet.h"
 #include "internals.h"
 
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	uint8_t level;
 	int logfds[2];
 
 	printf("Test knet_log_get_loglevel incorrect knet_h\n");
 
 	if ((!knet_log_get_loglevel(NULL, KNET_SUB_UNKNOWN, &level)) || (errno != EINVAL)) {
 		printf("knet_log_get_loglevel accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	printf("Test knet_log_get_loglevel incorrect subsystem\n");
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_INFO);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_log_get_loglevel(knet_h, KNET_SUB_UNKNOWN - 1, &level)) || (errno != EINVAL)) {
 		printf("knet_log_get_loglevel accepted invalid subsystem or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_log_get_loglevel incorrect log level\n");
 
 	if ((!knet_log_get_loglevel(knet_h, KNET_SUB_UNKNOWN, NULL)) || (errno != EINVAL)) {
 		printf("knet_log_get_loglevel accepted invalid log level or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_log_get_loglevel with valid parameters\n");
 
 	if (knet_log_get_loglevel(knet_h, KNET_SUB_UNKNOWN, &level ) < 0) {
 		printf("knet_log_get_loglevel failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->log_levels[KNET_SUB_UNKNOWN] != level) {
 		printf("knet_log_get_loglevel failed to get the right value\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_log_set_loglevel.c b/libknet/tests/api_knet_log_set_loglevel.c
index 1eb32225..f32a951a 100644
--- a/libknet/tests/api_knet_log_set_loglevel.c
+++ b/libknet/tests/api_knet_log_set_loglevel.c
@@ -1,109 +1,107 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 
 #include "libknet.h"
 #include "internals.h"
 
 #include "test-common.h"
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 
 	printf("Test knet_log_set_loglevel incorrect knet_h\n");
 
 	if ((!knet_log_set_loglevel(NULL, KNET_SUB_COMMON, KNET_LOG_DEBUG)) || (errno != EINVAL)) {
 		printf("knet_log_set_loglevel accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	printf("Test knet_log_set_loglevel incorrect subsystem\n");
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_INFO);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((!knet_log_set_loglevel(knet_h, KNET_SUB_UNKNOWN - 1, KNET_LOG_DEBUG)) || (errno != EINVAL)) {
 		printf("knet_log_set_loglevel accepted invalid subsystem or returned incorrect error: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		knet_handle_free(knet_h);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_log_set_loglevel incorrect log level\n");
 
 	if ((!knet_log_set_loglevel(knet_h, KNET_SUB_UNKNOWN, KNET_LOG_DEBUG + 1)) || (errno != EINVAL)) {
 		printf("knet_log_set_loglevel accepted invalid log level or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_log_set_loglevel with valid parameters\n");
 
 	if (knet_h->log_levels[KNET_SUB_UNKNOWN] != KNET_LOG_INFO) {
 		printf("knet_handle_new did not init log_levels correctly?\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_log_set_loglevel(knet_h, KNET_SUB_UNKNOWN, KNET_LOG_DEBUG) < 0) {
 		printf("knet_log_set_loglevel failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_h->log_levels[KNET_SUB_UNKNOWN] != KNET_LOG_DEBUG) {
 		printf("knet_log_set_loglevel did not set log level correctly\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_recv.c b/libknet/tests/api_knet_recv.c
index 4b7171b3..e9077d02 100644
--- a/libknet/tests/api_knet_recv.c
+++ b/libknet/tests/api_knet_recv.c
@@ -1,216 +1,214 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/uio.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "test-common.h"
 
 static int private_data;
 
 static void sock_notify(void *pvt_data,
 			int datafd,
 			int8_t channel,
 			uint8_t tx_rx,
 			int error,
 			int errorno)
 {
 	return;
 }
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	int datafd = 0;
 	int8_t channel = 0;
 	char recv_buff[KNET_MAX_PACKET_SIZE];
 	char send_buff[KNET_MAX_PACKET_SIZE];
 	ssize_t recv_len = 0;
 	struct iovec iov_out[1];
 
 	printf("Test knet_recv incorrect knet_h\n");
 
 	if ((!knet_recv(NULL, recv_buff, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_recv accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_recv with no recv_buff\n");
 
 	if ((!knet_recv(knet_h, NULL, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_recv accepted invalid recv_buff or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_recv with invalid recv_buff len (0)\n");
 
 	if ((!knet_recv(knet_h, recv_buff, 0, channel)) || (errno != EINVAL)) {
 		printf("knet_recv accepted invalid recv_buff len (0) or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_recv with invalid recv_buff len (> KNET_MAX_PACKET_SIZE)\n");
 
 	if ((!knet_recv(knet_h, recv_buff, KNET_MAX_PACKET_SIZE + 1, channel)) || (errno != EINVAL)) {
 		printf("knet_recv accepted invalid recv_buff len (> KNET_MAX_PACKET_SIZE) or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_recv with invalid channel (-1)\n");
 
 	channel = -1;
 
 	if ((!knet_recv(knet_h, recv_buff, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_recv accepted invalid channel (-1) or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_recv with invalid channel (KNET_DATAFD_MAX)\n");
 
 	channel = KNET_DATAFD_MAX;
 
 	if ((!knet_recv(knet_h, recv_buff, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_recv accepted invalid channel (KNET_DATAFD_MAX) or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_recv with unconfigured channel\n");
 
 	channel = 0;
 
 	if ((!knet_recv(knet_h, recv_buff, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_recv accepted invalid unconfigured channel or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_recv with valid data\n");
 
 	if (knet_handle_enable_sock_notify(knet_h, &private_data, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
         }
 
 	datafd = 0;
 	channel = -1;
 
 	if (knet_handle_add_datafd(knet_h, &datafd, &channel) < 0) {
 		printf("knet_handle_add_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	memset(recv_buff, 0, KNET_MAX_PACKET_SIZE);
 	memset(send_buff, 1, sizeof(send_buff));
 
 	iov_out[0].iov_base = (void *)send_buff;
 	iov_out[0].iov_len = sizeof(send_buff);
 
 	if (writev(knet_h->sockfd[channel].sockfd[1], iov_out, 1) != sizeof(send_buff)) {
 		printf("Unable to write data: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	recv_len = knet_recv(knet_h, recv_buff, KNET_MAX_PACKET_SIZE, channel);
 	if (recv_len <= 0) {
 		printf("knet_recv failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (recv_len != sizeof(send_buff)) {
 		printf("knet_recv received only %zd bytes: %s\n", recv_len, strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (memcmp(recv_buff, send_buff, KNET_MAX_PACKET_SIZE)) {
 		printf("knet_recv received bad data\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_send.c b/libknet/tests/api_knet_send.c
index 68bd4041..8ea0634c 100644
--- a/libknet/tests/api_knet_send.c
+++ b/libknet/tests/api_knet_send.c
@@ -1,329 +1,327 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <inttypes.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static int private_data;
 
 static void sock_notify(void *pvt_data,
 			int datafd,
 			int8_t channel,
 			uint8_t tx_rx,
 			int error,
 			int errorno)
 {
 	return;
 }
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	int datafd = 0;
 	int8_t channel = 0;
 	struct knet_link_status link_status;
 	char send_buff[KNET_MAX_PACKET_SIZE];
 	char recv_buff[KNET_MAX_PACKET_SIZE];
 	ssize_t send_len = 0;
 	int recv_len = 0;
 	int savederrno;
 	struct sockaddr_storage lo;
 
 	if (make_local_sockaddr(&lo, 0) < 0) {
 		printf("Unable to convert loopback to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	memset(send_buff, 0, sizeof(send_buff));
 
 	printf("Test knet_send incorrect knet_h\n");
 
 	if ((!knet_send(NULL, send_buff, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_send accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_send with no send_buff\n");
 
 	if ((!knet_send(knet_h, NULL, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_send accepted invalid send_buff or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send with invalid send_buff len (0)\n");
 
 	if ((!knet_send(knet_h, send_buff, 0, channel)) || (errno != EINVAL)) {
 		printf("knet_send accepted invalid send_buff len (0) or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send with invalid send_buff len (> KNET_MAX_PACKET_SIZE)\n");
 
 	if ((!knet_send(knet_h, send_buff, KNET_MAX_PACKET_SIZE + 1, channel)) || (errno != EINVAL)) {
 		printf("knet_send accepted invalid send_buff len (> KNET_MAX_PACKET_SIZE) or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send with invalid channel (-1)\n");
 
 	channel = -1;
 
 	if ((!knet_send(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_send accepted invalid channel (-1) or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send with invalid channel (KNET_DATAFD_MAX)\n");
 
 	channel = KNET_DATAFD_MAX;
 
 	if ((!knet_send(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_send accepted invalid channel (KNET_DATAFD_MAX) or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send with unconfigured channel\n");
 
 	channel = 0;
 
 	if ((!knet_send(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_send accepted invalid unconfigured channel or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send with valid data\n");
 
 	if (knet_handle_enable_sock_notify(knet_h, &private_data, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
         }
 
 	datafd = 0;
 	channel = -1;
 
 	if (knet_handle_add_datafd(knet_h, &datafd, &channel) < 0) {
 		printf("knet_handle_add_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("knet_host_add failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &lo, &lo, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_enable(knet_h, 1, 0, 1) < 0) {
 		printf("knet_link_set_enable failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_handle_setfwd(knet_h, 1) < 0) {
 		printf("knet_handle_setfwd failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (wait_for_host(knet_h, 1, 10, logfds[0], stdout) < 0) {
 		printf("timeout waiting for host to be reachable");
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	send_len = knet_send(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel);
 	if (send_len <= 0) {
 		printf("knet_send failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (send_len != sizeof(send_buff)) {
 		printf("knet_send sent only %zd bytes: %s\n", send_len, strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	if (wait_for_packet(knet_h, 10, datafd)) {
 		printf("Error waiting for packet: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	recv_len = knet_recv(knet_h, recv_buff, KNET_MAX_PACKET_SIZE, channel);
 	savederrno = errno;
 	if (recv_len != send_len) {
 		printf("knet_recv received only %d bytes: %s (errno: %d)\n", recv_len, strerror(errno), errno);
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		if ((is_helgrind()) && (recv_len == -1) && (savederrno == EAGAIN)) {
 			printf("helgrind exception. this is normal due to possible timeouts\n");
 			exit(PASS);
 		}
 		exit(FAIL);
 	}
 
 	if (memcmp(recv_buff, send_buff, KNET_MAX_PACKET_SIZE)) {
 		printf("recv and send buffers are different!\n");
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	/* A sanity check on the stats */
 	if (knet_link_get_status(knet_h, 1, 0, &link_status, sizeof(link_status)) < 0) {
 		printf("knet_link_get_status failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (link_status.stats.tx_data_packets != 2 ||
 	    link_status.stats.rx_data_packets != 2 ||
 	    link_status.stats.tx_data_bytes < KNET_MAX_PACKET_SIZE ||
 	    link_status.stats.rx_data_bytes < KNET_MAX_PACKET_SIZE ||
 	    link_status.stats.tx_data_bytes > KNET_MAX_PACKET_SIZE*2 ||
 	    link_status.stats.rx_data_bytes > KNET_MAX_PACKET_SIZE*2) {
 	    printf("stats look wrong: tx_packets: %" PRIu64 " (%" PRIu64 " bytes), rx_packets: %" PRIu64 " (%" PRIu64 " bytes)\n",
 		   link_status.stats.tx_data_packets,
 		   link_status.stats.tx_data_bytes,
 		   link_status.stats.rx_data_packets,
 		   link_status.stats.rx_data_bytes);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_link_set_enable(knet_h, 1, 0, 0);
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_send_compress.c b/libknet/tests/api_knet_send_compress.c
index 5c6aa490..1386768f 100644
--- a/libknet/tests/api_knet_send_compress.c
+++ b/libknet/tests/api_knet_send_compress.c
@@ -1,292 +1,290 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <inttypes.h>
 
 #include "libknet.h"
 
 #include "compress.h"
 #include "internals.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static int private_data;
 
 static void sock_notify(void *pvt_data,
 			int datafd,
 			int8_t channel,
 			uint8_t tx_rx,
 			int error,
 			int errorno)
 {
 	return;
 }
 
 static void test(const char *model)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	int datafd = 0;
 	int8_t channel = 0;
 	struct knet_handle_stats stats;
 	char send_buff[KNET_MAX_PACKET_SIZE];
 	char recv_buff[KNET_MAX_PACKET_SIZE];
 	ssize_t send_len = 0;
 	int recv_len = 0;
 	int savederrno;
 	struct sockaddr_storage lo;
 	struct knet_handle_compress_cfg knet_handle_compress_cfg;
 
 	if (make_local_sockaddr(&lo, 0) < 0) {
 		printf("Unable to convert loopback to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	memset(send_buff, 0, sizeof(send_buff));
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send with %s and valid data\n", model);
 
 	memset(&knet_handle_compress_cfg, 0, sizeof(struct knet_handle_compress_cfg));
 	strncpy(knet_handle_compress_cfg.compress_model, model, sizeof(knet_handle_compress_cfg.compress_model) - 1);
 	knet_handle_compress_cfg.compress_level = 4;
 	knet_handle_compress_cfg.compress_threshold = 0;
 
 	if (knet_handle_compress(knet_h, &knet_handle_compress_cfg) < 0) {
 		printf("knet_handle_compress did not accept zlib compress mode with compress level 1 cfg\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
         }
 
 	if (knet_handle_enable_sock_notify(knet_h, &private_data, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
         }
 
 	datafd = 0;
 	channel = -1;
 
 	if (knet_handle_add_datafd(knet_h, &datafd, &channel) < 0) {
 		printf("knet_handle_add_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("knet_host_add failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &lo, &lo, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_enable(knet_h, 1, 0, 1) < 0) {
 		printf("knet_link_set_enable failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_handle_setfwd(knet_h, 1) < 0) {
 		printf("knet_handle_setfwd failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (wait_for_host(knet_h, 1, 10, logfds[0], stdout) < 0) {
 		printf("timeout waiting for host to be reachable");
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	send_len = knet_send(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel);
 	if (send_len <= 0) {
 		printf("knet_send failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (send_len != sizeof(send_buff)) {
 		printf("knet_send sent only %zd bytes: %s\n", send_len, strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	if (wait_for_packet(knet_h, 10, datafd)) {
 		printf("Error waiting for packet: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	recv_len = knet_recv(knet_h, recv_buff, KNET_MAX_PACKET_SIZE, channel);
 	savederrno = errno;
 	if (recv_len != send_len) {
 		printf("knet_recv received only %d bytes: %s (errno: %d)\n", recv_len, strerror(errno), errno);
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		if ((is_helgrind()) && (recv_len == -1) && (savederrno == EAGAIN)) {
 			printf("helgrind exception. this is normal due to possible timeouts\n");
 			exit(PASS);
 		}
 		exit(FAIL);
 	}
 
 	if (memcmp(recv_buff, send_buff, KNET_MAX_PACKET_SIZE)) {
 		printf("recv and send buffers are different!\n");
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	/* A sanity check on the stats */
 	if (knet_handle_get_stats(knet_h, &stats, sizeof(stats)) < 0) {
 		printf("knet_handle_get_stats failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (strcmp(model, "none") == 0) {
 		if (stats.tx_compressed_packets != 0 ||
 		    stats.rx_compressed_packets != 0) {
 
 			printf("stats look wrong: s/b all 0 for model 'none' tx_packets: %" PRIu64 " (%" PRIu64 "/%" PRIu64 " comp/uncomp), rx_packets: %" PRIu64 " (%" PRIu64 "/%" PRIu64 " comp/uncomp)\n",
 			       stats.tx_compressed_packets,
 			       stats.tx_compressed_size_bytes,
 			       stats.tx_compressed_original_bytes,
 			       stats.rx_compressed_packets,
 			       stats.rx_compressed_size_bytes,
 			       stats.rx_compressed_original_bytes);
 		}
 	} else {
 		if (stats.tx_compressed_packets != 1 ||
 		    stats.rx_compressed_packets != 1 ||
 		    stats.tx_compressed_original_bytes < stats.tx_compressed_size_bytes ||
 		    stats.tx_compressed_original_bytes < stats.tx_compressed_size_bytes) {
 			printf("stats look wrong: tx_packets: %" PRIu64 " (%" PRIu64 "/%" PRIu64 " comp/uncomp), rx_packets: %" PRIu64 " (%" PRIu64 "/%" PRIu64 " comp/uncomp)\n",
 			       stats.tx_compressed_packets,
 			       stats.tx_compressed_size_bytes,
 			       stats.tx_compressed_original_bytes,
 			       stats.rx_compressed_packets,
 			       stats.rx_compressed_size_bytes,
 			       stats.rx_compressed_original_bytes);
 
 		}
 	}
 	flush_logs(logfds[0], stdout);
 
 	knet_link_set_enable(knet_h, 1, 0, 0);
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test("none");
 
 #ifdef BUILDCOMPZLIB
 	test("zlib");
 #endif
 #ifdef BUILDCOMPLZ4
 	test("lz4");
 	test("lz4hc");
 #endif
 #ifdef BUILDCOMPLZO2
 	test("lzo2");
 #endif
 #ifdef BUILDCOMPLZMA
 	test("lzma");
 #endif
 #ifdef BUILDCOMPBZIP2
 	test("bzip2");
 #endif
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_send_crypto.c b/libknet/tests/api_knet_send_crypto.c
index 5c245abe..3061ce67 100644
--- a/libknet/tests/api_knet_send_crypto.c
+++ b/libknet/tests/api_knet_send_crypto.c
@@ -1,267 +1,265 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <inttypes.h>
 
 #include "libknet.h"
 
 #include "compress.h"
 #include "internals.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static int private_data;
 
 static void sock_notify(void *pvt_data,
 			int datafd,
 			int8_t channel,
 			uint8_t tx_rx,
 			int error,
 			int errorno)
 {
 	return;
 }
 
 static void test(const char *model)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	int datafd = 0;
 	int8_t channel = 0;
 	struct knet_handle_stats stats;
 	char send_buff[KNET_MAX_PACKET_SIZE];
 	char recv_buff[KNET_MAX_PACKET_SIZE];
 	ssize_t send_len = 0;
 	int recv_len = 0;
 	int savederrno;
 	struct sockaddr_storage lo;
 	struct knet_handle_crypto_cfg knet_handle_crypto_cfg;
 
 	if (make_local_sockaddr(&lo, 0) < 0) {
 		printf("Unable to convert loopback to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	memset(send_buff, 0, sizeof(send_buff));
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send with %s and valid data\n", model);
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 	strncpy(knet_handle_crypto_cfg.crypto_model, model, sizeof(knet_handle_crypto_cfg.crypto_model) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_cipher_type, "aes128", sizeof(knet_handle_crypto_cfg.crypto_cipher_type) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_hash_type, "sha1", sizeof(knet_handle_crypto_cfg.crypto_hash_type) - 1);
 	knet_handle_crypto_cfg.private_key_len = 2000;
 
 	if (knet_handle_crypto(knet_h, &knet_handle_crypto_cfg)) {
 		printf("knet_handle_crypto failed with correct config: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
         }
 
 	if (knet_handle_enable_sock_notify(knet_h, &private_data, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
         }
 
 	datafd = 0;
 	channel = -1;
 
 	if (knet_handle_add_datafd(knet_h, &datafd, &channel) < 0) {
 		printf("knet_handle_add_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("knet_host_add failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &lo, &lo, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_enable(knet_h, 1, 0, 1) < 0) {
 		printf("knet_link_set_enable failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_handle_setfwd(knet_h, 1) < 0) {
 		printf("knet_handle_setfwd failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (wait_for_host(knet_h, 1, 10, logfds[0], stdout) < 0) {
 		printf("timeout waiting for host to be reachable");
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	send_len = knet_send(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel);
 	if (send_len <= 0) {
 		printf("knet_send failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (send_len != sizeof(send_buff)) {
 		printf("knet_send sent only %zd bytes: %s\n", send_len, strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	if (wait_for_packet(knet_h, 10, datafd)) {
 		printf("Error waiting for packet: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	recv_len = knet_recv(knet_h, recv_buff, KNET_MAX_PACKET_SIZE, channel);
 	savederrno = errno;
 	if (recv_len != send_len) {
 		printf("knet_recv received only %d bytes: %s (errno: %d)\n", recv_len, strerror(errno), errno);
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		if ((is_helgrind()) && (recv_len == -1) && (savederrno == EAGAIN)) {
 			printf("helgrind exception. this is normal due to possible timeouts\n");
 			exit(PASS);
 		}
 		exit(FAIL);
 	}
 
 	if (memcmp(recv_buff, send_buff, KNET_MAX_PACKET_SIZE)) {
 		printf("recv and send buffers are different!\n");
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	/* A sanity check on the stats */
 	if (knet_handle_get_stats(knet_h, &stats, sizeof(stats)) < 0) {
 		printf("knet_handle_get_stats failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (stats.tx_crypt_packets >= 1 ||
 	    stats.rx_crypt_packets < 1) {
 		printf("stats look wrong: tx_packets: %" PRIu64 ", rx_packets: %" PRIu64 "\n",
 		       stats.tx_crypt_packets,
 		       stats.rx_crypt_packets);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_link_set_enable(knet_h, 1, 0, 0);
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 #ifdef BUILDCRYPTONSS
 	test("nss");
 #endif
 #ifdef BUILDCRYPTOOPENSSL
 #ifdef KNET_BSD
 	if (is_memcheck() || is_helgrind()) {
 		printf("valgrind-freebsd cannot run this test properly. Skipping\n");
 		return PASS;
 	}
 #endif
 	test("openssl");
 #endif
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_send_loopback.c b/libknet/tests/api_knet_send_loopback.c
index 3ea0fc8b..fe54236f 100644
--- a/libknet/tests/api_knet_send_loopback.c
+++ b/libknet/tests/api_knet_send_loopback.c
@@ -1,408 +1,406 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <inttypes.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static int private_data;
 
 static void sock_notify(void *pvt_data,
 			int datafd,
 			int8_t channel,
 			uint8_t tx_rx,
 			int error,
 			int errorno)
 {
 	return;
 }
 
 static int dhost_filter(void *pvt_data,
 			const unsigned char *outdata,
 			ssize_t outdata_len,
 			uint8_t tx_rx,
 			knet_node_id_t this_host_id,
 			knet_node_id_t src_host_id,
 			int8_t *dst_channel,
 			knet_node_id_t *dst_host_ids,
 			size_t *dst_host_ids_entries)
 {
 	dst_host_ids[0] = 1;
 	*dst_host_ids_entries = 1;
 
 	return 0;
 }
 
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	int datafd = 0;
 	int8_t channel = 0;
 	struct knet_link_status link_status;
 	char send_buff[KNET_MAX_PACKET_SIZE];
 	char recv_buff[KNET_MAX_PACKET_SIZE];
 	ssize_t send_len = 0;
 	int recv_len = 0;
 	int savederrno;
 	struct sockaddr_storage lo;
 
 	if (make_local_sockaddr(&lo, 1) < 0) {
 		printf("Unable to convert loopback to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 	memset(send_buff, 0, sizeof(send_buff));
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test configuring multiple links with loopback\n");
 
 	if (knet_handle_enable_sock_notify(knet_h, &private_data, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
         }
 
 	datafd = 0;
 	channel = -1;
 
 	if (knet_handle_add_datafd(knet_h, &datafd, &channel) < 0) {
 		printf("knet_handle_add_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("knet_host_add failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_LOOPBACK, &lo, &lo, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_config(knet_h, 1, 1, KNET_TRANSPORT_LOOPBACK, &lo, &lo, 0) == 0) {
 		printf("Managed to configure two LOOPBACK links - this is wrong\n");
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 	printf("Test configuring UDP link after loopback\n");
 
 	if (knet_link_set_config(knet_h, 1, 1, KNET_TRANSPORT_UDP, &lo, &lo, 0) == 0) {
 		printf("Managed to configure UDP and LOOPBACK links together: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 	printf("Test configuring UDP link before loopback\n");
 
 	if (knet_link_clear_config(knet_h, 1, 0) < 0) {
 		printf("Failed to clear existing LOOPBACK link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &lo, &lo, 0) < 0) {
 		printf("Failed to configure UDP link for testing: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_config(knet_h, 1, 1, KNET_TRANSPORT_LOOPBACK, &lo, &lo, 0) == 0) {
 		printf("Managed to configure LOOPBACK link after UDP: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 	printf("Test knet_send with valid data\n");
 
 	if (knet_link_clear_config(knet_h, 1, 0) < 0) {
 		printf("Failed to clear existing UDP link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_LOOPBACK, &lo, &lo, 0) < 0) {
 		printf("Failed configure LOOPBACK link for sending: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_enable(knet_h, 1, 0, 1) < 0) {
 		printf("knet_link_set_enable failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_handle_setfwd(knet_h, 1) < 0) {
 		printf("knet_handle_setfwd failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (wait_for_host(knet_h, 1, 10, logfds[0], stdout) < 0) {
 		printf("timeout waiting for host to be reachable");
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	send_len = knet_send(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel);
 	if (send_len <= 0) {
 		printf("knet_send failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (send_len != sizeof(send_buff)) {
 		printf("knet_send sent only %zd bytes: %s\n", send_len, strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	if (wait_for_packet(knet_h, 10, datafd)) {
 		printf("Error waiting for packet: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	recv_len = knet_recv(knet_h, recv_buff, KNET_MAX_PACKET_SIZE, channel);
 	savederrno = errno;
 	if (recv_len != send_len) {
 		printf("knet_recv received only %d bytes: %s (errno: %d)\n", recv_len, strerror(errno), errno);
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		if ((is_helgrind()) && (recv_len == -1) && (savederrno == EAGAIN)) {
 			printf("helgrind exception. this is normal due to possible timeouts\n");
 			exit(PASS);
 		}
 		exit(FAIL);
 	}
 
 	if (memcmp(recv_buff, send_buff, KNET_MAX_PACKET_SIZE)) {
 		printf("recv and send buffers are different!\n");
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	/* A sanity check on the stats */
 	if (knet_link_get_status(knet_h, 1, 0, &link_status, sizeof(link_status)) < 0) {
 		printf("knet_link_get_status failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (link_status.stats.tx_data_packets != 1 ||
 	    link_status.stats.rx_data_packets != 0 ||
 	    link_status.stats.tx_data_bytes != KNET_MAX_PACKET_SIZE) {
 	    printf("stats look wrong: tx_packets: %" PRIu64 " (%" PRIu64 " bytes), rx_packets: %" PRIu64 " (%" PRIu64 " bytes)\n",
 		   link_status.stats.tx_data_packets,
 		   link_status.stats.tx_data_bytes,
 		   link_status.stats.rx_data_packets,
 		   link_status.stats.rx_data_bytes);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 
 	printf("Test knet_send with only localhost\n");
 
 	if (knet_handle_enable_filter(knet_h, NULL, dhost_filter) < 0) {
 		printf("knet_handle_enable_filter failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 	send_len = knet_send(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel);
 	if (send_len <= 0) {
 		printf("knet_send failed: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (send_len != sizeof(send_buff)) {
 		printf("knet_send sent only %zd bytes: %s\n", send_len, strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	if (wait_for_packet(knet_h, 10, datafd)) {
 		printf("Error waiting for packet: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	recv_len = knet_recv(knet_h, recv_buff, KNET_MAX_PACKET_SIZE, channel);
 	savederrno = errno;
 	if (recv_len != send_len) {
 		printf("knet_recv received only %d bytes: %s (errno: %d)\n", recv_len, strerror(errno), errno);
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		if ((is_helgrind()) && (recv_len == -1) && (savederrno == EAGAIN)) {
 			printf("helgrind exception. this is normal due to possible timeouts\n");
 			exit(PASS);
 		}
 		exit(FAIL);
 	}
 
 	if (memcmp(recv_buff, send_buff, KNET_MAX_PACKET_SIZE)) {
 		printf("recv and send buffers are different!\n");
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	knet_link_set_enable(knet_h, 1, 0, 0);
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/api_knet_send_sync.c b/libknet/tests/api_knet_send_sync.c
index 3e1db467..c640183c 100644
--- a/libknet/tests/api_knet_send_sync.c
+++ b/libknet/tests/api_knet_send_sync.c
@@ -1,400 +1,398 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "libknet.h"
 
 #include "internals.h"
 #include "netutils.h"
 #include "test-common.h"
 
 static int private_data;
 
 static void sock_notify(void *pvt_data,
 			int datafd,
 			int8_t channel,
 			uint8_t tx_rx,
 			int error,
 			int errorno)
 {
 	return;
 }
 
 static int dhost_filter_ret = 0;
 
 static int dhost_filter(void *pvt_data,
 			const unsigned char *outdata,
 			ssize_t outdata_len,
 			uint8_t tx_rx,
 			knet_node_id_t this_host_id,
 			knet_node_id_t src_host_id,
 			int8_t *dst_channel,
 			knet_node_id_t *dst_host_ids,
 			size_t *dst_host_ids_entries)
 {
 	dst_host_ids[0] = 0;
 
 	/*
 	 * fatal fault
 	 */
 	if (dhost_filter_ret < 0) {
 		return -1;
 	}
 
 	/*
 	 * trigger EINVAL
 	 * no ids found
 	 */
 	if (dhost_filter_ret == 0) {
 		*dst_host_ids_entries = 0;
 		return 0;
 	}
 
 	/*
  	 * send correct info back
  	 */
 
 	if (dhost_filter_ret == 1) {
 		dst_host_ids[0] = 1;
 		*dst_host_ids_entries = 1;
 		return 0;
 	}
 
 	/*
 	 * trigger E2BIG
 	 * mcast destinations
 	 */
 	if (dhost_filter_ret == 2) {
 		dst_host_ids[0] = 1;
 		*dst_host_ids_entries = 2;
 		return 0;
 	}
 
 	/*
 	 * return mcast
 	 */
 	if (dhost_filter_ret == 3) {
 		return 1;
 	}
 
 	return dhost_filter_ret;
 }
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	int datafd = 0;
 	int8_t channel = 0;
 	char send_buff[KNET_MAX_PACKET_SIZE];
 	struct sockaddr_storage lo;
 
 	if (make_local_sockaddr(&lo, 1) < 0) {
 		printf("Unable to convert loopback to sockaddr: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	memset(send_buff, 0, sizeof(send_buff));
 
 	printf("Test knet_send_sync incorrect knet_h\n");
 
 	if ((!knet_send_sync(NULL, send_buff, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_send_sync accepted invalid knet_h or returned incorrect error: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Test knet_send_sync with no send_buff\n");
 
 	if ((!knet_send_sync(knet_h, NULL, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_send_sync accepted invalid send_buff or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send_sync with invalid send_buff len (0)\n");
 
 	if ((!knet_send_sync(knet_h, send_buff, 0, channel)) || (errno != EINVAL)) {
 		printf("knet_send_sync accepted invalid send_buff len (0) or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send_sync with invalid send_buff len (> KNET_MAX_PACKET_SIZE)\n");
 
 	if ((!knet_send_sync(knet_h, send_buff, KNET_MAX_PACKET_SIZE + 1, channel)) || (errno != EINVAL)) {
 		printf("knet_send_sync accepted invalid send_buff len (> KNET_MAX_PACKET_SIZE) or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send_sync with invalid channel (-1)\n");
 
 	channel = -1;
 
 	if ((!knet_send_sync(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_send_sync accepted invalid channel (-1) or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send_sync with invalid channel (KNET_DATAFD_MAX)\n");
 
 	channel = KNET_DATAFD_MAX;
 
 	if ((!knet_send_sync(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_send_sync accepted invalid channel (KNET_DATAFD_MAX) or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send_sync with unconfigured channel\n");
 
 	channel = 0;
 
 	if ((!knet_send_sync(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel)) || (errno != EINVAL)) {
 		printf("knet_send_sync accepted invalid unconfigured channel or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send_sync with data forwarding disabled\n");
 
 	if (knet_handle_enable_sock_notify(knet_h, &private_data, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
         }
 
 	datafd = 0;
 	channel = -1;
 
 	if (knet_handle_add_datafd(knet_h, &datafd, &channel) < 0) {
 		printf("knet_handle_add_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if ((knet_send_sync(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel) == sizeof(send_buff)) || (errno != ECANCELED)) {
 		printf("knet_send_sync didn't detect datafwd disabled or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send_sync with broken dst_host_filter\n");
 
 	if (knet_handle_setfwd(knet_h, 1) < 0) {
 		printf("knet_handle_setfwd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_handle_enable_filter(knet_h, NULL, dhost_filter) < 0) {
 		printf("knet_handle_enable_filter failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	dhost_filter_ret = -1;
 
 	if ((knet_send_sync(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel) == sizeof(send_buff)) || (errno != EFAULT)) {
 		printf("knet_send_sync didn't detect fatal error from dst_host_filter or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send_sync with dst_host_filter returning no host_ids_entries\n");
 
 	dhost_filter_ret = 0;
 
 	if ((knet_send_sync(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel) == sizeof(send_buff)) || (errno != EINVAL)) {
 		printf("knet_send_sync didn't detect 0 host_ids from dst_host_filter or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send_sync with host down\n");
 
 	dhost_filter_ret = 1;
 
 	if ((knet_send_sync(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel) == sizeof(send_buff)) || (errno != EHOSTDOWN)) {
 		printf("knet_send_sync didn't detect hostdown or returned incorrect error: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send_sync with dst_host_filter returning too many host_ids_entries\n");
 
 	if (knet_host_add(knet_h, 1) < 0) {
 		printf("knet_host_add failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_config(knet_h, 1, 0, KNET_TRANSPORT_UDP, &lo, &lo, 0) < 0) {
 		printf("Unable to configure link: %s\n", strerror(errno));
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (knet_link_set_enable(knet_h, 1, 0, 1) < 0) {
 		printf("knet_link_set_enable failed: %s\n", strerror(errno));
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	if (wait_for_host(knet_h, 1, 10, logfds[0], stdout) < 0) {
 		printf("timeout waiting for host to be reachable");
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	dhost_filter_ret = 2;
 
 	if ((knet_send_sync(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel) == sizeof(send_buff)) || (errno != E2BIG)) {
 		printf("knet_send_sync didn't detect 2+ host_ids from dst_host_filter or returned incorrect error: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send_sync with dst_host_filter returning mcast packets\n");
 
 	dhost_filter_ret = 3;
 
 	if ((knet_send_sync(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel) == sizeof(send_buff)) || (errno != E2BIG)) {
 		printf("knet_send_sync didn't detect mcast packet from dst_host_filter or returned incorrect error: %s\n", strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_send_sync with valid data\n");
 
 	dhost_filter_ret = 1;
 
 	if (knet_send_sync(knet_h, send_buff, KNET_MAX_PACKET_SIZE, channel) < 0) {
 		printf("knet_send_sync failed: %d %s\n", errno, strerror(errno));
 		knet_link_set_enable(knet_h, 1, 0, 0);
 		knet_link_clear_config(knet_h, 1, 0);
 		knet_host_remove(knet_h, 1);
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	knet_link_set_enable(knet_h, 1, 0, 0);
 	knet_link_clear_config(knet_h, 1, 0);
 	knet_host_remove(knet_h, 1);
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/crypto_bench.c b/libknet/tests/crypto_bench.c
index 723485dd..cf00403d 100644
--- a/libknet/tests/crypto_bench.c
+++ b/libknet/tests/crypto_bench.c
@@ -1,273 +1,271 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <time.h>
 #include <pthread.h>
 
 #include "libknet.h"
 
 #include "common.h"
 #include "internals.h"
 #include "crypto.h"
 #include "threads_common.h"
 
 #include "test-common.h"
 
 pthread_rwlock_t shlib_rwlock;
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfd;
 	struct knet_handle_crypto_cfg knet_handle_crypto_cfg;
 	struct knet_handle_stats knet_stats;
 	char *buf1, *buf2, *buf3;
 	const char *input = "Encrypt me!\x0";
 	ssize_t input_len = strlen(input) + 1;
 	ssize_t outbuf_len;
 	int loops;
 	struct timespec clock_start, clock_end;
 	unsigned long long time_diff;
 	struct iovec iov_in;
 	struct iovec iov_multi[4];
 	int err = 0;
 
 	err = pthread_rwlock_init(&shlib_rwlock, NULL);
 	if (err) {
 		printf("unable to init lock: %s\n", strerror(err));
 		exit(FAIL);
 	}
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 
 	logfd = start_logging(stdout);
 
 	knet_h = knet_handle_new(1, logfd, KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	printf("Test knet_handle_crypto with nss/aes128/sha1 and normal key\n");
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 	strncpy(knet_handle_crypto_cfg.crypto_model, "nss", sizeof(knet_handle_crypto_cfg.crypto_model) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_cipher_type, "aes128", sizeof(knet_handle_crypto_cfg.crypto_cipher_type) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_hash_type, "sha1", sizeof(knet_handle_crypto_cfg.crypto_hash_type) - 1);
 	knet_handle_crypto_cfg.private_key_len = 2000;
 
 	if (crypto_init(knet_h, &knet_handle_crypto_cfg) < 0) {
 		printf("knet_handle_crypto failed with correct config: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		exit(FAIL);
 	}
 
 	buf1=malloc(input_len);
 	buf2=malloc(input_len + knet_h->sec_header_size);
 	buf3=malloc(input_len + knet_h->sec_header_size);
 
 	memset(buf1, 0, input_len);
 	memset(buf2, 0, input_len + knet_h->sec_header_size);
 	memset(buf3, 0, input_len + knet_h->sec_header_size);
 
 	/*
 	 * setup source buffer
 	 */
 
 	if (clock_gettime(CLOCK_MONOTONIC, &clock_start) != 0) {
 		printf("Unable to get start time!\n");
 		knet_handle_free(knet_h);
 		exit(FAIL);
 	}
 
 	for (loops=0; loops<1000000; loops++) {
 		memset(buf1, 0, input_len);
 		memset(buf2, 0, input_len + knet_h->sec_header_size);
 		memset(buf3, 0, input_len + knet_h->sec_header_size);
 
 		strncpy(buf1, input, input_len);
 
 		if (crypto_encrypt_and_sign(knet_h, (unsigned char *)buf1, strlen(buf1)+1, (unsigned char *)buf2, &outbuf_len) < 0) {
 			printf("Unable to crypt and sign!\n");
 			knet_handle_free(knet_h);
 			exit(FAIL);
 		}
 
 		if (crypto_authenticate_and_decrypt(knet_h, (unsigned char *)buf2, outbuf_len, (unsigned char *)buf3, &outbuf_len) < 0) {
 			printf("Unable to auth and decrypt!\n");
 			knet_handle_free(knet_h);
 			exit(FAIL);
 		}
 
 
 		if (memcmp(buf1, buf3, outbuf_len)) {
 			printf("Crypt / Descrypt produced two different data set!\n");
 			knet_handle_free(knet_h);
 			exit(FAIL);
 		}
 	}
 
 	if (clock_gettime(CLOCK_MONOTONIC, &clock_end) != 0) {
 		printf("Unable to get end time!\n");
 		knet_handle_free(knet_h);
 		exit(FAIL);
 	}
 
 	timespec_diff(clock_start, clock_end, &time_diff);
 
 	printf("Execution of 1000000 loops (buf_in api): %llu/ns\n", time_diff);
 
 	if (clock_gettime(CLOCK_MONOTONIC, &clock_start) != 0) {
 		printf("Unable to get start time!\n");
 		knet_handle_free(knet_h);
 		exit(FAIL);
 	}
 
 	memset(buf1, 0, input_len);
 	strncpy(buf1, input, input_len);
 
 	for (loops=0; loops<1000000; loops++) {
 		memset(buf2, 0, input_len + knet_h->sec_header_size);
 		memset(buf3, 0, input_len + knet_h->sec_header_size);
 		memset(&iov_in, 0, sizeof(iov_in));
 
 		iov_in.iov_base = (unsigned char *)buf1;
 		iov_in.iov_len = strlen(buf1)+1;
 
 		if (crypto_encrypt_and_signv(knet_h, &iov_in, 1, (unsigned char *)buf2, &outbuf_len) < 0) {
 			printf("Unable to crypt and sign!\n");
 			knet_handle_free(knet_h);
 			exit(FAIL);
 		}
 
 		if (crypto_authenticate_and_decrypt(knet_h, (unsigned char *)buf2, outbuf_len, (unsigned char *)buf3, &outbuf_len) < 0) {
 			printf("Unable to auth and decrypt!\n");
 			knet_handle_free(knet_h);
 			exit(FAIL);
 		}
 
 
 		if (memcmp(buf1, buf3, outbuf_len)) {
 			printf("Crypt / Descrypt produced two different data set!\n");
 			knet_handle_free(knet_h);
 			exit(FAIL);
 		}
 	}
 
 	if (clock_gettime(CLOCK_MONOTONIC, &clock_end) != 0) {
 		printf("Unable to get end time!\n");
 		knet_handle_free(knet_h);
 		exit(FAIL);
 	}
 
 	timespec_diff(clock_start, clock_end, &time_diff);
 
 	printf("Execution of 1000000 loops (iov_in api): %llu/ns\n", time_diff);
 
 	if (clock_gettime(CLOCK_MONOTONIC, &clock_start) != 0) {
 		printf("Unable to get start time!\n");
 		knet_handle_free(knet_h);
 		exit(FAIL);
 	}
 
 	memset(buf1, 0, input_len);
 	strncpy(buf1, input, input_len);
 
 	for (loops=0; loops<1000000; loops++) {
 		memset(buf2, 0, input_len + knet_h->sec_header_size);
 		memset(buf3, 0, input_len + knet_h->sec_header_size);
 		memset(&iov_multi, 0, sizeof(iov_multi));
 
 		/*
 		 * "Encrypt me!\n" = 12 bytes
 		 */
 
 		iov_multi[0].iov_base = (unsigned char *)buf1;
 		iov_multi[0].iov_len = 3;
 		iov_multi[1].iov_base = (unsigned char *)buf1 + 3;
 		iov_multi[1].iov_len = 3;
 		iov_multi[2].iov_base = (unsigned char *)buf1 + 6;
 		iov_multi[2].iov_len = 3;
 		iov_multi[3].iov_base = (unsigned char *)buf1 + 9;
 		iov_multi[3].iov_len = 3;
 
 		if (crypto_encrypt_and_signv(knet_h, iov_multi, 4, (unsigned char *)buf2, &outbuf_len) < 0) {
 			printf("Unable to crypt and sign!\n");
 			knet_handle_free(knet_h);
 			exit(FAIL);
 		}
 
 		if (crypto_authenticate_and_decrypt(knet_h, (unsigned char *)buf2, outbuf_len, (unsigned char *)buf3, &outbuf_len) < 0) {
 			printf("Unable to auth and decrypt!\n");
 			knet_handle_free(knet_h);
 			exit(FAIL);
 		}
 
 
 		if (memcmp(buf1, buf3, outbuf_len)) {
 			printf("Crypt / Descrypt produced two different data set!\n");
 			knet_handle_free(knet_h);
 			exit(FAIL);
 		}
 	}
 
 	if (clock_gettime(CLOCK_MONOTONIC, &clock_end) != 0) {
 		printf("Unable to get end time!\n");
 		knet_handle_free(knet_h);
 		exit(FAIL);
 	}
 
 	timespec_diff(clock_start, clock_end, &time_diff);
 
 	printf("Execution of 1000000 loops (iov_in multi api): %llu/ns\n", time_diff);
 
 	knet_handle_get_stats(knet_h, &knet_stats, sizeof(knet_stats));
 
 	printf("Shutdown crypto\n");
 
 	crypto_fini(knet_h);
 
 	knet_handle_free(knet_h);
 	free(buf1);
 	free(buf2);
 	free(buf3);
 	pthread_rwlock_destroy(&shlib_rwlock);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	printf("Testing with default scheduler\n");
 
 	set_scheduler(SCHED_OTHER);
 
 	test();
 
 	printf("Testing with SCHED_RR scheduler\n");
 
 	set_scheduler(SCHED_RR);
 
 	test();
 
 	printf("Testing with SCHED_FIFO scheduler\n");
 
 	set_scheduler(SCHED_FIFO);
 
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/int_crypto.c b/libknet/tests/int_crypto.c
index 10214a22..164c40da 100644
--- a/libknet/tests/int_crypto.c
+++ b/libknet/tests/int_crypto.c
@@ -1,146 +1,144 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <pthread.h>
 
 #include "libknet.h"
 
 #include "common.h"
 #include "internals.h"
 #include "crypto.h"
 #include "test-common.h"
 
 pthread_rwlock_t shlib_rwlock;
 
 static void test(void)
 {
 	knet_handle_t knet_h;
 	int logfds[2];
 	struct knet_handle_crypto_cfg knet_handle_crypto_cfg;
 	char *buf1, *buf2, *buf3;
 	const char *input = "Encrypt me!\x0";
 	ssize_t input_len = strlen(input) + 1;
 	ssize_t outbuf_len;
 	int i;
 	int err = 0;
 
 	err = pthread_rwlock_init(&shlib_rwlock, NULL);
 	if (err) {
 		printf("unable to init lock: %s\n", strerror(err));
 		exit(FAIL);
 	}
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 
 	setup_logpipes(logfds);
 
 	knet_h = knet_handle_new(1, logfds[1], KNET_LOG_DEBUG);
 
 	if (!knet_h) {
 		printf("knet_handle_new failed: %s\n", strerror(errno));
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	printf("Test knet_handle_crypto with nss/aes128/sha1 and normal key\n");
 
 	memset(&knet_handle_crypto_cfg, 0, sizeof(struct knet_handle_crypto_cfg));
 	strncpy(knet_handle_crypto_cfg.crypto_model, "nss", sizeof(knet_handle_crypto_cfg.crypto_model) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_cipher_type, "aes128", sizeof(knet_handle_crypto_cfg.crypto_cipher_type) - 1);
 	strncpy(knet_handle_crypto_cfg.crypto_hash_type, "sha1", sizeof(knet_handle_crypto_cfg.crypto_hash_type) - 1);
 	knet_handle_crypto_cfg.private_key_len = 2000;
 
 	if (crypto_init(knet_h, &knet_handle_crypto_cfg) < 0) {
 		printf("crypto_init failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	flush_logs(logfds[0], stdout);
 
 	buf1=malloc(input_len);
 	buf2=malloc(input_len + knet_h->sec_header_size);
 	buf3=malloc(input_len + knet_h->sec_header_size);
 
 	memset(buf1, 0, input_len);
 	memset(buf2, 0, input_len + knet_h->sec_header_size);
 	memset(buf3, 0, input_len + knet_h->sec_header_size);
 
 	/*
 	 * setup source buffer
 	 */
 
 	strncpy(buf1, input, input_len);
 	printf("Source Data: %s\n", buf1);
 
 	if (crypto_encrypt_and_sign(knet_h, (unsigned char *)buf1, strlen(buf1)+1, (unsigned char *)buf2, &outbuf_len) < 0) {
 		printf("Unable to crypt and sign!\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Encrypted Data: ");
 	for (i=0; i<outbuf_len; i++) {
 		printf("%02x ", (unsigned char)buf2[i]);
 	}
 	printf("\n");
 
 	if (crypto_authenticate_and_decrypt(knet_h, (unsigned char *)buf2, outbuf_len, (unsigned char *)buf3, &outbuf_len) < 0) {
 		printf("Unable to auth and decrypt!\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Decrypted Data: %s\n", buf3);
 
 	if (memcmp(buf1, buf3, outbuf_len)) {
 		printf("Crypt / Descrypt produced two different data set!\n");
 		knet_handle_free(knet_h);
 		flush_logs(logfds[0], stdout);
 		close_logpipes(logfds);
 		exit(FAIL);
 	}
 
 	printf("Shutdown crypto\n");
 	crypto_fini(knet_h);
 	flush_logs(logfds[0], stdout);
 
 	knet_handle_free(knet_h);
 	flush_logs(logfds[0], stdout);
 	close_logpipes(logfds);
 
 	free(buf1);
 	free(buf2);
 	free(buf3);
 	pthread_rwlock_destroy(&shlib_rwlock);
 }
 
 int main(int argc, char *argv[])
 {
-	need_root();
-
 	test();
 
 	return PASS;
 }
diff --git a/libknet/tests/knet_bench.c b/libknet/tests/knet_bench.c
index 40013096..dc540d77 100644
--- a/libknet/tests/knet_bench.c
+++ b/libknet/tests/knet_bench.c
@@ -1,1254 +1,1252 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <signal.h>
 #include <pthread.h>
 #include <sys/types.h>
 #include <inttypes.h>
 
 #include "libknet.h"
 
 #include "compat.h"
 #include "internals.h"
 #include "netutils.h"
 #include "transport_common.h"
 #include "threads_common.h"
 #include "test-common.h"
 
 #define MAX_NODES 128
 
 static int senderid = -1;
 static int thisnodeid = -1;
 static knet_handle_t knet_h;
 static int datafd = 0;
 static int8_t channel = 0;
 static int globallistener = 0;
 static int continous = 0;
 static int show_stats = 0;
 static struct sockaddr_storage allv4;
 static struct sockaddr_storage allv6;
 static int broadcast_test = 1;
 static pthread_t rx_thread = (pthread_t)NULL;
 static char *rx_buf[PCKT_FRAG_MAX];
 static int wait_for_perf_rx = 0;
 static char *compresscfg = NULL;
 static char *cryptocfg = NULL;
 
 static int bench_shutdown_in_progress = 0;
 static pthread_mutex_t shutdown_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 #define TEST_PING 0
 #define TEST_PING_AND_DATA 1
 #define TEST_PERF_BY_SIZE 2
 #define TEST_PERF_BY_TIME 3
 
 static int test_type = TEST_PING;
 
 #define TEST_START 2
 #define TEST_STOP 4
 #define TEST_COMPLETE 6
 
 #define ONE_GIGABYTE 1073741824
 
 static uint64_t perf_by_size_size = 1 * ONE_GIGABYTE;
 static uint64_t perf_by_time_secs = 10;
 
 struct node {
 	int nodeid;
 	int links;
 	struct sockaddr_storage address[KNET_MAX_LINK];
 };
 
 static void print_help(void)
 {
 	printf("knet_bench usage:\n");
 	printf(" -h                                        print this help (no really)\n");
 	printf(" -d                                        enable debug logs (default INFO)\n");
 	printf(" -c [implementation]:[crypto]:[hashing]    crypto configuration. (default disabled)\n");
 	printf("                                           Example: -c nss:aes128:sha1\n");
 	printf(" -z [implementation]:[level]:[threshold]   compress configuration. (default disabled)\n");
 	printf("                                           Example: -z zlib:5:100\n");
 	printf(" -p [active|passive|rr]                    (default: passive)\n");
 	printf(" -P [udp|sctp]                             (default: udp) protocol (transport) to use\n");
 	printf(" -t [nodeid]                               This nodeid (required)\n");
 	printf(" -n [nodeid],[link1_ip_addr],[link2_..]    Other nodes information (at least one required)\n");
 	printf("                                           Example: -t 1,192.168.8.1,3ffe::8:1,..\n");
 	printf("                                           can be repeated up to %d and should contain also the localnode info\n", MAX_NODES);
 	printf(" -b [port]                                 baseport (default: 50000)\n");
 	printf(" -l                                        enable global listener on 0.0.0.0/:: (default: off, incompatible with -o)\n");
 	printf(" -o                                        enable baseport offset per nodeid\n");
 	printf(" -w                                        dont wait for all nodes to be up before starting the test (default: wait)\n");
 	printf(" -T [ping|ping_data|perf-by-size|perf-by-time]\n");
 	printf("                                           test type (default: ping)\n");
 	printf("                                           ping: will wait for all hosts to join the knet network, sleep 5 seconds and quit\n");
 	printf("                                           ping_data: will wait for all hosts to join the knet network, sends some data to all nodes and quit\n");
 	printf("                                           perf-by-size: will wait for all hosts to join the knet network,\n");
 	printf("                                                         perform a series of benchmarks by transmitting a known\n");
 	printf("                                                         size/quantity of packets and measuring the time, then quit\n");
 	printf("                                           perf-by-time: will wait for all hosts to join the knet network,\n");
 	printf("                                                         perform a series of benchmarks by transmitting a known\n");
 	printf("                                                         size of packets for a given amount of time (10 seconds)\n");
 	printf("                                                         and measuring the quantity of data transmitted, then quit\n");
 	printf(" -s                                        nodeid that will generate traffic for benchmarks\n");
 	printf(" -S [size|seconds]                         when used in combination with -T perf-by-size it indicates how many GB of traffic to generate for the test. (default: 1GB)\n");
 	printf("                                           when used in combination with -T perf-by-time it indicates how many Seconds of traffic to generate for the test. (default: 10 seconds)\n");
 	printf(" -C                                        repeat the test continously (default: off)\n");
 	printf(" -X[XX]                                    show stats at the end of the run (default: 1)\n");
 	printf("                                           1: show handle stats, 2: show summary link stats\n");
 	printf("                                           3: show detailed link stats\n");
 }
 
 static void parse_nodes(char *nodesinfo[MAX_NODES], int onidx, int port, struct node nodes[MAX_NODES], int *thisidx)
 {
 	int i;
 	char *temp = NULL;
 	char port_str[10];
 
 	memset(port_str, 0, sizeof(port_str));
 	sprintf(port_str, "%d", port);
 
 	for (i = 0; i < onidx; i++) {
 		nodes[i].nodeid = atoi(strtok(nodesinfo[i], ","));
 		if ((nodes[i].nodeid < 0) || (nodes[i].nodeid > KNET_MAX_HOST)) {
 			printf("Invalid nodeid: %d (0 - %d)\n", nodes[i].nodeid, KNET_MAX_HOST);
 			exit(FAIL);
 		}
 		if (thisnodeid == nodes[i].nodeid) {
 			*thisidx = i;
 		}
 		while((temp = strtok(NULL, ","))) {
 			if (nodes[i].links == KNET_MAX_LINK) {
 				printf("Too many links configured. Max %d\n", KNET_MAX_LINK);
 				exit(FAIL);
 			}
 			if (knet_strtoaddr(temp, port_str,
 					   &nodes[i].address[nodes[i].links],
 					   sizeof(struct sockaddr_storage)) < 0) {
 				printf("Unable to convert %s to sockaddress\n", temp);
 				exit(FAIL);
 			}
 			nodes[i].links++;
 		}
 	}
 
 	if (knet_strtoaddr("0.0.0.0", port_str, &allv4, sizeof(struct sockaddr_storage)) < 0) {
 		printf("Unable to convert 0.0.0.0 to sockaddress\n");
 		exit(FAIL);
 	}
 
 	if (knet_strtoaddr("::", port_str, &allv6, sizeof(struct sockaddr_storage)) < 0) {
 		printf("Unable to convert :: to sockaddress\n");
 		exit(FAIL);
 	}
 
 	for (i = 1; i < onidx; i++) {
 		if (nodes[0].links != nodes[i].links) {
 			printf("knet_bench does not support unbalanced link configuration\n");
 			exit(FAIL);
 		}
 	}
 
 	return;
 }
 
 static int private_data;
 
 static void sock_notify(void *pvt_data,
 			int local_datafd,
 			int8_t local_channel,
 			uint8_t tx_rx,
 			int error,
 			int errorno)
 {
 	printf("Error (%d - %d - %s) from socket: %d\n", error, errorno, strerror(errno), local_datafd);
 	return;
 }
 
 static int ping_dst_host_filter(void *pvt_data,
 				const unsigned char *outdata,
 				ssize_t outdata_len,
 				uint8_t tx_rx,
 				knet_node_id_t this_host_id,
 				knet_node_id_t src_host_id,
 				int8_t *dst_channel,
 				knet_node_id_t *dst_host_ids,
 				size_t *dst_host_ids_entries)
 {
 	if (broadcast_test) {
 		return 1;
 	}
 
 	if (tx_rx == KNET_NOTIFY_TX) {
 		memmove(&dst_host_ids[0], outdata, 2);
 	} else {
 		dst_host_ids[0] = this_host_id;
 	}
 	*dst_host_ids_entries = 1;
 	return 0;
 }
 
 static void setup_knet(int argc, char *argv[])
 {
 	int logfd;
 	int rv;
 	char *policystr = NULL, *protostr = NULL;
 	char *othernodeinfo[MAX_NODES];
 	struct node nodes[MAX_NODES];
 	int thisidx = -1;
 	int onidx = 0;
 	int debug = KNET_LOG_INFO;
 	int port = 50000, portoffset = 0;
 	int thisport = 0, otherport = 0;
 	int thisnewport = 0, othernewport = 0;
 	struct sockaddr_in *so_in;
 	struct sockaddr_in6 *so_in6;
 	struct sockaddr_storage *src;
 	int i, link_idx, allnodesup = 0;
 	int policy = KNET_LINK_POLICY_PASSIVE, policyfound = 0;
 	int protocol = KNET_TRANSPORT_UDP, protofound = 0;
 	int wait = 1;
 	struct knet_handle_crypto_cfg knet_handle_crypto_cfg;
 	char *cryptomodel = NULL, *cryptotype = NULL, *cryptohash = NULL;
 	struct knet_handle_compress_cfg knet_handle_compress_cfg;
 
 	memset(nodes, 0, sizeof(nodes));
 
 	while ((rv = getopt(argc, argv, "CT:S:s:ldowb:t:n:c:p:X::P:z:h")) != EOF) {
 		switch(rv) {
 			case 'h':
 				print_help();
 				exit(PASS);
 				break;
 			case 'd':
 				debug = KNET_LOG_DEBUG;
 				break;
 			case 'c':
 				if (cryptocfg) {
 					printf("Error: -c can only be specified once\n");
 					exit(FAIL);
 				}
 				cryptocfg = optarg;
 				break;
 			case 'p':
 				if (policystr) {
 					printf("Error: -p can only be specified once\n");
 					exit(FAIL);
 				}
 				policystr = optarg;
 				if (!strcmp(policystr, "active")) {
 					policy = KNET_LINK_POLICY_ACTIVE;
 					policyfound = 1;
 				}
 				/*
 				 * we can't use rr because clangs can't compile
 				 * an array of 3 strings, one of which is 2 bytes long
 				 */
 				if (!strcmp(policystr, "round-robin")) {
 					policy = KNET_LINK_POLICY_RR;
 					policyfound = 1;
 				}
 				if (!strcmp(policystr, "passive")) {
 					policy = KNET_LINK_POLICY_PASSIVE;
 					policyfound = 1;
 				}
 				if (!policyfound) {
 					printf("Error: invalid policy %s specified. -p accepts active|passive|rr\n", policystr);
 					exit(FAIL);
 				}
 				break;
 		        case 'P':
 				if (protostr) {
 					printf("Error: -P can only be specified once\n");
 					exit(FAIL);
 				}
 				protostr = optarg;
 				if (!strcmp(protostr, "udp")) {
 					protocol = KNET_TRANSPORT_UDP;
 					protofound = 1;
 				}
 				if (!strcmp(protostr, "sctp")) {
 					protocol = KNET_TRANSPORT_SCTP;
 					protofound = 1;
 				}
 				if (!protofound) {
 					printf("Error: invalid protocol %s specified. -P accepts udp|sctp\n", policystr);
 					exit(FAIL);
 				}
 				break;
 			case 't':
 				if (thisnodeid >= 0) {
 					printf("Error: -t can only be specified once\n");
 					exit(FAIL);
 				}
 				thisnodeid = atoi(optarg);
 				if ((thisnodeid < 0) || (thisnodeid > 65536)) {
 					printf("Error: -t nodeid out of range %d (1 - 65536)\n", thisnodeid);
                                         exit(FAIL);
 				}
 				break;
 			case 'n':
 				if (onidx == MAX_NODES) {
 					printf("Error: too many other nodes. Max %d\n", MAX_NODES);
 					exit(FAIL);
 				}
 				othernodeinfo[onidx] = optarg;
 				onidx++;
 				break;
 			case 'b':
 				port = atoi(optarg);
 				if ((port < 1) || (port > 65536)) {
 					printf("Error: port %d out of range (1 - 65536)\n", port);
 					exit(FAIL);
 				}
 				break;
 			case 'o':
 				if (globallistener) {
 					printf("Error: -l cannot be used with -o\n");
 					exit(FAIL);
 				}
 				portoffset = 1;
 				break;
 			case 'l':
 				if (portoffset) {
 					printf("Error: -o cannot be used with -l\n");
 					exit(FAIL);
 				}
 				globallistener = 1;
 				break;
 			case 'w':
 				wait = 0;
 				break;
 			case 's':
 				if (senderid >= 0) {
 					printf("Error: -s can only be specified once\n");
 					exit(FAIL);
 				}
 				senderid = atoi(optarg);
 				if ((senderid < 0) || (senderid > 65536)) {
 					printf("Error: -s nodeid out of range %d (1 - 65536)\n", senderid);
                                         exit(FAIL);
 				}
 				break;
 			case 'T':
 				if (!strcmp("ping", optarg)) {
 					test_type = TEST_PING;
 				}
 				if (!strcmp("ping_data", optarg)) {
 					test_type = TEST_PING_AND_DATA;
 				}
 				if (!strcmp("perf-by-size", optarg)) {
 					test_type = TEST_PERF_BY_SIZE;
 				}
 				if (!strcmp("perf-by-time", optarg)) {
 					test_type = TEST_PERF_BY_TIME;
 				}
 				break;
 			case 'S':
 				perf_by_size_size = (uint64_t)atoi(optarg) * ONE_GIGABYTE;
 				perf_by_time_secs = (uint64_t)atoi(optarg);
 				break;
 			case 'C':
 				continous = 1;
 				break;
 			case 'X':
 				if (optarg) {
 					show_stats = atoi(optarg);
 				} else {
 					show_stats = 1;
 				}
 				break;
 			case 'z':
 				if (compresscfg) {
 					printf("Error: -c can only be specified once\n");
 					exit(FAIL);
 				}
 				compresscfg = optarg;
 				break;
 			default:
 				break;
 		}
 	}
 
 	if (thisnodeid < 0) {
 		printf("Who am I?!? missing -t from command line?\n");
 		exit(FAIL);
 	}
 
 	if (onidx < 1) {
 		printf("no other nodes configured?!? missing -n from command line\n");
 		exit(FAIL);
 	}
 
 	parse_nodes(othernodeinfo, onidx, port, nodes, &thisidx);
 
 	if (thisidx < 0) {
 		printf("no config for this node found\n");
 		exit(FAIL);
 	}
 
 	if (senderid >= 0) {
 		for (i=0; i < onidx; i++) {
 			if (senderid == nodes[i].nodeid) {
 				break;
 			}
 		}
 		if (i == onidx) {
 			printf("Unable to find senderid in nodelist\n");
 			exit(FAIL);
 		}
 	}
 
 	if (((test_type == TEST_PERF_BY_SIZE) || (test_type == TEST_PERF_BY_TIME)) && (senderid < 0)) {
 		printf("Error: performance test requires -s to be set (for now)\n");
 		exit(FAIL);
 	}
 
 	logfd = start_logging(stdout);
 
 	knet_h = knet_handle_new(thisnodeid, logfd, debug);
 	if (!knet_h) {
 		printf("Unable to knet_handle_new: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (cryptocfg) {
 		memset(&knet_handle_crypto_cfg, 0, sizeof(knet_handle_crypto_cfg));
 		cryptomodel = strtok(cryptocfg, ":");
 		cryptotype = strtok(NULL, ":");
 		cryptohash = strtok(NULL, ":");
 		if (cryptomodel) {
 			strncpy(knet_handle_crypto_cfg.crypto_model, cryptomodel, sizeof(knet_handle_crypto_cfg.crypto_model) - 1);
 		}
 		if (cryptotype) {
 			strncpy(knet_handle_crypto_cfg.crypto_cipher_type, cryptotype, sizeof(knet_handle_crypto_cfg.crypto_cipher_type) - 1);
 		}
 		if (cryptohash) {
 			strncpy(knet_handle_crypto_cfg.crypto_hash_type, cryptohash, sizeof(knet_handle_crypto_cfg.crypto_hash_type) - 1);
 		}
 		knet_handle_crypto_cfg.private_key_len = KNET_MAX_KEY_LEN;
 		if (knet_handle_crypto(knet_h, &knet_handle_crypto_cfg)) {
 			printf("Unable to init crypto\n");
 			exit(FAIL);
 		}
 	}
 
 	if (compresscfg) {
 		memset(&knet_handle_compress_cfg, 0, sizeof(struct knet_handle_compress_cfg));
 		snprintf(knet_handle_compress_cfg.compress_model, 16, "%s", strtok(compresscfg, ":"));
 		knet_handle_compress_cfg.compress_level = atoi(strtok(NULL, ":"));
 		knet_handle_compress_cfg.compress_threshold = atoi(strtok(NULL, ":"));
 		if (knet_handle_compress(knet_h, &knet_handle_compress_cfg)) {
 			printf("Unable to configure compress\n");
 			exit(FAIL);
 		}
 	}
 
 	if (knet_handle_enable_sock_notify(knet_h, &private_data, sock_notify) < 0) {
 		printf("knet_handle_enable_sock_notify failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		exit(FAIL);
         }
 
 	datafd = 0;
 	channel = -1;
 
 	if (knet_handle_add_datafd(knet_h, &datafd, &channel) < 0) {
 		printf("knet_handle_add_datafd failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		exit(FAIL);
 	}
 
 	if (knet_handle_pmtud_setfreq(knet_h, 60) < 0) {
 		printf("knet_handle_pmtud_setfreq failed: %s\n", strerror(errno));
 		knet_handle_free(knet_h);
 		exit(FAIL);
 	}
 
 	for (i=0; i < onidx; i++) {
 		if (i == thisidx) {
 			continue;
 		}
 
 		if (knet_host_add(knet_h, nodes[i].nodeid) < 0) {
 			printf("knet_host_add failed: %s\n", strerror(errno));
 			exit(FAIL);
 		}
 
 		if (knet_host_set_policy(knet_h, nodes[i].nodeid, policy) < 0) {
 			printf("knet_host_set_policy failed: %s\n", strerror(errno));
 			exit(FAIL);
 		}
 
 		for (link_idx = 0; link_idx < nodes[i].links; link_idx++) {
 			if (portoffset) {
 				if (nodes[thisidx].address[link_idx].ss_family == AF_INET) {
 					so_in = (struct sockaddr_in *)&nodes[thisidx].address[link_idx];
 					thisport = ntohs(so_in->sin_port);
 					thisnewport = thisport + nodes[i].nodeid;
 					so_in->sin_port = (htons(thisnewport));
 					so_in = (struct sockaddr_in *)&nodes[i].address[link_idx];
 					otherport = ntohs(so_in->sin_port);
 					othernewport = otherport + nodes[thisidx].nodeid;
 					so_in->sin_port = (htons(othernewport));
 				} else {
 					so_in6 = (struct sockaddr_in6 *)&nodes[thisidx].address[link_idx];
 					thisport = ntohs(so_in6->sin6_port);
 					thisnewport = thisport + nodes[i].nodeid;
 					so_in6->sin6_port = (htons(thisnewport));
 					so_in6 = (struct sockaddr_in6 *)&nodes[i].address[link_idx];
 					otherport = ntohs(so_in6->sin6_port);
 					othernewport = otherport + nodes[thisidx].nodeid;
 					so_in6->sin6_port = (htons(othernewport));
 				}
 			}
 			if (!globallistener) {
 				src = &nodes[thisidx].address[link_idx];
 			} else {
 				if (nodes[thisidx].address[link_idx].ss_family == AF_INET) {
 					src = &allv4;
 				} else {
 					src = &allv6;
 				}
 			}
 			if (knet_link_set_config(knet_h, nodes[i].nodeid, link_idx,
 						 protocol, src,
 						 &nodes[i].address[link_idx], 0) < 0) {
 				printf("Unable to configure link: %s\n", strerror(errno));
 				exit(FAIL);
 			}
 			if (portoffset) {
 				if (nodes[thisidx].address[link_idx].ss_family == AF_INET) {
 					so_in = (struct sockaddr_in *)&nodes[thisidx].address[link_idx];
 					so_in->sin_port = (htons(thisport));
 					so_in = (struct sockaddr_in *)&nodes[i].address[link_idx];
 					so_in->sin_port = (htons(otherport));
 				} else {
 					so_in6 = (struct sockaddr_in6 *)&nodes[thisidx].address[link_idx];
 					so_in6->sin6_port = (htons(thisport));
 					so_in6 = (struct sockaddr_in6 *)&nodes[i].address[link_idx];
 					so_in6->sin6_port = (htons(otherport));
 				}
 			}
 			if (knet_link_set_enable(knet_h, nodes[i].nodeid, link_idx, 1) < 0) {
 				printf("knet_link_set_enable failed: %s\n", strerror(errno));
 				exit(FAIL);
 			}
 			if (knet_link_set_ping_timers(knet_h, nodes[i].nodeid, link_idx, 1000, 10000, 2048) < 0) {
 				printf("knet_link_set_ping_timers failed: %s\n", strerror(errno));
 				exit(FAIL);
 			}
 			if (knet_link_set_pong_count(knet_h, nodes[i].nodeid, link_idx, 2) < 0) {
 				printf("knet_link_set_pong_count failed: %s\n", strerror(errno));
 				exit(FAIL);
 			}
 		}
 	}
 
 	if (knet_handle_enable_filter(knet_h, NULL, ping_dst_host_filter)) {
 		printf("Unable to enable dst_host_filter: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (knet_handle_setfwd(knet_h, 1) < 0) {
 		printf("knet_handle_setfwd failed: %s\n", strerror(errno));
 		exit(FAIL);
 	}
 
 	if (wait) {
 		while(!allnodesup) {
 			allnodesup = 1;
 			for (i=0; i < onidx; i++) {
 				if (i == thisidx) {
 					continue;
 				}
 				if(knet_h->host_index[nodes[i].nodeid]->status.reachable != 1) {
 					printf("waiting host %d to be reachable\n", nodes[i].nodeid);
 					allnodesup = 0;
 				}
 			}
 			if (!allnodesup) {
 				sleep(1);
 			}
 		}
 		sleep(1);
 	}
 }
 
 static void *_rx_thread(void *args)
 {
 	int rx_epoll;
 	struct epoll_event ev;
 	struct epoll_event events[KNET_EPOLL_MAX_EVENTS];
 
 	struct sockaddr_storage address[PCKT_FRAG_MAX];
 	struct knet_mmsghdr msg[PCKT_FRAG_MAX];
 	struct iovec iov_in[PCKT_FRAG_MAX];
 	int i, msg_recv;
 	struct timespec clock_start, clock_end;
 	unsigned long long time_diff = 0;
 	uint64_t rx_pkts = 0;
 	uint64_t rx_bytes = 0;
 	unsigned int current_pckt_size = 0;
 
 	for (i = 0; i < PCKT_FRAG_MAX; i++) {
 		rx_buf[i] = malloc(KNET_MAX_PACKET_SIZE);
 		if (!rx_buf[i]) {
 			printf("RXT: Unable to malloc!\n");
 			return NULL;
 		}
 		memset(rx_buf[i], 0, KNET_MAX_PACKET_SIZE);
 		iov_in[i].iov_base = (void *)rx_buf[i];
 		iov_in[i].iov_len = KNET_MAX_PACKET_SIZE;
 		memset(&msg[i].msg_hdr, 0, sizeof(struct msghdr));
 		msg[i].msg_hdr.msg_name = &address[i];
 		msg[i].msg_hdr.msg_namelen = sizeof(struct sockaddr_storage);
 		msg[i].msg_hdr.msg_iov = &iov_in[i];
 		msg[i].msg_hdr.msg_iovlen = 1;
 	}
 
 	rx_epoll = epoll_create(KNET_EPOLL_MAX_EVENTS + 1);
 	if (rx_epoll < 0) {
 		printf("RXT: Unable to create epoll!\nHALTING RX THREAD!\n");
 		return NULL;
 	}
 
 	memset(&ev, 0, sizeof(struct epoll_event));
 	ev.events = EPOLLIN;
 	ev.data.fd = datafd;
 
 	if (epoll_ctl(rx_epoll, EPOLL_CTL_ADD, datafd, &ev)) {
 		printf("RXT: Unable to add datafd to epoll\nHALTING RX THREAD!\n");
 		return NULL;
 	}
 
 	memset(&clock_start, 0, sizeof(clock_start));
 	memset(&clock_end, 0, sizeof(clock_start));
 
 	while (!bench_shutdown_in_progress) {
 		if (epoll_wait(rx_epoll, events, KNET_EPOLL_MAX_EVENTS, 1) >= 1) {
 			msg_recv = _recvmmsg(datafd, &msg[0], PCKT_FRAG_MAX, MSG_DONTWAIT | MSG_NOSIGNAL);
 			if (msg_recv < 0) {
 				printf("RXT: error from recvmmsg: %s\n", strerror(errno));
 			}
 			switch(test_type) {
 				case TEST_PING_AND_DATA:
 					for (i = 0; i < msg_recv; i++) {
 						if (msg[i].msg_len == 0) {
 							printf("RXT: received 0 bytes message?\n");
 						}
 						printf("received %u bytes message: %s\n", msg[i].msg_len, (char *)msg[i].msg_hdr.msg_iov->iov_base);
 					}
 					break;
 				case TEST_PERF_BY_TIME:
 				case TEST_PERF_BY_SIZE:
 					for (i = 0; i < msg_recv; i++) {
 						if (msg[i].msg_len < 64) {
 							if (msg[i].msg_len == 0) {
 								printf("RXT: received 0 bytes message?\n");
 							}
 							if (msg[i].msg_len == TEST_START) {
 								if (clock_gettime(CLOCK_MONOTONIC, &clock_start) != 0) {
 									printf("Unable to get start time!\n");
 								}
 							}
 							if (msg[i].msg_len == TEST_STOP) {
 								double average_rx_mbytes;
 								double average_rx_pkts;
 								double time_diff_sec;
 								if (clock_gettime(CLOCK_MONOTONIC, &clock_end) != 0) {
 									printf("Unable to get end time!\n");
 								}
 								timespec_diff(clock_start, clock_end, &time_diff);
 								/*
 								 * adjust for sleep(2) between sending the last data and TEST_STOP
 								 */
 								time_diff = time_diff - 2000000000llu;
 
 								/*
 								 * convert to seconds
 								 */
 								time_diff_sec = (double)time_diff / 1000000000llu;
 
 								average_rx_mbytes = (double)((rx_bytes / time_diff_sec) / (1024 * 1024));
 								average_rx_pkts = (double)(rx_pkts / time_diff_sec);
 								printf("Execution time: %8.4f secs Average speed: %8.4f MB/sec %8.4f pckts/sec (size: %u total: %" PRIu64 ")\n", time_diff_sec, average_rx_mbytes, average_rx_pkts, current_pckt_size, rx_pkts);
 								rx_pkts = 0;
 								rx_bytes = 0;
 								current_pckt_size = 0;
 							}
 							if (msg[i].msg_len == TEST_COMPLETE) {
 								wait_for_perf_rx = 1;
 							}
 							continue;
 						}
 						rx_pkts++;
 						rx_bytes = rx_bytes + msg[i].msg_len;
 						current_pckt_size = msg[i].msg_len;
 					}
 					break;
 			}
 		}
 	}
 
 	epoll_ctl(rx_epoll, EPOLL_CTL_DEL, datafd, &ev);
 	close(rx_epoll);
 
 	return NULL;
 }
 
 static void setup_data_txrx_common(void)
 {
 	if (!rx_thread) {
 		if (knet_handle_enable_filter(knet_h, NULL, ping_dst_host_filter)) {
 			printf("Unable to enable dst_host_filter: %s\n", strerror(errno));
 			exit(FAIL);
 		}
 		printf("Setting up rx thread\n");
 		if (pthread_create(&rx_thread, 0, _rx_thread, NULL)) {
 			printf("Unable to start rx thread\n");
 			exit(FAIL);
 		}
 	}
 }
 
 static void stop_rx_thread(void)
 {
 	void *retval;
 	int i;
 
 	if (rx_thread) {
 		printf("Shutting down rx thread\n");
 		sleep(2);
 		pthread_cancel(rx_thread);
 		pthread_join(rx_thread, &retval);
 		for (i = 0; i < PCKT_FRAG_MAX; i ++) {
 			free(rx_buf[i]);
 		}
 	}
 }
 
 static void send_ping_data(void)
 {
 	char buf[65535];
 	ssize_t len;
 
 	memset(&buf, 0, sizeof(buf));
 	snprintf(buf, sizeof(buf), "Hello world!");
 
 	if (compresscfg) {
 		len = sizeof(buf);
 	} else {
 		len = strlen(buf);
 	}
 
 	if (knet_send(knet_h, buf, len, channel) != len) {
 		printf("Error sending hello world: %s\n", strerror(errno));
 	}
 	sleep(1);
 }
 
 static int send_messages(struct knet_mmsghdr *msg, int msgs_to_send)
 {
 	int sent_msgs, prev_sent, progress, total_sent;
 
 	total_sent = 0;
 	sent_msgs = 0;
 	prev_sent = 0;
 	progress = 1;
 
 retry:
 	errno = 0;
 	sent_msgs = _sendmmsg(datafd, &msg[0], msgs_to_send, MSG_NOSIGNAL);
 
 	if (sent_msgs < 0) {
 		if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
 			usleep(KNET_THREADS_TIMERES / 16);
 			goto retry;
 		}
 		printf("Unable to send messages: %s\n", strerror(errno));
 		return -1;
 	}
 
 	total_sent = total_sent + sent_msgs;
 
 	if ((sent_msgs >= 0) && (sent_msgs < msgs_to_send)) {
 		if ((sent_msgs) || (progress)) {
 			msgs_to_send = msgs_to_send - sent_msgs;
 			prev_sent = prev_sent + sent_msgs;
 			if (sent_msgs) {
 				progress = 1;
 			} else {
 				progress = 0;
 			}
 			goto retry;
 		}
 		if (!progress) {
 			printf("Unable to send more messages after retry\n");
 		}
 	}
 	return total_sent;
 }
 
 static int setup_send_buffers_common(struct knet_mmsghdr *msg, struct iovec *iov_out, char *tx_buf[])
 {
 	int i;
 
 	for (i = 0; i < PCKT_FRAG_MAX; i++) {
 		tx_buf[i] = malloc(KNET_MAX_PACKET_SIZE);
 		if (!tx_buf[i]) {
 			printf("TXT: Unable to malloc!\n");
 			return -1;
 		}
 		memset(tx_buf[i], 0, KNET_MAX_PACKET_SIZE);
 		iov_out[i].iov_base = (void *)tx_buf[i];
 		memset(&msg[i].msg_hdr, 0, sizeof(struct msghdr));
 		msg[i].msg_hdr.msg_iov = &iov_out[i];
 		msg[i].msg_hdr.msg_iovlen = 1;
 	}
 	return 0;
 }
 
 static void send_perf_data_by_size(void)
 {
 	char *tx_buf[PCKT_FRAG_MAX];
 	struct knet_mmsghdr msg[PCKT_FRAG_MAX];
 	struct iovec iov_out[PCKT_FRAG_MAX];
 	char ctrl_message[16];
 	int sent_msgs;
 	int i;
 	uint64_t total_pkts_to_tx;
 	uint64_t packets_to_send;
 	uint32_t packetsize = 64;
 
 	setup_send_buffers_common(msg, iov_out, tx_buf);
 
 	while (packetsize <= KNET_MAX_PACKET_SIZE) {
 		for (i = 0; i < PCKT_FRAG_MAX; i++) {
 			iov_out[i].iov_len = packetsize;
 		}
 
 		total_pkts_to_tx = perf_by_size_size / packetsize;
 		printf("Testing with %u packet size. Total bytes to transfer: %" PRIu64 " (%" PRIu64 " packets)\n", packetsize, perf_by_size_size, total_pkts_to_tx);
 
 		memset(ctrl_message, 0, sizeof(ctrl_message));
 		knet_send(knet_h, ctrl_message, TEST_START, channel);
 
 		while (total_pkts_to_tx > 0) {
 			if (total_pkts_to_tx >= PCKT_FRAG_MAX) {
 				packets_to_send = PCKT_FRAG_MAX;
 			} else {
 				packets_to_send = total_pkts_to_tx;
 			}
 			sent_msgs = send_messages(&msg[0], packets_to_send);
 			if (sent_msgs < 0) {
 				printf("Something went wrong, aborting\n");
 				exit(FAIL);
 			}
 			total_pkts_to_tx = total_pkts_to_tx - sent_msgs;
 		}
 
 		sleep(2);
 
 		knet_send(knet_h, ctrl_message, TEST_STOP, channel);
 
 		if (packetsize == KNET_MAX_PACKET_SIZE) {
 			break;
 		}
 
 		/*
 		 * Use a multiplier that can always divide properly a GB
 		 * into smaller chunks without worry about boundaries
 		 */
 		packetsize *= 4;
 
 		if (packetsize > KNET_MAX_PACKET_SIZE) {
 			packetsize = KNET_MAX_PACKET_SIZE;
 		}
 	}
 
 	knet_send(knet_h, ctrl_message, TEST_COMPLETE, channel);
 
 	for (i = 0; i < PCKT_FRAG_MAX; i++) {
 		free(tx_buf[i]);
 	}
 }
 
 /* For sorting the node list into order */
 static int node_compare(const void *aptr, const void *bptr)
 {
 	uint16_t a,b;
 
 	a = *(uint16_t *)aptr;
 	b = *(uint16_t *)bptr;
 
 	return a > b;
 }
 
 static void display_stats(int level)
 {
 	struct knet_handle_stats handle_stats;
 	struct knet_link_status link_status;
 	struct knet_link_stats total_link_stats;
 	knet_node_id_t host_list[KNET_MAX_HOST];
 	uint8_t link_list[KNET_MAX_LINK];
 	int res;
 	unsigned int i,j;
 	size_t num_hosts, num_links;
 
 	res = knet_handle_get_stats(knet_h, &handle_stats, sizeof(handle_stats));
 	if (res) {
 		perror("Failed to get knet handle stats");
 		return;
 	}
 	if (compresscfg || cryptocfg) {
 		printf("\n");
 		printf("handle stats\n");
 		printf("------------\n");
 		if (compresscfg) {
 			printf(" tx_uncompressed_packets: %" PRIu64 "\n", handle_stats.tx_uncompressed_packets);
 			printf(" tx_compressed_packets: %" PRIu64 "\n", handle_stats.tx_compressed_packets);
 			printf(" tx_compressed_original_bytes: %" PRIu64 "\n", handle_stats.tx_compressed_original_bytes);
 			printf(" tx_compressed_size_bytes: %" PRIu64 "\n", handle_stats.tx_compressed_size_bytes );
 			printf(" tx_compress_time_ave: %" PRIu64 "\n", handle_stats.tx_compress_time_ave);
 			printf(" tx_compress_time_min: %" PRIu64 "\n", handle_stats.tx_compress_time_min);
 			printf(" tx_compress_time_max: %" PRIu64 "\n", handle_stats.tx_compress_time_max);
 			printf(" rx_compressed_packets: %" PRIu64 "\n", handle_stats.rx_compressed_packets);
 			printf(" rx_compressed_original_bytes: %" PRIu64 "\n", handle_stats.rx_compressed_original_bytes);
 			printf(" rx_compressed_size_bytes: %" PRIu64 "\n", handle_stats.rx_compressed_size_bytes);
 			printf(" rx_compress_time_ave: %" PRIu64 "\n", handle_stats.rx_compress_time_ave);
 			printf(" rx_compress_time_min: %" PRIu64 "\n", handle_stats.rx_compress_time_min);
 			printf(" rx_compress_time_max: %" PRIu64 "\n", handle_stats.rx_compress_time_max);
 			printf("\n");
 		}
 		if (cryptocfg) {
 			printf(" tx_crypt_packets: %" PRIu64 "\n", handle_stats.tx_crypt_packets);
 			printf(" tx_crypt_byte_overhead: %" PRIu64 "\n", handle_stats.tx_crypt_byte_overhead);
 			printf(" tx_crypt_time_ave: %" PRIu64 "\n", handle_stats.tx_crypt_time_ave);
 			printf(" tx_crypt_time_min: %" PRIu64 "\n", handle_stats.tx_crypt_time_min);
 			printf(" tx_crypt_time_max: %" PRIu64 "\n", handle_stats.tx_crypt_time_max);
 			printf(" rx_crypt_packets: %" PRIu64 "\n", handle_stats.rx_crypt_packets);
 			printf(" rx_crypt_time_ave: %" PRIu64 "\n", handle_stats.rx_crypt_time_ave);
 			printf(" rx_crypt_time_min: %" PRIu64 "\n", handle_stats.rx_crypt_time_min);
 			printf(" rx_crypt_time_max: %" PRIu64 "\n", handle_stats.rx_crypt_time_max);
 			printf("\n");
 		}
 	}
 	if (level < 2) {
 		return;
 	}
 
 	memset(&total_link_stats, 0, sizeof(struct knet_link_stats));
 
 	res = knet_host_get_host_list(knet_h, host_list, &num_hosts);
 	if (res) {
 		perror("Cannot get host list for stats");
 		return;
 	}
 
 	/* Print in host ID order */
 	qsort(host_list, num_hosts, sizeof(uint16_t), node_compare);
 
 	for (j=0; j<num_hosts; j++) {
 		res = knet_link_get_link_list(knet_h, host_list[j], link_list, &num_links);
 		if (res) {
 			perror("Cannot get link list for stats");
 			return;
 		}
 
 		for (i=0; i < num_links; i++) {
 			res = knet_link_get_status(knet_h,
 						   host_list[j],
 						   link_list[i],
 						   &link_status,
 						   sizeof(link_status));
 
 			total_link_stats.tx_data_packets += link_status.stats.tx_data_packets;
 			total_link_stats.rx_data_packets += link_status.stats.rx_data_packets;
 			total_link_stats.tx_data_bytes += link_status.stats.tx_data_bytes;
 			total_link_stats.rx_data_bytes += link_status.stats.rx_data_bytes;
 			total_link_stats.rx_ping_packets += link_status.stats.rx_ping_packets;
 			total_link_stats.tx_ping_packets += link_status.stats.tx_ping_packets;
 			total_link_stats.rx_ping_bytes += link_status.stats.rx_ping_bytes;
 			total_link_stats.tx_ping_bytes += link_status.stats.tx_ping_bytes;
 			total_link_stats.rx_pong_packets += link_status.stats.rx_pong_packets;
 			total_link_stats.tx_pong_packets += link_status.stats.tx_pong_packets;
 			total_link_stats.rx_pong_bytes += link_status.stats.rx_pong_bytes;
 			total_link_stats.tx_pong_bytes += link_status.stats.tx_pong_bytes;
 			total_link_stats.rx_pmtu_packets += link_status.stats.rx_pmtu_packets;
 			total_link_stats.tx_pmtu_packets += link_status.stats.tx_pmtu_packets;
 			total_link_stats.rx_pmtu_bytes += link_status.stats.rx_pmtu_bytes;
 			total_link_stats.tx_pmtu_bytes += link_status.stats.tx_pmtu_bytes;
 
 			total_link_stats.tx_total_packets += link_status.stats.tx_total_packets;
 			total_link_stats.rx_total_packets += link_status.stats.rx_total_packets;
 			total_link_stats.tx_total_bytes += link_status.stats.tx_total_bytes;
 			total_link_stats.rx_total_bytes += link_status.stats.rx_total_bytes;
 			total_link_stats.tx_total_errors += link_status.stats.tx_total_errors;
 			total_link_stats.tx_total_retries += link_status.stats.tx_total_retries;
 
 			total_link_stats.tx_pmtu_errors += link_status.stats.tx_pmtu_errors;
 			total_link_stats.tx_pmtu_retries += link_status.stats.tx_pmtu_retries;
 			total_link_stats.tx_ping_errors += link_status.stats.tx_ping_errors;
 			total_link_stats.tx_ping_retries += link_status.stats.tx_ping_retries;
 			total_link_stats.tx_pong_errors += link_status.stats.tx_pong_errors;
 			total_link_stats.tx_pong_retries += link_status.stats.tx_pong_retries;
 			total_link_stats.tx_data_errors += link_status.stats.tx_data_errors;
 			total_link_stats.tx_data_retries += link_status.stats.tx_data_retries;
 
 			total_link_stats.down_count += link_status.stats.down_count;
 			total_link_stats.up_count += link_status.stats.up_count;
 
 			if (level > 2) {
 				printf("\n");
 				printf("Node %d Link %d\n", host_list[j], link_list[i]);
 
 				printf("  tx_data_packets:  %" PRIu64 "\n", link_status.stats.tx_data_packets);
 				printf("  rx_data_packets:  %" PRIu64 "\n", link_status.stats.rx_data_packets);
 				printf("  tx_data_bytes:    %" PRIu64 "\n", link_status.stats.tx_data_bytes);
 				printf("  rx_data_bytes:    %" PRIu64 "\n", link_status.stats.rx_data_bytes);
 				printf("  rx_ping_packets:  %" PRIu64 "\n", link_status.stats.rx_ping_packets);
 				printf("  tx_ping_packets:  %" PRIu64 "\n", link_status.stats.tx_ping_packets);
 				printf("  rx_ping_bytes:    %" PRIu64 "\n", link_status.stats.rx_ping_bytes);
 				printf("  tx_ping_bytes:    %" PRIu64 "\n", link_status.stats.tx_ping_bytes);
 				printf("  rx_pong_packets:  %" PRIu64 "\n", link_status.stats.rx_pong_packets);
 				printf("  tx_pong_packets:  %" PRIu64 "\n", link_status.stats.tx_pong_packets);
 				printf("  rx_pong_bytes:    %" PRIu64 "\n", link_status.stats.rx_pong_bytes);
 				printf("  tx_pong_bytes:    %" PRIu64 "\n", link_status.stats.tx_pong_bytes);
 				printf("  rx_pmtu_packets:  %" PRIu64 "\n", link_status.stats.rx_pmtu_packets);
 				printf("  tx_pmtu_packets:  %" PRIu64 "\n", link_status.stats.tx_pmtu_packets);
 				printf("  rx_pmtu_bytes:    %" PRIu64 "\n", link_status.stats.rx_pmtu_bytes);
 				printf("  tx_pmtu_bytes:    %" PRIu64 "\n", link_status.stats.tx_pmtu_bytes);
 
 				printf("  tx_total_packets: %" PRIu64 "\n", link_status.stats.tx_total_packets);
 				printf("  rx_total_packets: %" PRIu64 "\n", link_status.stats.rx_total_packets);
 				printf("  tx_total_bytes:   %" PRIu64 "\n", link_status.stats.tx_total_bytes);
 				printf("  rx_total_bytes:   %" PRIu64 "\n", link_status.stats.rx_total_bytes);
 				printf("  tx_total_errors:  %" PRIu64 "\n", link_status.stats.tx_total_errors);
 				printf("  tx_total_retries: %" PRIu64 "\n", link_status.stats.tx_total_retries);
 
 				printf("  tx_pmtu_errors:   %" PRIu32 "\n", link_status.stats.tx_pmtu_errors);
 				printf("  tx_pmtu_retries:  %" PRIu32 "\n", link_status.stats.tx_pmtu_retries);
 				printf("  tx_ping_errors:   %" PRIu32 "\n", link_status.stats.tx_ping_errors);
 				printf("  tx_ping_retries:  %" PRIu32 "\n", link_status.stats.tx_ping_retries);
 				printf("  tx_pong_errors:   %" PRIu32 "\n", link_status.stats.tx_pong_errors);
 				printf("  tx_pong_retries:  %" PRIu32 "\n", link_status.stats.tx_pong_retries);
 				printf("  tx_data_errors:   %" PRIu32 "\n", link_status.stats.tx_data_errors);
 				printf("  tx_data_retries:  %" PRIu32 "\n", link_status.stats.tx_data_retries);
 
 				printf("  latency_min:      %" PRIu32 "\n", link_status.stats.latency_min);
 				printf("  latency_max:      %" PRIu32 "\n", link_status.stats.latency_max);
 				printf("  latency_ave:      %" PRIu32 "\n", link_status.stats.latency_ave);
 				printf("  latency_samples:  %" PRIu32 "\n", link_status.stats.latency_samples);
 
 				printf("  down_count:       %" PRIu32 "\n", link_status.stats.down_count);
 				printf("  up_count:         %" PRIu32 "\n", link_status.stats.up_count);
 			}
 		}
 	}
 	printf("\n");
 	printf("Total link stats\n");
 	printf("----------------\n");
 	printf("tx_data_packets:  %" PRIu64 "\n", total_link_stats.tx_data_packets);
 	printf("rx_data_packets:  %" PRIu64 "\n", total_link_stats.rx_data_packets);
 	printf("tx_data_bytes:    %" PRIu64 "\n", total_link_stats.tx_data_bytes);
 	printf("rx_data_bytes:    %" PRIu64 "\n", total_link_stats.rx_data_bytes);
 	printf("rx_ping_packets:  %" PRIu64 "\n", total_link_stats.rx_ping_packets);
 	printf("tx_ping_packets:  %" PRIu64 "\n", total_link_stats.tx_ping_packets);
 	printf("rx_ping_bytes:    %" PRIu64 "\n", total_link_stats.rx_ping_bytes);
 	printf("tx_ping_bytes:    %" PRIu64 "\n", total_link_stats.tx_ping_bytes);
 	printf("rx_pong_packets:  %" PRIu64 "\n", total_link_stats.rx_pong_packets);
 	printf("tx_pong_packets:  %" PRIu64 "\n", total_link_stats.tx_pong_packets);
 	printf("rx_pong_bytes:    %" PRIu64 "\n", total_link_stats.rx_pong_bytes);
 	printf("tx_pong_bytes:    %" PRIu64 "\n", total_link_stats.tx_pong_bytes);
 	printf("rx_pmtu_packets:  %" PRIu64 "\n", total_link_stats.rx_pmtu_packets);
 	printf("tx_pmtu_packets:  %" PRIu64 "\n", total_link_stats.tx_pmtu_packets);
 	printf("rx_pmtu_bytes:    %" PRIu64 "\n", total_link_stats.rx_pmtu_bytes);
 	printf("tx_pmtu_bytes:    %" PRIu64 "\n", total_link_stats.tx_pmtu_bytes);
 
 	printf("tx_total_packets: %" PRIu64 "\n", total_link_stats.tx_total_packets);
 	printf("rx_total_packets: %" PRIu64 "\n", total_link_stats.rx_total_packets);
 	printf("tx_total_bytes:   %" PRIu64 "\n", total_link_stats.tx_total_bytes);
 	printf("rx_total_bytes:   %" PRIu64 "\n", total_link_stats.rx_total_bytes);
 	printf("tx_total_errors:  %" PRIu64 "\n", total_link_stats.tx_total_errors);
 	printf("tx_total_retries: %" PRIu64 "\n", total_link_stats.tx_total_retries);
 
 	printf("tx_pmtu_errors:   %" PRIu32 "\n", total_link_stats.tx_pmtu_errors);
 	printf("tx_pmtu_retries:  %" PRIu32 "\n", total_link_stats.tx_pmtu_retries);
 	printf("tx_ping_errors:   %" PRIu32 "\n", total_link_stats.tx_ping_errors);
 	printf("tx_ping_retries:  %" PRIu32 "\n", total_link_stats.tx_ping_retries);
 	printf("tx_pong_errors:   %" PRIu32 "\n", total_link_stats.tx_pong_errors);
 	printf("tx_pong_retries:  %" PRIu32 "\n", total_link_stats.tx_pong_retries);
 	printf("tx_data_errors:   %" PRIu32 "\n", total_link_stats.tx_data_errors);
 	printf("tx_data_retries:  %" PRIu32 "\n", total_link_stats.tx_data_retries);
 
 	printf("down_count:       %" PRIu32 "\n", total_link_stats.down_count);
 	printf("up_count:         %" PRIu32 "\n", total_link_stats.up_count);
 
 }
 
 static void send_perf_data_by_time(void)
 {
 	char *tx_buf[PCKT_FRAG_MAX];
 	struct knet_mmsghdr msg[PCKT_FRAG_MAX];
 	struct iovec iov_out[PCKT_FRAG_MAX];
 	char ctrl_message[16];
 	int sent_msgs;
 	int i;
 	uint32_t packetsize = 65536;
 	struct timespec clock_start, clock_end;
 	unsigned long long time_diff = 0;
 
 	setup_send_buffers_common(msg, iov_out, tx_buf);
 
 	memset(&clock_start, 0, sizeof(clock_start));
 	memset(&clock_end, 0, sizeof(clock_start));
 
 	while (packetsize <= KNET_MAX_PACKET_SIZE) {
 		for (i = 0; i < PCKT_FRAG_MAX; i++) {
 			iov_out[i].iov_len = packetsize;
 		}
 		printf("Testing with %u bytes packet size for %" PRIu64 " seconds.\n", packetsize, perf_by_time_secs);
 
 		memset(ctrl_message, 0, sizeof(ctrl_message));
 		knet_send(knet_h, ctrl_message, TEST_START, channel);
 
 		if (clock_gettime(CLOCK_MONOTONIC, &clock_start) != 0) {
 			printf("Unable to get start time!\n");
 		}
 
 		time_diff = 0;
 
 		while (time_diff < (perf_by_time_secs * 1000000000llu)) {
 			sent_msgs = send_messages(&msg[0], PCKT_FRAG_MAX);
 			if (sent_msgs < 0) {
 				printf("Something went wrong, aborting\n");
 				exit(FAIL);
 			}
 			if (clock_gettime(CLOCK_MONOTONIC, &clock_end) != 0) {
 				printf("Unable to get end time!\n");
 			}
 			timespec_diff(clock_start, clock_end, &time_diff);
 		}
 
 		sleep(2);
 
 		knet_send(knet_h, ctrl_message, TEST_STOP, channel);
 
 		if (packetsize == KNET_MAX_PACKET_SIZE) {
 			break;
 		}
 
 		/*
 		 * Use a multiplier that can always divide properly a GB
 		 * into smaller chunks without worry about boundaries
 		 */
 		packetsize *= 4;
 
 		if (packetsize > KNET_MAX_PACKET_SIZE) {
 			packetsize = KNET_MAX_PACKET_SIZE;
 		}
 	}
 
 	knet_send(knet_h, ctrl_message, TEST_COMPLETE, channel);
 
 	for (i = 0; i < PCKT_FRAG_MAX; i++) {
 		free(tx_buf[i]);
 	}
 }
 
 static void cleanup_all(void)
 {
 	if (pthread_mutex_lock(&shutdown_mutex)) {
 		return;
 	}
 
 	if (bench_shutdown_in_progress) {
 		pthread_mutex_unlock(&shutdown_mutex);
 		return;
 	}
 
 	bench_shutdown_in_progress = 1;
 
 	pthread_mutex_unlock(&shutdown_mutex);
 
 	if (rx_thread) {
 		stop_rx_thread();
 	}
 	knet_handle_stop(knet_h);
 }
 
 static void sigint_handler(int signum)
 {
 	printf("Cleaning up... got signal: %d\n", signum);
 	cleanup_all();
 	exit(PASS);
 }
 
 int main(int argc, char *argv[])
 {
 	if (signal(SIGINT, sigint_handler) == SIG_ERR) {
 		printf("Unable to configure SIGINT handler\n");
 		exit(FAIL);
 	}
 
-	need_root();
-
 	setup_knet(argc, argv);
 
 	setup_data_txrx_common();
 
 	sleep(5);
 
 restart:
 	switch(test_type) {
 		default:
 		case TEST_PING: /* basic ping, no data */
 			sleep(5);
 			break;
 		case TEST_PING_AND_DATA:
 			send_ping_data();
 			break;
 		case TEST_PERF_BY_SIZE:
 			if (senderid == thisnodeid) {
 				send_perf_data_by_size();
 			} else {
 				printf("Waiting for perf rx thread to finish\n");
 				while(!wait_for_perf_rx) {
 					sleep(1);
 				}
 			}
 			break;
 		case TEST_PERF_BY_TIME:
 			if (senderid == thisnodeid) {
 				send_perf_data_by_time();
 			} else {
 				printf("Waiting for perf rx thread to finish\n");
 				while(!wait_for_perf_rx) {
 					sleep(1);
 				}
 			}
 			break;
 	}
 	if (continous) {
 		goto restart;
 	}
 	if (show_stats) {
 		display_stats(show_stats);
 	}
 
 	cleanup_all();
 
 	return PASS;
 }
diff --git a/libknet/tests/test-common.c b/libknet/tests/test-common.c
index ecbf3530..fb58021a 100644
--- a/libknet/tests/test-common.c
+++ b/libknet/tests/test-common.c
@@ -1,502 +1,492 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Author: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <errno.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <sys/select.h>
 
 #include "libknet.h"
 #include "test-common.h"
 
 static pthread_mutex_t log_mutex = PTHREAD_MUTEX_INITIALIZER;
 static int log_init = 0;
 static pthread_mutex_t log_thread_mutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_t log_thread;
 static int log_thread_init = 0;
 static int log_fds[2];
 struct log_thread_data {
 	int logfd;
 	FILE *std;
 };
 static struct log_thread_data data;
 static pthread_mutex_t shutdown_mutex = PTHREAD_MUTEX_INITIALIZER;
 static int shutdown_in_progress = 0;
 
 static int _read_pipe(int fd, char **file, size_t *length)
 {
 	char buf[4096];
 	int n;
 	int done = 0;
 
 	*file = NULL;
 	*length = 0;
 
 	memset(buf, 0, sizeof(buf));
 
 	while (!done) {
 
 		n = read(fd, buf, sizeof(buf));
 
 		if (n < 0) {
 			if (errno == EINTR)
 				continue;
 
 			if (*file)
 				free(*file);
 
 			return n;
 		}
 
 		if (n == 0 && (!*length))
 			return 0;
 
 		if (n == 0)
 			done = 1;
 
 		if (*file)
 			*file = realloc(*file, (*length) + n + done);
 		else
 			*file = malloc(n + done);
 
 		if (!*file)
 			return -1;
 
 		memmove((*file) + (*length), buf, n);
 		*length += (done + n);
 	}
 
 	/* Null terminator */
 	(*file)[(*length) - 1] = 0;
 
 	return 0;
 }
 
 int execute_shell(const char *command, char **error_string)
 {
 	pid_t pid;
 	int status, err = 0;
 	int fd[2];
 	size_t size = 0;
 
 	if ((command == NULL) || (!error_string)) {
 		errno = EINVAL;
 		return FAIL;
 	}
 
 	*error_string = NULL;
 
 	err = pipe(fd);
 	if (err)
 		goto out_clean;
 
 	pid = fork();
 	if (pid < 0) {
 		err = pid;
 		goto out_clean;
 	}
 
 	if (pid) { /* parent */
 
 		close(fd[1]);
 		err = _read_pipe(fd[0], error_string, &size);
 		if (err)
 			goto out_clean0;
 
 		waitpid(pid, &status, 0);
 		if (!WIFEXITED(status)) {
 			err = -1;
 			goto out_clean0;
 		}
 		if (WIFEXITED(status) && WEXITSTATUS(status) != 0) {
 			err = WEXITSTATUS(status);
 			goto out_clean0;
 		}
 		goto out_clean0;
 	} else { /* child */
 		close(0);
 		close(1);
 		close(2);
 
 		close(fd[0]);
 		dup2(fd[1], 1);
 		dup2(fd[1], 2);
 		close(fd[1]);
 
 		execlp("/bin/sh", "/bin/sh", "-c", command, NULL);
 		exit(FAIL);
 	}
 
 out_clean:
 	close(fd[1]);
 out_clean0:
 	close(fd[0]);
 
 	return err;
 }
 
 int is_memcheck(void)
 {
 	char *val;
 
 	val = getenv("KNETMEMCHECK");
 
 	if (val) {
 		if (!strncmp(val, "yes", 3)) {
 			return 1;
 		}
 	}
 
 	return 0;
 }
 
 int is_helgrind(void)
 {
 	char *val;
 
 	val = getenv("KNETHELGRIND");
 
 	if (val) {
 		if (!strncmp(val, "yes", 3)) {
 			return 1;
 		}
 	}
 
 	return 0;
 }
 
-int need_root(void)
-{
-	if (geteuid() != 0) {
-		printf("This test requires root privileges\n");
-		exit(SKIP);
-	}
-
-	return PASS;
-}
-
 void set_scheduler(int policy)
 {
 	struct sched_param sched_param;
 	int err;
 
 	err = sched_get_priority_max(policy);
 	if (err < 0) {
 		printf("Could not get maximum scheduler priority\n");
 		exit(FAIL);
 	}
 	sched_param.sched_priority = err;
 	err = sched_setscheduler(0, policy, &sched_param);
 	if (err < 0) {
 		printf("Could not set priority\n");
 		exit(FAIL);
 	}
 	return;
 }
 
 int setup_logpipes(int *logfds)
 {
 	if (pipe2(logfds, O_CLOEXEC | O_NONBLOCK) < 0) {
 		printf("Unable to setup logging pipe\n");
 		exit(FAIL);
 	}
 
 	return PASS;
 }
 
 void close_logpipes(int *logfds)
 {
 	close(logfds[0]);
 	logfds[0] = 0;
 	close(logfds[1]);
 	logfds[1] = 0;
 }
 
 void flush_logs(int logfd, FILE *std)
 {
 	struct knet_log_msg msg;
 	size_t bytes_read;
 	int len;
 
 next:
 	len = 0;
 	bytes_read = 0;
 	memset(&msg, 0, sizeof(struct knet_log_msg));
 
 	while (bytes_read < sizeof(struct knet_log_msg)) {
 		len = read(logfd, &msg + bytes_read,
 			   sizeof(struct knet_log_msg) - bytes_read);
 		if (len <= 0) {
 			return;
 		}
 		bytes_read += len;
 	}
 
 	if (len > 0) {
 		fprintf(std, "knet logs: [%s] %s: %s\n",
 			knet_log_get_loglevel_name(msg.msglevel),
 			knet_log_get_subsystem_name(msg.subsystem),
 			msg.msg);
 		goto next;
 	}
 }
 
 static void *_logthread(void *args)
 {
 	fd_set rfds;
 	ssize_t len;
 	struct timeval tv;
 
 select_loop:
 	tv.tv_sec = 60;
 	tv.tv_usec = 0;
 
 	FD_ZERO(&rfds);
 	FD_SET(data.logfd, &rfds);
 
 	len = select(FD_SETSIZE, &rfds, NULL, NULL, &tv);
 	if (len < 0) {
 		fprintf(data.std, "Unable select over logfd!\nHALTING LOGTHREAD!\n");
 		return NULL;
 	}
 	if (!len) {
 		fprintf(data.std, "knet logs: No logs in the last 60 seconds\n");
 	}
 	if (FD_ISSET(data.logfd, &rfds)) {
 		flush_logs(data.logfd, data.std);
 	}
 	goto select_loop;
 
 	return NULL;
 }
 
 int start_logthread(int logfd, FILE *std)
 {
 	int savederrno = 0;
 
 	savederrno = pthread_mutex_lock(&log_thread_mutex);
 	if (savederrno) {
 		printf("Unable to get log_thread mutex lock\n");
 		return -1;
 	}
 
 	if (!log_thread_init) {
 		data.logfd = logfd;
 		data.std = std;
 
 		savederrno = pthread_create(&log_thread, 0, _logthread, NULL);
 		if (savederrno) {
 			printf("Unable to start logging thread: %s\n", strerror(savederrno));
 			pthread_mutex_unlock(&log_thread_mutex);
 			return -1;
 		}
 		log_thread_init = 1;
 	}
 
 	pthread_mutex_unlock(&log_thread_mutex);
 	return 0;
 }
 
 int stop_logthread(void)
 {
 	int savederrno = 0;
 	void *retval;
 
 	savederrno = pthread_mutex_lock(&log_thread_mutex);
 	if (savederrno) {
 		printf("Unable to get log_thread mutex lock\n");
 		return -1;
 	}
 
 	if (log_thread_init) {
 		pthread_cancel(log_thread);
 		pthread_join(log_thread, &retval);
 		log_thread_init = 0;
 	}
 
 	pthread_mutex_unlock(&log_thread_mutex);
 	return 0;
 }
 
 static void stop_logging(void)
 {
 	stop_logthread();
 	flush_logs(log_fds[0], stdout);
 	close_logpipes(log_fds);
 }
 
 int start_logging(FILE *std)
 {
 	int savederrno = 0;
 
 	savederrno = pthread_mutex_lock(&log_mutex);
 	if (savederrno) {
 		printf("Unable to get log_mutex lock\n");
 		return -1;
 	}
 
 	if (!log_init) {
 		setup_logpipes(log_fds);
 
 		if (atexit(&stop_logging) != 0) {
 			printf("Unable to register atexit handler to stop logging: %s\n",
 			       strerror(errno));
 			exit(FAIL);
 		}
 
 		if (start_logthread(log_fds[0], std) < 0) {
 			exit(FAIL);
 		}
 
 		log_init = 1;
 	}
 
 	pthread_mutex_unlock(&log_mutex);
 
 	return log_fds[1];
 }
 
 int knet_handle_stop(knet_handle_t knet_h)
 {
 	int savederrno;
 	size_t i, j;
 	knet_node_id_t host_ids[KNET_MAX_HOST];
 	uint8_t link_ids[KNET_MAX_LINK];
 	size_t host_ids_entries = 0, link_ids_entries = 0;
 	struct knet_link_status status;
 
 	savederrno = pthread_mutex_lock(&shutdown_mutex);
 	if (savederrno) {
 		printf("Unable to get shutdown mutex lock\n");
 		return -1;
 	}
 
 	if (shutdown_in_progress) {
 		pthread_mutex_unlock(&shutdown_mutex);
 		errno = EINVAL;
 		return -1;
 	}
 
 	shutdown_in_progress = 1;
 
 	pthread_mutex_unlock(&shutdown_mutex);
 
 	if (!knet_h) {
 		errno = EINVAL;
 		return -1;
 	}
 
 	if (knet_host_get_host_list(knet_h, host_ids, &host_ids_entries) < 0) {
 		printf("knet_host_get_host_list failed: %s\n", strerror(errno));
 		return -1;
 	}
 
 	for (i = 0; i < host_ids_entries; i++) {
 		if (knet_link_get_link_list(knet_h, host_ids[i], link_ids, &link_ids_entries)) {
 			printf("knet_link_get_link_list failed: %s\n", strerror(errno));
 			return -1;
 		}
 		for (j = 0; j < link_ids_entries; j++) {
 			if (knet_link_get_status(knet_h, host_ids[i], link_ids[j], &status, sizeof(struct knet_link_status))) {
 				printf("knet_link_get_status failed: %s\n", strerror(errno));
 				return -1;
 			}
 			if (status.enabled) {
 				if (knet_link_set_enable(knet_h, host_ids[i], j, 0)) {
 					printf("knet_link_set_enable failed: %s\n", strerror(errno));
 					return -1;
 				}
 			}
 			knet_link_clear_config(knet_h, host_ids[i], j);
 		}
 		if (knet_host_remove(knet_h, host_ids[i]) < 0) {
 			printf("knet_host_remove failed: %s\n", strerror(errno));
 			return -1;
 		}
 	}
 
 	if (knet_handle_free(knet_h)) {
 		printf("knet_handle_free failed: %s\n", strerror(errno));
 		return -1;
 	}
 	return 0;
 }
 
 int make_local_sockaddr(struct sockaddr_storage *lo, uint16_t offset)
 {
 	uint32_t port;
 	char portstr[32];
 
 	/* Use the pid if we can. but makes sure its in a sensible range */
 	port = (uint32_t)getpid() + offset;
 	if (port < 1024) {
 		port += 1024;
 	}
 	if (port > 65536) {
 		port = port & 0xFFFF;
 	}
 	sprintf(portstr, "%u", port);
 	memset(lo, 0, sizeof(struct sockaddr_storage));
 	printf("Using port %u\n", port);
 
 	return knet_strtoaddr("127.0.0.1", portstr, lo, sizeof(struct sockaddr_storage));
 }
 
 int wait_for_host(knet_handle_t knet_h, uint16_t host_id, int seconds, int logfd, FILE *std)
 {
 	int i = 0;
 
 	if (is_memcheck() || is_helgrind()) {
 		printf("Test suite is running under valgrind, adjusting wait_for_host timeout\n");
 		seconds = seconds * 16;
 	}
 
 	while (i < seconds) {
 		flush_logs(logfd, std);
 		if (knet_h->host_index[host_id]->status.reachable == 1) {
 			return 0;
 		}
 		printf("waiting host %u to be reachable for %d more seconds\n", host_id, seconds - i);
 		sleep(1);
 		i++;
 	}
 	return -1;
 }
 
 int wait_for_packet(knet_handle_t knet_h, int seconds, int datafd)
 {
 	fd_set rfds;
 	struct timeval tv;
 	int err = 0;
 
 	if (is_memcheck() || is_helgrind()) {
 		printf("Test suite is running under valgrind, adjusting wait_for_packet timeout\n");
 		seconds = seconds * 16;
 	}
 
 	FD_ZERO(&rfds);
 	FD_SET(datafd, &rfds);
 
 	tv.tv_sec = seconds;
 	tv.tv_usec = 0;
 
 	err = select(datafd+1, &rfds, NULL, NULL, &tv);
 	if ((err > 0) && (FD_ISSET(datafd, &rfds))) {
 		return 0;
 	}
 
 	return -1;
 }
diff --git a/libknet/tests/test-common.h b/libknet/tests/test-common.h
index efa7ab20..30d19718 100644
--- a/libknet/tests/test-common.h
+++ b/libknet/tests/test-common.h
@@ -1,74 +1,72 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #ifndef __KNET_TEST_COMMON_H__
 #define __KNET_TEST_COMMON_H__
 
 #include "internals.h"
 #include <sched.h>
 
 /*
  * error codes from automake test-driver
  */
 
 #define PASS	0
 #define SKIP	77
 #define ERROR	99
 #define FAIL	-1
 
 /* For *BSD compatibility */
 #ifndef s6_addr16
 #define s6_addr8  __u6_addr.__u6_addr8
 #define s6_addr16 __u6_addr.__u6_addr16
 #define s6_addr32 __u6_addr.__u6_addr32
 #endif
 
 /*
  * common facilities
  */
 
 int execute_shell(const char *command, char **error_string);
 
 int is_memcheck(void);
 int is_helgrind(void);
 
-int need_root(void);
-
 void set_scheduler(int policy);
 
 /*
  * consider moving this one as official API
  */
 int knet_handle_stop(knet_handle_t knet_h);
 
 /*
  * high level logging function.
  * automatically setup logpipes and start/stop logging thread.
  *
  * start_logging exit(FAIL) on error or fd to pass to knet_handle_new
  * and it will install an atexit handle to close logging properly
  *
  * WARNING: DO NOT use start_logging for api_ or int_ testing.
  * while start_logging would work just fine, the output
  * of the logs is more complex to read because of the way
  * the thread would interleave the output of printf from api_/int_ testing
  * with knet logs. Functionally speaking you get the exact same logs,
  * but a lot harder to read due to the thread latency in printing logs.
  */
 int start_logging(FILE *std);
 
 int setup_logpipes(int *logfds);
 void close_logpipes(int *logfds);
 void flush_logs(int logfd, FILE *std);
 int start_logthread(int logfd, FILE *std);
 int stop_logthread(void);
 int make_local_sockaddr(struct sockaddr_storage *lo, uint16_t offset);
 int wait_for_host(knet_handle_t knet_h, uint16_t host_id, int seconds, int logfd, FILE *std);
 int wait_for_packet(knet_handle_t knet_h, int seconds, int datafd);
 
 #endif
diff --git a/libknet/transport_common.c b/libknet/transport_common.c
index 7269d585..70145b29 100644
--- a/libknet/transport_common.c
+++ b/libknet/transport_common.c
@@ -1,348 +1,365 @@
 /*
  * Copyright (C) 2016-2017 Red Hat, Inc.  All rights reserved.
  *
  * Author: Fabio M. Di Nitto <fabbione@kronosnet.org>
  *
  * This software licensed under GPL-2.0+, LGPL-2.0+
  */
 
 #include "config.h"
 
 #include <unistd.h>
 #include <string.h>
 #include <errno.h>
 #include <pthread.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 
 #include "libknet.h"
 #include "compat.h"
 #include "host.h"
 #include "link.h"
 #include "logging.h"
 #include "common.h"
 #include "transport_common.h"
 
 /*
  * reuse Jan Friesse's compat layer as wrapper to drop usage of sendmmsg
  *
  * TODO: kill those wrappers once we work on packet delivery guaranteed
  */
 
 int _recvmmsg(int sockfd, struct knet_mmsghdr *msgvec, unsigned int vlen, unsigned int flags)
 {
 	int savederrno = 0, err = 0;
 	unsigned int i;
 
 	for (i = 0; i < vlen; i++) {
 		err = recvmsg(sockfd, &msgvec[i].msg_hdr, flags);
 		savederrno = errno;
 		if (err >= 0) {
 			msgvec[i].msg_len = err;
 		} else {
 			if ((i > 0) &&
 			    ((errno == EAGAIN) || (errno == EWOULDBLOCK))) {
 				savederrno = 0;
 			}
 			break;
 		}
 	}
 
 	errno = savederrno;
 	return ((i > 0) ? (int)i : err);
 }
 
 int _sendmmsg(int sockfd, struct knet_mmsghdr *msgvec, unsigned int vlen, unsigned int flags)
 {
 	int savederrno = 0, err = 0;
 	unsigned int i;
 
 	for (i = 0; i < vlen; i++) {
 		err = sendmsg(sockfd, &msgvec[i].msg_hdr, flags);
 		savederrno = errno;
 		if (err < 0) {
 			break;
 		}
 	}
 
 	errno = savederrno;
 	return ((i > 0) ? (int)i : err);
 }
 
+/* Assume neither of these constants can ever be zero */
+#ifndef SO_RCVBUFFORCE
+#define SO_RCVBUFFORCE 0
+#endif
+#ifndef SO_SNDBUFFORCE
+#define SO_SNDBUFFORCE 0
+#endif
+
+static int _configure_sockbuf (knet_handle_t knet_h, int sock, int option, int force, int target)
+{
+	int new_value;
+	socklen_t value_len = sizeof new_value;
+
+	if (setsockopt(sock, SOL_SOCKET, option, &target, sizeof target) == 0 &&
+	    getsockopt(sock, SOL_SOCKET, option, &new_value, &value_len) == 0) {
+		if (value_len == sizeof new_value && target <= new_value) {
+			return 0;
+		}
+		errno = ERANGE;
+	}
+
+	log_debug (knet_h, KNET_SUB_TRANSPORT, "Failed to set socket buffer via option %d to value %d: %s",
+		   option, target, strerror(errno));
+
+	if (force) {
+		if (setsockopt(sock, SOL_SOCKET, force, &target, sizeof target)) {
+			int savederrno = errno;
+			log_debug (knet_h, KNET_SUB_TRANSPORT,
+				   "Failed to set socket buffer via fallback option %d as well: %s",
+				   force, strerror(errno));
+			errno = savederrno;
+			return -1;
+		} else {
+			return 0;
+		}
+	} else {
+		return -1;
+	}
+}
+
 int _configure_common_socket(knet_handle_t knet_h, int sock, uint64_t flags, const char *type)
 {
 	int err = 0, savederrno = 0;
-	int value;
 
 	if (_fdset_cloexec(sock)) {
 		savederrno = errno;
 		err = -1;
 		log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set %s CLOEXEC socket opts: %s",
 			type, strerror(savederrno));
 		goto exit_error;
 	}
 
 	if (_fdset_nonblock(sock)) {
 		savederrno = errno;
 		err = -1;
 		log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set %s NONBLOCK socket opts: %s",
 			type, strerror(savederrno));
 		goto exit_error;
 	}
 
-	value = KNET_RING_RCVBUFF;
-#ifdef SO_RCVBUFFORCE
-	if (setsockopt(sock, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0) {
+	if (_configure_sockbuf (knet_h, sock, SO_RCVBUF, SO_RCVBUFFORCE, KNET_RING_RCVBUFF)) {
 		savederrno = errno;
 		err = -1;
 		log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set %s receive buffer: %s",
 			type, strerror(savederrno));
 		goto exit_error;
 	}
-#else
-	if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0) {
-		savederrno = errno;
-		err = -1;
-		log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set %s SO_RECVBUF: %s",
-			type, strerror(savederrno));
-		goto exit_error;
-	}
-#endif
 
-	value = KNET_RING_RCVBUFF;
-#ifdef SO_SNDBUFFORCE
-	if (setsockopt(sock, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0) {
+	if (_configure_sockbuf (knet_h, sock, SO_SNDBUF, SO_SNDBUFFORCE, KNET_RING_RCVBUFF)) {
 		savederrno = errno;
 		err = -1;
 		log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set %s send buffer: %s",
 			type, strerror(savederrno));
 		goto exit_error;
 	}
-#else
-	if (setsockopt(sock, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0) {
-		savederrno = errno;
-		err = -1;
-		log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set %s SO_SNDBUF: %s",
-			type, strerror(savederrno));
-		goto exit_error;
-	}
-#endif
 
 #ifdef SO_PRIORITY
 	if (flags & KNET_LINK_FLAG_TRAFFICHIPRIO) {
-		value = 6; /* TC_PRIO_INTERACTIVE */
+		int value = 6; /* TC_PRIO_INTERACTIVE */
 		if (setsockopt(sock, SOL_SOCKET, SO_PRIORITY, &value, sizeof(value)) < 0) {
 			savederrno = errno;
 			err = -1;
 			log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set %s priority: %s",
 				type, strerror(savederrno));
 			goto exit_error;
 		}
 	}
 #endif
 #if defined(IP_TOS) && defined(IPTOS_LOWDELAY)
 	if (flags & KNET_LINK_FLAG_TRAFFICHIPRIO) {
-		value = IPTOS_LOWDELAY;
+		int value = IPTOS_LOWDELAY;
 		if (setsockopt(sock, IPPROTO_IP, IP_TOS, &value, sizeof(value)) < 0) {
 			savederrno = errno;
 			err = -1;
 			log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set %s priority: %s",
 				type, strerror(savederrno));
 			goto exit_error;
 		}
 	}
 #endif
 
 exit_error:
 	errno = savederrno;
 	return err;
 }
 
 int _configure_transport_socket(knet_handle_t knet_h, int sock, struct sockaddr_storage *address, uint64_t flags, const char *type)
 {
 	int err = 0, savederrno = 0;
 	int value;
 
 	if (_configure_common_socket(knet_h, sock, flags, type) < 0) {
 		savederrno = errno;
 		err = -1;
 		goto exit_error;
 	}
 
 #ifdef IP_FREEBIND
 	value = 1;
 	if (setsockopt(sock, SOL_IP, IP_FREEBIND, &value, sizeof(value)) <0) {
 		savederrno = errno;
 		err = -1;
 		log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set FREEBIND on %s socket: %s",
 			type, strerror(savederrno));
 		goto exit_error;
 	}
 #endif
 #ifdef IP_BINDANY /* BSD */
 	value = 1;
 	if (setsockopt(sock, IPPROTO_IP, IP_BINDANY, &value, sizeof(value)) <0) {
 		savederrno = errno;
 		err = -1;
 		log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set BINDANY on %s socket: %s",
 			type, strerror(savederrno));
 		goto exit_error;
 	}
 #endif
 
 	if (address->ss_family == AF_INET6) {
 		value = 1;
 		if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
 			       &value, sizeof(value)) < 0) {
 			savederrno = errno;
 			err = -1;
 			log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set %s IPv6 only: %s",
 				type, strerror(savederrno));
 			goto exit_error;
 
 		}
 #ifdef IPV6_MTU_DISCOVER
 		value = IPV6_PMTUDISC_PROBE;
 		if (setsockopt(sock, SOL_IPV6, IPV6_MTU_DISCOVER, &value, sizeof(value)) <0) {
 			savederrno = errno;
 			err = -1;
 			log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set PMTUDISC on %s socket: %s",
 				type, strerror(savederrno));
 			goto exit_error;
 		}
 #else
 		value = 1;
 		if (setsockopt(sock, IPPROTO_IPV6, IPV6_DONTFRAG, &value, sizeof(value)) <0) {
 			savederrno = errno;
 			err = -1;
 			log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set DONTFRAG on %s socket: %s",
 				type, strerror(savederrno));
 			goto exit_error;
 		}
 #endif
 	} else {
 #ifdef IP_MTU_DISCOVER
 		value = IP_PMTUDISC_PROBE;
 		if (setsockopt(sock, SOL_IP, IP_MTU_DISCOVER, &value, sizeof(value)) <0) {
 			savederrno = errno;
 			err = -1;
 			log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set PMTUDISC on %s socket: %s",
 				type, strerror(savederrno));
 			goto exit_error;
 		}
 #else
 		value = 1;
 		if (setsockopt(sock, IPPROTO_IP, IP_DONTFRAG, &value, sizeof(value)) <0) {
 			savederrno = errno;
 			err = -1;
 			log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set DONTFRAG on %s socket: %s",
 				type, strerror(savederrno));
 			goto exit_error;
 		}
 #endif
 	}
 
 	value = 1;
 	if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &value, sizeof(value)) < 0) {
 		savederrno = errno;
 		err = -1;
 		log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set %s reuseaddr: %s",
 			type, strerror(savederrno));
 		goto exit_error;
 	}
 
 exit_error:
 	errno = savederrno;
 	return err;
 }
 
 int _init_socketpair(knet_handle_t knet_h, int *sock)
 {
 	int err = 0, savederrno = 0;
 	int i;
 
 	if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sock) != 0) {
 		savederrno = errno;
 		err = -1;
 		log_err(knet_h, KNET_SUB_HANDLE, "Unable to initialize socketpair: %s",
 			strerror(savederrno));
 		goto exit_fail;
 	}
 
 	for (i = 0; i < 2; i++) {
 		if (_configure_common_socket(knet_h, sock[i], 0, "local socketpair") < 0) {
 			savederrno = errno;
 			err = -1;
 			goto exit_fail;
 		}
 	}
 
 exit_fail:
 	errno = savederrno;
 	return err;
 }
 
 void _close_socketpair(knet_handle_t knet_h, int *sock)
 {
 	int i;
 
 	for (i = 0; i < 2; i++) {
 		if (sock[i]) {
 			close(sock[i]);
 			sock[i] = 0;
 		}
 	}
 }
 
 /*
  * must be called with global read lock
  *
  * return -1 on error
  * return 0 if fd is invalid
  * return 1 if fd is valid
  */
 int _is_valid_fd(knet_handle_t knet_h, int sockfd)
 {
 	int ret = 0;
 
 	if (sockfd < 0) {
 		errno = EINVAL;
 		return -1;
 	}
 
 	if (sockfd > KNET_MAX_FDS) {
 		errno = EINVAL;
 		return -1;
 	}
 
 	if (knet_h->knet_transport_fd_tracker[sockfd].transport >= KNET_MAX_TRANSPORTS) {
 		ret = 0;
 	} else {
 		ret = 1;
 	}
 
 	return ret;
 }
 
 /*
  * must be called with global write lock
  */
 
 int _set_fd_tracker(knet_handle_t knet_h, int sockfd, uint8_t transport, uint8_t data_type, void *data)
 {
 	if (sockfd < 0) {
 		errno = EINVAL;
 		return -1;
 	}
 
 	if (sockfd > KNET_MAX_FDS) {
 		errno = EINVAL;
 		return -1;
 	}
 
 	knet_h->knet_transport_fd_tracker[sockfd].transport = transport;
 	knet_h->knet_transport_fd_tracker[sockfd].data_type = data_type;
 	knet_h->knet_transport_fd_tracker[sockfd].data = data;
 
 	return 0;
 }