No OneTemporary
Actions

Size

60 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/libknet/tests/api_knet_handle_clear_stats.c b/libknet/tests/api_knet_handle_clear_stats.c
	index 8e64235c..07f059a2 100644
	--- a/libknet/tests/api_knet_handle_clear_stats.c
	+++ b/libknet/tests/api_knet_handle_clear_stats.c
	@@ -1,288 +1,288 @@
	/*
	* Copyright (C) 2016-2019 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_start(logfds, KNET_LOG_DEBUG);

	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)) {
	+ if (wait_for_packet(knet_h, 10, datafd, logfds[0], stdout)) {
	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[])
	{
	test();

	return PASS;
	}
	diff --git a/libknet/tests/api_knet_send.c b/libknet/tests/api_knet_send.c
	index 6c255b92..57994fbc 100644
	--- a/libknet/tests/api_knet_send.c
	+++ b/libknet/tests/api_knet_send.c
	@@ -1,334 +1,334 @@
	/*
	* Copyright (C) 2016-2019 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(uint8_t transport)
	{
	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_start(logfds, KNET_LOG_DEBUG);

	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_access_lists(knet_h, 1) < 0) {
	printf("knet_handle_enable_access_lists failed: %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, transport, &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)) {
	+ if (wait_for_packet(knet_h, 10, datafd, logfds[0], stdout)) {
	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[])
	{
	printf("Testing with UDP\n");
	test(KNET_TRANSPORT_UDP);

	#ifdef HAVE_NETINET_SCTP_H
	printf("Testing with SCTP\n");
	test(KNET_TRANSPORT_SCTP);
	#endif

	return PASS;
	}
	diff --git a/libknet/tests/api_knet_send_compress.c b/libknet/tests/api_knet_send_compress.c
	index 6de46746..b03f4e73 100644
	--- a/libknet/tests/api_knet_send_compress.c
	+++ b/libknet/tests/api_knet_send_compress.c
	@@ -1,286 +1,286 @@
	/*
	* Copyright (C) 2016-2019 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_start(logfds, KNET_LOG_DEBUG);

	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)) {
	+ if (wait_for_packet(knet_h, 10, datafd, logfds[0], stdout)) {
	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[])
	{
	struct knet_compress_info compress_list[16];
	size_t compress_list_entries;
	size_t i;

	memset(compress_list, 0, sizeof(compress_list));

	if (knet_get_compress_list(compress_list, &compress_list_entries) < 0) {
	printf("knet_get_compress_list failed: %s\n", strerror(errno));
	return FAIL;
	}

	if (compress_list_entries == 0) {
	printf("no compression modules detected. Skipping\n");
	return SKIP;
	}

	test("none");

	for (i=0; i < compress_list_entries; i++) {
	test(compress_list[i].name);
	}

	return PASS;
	}
	diff --git a/libknet/tests/api_knet_send_crypto.c b/libknet/tests/api_knet_send_crypto.c
	index f2ca3662..e33a808a 100644
	--- a/libknet/tests/api_knet_send_crypto.c
	+++ b/libknet/tests/api_knet_send_crypto.c
	@@ -1,272 +1,272 @@
	/*
	* Copyright (C) 2016-2019 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_start(logfds, KNET_LOG_DEBUG);

	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)) {
	+ if (wait_for_packet(knet_h, 10, datafd, logfds[0], stdout)) {
	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[])
	{
	struct knet_crypto_info crypto_list[16];
	size_t crypto_list_entries;
	size_t i;

	#ifdef KNET_BSD
	if (is_memcheck() \|\| is_helgrind()) {
	printf("valgrind-freebsd cannot run this test properly. Skipping\n");
	return SKIP;
	}
	#endif

	memset(crypto_list, 0, sizeof(crypto_list));

	if (knet_get_crypto_list(crypto_list, &crypto_list_entries) < 0) {
	printf("knet_get_crypto_list failed: %s\n", strerror(errno));
	return FAIL;
	}

	if (crypto_list_entries == 0) {
	printf("no crypto modules detected. Skipping\n");
	return SKIP;
	}

	for (i=0; i < crypto_list_entries; i++) {
	test(crypto_list[i].name);
	}

	return PASS;
	}
	diff --git a/libknet/tests/api_knet_send_loopback.c b/libknet/tests/api_knet_send_loopback.c
	index 0cfd29f7..2feca685 100644
	--- a/libknet/tests/api_knet_send_loopback.c
	+++ b/libknet/tests/api_knet_send_loopback.c
	@@ -1,407 +1,407 @@
	/*
	* Copyright (C) 2016-2019 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_start(logfds, KNET_LOG_DEBUG);

	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_handle_enable_access_lists(knet_h, 1) < 0) {
	printf("knet_handle_enable_access_lists failed: %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, 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)) {
	+ if (wait_for_packet(knet_h, 10, datafd, logfds[0], stdout)) {
	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)) {
	+ if (wait_for_packet(knet_h, 10, datafd, logfds[0], stdout)) {
	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[])
	{
	test();

	return PASS;
	}
	diff --git a/libknet/tests/test-common.c b/libknet/tests/test-common.c
	index d0ea1ef8..a4ff2974 100644
	--- a/libknet/tests/test-common.c
	+++ b/libknet/tests/test-common.c
	@@ -1,521 +1,522 @@
	/*
	* Copyright (C) 2016-2019 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 stop_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;
	}

	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)
	{
	while (1) {
	struct knet_log_msg msg;

	for (size_t bytes_read = 0; bytes_read < sizeof(msg); ) {
	int len = read(logfd, &msg + bytes_read,
	sizeof(msg) - bytes_read);
	if (len <= 0) {
	/*
	* clear errno to avoid incorrect propagation
	*/
	errno = 0;
	return;
	}
	bytes_read += len;
	}

	fprintf(std, "[knet]: [%s] %s: %.*s\n",
	knet_log_get_loglevel_name(msg.msglevel),
	knet_log_get_subsystem_name(msg.subsystem),
	KNET_MAX_LOG_MSG_SIZE, msg.msg);
	}
	}

	static void _logthread(void args)
	{
	while (1) {
	int num;
	struct timeval tv = { 60, 0 };
	fd_set rfds;

	FD_ZERO(&rfds);
	FD_SET(data.logfd, &rfds);

	num = select(FD_SETSIZE, &rfds, NULL, NULL, &tv);
	if (num < 0) {
	fprintf(data.std, "Unable select over logfd!\nHALTING LOGTHREAD!\n");
	return NULL;
	}
	if (num == 0) {
	fprintf(data.std, "[knet]: No logs in the last 60 seconds\n");
	continue;
	}
	if (FD_ISSET(data.logfd, &rfds)) {
	flush_logs(data.logfd, data.std);
	}
	}
	}

	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];
	}

	knet_handle_t knet_handle_start(int logfds[2], uint8_t log_level)
	{
	knet_handle_t knet_h = knet_handle_new_ex(1, logfds[1], log_level, 0);

	if (knet_h) {
	return knet_h;
	} else {
	printf("knet_handle_new failed: %s\n", strerror(errno));
	flush_logs(logfds[0], stdout);
	close_logpipes(logfds);
	exit(FAIL);
	}
	}

	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 (stop_in_progress) {
	pthread_mutex_unlock(&shutdown_mutex);
	errno = EINVAL;
	return -1;
	}

	stop_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;
	}

	static int _make_local_sockaddr(struct sockaddr_storage *lo, uint16_t offset, int family)
	{
	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);

	if (family == AF_INET6) {
	return knet_strtoaddr("::1", portstr, lo, sizeof(struct sockaddr_storage));
	}
	return knet_strtoaddr("127.0.0.1", portstr, lo, sizeof(struct sockaddr_storage));
	}

	int make_local_sockaddr(struct sockaddr_storage *lo, uint16_t offset)
	{
	return _make_local_sockaddr(lo, offset, AF_INET);
	}

	int make_local_sockaddr6(struct sockaddr_storage *lo, uint16_t offset)
	{
	return _make_local_sockaddr(lo, offset, AF_INET6);
	}

	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)
	+int wait_for_packet(knet_handle_t knet_h, int seconds, int datafd, int logfd, FILE *std)
	{
	fd_set rfds;
	struct timeval tv;
	int err = 0, i = 0;

	if (is_memcheck() \|\| is_helgrind()) {
	printf("Test suite is running under valgrind, adjusting wait_for_packet timeout\n");
	seconds = seconds * 16;
	}

	try_again:
	FD_ZERO(&rfds);
	FD_SET(datafd, &rfds);

	- tv.tv_sec = seconds;
	+ tv.tv_sec = 1;
	tv.tv_usec = 0;

	err = select(datafd+1, &rfds, NULL, NULL, &tv);
	/*
	* on slow arches the first call to select can return 0.
	* pick an arbitrary 10 times loop (multiplied by waiting seconds)
	* before failing.
	*/
	- if ((!err) && (i < 10)) {
	+ if ((!err) && (i < seconds)) {
	+ flush_logs(logfd, std);
	i++;
	goto try_again;
	}
	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 8742f8d1..a498a098 100644
	--- a/libknet/tests/test-common.h
	+++ b/libknet/tests/test-common.h
	@@ -1,75 +1,75 @@
	/*
	* Copyright (C) 2016-2019 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);

	void set_scheduler(int policy);

	knet_handle_t knet_handle_start(int logfds[2], uint8_t log_level);

	/*
	* 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 make_local_sockaddr6(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);
	+int wait_for_packet(knet_handle_t knet_h, int seconds, int datafd, int logfd, FILE *std);

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Mon, Feb 24, 3:57 PM (1 h, 6 m ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1464316
Default Alt Text: (60 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions