Page MenuHomeClusterLabs Projects
Files F3687645

No OneTemporary
Actions

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
diff --git a/libknet/Makefile.am b/libknet/Makefile.am
index c0bd4cfa..a0672528 100644
--- a/libknet/Makefile.am
+++ b/libknet/Makefile.am
@@ -1,130 +1,135 @@
#
# Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
#
# Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
# Federico Simoncelli <fsimon@kronosnet.org>
#
# This software licensed under GPL-2.0+, LGPL-2.0+
#
MAINTAINERCLEANFILES = Makefile.in
include $(top_srcdir)/build-aux/check.mk
SYMFILE = libknet_exported_syms
EXTRA_DIST = $(SYMFILE)
SUBDIRS = . tests man
libversion = 1:0:0
# override global LIBS that pulls in lots of craft we don't need here
LIBS =
sources = \
common.c \
compat.c \
compress.c \
compress_zlib.c \
compress_lz4.c \
compress_lzo2.c \
compress_lzma.c \
compress_bzip2.c \
crypto.c \
crypto_nss.c \
crypto_openssl.c \
handle.c \
host.c \
links.c \
logging.c \
netutils.c \
threads_common.c \
threads_dsthandler.c \
threads_heartbeat.c \
threads_pmtud.c \
threads_rx.c \
threads_tx.c \
- transport_udp.c \
- transport_sctp.c \
+ transports.c \
+ transport_common.c \
transport_loopback.c \
- transport_common.c
+ transport_udp.c \
+ transport_sctp.c
include_HEADERS = libknet.h
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = libknet.pc
noinst_HEADERS = \
common.h \
compat.h \
compress.h \
compress_bzip2.h \
compress_bzip2_remap.h \
compress_lz4.h \
compress_lz4_remap.h \
compress_lzma.h \
compress_lzma_remap.h \
compress_lzo2.h \
compress_lzo2_remap.h \
compress_zlib.h \
compress_zlib_remap.h \
crypto.h \
crypto_nss.h \
crypto_nss_remap.h \
crypto_openssl.h \
crypto_openssl_remap.h \
host.h \
internals.h \
links.h \
logging.h \
netutils.h \
onwire.h \
remap.h \
threads_common.h \
threads_dsthandler.h \
threads_heartbeat.h \
threads_pmtud.h \
threads_rx.h \
threads_tx.h \
- transports.h
+ transports.h \
+ transport_common.h \
+ transport_loopback.h \
+ transport_udp.h \
+ transport_sctp.h
lib_LTLIBRARIES = libknet.la
libknet_la_SOURCES = $(sources)
libknet_la_CFLAGS = $(nss_CFLAGS) $(openssl_CFLAGS) \
$(zlib_CFLAGS) $(liblz4_CFLAGS) $(lzo2_CFLAGS) $(liblzma_CFLAGS) $(bzip2_CFLAGS)
EXTRA_libknet_la_DEPENDENCIES = $(SYMFILE)
libknet_la_LDFLAGS = -Wl,--version-script=$(srcdir)/$(SYMFILE) \
--export-dynamic \
-version-number $(libversion)
libknet_la_LIBADD = $(dl_LIBS) $(pthread_LIBS) $(rt_LIBS) $(m_LIBS)
noinst_PROGRAMS = crypto_canary compress_canary
crypto_canary_SOURCES = crypto_canary.c
crypto_canary_CFLAGS = $(nss_CFLAGS) $(openssl_CFLAGS)
crypto_canary_LDADD = $(nss_LIBS) $(openssl_LIBS)
compress_canary_SOURCES = compress_canary.c
compress_canary_CFLAGS = $(zlib_CFLAGS) $(liblz4_CFLAGS) $(lzo2_CFLAGS) $(liblzma_CFLAGS) $(bzip2_CFLAGS)
compress_canary_LDADD = $(zlib_LIBS) $(liblz4_LIBS) $(lzo2_LIBS) $(liblzma_LIBS) $(bzip2_LIBS)
dist_man_MANS = man
update-man-pages: doxyfile.stamp
doxyfile.stamp: Doxyfile
if MANPAGEUPDATES
$(DOXYGEN) Doxyfile
$(DOXY2MAN) -o $(abs_srcdir)/man -s 3 --short-pkg @PACKAGE_NAME@ --pkg "Kronosnet Programmer's Manual" $(builddir)/xml/libknet_8h.xml
else
@echo this system does not have doxy2man or doxygen installed. Unable to update man pages automatically.
endif
touch doxyfile.stamp
clean-local:
rm -rf doxyfile.stamp xml
diff --git a/libknet/compress.c b/libknet/compress.c
index c009c430..e2b4f7ba 100644
--- a/libknet/compress.c
+++ b/libknet/compress.c
@@ -1,483 +1,467 @@
/*
* Copyright (C) 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 <stdlib.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <time.h>
#include "internals.h"
#include "compress.h"
#include "logging.h"
#include "threads_common.h"
#ifdef BUILDCOMPZLIB
#include "compress_zlib.h"
#endif
#ifdef BUILDCOMPLZ4
#include "compress_lz4.h"
#endif
#ifdef BUILDCOMPLZO2
#include "compress_lzo2.h"
#endif
#ifdef BUILDCOMPLZMA
#include "compress_lzma.h"
#endif
#ifdef BUILDCOMPBZIP2
#include "compress_bzip2.h"
#endif
/*
* internal module switch data
*/
/*
* DO NOT CHANGE MODEL_ID HERE OR ONWIRE COMPATIBILITY
* WILL BREAK!
*
* always add before the last NULL/NULL/NULL.
*/
#define empty_module 0, NULL, 0, NULL, NULL, NULL, NULL, NULL, NULL },
compress_model_t compress_modules_cmds[] = {
{ "none", 0, empty_module
{ "zlib", 1,
#ifdef BUILDCOMPZLIB
1, zlib_load_lib, 0, NULL, NULL, NULL, zlib_val_level, zlib_compress, zlib_decompress },
#else
empty_module
#endif
{ "lz4", 2,
#ifdef BUILDCOMPLZ4
1, lz4_load_lib, 0, NULL, NULL, NULL, lz4_val_level, lz4_compress, lz4_decompress },
#else
empty_module
#endif
{ "lz4hc", 3,
#ifdef BUILDCOMPLZ4
1, lz4_load_lib, 0, NULL, NULL, NULL, lz4hc_val_level, lz4hc_compress, lz4_decompress },
#else
empty_module
#endif
{ "lzo2", 4,
#ifdef BUILDCOMPLZO2
1, lzo2_load_lib, 0, lzo2_is_init, lzo2_init, lzo2_fini, lzo2_val_level, lzo2_compress, lzo2_decompress },
#else
empty_module
#endif
{ "lzma", 5,
#ifdef BUILDCOMPLZMA
1, lzma_load_lib, 0, NULL, NULL, NULL, lzma_val_level, lzma_compress, lzma_decompress },
#else
empty_module
#endif
{ "bzip2", 6,
#ifdef BUILDCOMPBZIP2
1, bzip2_load_lib, 0, NULL, NULL, NULL, bzip2_val_level, bzip2_compress, bzip2_decompress },
#else
empty_module
#endif
{ NULL, 255, empty_module
};
static int max_model = 0;
static struct timespec last_load_failure;
static int compress_get_model(const char *model)
{
int idx = 0;
while (compress_modules_cmds[idx].model_name != NULL) {
if (!strcmp(compress_modules_cmds[idx].model_name, model)) {
return compress_modules_cmds[idx].model_id;
}
idx++;
}
return -1;
}
static int compress_get_max_model(void)
{
int idx = 0;
while (compress_modules_cmds[idx].model_name != NULL) {
idx++;
}
return idx - 1;
}
static int compress_is_valid_model(int compress_model)
{
int idx = 0;
while (compress_modules_cmds[idx].model_name != NULL) {
if ((compress_model == compress_modules_cmds[idx].model_id) &&
(compress_modules_cmds[idx].built_in == 1)) {
return 0;
}
idx++;
}
return -1;
}
static int val_level(
knet_handle_t knet_h,
int compress_model,
int compress_level)
{
return compress_modules_cmds[compress_model].val_level(knet_h, compress_level);
}
/*
* compress_check_lib_is_init needs to be invoked in a locked context!
*/
static int compress_check_lib_is_init(knet_handle_t knet_h, int cmp_model)
{
/*
* lack of a .is_init function means that the module does not require
* init per handle so we use a fake reference in the compress_int_data
* to identify that we already increased the libref for this handle
*/
if (compress_modules_cmds[cmp_model].loaded == 1) {
if (compress_modules_cmds[cmp_model].is_init == NULL) {
if (knet_h->compress_int_data[cmp_model] != NULL) {
return 1;
}
} else {
if (compress_modules_cmds[cmp_model].is_init(knet_h, cmp_model) == 1) {
return 1;
}
}
}
return 0;
}
/*
* compress_load_lib should _always_ be invoked in write lock context
*/
static int compress_load_lib(knet_handle_t knet_h, int cmp_model, int rate_limit)
{
struct timespec clock_now;
unsigned long long timediff;
/*
* checking again for paranoia and because
* compress_check_lib_is_init is usually invoked in read context
* and we need to switch from read to write locking in between.
* another thread might have init the library in the meantime
*/
if (compress_check_lib_is_init(knet_h, cmp_model)) {
return 0;
}
/*
* due to the fact that decompress can load libraries
* on demand, depending on the compress model selected
* on other nodes, it is possible for an attacker
* to send crafted packets to attempt to load libraries
* at random in a DoS fashion.
* If there is an error loading a library, then we want
* to rate_limit a retry to reload the library every X
* seconds to avoid a lock DoS that could greatly slow
* down libknet.
*/
if (rate_limit) {
if ((last_load_failure.tv_sec != 0) ||
(last_load_failure.tv_nsec != 0)) {
clock_gettime(CLOCK_MONOTONIC, &clock_now);
timespec_diff(last_load_failure, clock_now, &timediff);
if (timediff < 10000000000) {
errno = EAGAIN;
return -1;
}
}
}
if (compress_modules_cmds[cmp_model].loaded == 0) {
if (compress_modules_cmds[cmp_model].load_lib(knet_h) < 0) {
clock_gettime(CLOCK_MONOTONIC, &last_load_failure);
return -1;
}
compress_modules_cmds[cmp_model].loaded = 1;
}
if (compress_modules_cmds[cmp_model].init != NULL) {
if (compress_modules_cmds[cmp_model].init(knet_h, cmp_model) < 0) {
return -1;
}
} else {
knet_h->compress_int_data[cmp_model] = (void *)&"1";
}
return 0;
}
int compress_init(
knet_handle_t knet_h)
{
max_model = compress_get_max_model();
if (max_model > KNET_MAX_COMPRESS_METHODS) {
log_err(knet_h, KNET_SUB_COMPRESS, "Too many compress methods defined in compress.c.");
errno = EINVAL;
return -1;
}
memset(&last_load_failure, 0, sizeof(struct timespec));
return 0;
}
int compress_cfg(
knet_handle_t knet_h,
struct knet_handle_compress_cfg *knet_handle_compress_cfg)
{
int savederrno = 0, err = 0;
int cmp_model;
cmp_model = compress_get_model(knet_handle_compress_cfg->compress_model);
if (cmp_model < 0) {
log_err(knet_h, KNET_SUB_COMPRESS, "compress model %s not supported", knet_handle_compress_cfg->compress_model);
errno = EINVAL;
return -1;
}
log_debug(knet_h, KNET_SUB_COMPRESS,
"Initizializing compress module [%s/%d/%u]",
knet_handle_compress_cfg->compress_model, knet_handle_compress_cfg->compress_level, knet_handle_compress_cfg->compress_threshold);
if (cmp_model > 0) {
if (compress_modules_cmds[cmp_model].built_in == 0) {
log_err(knet_h, KNET_SUB_COMPRESS, "compress model %s support has not been built in. Please contact your vendor or fix the build", knet_handle_compress_cfg->compress_model);
errno = EINVAL;
return -1;
}
if (knet_handle_compress_cfg->compress_threshold > KNET_MAX_PACKET_SIZE) {
log_err(knet_h, KNET_SUB_COMPRESS, "compress threshold cannot be higher than KNET_MAX_PACKET_SIZE (%d).",
KNET_MAX_PACKET_SIZE);
errno = EINVAL;
return -1;
}
if (knet_handle_compress_cfg->compress_threshold == 0) {
knet_h->compress_threshold = KNET_COMPRESS_THRESHOLD;
log_debug(knet_h, KNET_SUB_COMPRESS, "resetting compression threshold to default (%d)", KNET_COMPRESS_THRESHOLD);
} else {
knet_h->compress_threshold = knet_handle_compress_cfg->compress_threshold;
}
savederrno = pthread_rwlock_rdlock(&shlib_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_COMPRESS, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
if (!compress_check_lib_is_init(knet_h, cmp_model)) {
/*
* need to switch to write lock, load the lib, and return with a write lock
* this is not racy because compress_load_lib is written idempotent.
*/
pthread_rwlock_unlock(&shlib_rwlock);
savederrno = pthread_rwlock_wrlock(&shlib_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_COMPRESS, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
if (compress_load_lib(knet_h, cmp_model, 0) < 0) {
savederrno = errno;
log_err(knet_h, KNET_SUB_COMPRESS, "Unable to load library: %s",
strerror(savederrno));
err = -1;
goto out_unlock;
}
}
if (val_level(knet_h, cmp_model, knet_handle_compress_cfg->compress_level) < 0) {
log_err(knet_h, KNET_SUB_COMPRESS, "compress level %d not supported for model %s",
knet_handle_compress_cfg->compress_level, knet_handle_compress_cfg->compress_model);
savederrno = EINVAL;
err = -1;
goto out_unlock;
}
out_unlock:
pthread_rwlock_unlock(&shlib_rwlock);
}
if (!err) {
knet_h->compress_model = cmp_model;
knet_h->compress_level = knet_handle_compress_cfg->compress_level;
} else {
knet_h->compress_model = 0;
}
errno = savederrno;
return err;
}
void compress_fini(
knet_handle_t knet_h,
int all)
{
int savederrno = 0;
int idx = 0;
savederrno = pthread_rwlock_wrlock(&shlib_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_COMPRESS, "Unable to get write lock: %s",
strerror(savederrno));
return;
}
while (compress_modules_cmds[idx].model_name != NULL) {
if ((compress_modules_cmds[idx].built_in == 1) &&
(compress_modules_cmds[idx].loaded == 1) &&
(compress_modules_cmds[idx].model_id > 0) &&
(knet_h->compress_int_data[idx] != NULL) &&
(idx < KNET_MAX_COMPRESS_METHODS)) {
if ((all) || (compress_modules_cmds[idx].model_id == knet_h->compress_model)) {
if (compress_modules_cmds[idx].fini != NULL) {
compress_modules_cmds[idx].fini(knet_h, idx);
} else {
knet_h->compress_int_data[idx] = NULL;
}
}
}
idx++;
}
pthread_rwlock_unlock(&shlib_rwlock);
return;
}
/*
* compress does not require compress_check_lib_is_init
* because it's protected by compress_cfg
*/
int compress(
knet_handle_t knet_h,
const unsigned char *buf_in,
const ssize_t buf_in_len,
unsigned char *buf_out,
ssize_t *buf_out_len)
{
return compress_modules_cmds[knet_h->compress_model].compress(knet_h, buf_in, buf_in_len, buf_out, buf_out_len);
}
int decompress(
knet_handle_t knet_h,
int compress_model,
const unsigned char *buf_in,
const ssize_t buf_in_len,
unsigned char *buf_out,
ssize_t *buf_out_len)
{
int savederrno = 0, err = 0;
if (compress_model > max_model) {
log_err(knet_h, KNET_SUB_COMPRESS, "Received packet with unknown compress model %d", compress_model);
errno = EINVAL;
return -1;
}
if (compress_is_valid_model(compress_model) < 0) {
log_err(knet_h, KNET_SUB_COMPRESS, "Received packet compressed with %s but support is not built in this version of libknet. Please contact your distribution vendor or fix the build.", compress_modules_cmds[compress_model].model_name);
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_rdlock(&shlib_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_COMPRESS, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
if (!compress_check_lib_is_init(knet_h, compress_model)) {
/*
* need to switch to write lock, load the lib, and return with a write lock
* this is not racy because compress_load_lib is written idempotent.
*/
pthread_rwlock_unlock(&shlib_rwlock);
savederrno = pthread_rwlock_wrlock(&shlib_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_COMPRESS, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
if (compress_load_lib(knet_h, compress_model, 1) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_COMPRESS, "Unable to load library: %s",
strerror(savederrno));
goto out_unlock;
}
}
err = compress_modules_cmds[compress_model].decompress(knet_h, buf_in, buf_in_len, buf_out, buf_out_len);
savederrno = errno;
out_unlock:
pthread_rwlock_unlock(&shlib_rwlock);
errno = savederrno;
return err;
}
-int knet_handle_get_compress_list(knet_handle_t knet_h, const char **compress_names, size_t *num_names)
+int knet_get_compress_list(struct knet_compress_info *compress_list, size_t *compress_list_entries)
{
- int savederrno = 0;
int err = 0;
int idx = 0;
int outidx = 0;
- if (!knet_h) {
- errno = EINVAL;
- return -1;
- }
-
- if (!num_names) {
+ if (!compress_list_entries) {
errno = EINVAL;
return -1;
}
- savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
- if (savederrno) {
- log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
- strerror(savederrno));
- errno = savederrno;
- return -1;
- }
-
while (compress_modules_cmds[idx].model_name != NULL) {
if (compress_modules_cmds[idx].built_in) {
- if (compress_names) {
- compress_names[outidx] = compress_modules_cmds[idx].model_name;
+ if (compress_list) {
+ compress_list[outidx].name = compress_modules_cmds[idx].model_name;
}
outidx++;
}
idx++;
}
- *num_names = outidx;
+ *compress_list_entries = outidx;
- pthread_rwlock_unlock(&knet_h->global_rwlock);
- errno = savederrno;
return err;
}
diff --git a/libknet/crypto.c b/libknet/crypto.c
index 8ff26dfb..1d429dea 100644
--- a/libknet/crypto.c
+++ b/libknet/crypto.c
@@ -1,226 +1,210 @@
/*
* Copyright (C) 2012-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 <sys/errno.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <time.h>
#include "crypto.h"
#include "crypto_nss.h"
#include "crypto_openssl.h"
#include "internals.h"
#include "logging.h"
/*
* internal module switch data
*/
#define empty_module NULL, 0, NULL, NULL, NULL, NULL, NULL },
crypto_model_t crypto_modules_cmds[] = {
{ "nss",
#ifdef BUILDCRYPTONSS
1, nsscrypto_load_lib, 0, nsscrypto_init, nsscrypto_fini, nsscrypto_encrypt_and_sign, nsscrypto_encrypt_and_signv, nsscrypto_authenticate_and_decrypt },
#else
0,empty_module
#endif
{ "openssl",
#ifdef BUILDCRYPTOOPENSSL
1, opensslcrypto_load_lib, 0, opensslcrypto_init, opensslcrypto_fini, opensslcrypto_encrypt_and_sign, opensslcrypto_encrypt_and_signv, opensslcrypto_authenticate_and_decrypt },
#else
0,empty_module
#endif
{ NULL, 0, empty_module
};
static int crypto_get_model(const char *model)
{
int idx = 0;
while (crypto_modules_cmds[idx].model_name != NULL) {
if (!strcmp(crypto_modules_cmds[idx].model_name, model))
return idx;
idx++;
}
return -1;
}
/*
* exported API
*/
int crypto_encrypt_and_sign (
knet_handle_t knet_h,
const unsigned char *buf_in,
const ssize_t buf_in_len,
unsigned char *buf_out,
ssize_t *buf_out_len)
{
return crypto_modules_cmds[knet_h->crypto_instance->model].crypt(knet_h, buf_in, buf_in_len, buf_out, buf_out_len);
}
int crypto_encrypt_and_signv (
knet_handle_t knet_h,
const struct iovec *iov_in,
int iovcnt_in,
unsigned char *buf_out,
ssize_t *buf_out_len)
{
return crypto_modules_cmds[knet_h->crypto_instance->model].cryptv(knet_h, iov_in, iovcnt_in, buf_out, buf_out_len);
}
int crypto_authenticate_and_decrypt (
knet_handle_t knet_h,
const unsigned char *buf_in,
const ssize_t buf_in_len,
unsigned char *buf_out,
ssize_t *buf_out_len)
{
return crypto_modules_cmds[knet_h->crypto_instance->model].decrypt(knet_h, buf_in, buf_in_len, buf_out, buf_out_len);
}
int crypto_init(
knet_handle_t knet_h,
struct knet_handle_crypto_cfg *knet_handle_crypto_cfg)
{
int savederrno = 0;
int model = 0;
model = crypto_get_model(knet_handle_crypto_cfg->crypto_model);
if (model < 0) {
log_err(knet_h, KNET_SUB_CRYPTO, "model %s not supported", knet_handle_crypto_cfg->crypto_model);
return -1;
}
if (crypto_modules_cmds[model].built_in == 0) {
log_err(knet_h, KNET_SUB_CRYPTO, "this version of libknet was built without %s support. Please contact your vendor or fix the build.", knet_handle_crypto_cfg->crypto_model);
return -1;
}
savederrno = pthread_rwlock_wrlock(&shlib_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_CRYPTO, "Unable to get write lock: %s",
strerror(savederrno));
return -1;
}
if (!crypto_modules_cmds[model].loaded) {
if (crypto_modules_cmds[model].load_lib(knet_h) < 0) {
log_err(knet_h, KNET_SUB_CRYPTO, "Unable to load %s lib", crypto_modules_cmds[model].model_name);
goto out_err;
}
crypto_modules_cmds[model].loaded = 1;
}
log_debug(knet_h, KNET_SUB_CRYPTO,
"Initizializing crypto module [%s/%s/%s]",
knet_handle_crypto_cfg->crypto_model,
knet_handle_crypto_cfg->crypto_cipher_type,
knet_handle_crypto_cfg->crypto_hash_type);
knet_h->crypto_instance = malloc(sizeof(struct crypto_instance));
if (!knet_h->crypto_instance) {
log_err(knet_h, KNET_SUB_CRYPTO, "Unable to allocate memory for crypto instance");
pthread_rwlock_unlock(&shlib_rwlock);
goto out_err;
}
/*
* if crypto_modules_cmds.init fails, it is expected that
* it will clean everything by itself.
* crypto_modules_cmds.fini is not invoked on error.
*/
knet_h->crypto_instance->model = model;
if (crypto_modules_cmds[knet_h->crypto_instance->model].init(knet_h, knet_handle_crypto_cfg))
goto out_err;
log_debug(knet_h, KNET_SUB_CRYPTO, "security network overhead: %zu", knet_h->sec_header_size);
pthread_rwlock_unlock(&shlib_rwlock);
return 0;
out_err:
if (knet_h->crypto_instance) {
free(knet_h->crypto_instance);
knet_h->crypto_instance = NULL;
}
pthread_rwlock_unlock(&shlib_rwlock);
return -1;
}
void crypto_fini(
knet_handle_t knet_h)
{
int savederrno = 0;
int model = 0;
savederrno = pthread_rwlock_wrlock(&shlib_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_CRYPTO, "Unable to get write lock: %s",
strerror(savederrno));
return;
}
if (knet_h->crypto_instance) {
model = knet_h->crypto_instance->model;
if (crypto_modules_cmds[model].fini != NULL) {
crypto_modules_cmds[model].fini(knet_h);
}
free(knet_h->crypto_instance);
knet_h->crypto_instance = NULL;
}
pthread_rwlock_unlock(&shlib_rwlock);
return;
}
-int knet_handle_get_crypto_list(knet_handle_t knet_h, const char **crypto_names, size_t *num_names)
+int knet_get_crypto_list(struct knet_crypto_info *crypto_list, size_t *crypto_list_entries)
{
- int savederrno = 0;
int err = 0;
int idx = 0;
int outidx = 0;
- if (!knet_h) {
- errno = EINVAL;
- return -1;
- }
-
- if (!num_names) {
+ if (!crypto_list_entries) {
errno = EINVAL;
return -1;
}
- savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
- if (savederrno) {
- log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
- strerror(savederrno));
- errno = savederrno;
- return -1;
- }
-
while (crypto_modules_cmds[idx].model_name != NULL) {
if (crypto_modules_cmds[idx].built_in) {
- if (crypto_names) {
- crypto_names[outidx] = crypto_modules_cmds[idx].model_name;
+ if (crypto_list) {
+ crypto_list[outidx].name = crypto_modules_cmds[idx].model_name;
}
outidx++;
}
idx++;
}
- *num_names = outidx;
+ *crypto_list_entries = outidx;
- pthread_rwlock_unlock(&knet_h->global_rwlock);
- errno = savederrno;
return err;
}
diff --git a/libknet/handle.c b/libknet/handle.c
index 3ad8d627..d90fcfb3 100644
--- a/libknet/handle.c
+++ b/libknet/handle.c
@@ -1,1615 +1,1571 @@
/*
* Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
*
* Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
* Federico Simoncelli <fsimon@kronosnet.org>
*
* This software licensed under GPL-2.0+, LGPL-2.0+
*/
#include "config.h"
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <sys/uio.h>
#include <math.h>
#include <sys/time.h>
#include <sys/resource.h>
#include "internals.h"
#include "crypto.h"
#include "links.h"
#include "compress.h"
#include "compat.h"
#include "common.h"
#include "threads_common.h"
#include "threads_heartbeat.h"
#include "threads_pmtud.h"
#include "threads_dsthandler.h"
#include "threads_rx.h"
#include "threads_tx.h"
#include "transports.h"
+#include "transport_common.h"
#include "logging.h"
static pthread_mutex_t handle_config_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_rwlock_t shlib_rwlock;
static uint8_t shlib_wrlock_init = 0;
static uint32_t knet_ref = 0;
static int _init_shlib_tracker(knet_handle_t knet_h)
{
int savederrno = 0;
if (!shlib_wrlock_init) {
savederrno = pthread_rwlock_init(&shlib_rwlock, NULL);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to initialize shared lib rwlock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
shlib_wrlock_init = 1;
}
return 0;
}
static void _fini_shlib_tracker(void)
{
if (knet_ref == 0) {
pthread_rwlock_destroy(&shlib_rwlock);
shlib_wrlock_init = 0;
}
return;
}
static int _init_locks(knet_handle_t knet_h)
{
int savederrno = 0;
savederrno = pthread_rwlock_init(&knet_h->global_rwlock, NULL);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to initialize list rwlock: %s",
strerror(savederrno));
goto exit_fail;
}
knet_h->lock_init_done = 1;
savederrno = pthread_mutex_init(&knet_h->pmtud_mutex, NULL);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to initialize pmtud mutex: %s",
strerror(savederrno));
goto exit_fail;
}
savederrno = pthread_cond_init(&knet_h->pmtud_cond, NULL);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to initialize pmtud conditional mutex: %s",
strerror(savederrno));
goto exit_fail;
}
savederrno = pthread_mutex_init(&knet_h->hb_mutex, NULL);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to initialize hb_thread mutex: %s",
strerror(savederrno));
goto exit_fail;
}
savederrno = pthread_mutex_init(&knet_h->tx_mutex, NULL);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to initialize tx_thread mutex: %s",
strerror(savederrno));
goto exit_fail;
}
savederrno = pthread_mutex_init(&knet_h->tx_seq_num_mutex, NULL);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to initialize tx_seq_num_mutex mutex: %s",
strerror(savederrno));
goto exit_fail;
}
return 0;
exit_fail:
errno = savederrno;
return -1;
}
static void _destroy_locks(knet_handle_t knet_h)
{
knet_h->lock_init_done = 0;
pthread_rwlock_destroy(&knet_h->global_rwlock);
pthread_mutex_destroy(&knet_h->pmtud_mutex);
pthread_cond_destroy(&knet_h->pmtud_cond);
pthread_mutex_destroy(&knet_h->hb_mutex);
pthread_mutex_destroy(&knet_h->tx_mutex);
pthread_mutex_destroy(&knet_h->tx_seq_num_mutex);
}
static int _init_socks(knet_handle_t knet_h)
{
int savederrno = 0;
if (_init_socketpair(knet_h, knet_h->hostsockfd)) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to initialize internal hostsockpair: %s",
strerror(savederrno));
goto exit_fail;
}
if (_init_socketpair(knet_h, knet_h->dstsockfd)) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to initialize internal dstsockpair: %s",
strerror(savederrno));
goto exit_fail;
}
return 0;
exit_fail:
errno = savederrno;
return -1;
}
static void _close_socks(knet_handle_t knet_h)
{
_close_socketpair(knet_h, knet_h->dstsockfd);
_close_socketpair(knet_h, knet_h->hostsockfd);
}
static int _init_buffers(knet_handle_t knet_h)
{
int savederrno = 0;
int i;
size_t bufsize;
for (i = 0; i < PCKT_FRAG_MAX; i++) {
bufsize = ceil((float)KNET_MAX_PACKET_SIZE / (i + 1)) + KNET_HEADER_ALL_SIZE;
knet_h->send_to_links_buf[i] = malloc(bufsize);
if (!knet_h->send_to_links_buf[i]) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to allocate memory datafd to link buffer: %s",
strerror(savederrno));
goto exit_fail;
}
memset(knet_h->send_to_links_buf[i], 0, bufsize);
}
for (i = 0; i < PCKT_RX_BUFS; i++) {
knet_h->recv_from_links_buf[i] = malloc(KNET_DATABUFSIZE);
if (!knet_h->recv_from_links_buf[i]) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to allocate memory for link to datafd buffer: %s",
strerror(savederrno));
goto exit_fail;
}
memset(knet_h->recv_from_links_buf[i], 0, KNET_DATABUFSIZE);
}
knet_h->recv_from_sock_buf = malloc(KNET_DATABUFSIZE);
if (!knet_h->recv_from_sock_buf) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to allocate memory for app to datafd buffer: %s",
strerror(savederrno));
goto exit_fail;
}
memset(knet_h->recv_from_sock_buf, 0, KNET_DATABUFSIZE);
knet_h->pingbuf = malloc(KNET_HEADER_PING_SIZE);
if (!knet_h->pingbuf) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to allocate memory for hearbeat buffer: %s",
strerror(savederrno));
goto exit_fail;
}
memset(knet_h->pingbuf, 0, KNET_HEADER_PING_SIZE);
knet_h->pmtudbuf = malloc(KNET_PMTUD_SIZE_V6);
if (!knet_h->pmtudbuf) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to allocate memory for pmtud buffer: %s",
strerror(savederrno));
goto exit_fail;
}
memset(knet_h->pmtudbuf, 0, KNET_PMTUD_SIZE_V6);
for (i = 0; i < PCKT_FRAG_MAX; i++) {
bufsize = ceil((float)KNET_MAX_PACKET_SIZE / (i + 1)) + KNET_HEADER_ALL_SIZE + KNET_DATABUFSIZE_CRYPT_PAD;
knet_h->send_to_links_buf_crypt[i] = malloc(bufsize);
if (!knet_h->send_to_links_buf_crypt[i]) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to allocate memory for crypto datafd to link buffer: %s",
strerror(savederrno));
goto exit_fail;
}
memset(knet_h->send_to_links_buf_crypt[i], 0, bufsize);
}
knet_h->recv_from_links_buf_decrypt = malloc(KNET_DATABUFSIZE_CRYPT);
if (!knet_h->recv_from_links_buf_decrypt) {
savederrno = errno;
log_err(knet_h, KNET_SUB_CRYPTO, "Unable to allocate memory for crypto link to datafd buffer: %s",
strerror(savederrno));
goto exit_fail;
}
memset(knet_h->recv_from_links_buf_decrypt, 0, KNET_DATABUFSIZE_CRYPT);
knet_h->recv_from_links_buf_crypt = malloc(KNET_DATABUFSIZE_CRYPT);
if (!knet_h->recv_from_links_buf_crypt) {
savederrno = errno;
log_err(knet_h, KNET_SUB_CRYPTO, "Unable to allocate memory for crypto link to datafd buffer: %s",
strerror(savederrno));
goto exit_fail;
}
memset(knet_h->recv_from_links_buf_crypt, 0, KNET_DATABUFSIZE_CRYPT);
knet_h->pingbuf_crypt = malloc(KNET_DATABUFSIZE_CRYPT);
if (!knet_h->pingbuf_crypt) {
savederrno = errno;
log_err(knet_h, KNET_SUB_CRYPTO, "Unable to allocate memory for crypto hearbeat buffer: %s",
strerror(savederrno));
goto exit_fail;
}
memset(knet_h->pingbuf_crypt, 0, KNET_DATABUFSIZE_CRYPT);
knet_h->pmtudbuf_crypt = malloc(KNET_DATABUFSIZE_CRYPT);
if (!knet_h->pmtudbuf_crypt) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to allocate memory for crypto pmtud buffer: %s",
strerror(savederrno));
goto exit_fail;
}
memset(knet_h->pmtudbuf_crypt, 0, KNET_DATABUFSIZE_CRYPT);
knet_h->recv_from_links_buf_decompress = malloc(KNET_DATABUFSIZE_COMPRESS);
if (!knet_h->recv_from_links_buf_decompress) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to allocate memory for decompress buffer: %s",
strerror(savederrno));
goto exit_fail;
}
memset(knet_h->recv_from_links_buf_decompress, 0, KNET_DATABUFSIZE_COMPRESS);
knet_h->send_to_links_buf_compress = malloc(KNET_DATABUFSIZE_COMPRESS);
if (!knet_h->send_to_links_buf_compress) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to allocate memory for compress buffer: %s",
strerror(savederrno));
goto exit_fail;
}
memset(knet_h->send_to_links_buf_compress, 0, KNET_DATABUFSIZE_COMPRESS);
memset(knet_h->knet_transport_fd_tracker, KNET_MAX_TRANSPORTS, sizeof(knet_h->knet_transport_fd_tracker));
return 0;
exit_fail:
errno = savederrno;
return -1;
}
static void _destroy_buffers(knet_handle_t knet_h)
{
int i;
for (i = 0; i < PCKT_FRAG_MAX; i++) {
free(knet_h->send_to_links_buf[i]);
free(knet_h->send_to_links_buf_crypt[i]);
}
for (i = 0; i < PCKT_RX_BUFS; i++) {
free(knet_h->recv_from_links_buf[i]);
}
free(knet_h->recv_from_links_buf_decompress);
free(knet_h->send_to_links_buf_compress);
free(knet_h->recv_from_sock_buf);
free(knet_h->recv_from_links_buf_decrypt);
free(knet_h->recv_from_links_buf_crypt);
free(knet_h->pingbuf);
free(knet_h->pingbuf_crypt);
free(knet_h->pmtudbuf);
free(knet_h->pmtudbuf_crypt);
}
static int _init_epolls(knet_handle_t knet_h)
{
struct epoll_event ev;
int savederrno = 0;
/*
* even if the kernel does dynamic allocation with epoll_ctl
* we need to reserve one extra for host to host communication
*/
knet_h->send_to_links_epollfd = epoll_create(KNET_EPOLL_MAX_EVENTS + 1);
if (knet_h->send_to_links_epollfd < 0) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to create epoll datafd to link fd: %s",
strerror(savederrno));
goto exit_fail;
}
knet_h->recv_from_links_epollfd = epoll_create(KNET_EPOLL_MAX_EVENTS);
if (knet_h->recv_from_links_epollfd < 0) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to create epoll link to datafd fd: %s",
strerror(savederrno));
goto exit_fail;
}
knet_h->dst_link_handler_epollfd = epoll_create(KNET_EPOLL_MAX_EVENTS);
if (knet_h->dst_link_handler_epollfd < 0) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to create epoll dst cache fd: %s",
strerror(savederrno));
goto exit_fail;
}
if (_fdset_cloexec(knet_h->send_to_links_epollfd)) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to set CLOEXEC on datafd to link epoll fd: %s",
strerror(savederrno));
goto exit_fail;
}
if (_fdset_cloexec(knet_h->recv_from_links_epollfd)) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to set CLOEXEC on link to datafd epoll fd: %s",
strerror(savederrno));
goto exit_fail;
}
if (_fdset_cloexec(knet_h->dst_link_handler_epollfd)) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to set CLOEXEC on dst cache epoll fd: %s",
strerror(savederrno));
goto exit_fail;
}
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = knet_h->hostsockfd[0];
if (epoll_ctl(knet_h->send_to_links_epollfd,
EPOLL_CTL_ADD, knet_h->hostsockfd[0], &ev)) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to add hostsockfd[0] to epoll pool: %s",
strerror(savederrno));
goto exit_fail;
}
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = knet_h->dstsockfd[0];
if (epoll_ctl(knet_h->dst_link_handler_epollfd,
EPOLL_CTL_ADD, knet_h->dstsockfd[0], &ev)) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to add dstsockfd[0] to epoll pool: %s",
strerror(savederrno));
goto exit_fail;
}
return 0;
exit_fail:
errno = savederrno;
return -1;
}
static void _close_epolls(knet_handle_t knet_h)
{
struct epoll_event ev;
int i;
memset(&ev, 0, sizeof(struct epoll_event));
for (i = 0; i < KNET_DATAFD_MAX; i++) {
if (knet_h->sockfd[i].in_use) {
epoll_ctl(knet_h->send_to_links_epollfd, EPOLL_CTL_DEL, knet_h->sockfd[i].sockfd[knet_h->sockfd[i].is_created], &ev);
if (knet_h->sockfd[i].sockfd[knet_h->sockfd[i].is_created]) {
_close_socketpair(knet_h, knet_h->sockfd[i].sockfd);
}
}
}
epoll_ctl(knet_h->send_to_links_epollfd, EPOLL_CTL_DEL, knet_h->hostsockfd[0], &ev);
epoll_ctl(knet_h->dst_link_handler_epollfd, EPOLL_CTL_DEL, knet_h->dstsockfd[0], &ev);
close(knet_h->send_to_links_epollfd);
close(knet_h->recv_from_links_epollfd);
close(knet_h->dst_link_handler_epollfd);
}
-static int _start_transports(knet_handle_t knet_h)
-{
- int i, savederrno = 0, err = 0;
-
- for (i=0; i<KNET_MAX_TRANSPORTS; i++) {
- switch (i) {
- case KNET_TRANSPORT_UDP:
- knet_h->transport_ops[i] = get_udp_transport();
- break;
- case KNET_TRANSPORT_SCTP:
- knet_h->transport_ops[i] = get_sctp_transport();
- break;
- case KNET_TRANSPORT_LOOPBACK:
- knet_h->transport_ops[i] = get_loopback_transport();
- break;
- }
-
- if (knet_h->transport_ops[i]) {
- if (knet_h->transport_ops[i]->transport_init(knet_h) < 0) {
- savederrno = errno;
- log_err(knet_h, KNET_SUB_HANDLE, "Failed to allocate transport handle for %s: %s",
- knet_h->transport_ops[i]->transport_name,
- strerror(savederrno));
- err = -1;
- goto out;
- }
- }
- }
-
-out:
- errno = savederrno;
- return err;
-}
-
-static void _stop_transports(knet_handle_t knet_h)
-{
- int i;
-
- for (i=0; i<KNET_MAX_TRANSPORTS; i++) {
- if (knet_h->transport_ops[i]) {
- knet_h->transport_ops[i]->transport_free(knet_h);
- }
- }
-}
-
static int _start_threads(knet_handle_t knet_h)
{
int savederrno = 0;
savederrno = pthread_create(&knet_h->pmtud_link_handler_thread, 0,
_handle_pmtud_link_thread, (void *) knet_h);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to start pmtud link thread: %s",
strerror(savederrno));
goto exit_fail;
}
savederrno = pthread_create(&knet_h->dst_link_handler_thread, 0,
_handle_dst_link_handler_thread, (void *) knet_h);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to start dst cache thread: %s",
strerror(savederrno));
goto exit_fail;
}
savederrno = pthread_create(&knet_h->send_to_links_thread, 0,
_handle_send_to_links_thread, (void *) knet_h);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to start datafd to link thread: %s",
strerror(savederrno));
goto exit_fail;
}
savederrno = pthread_create(&knet_h->recv_from_links_thread, 0,
_handle_recv_from_links_thread, (void *) knet_h);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to start link to datafd thread: %s",
strerror(savederrno));
goto exit_fail;
}
savederrno = pthread_create(&knet_h->heartbt_thread, 0,
_handle_heartbt_thread, (void *) knet_h);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to start heartbeat thread: %s",
strerror(savederrno));
goto exit_fail;
}
return 0;
exit_fail:
errno = savederrno;
return -1;
}
static void _stop_threads(knet_handle_t knet_h)
{
void *retval;
/*
* allow threads to catch on shutdown request
* and release locks before we stop them.
* this isn't the most efficent way to handle it
* but it works good enough for now
*/
sleep(1);
if (knet_h->heartbt_thread) {
pthread_cancel(knet_h->heartbt_thread);
pthread_join(knet_h->heartbt_thread, &retval);
}
if (knet_h->send_to_links_thread) {
pthread_cancel(knet_h->send_to_links_thread);
pthread_join(knet_h->send_to_links_thread, &retval);
}
if (knet_h->recv_from_links_thread) {
pthread_cancel(knet_h->recv_from_links_thread);
pthread_join(knet_h->recv_from_links_thread, &retval);
}
if (knet_h->dst_link_handler_thread) {
pthread_cancel(knet_h->dst_link_handler_thread);
pthread_join(knet_h->dst_link_handler_thread, &retval);
}
pthread_mutex_lock(&knet_h->pmtud_mutex);
pthread_cond_signal(&knet_h->pmtud_cond);
pthread_mutex_unlock(&knet_h->pmtud_mutex);
sleep(1);
if (knet_h->pmtud_link_handler_thread) {
pthread_cancel(knet_h->pmtud_link_handler_thread);
pthread_join(knet_h->pmtud_link_handler_thread, &retval);
}
}
knet_handle_t knet_handle_new(knet_node_id_t host_id,
int log_fd,
uint8_t default_log_level)
{
knet_handle_t knet_h;
int savederrno = 0;
struct rlimit cur;
if (getrlimit(RLIMIT_NOFILE, &cur) < 0) {
return NULL;
}
if ((log_fd < 0) || ((unsigned int)log_fd >= cur.rlim_max)) {
errno = EINVAL;
return NULL;
}
/*
* validate incoming request
*/
if ((log_fd) && (default_log_level > KNET_LOG_DEBUG)) {
errno = EINVAL;
return NULL;
}
/*
* allocate handle
*/
knet_h = malloc(sizeof(struct knet_handle));
if (!knet_h) {
errno = ENOMEM;
return NULL;
}
memset(knet_h, 0, sizeof(struct knet_handle));
savederrno = pthread_mutex_lock(&handle_config_mutex);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get handle mutex lock: %s",
strerror(savederrno));
errno = savederrno;
goto exit_fail;
}
/*
* copy config in place
*/
knet_h->host_id = host_id;
knet_h->logfd = log_fd;
if (knet_h->logfd > 0) {
memset(&knet_h->log_levels, default_log_level, KNET_MAX_SUBSYSTEMS);
}
/*
* set pmtud default timers
*/
knet_h->pmtud_interval = KNET_PMTUD_DEFAULT_INTERVAL;
/*
* set transports reconnect default timers
*/
knet_h->reconnect_int = KNET_TRANSPORT_DEFAULT_RECONNECT_INTERVAL;
/*
* Set 'min' stats to the maximum value so the
* first value we get is always less
*/
knet_h->stats.tx_compress_time_min = UINT64_MAX;
knet_h->stats.rx_compress_time_min = UINT64_MAX;
knet_h->stats.tx_crypt_time_min = UINT64_MAX;
knet_h->stats.rx_crypt_time_min = UINT64_MAX;
/*
* init global shlib tracker
*/
if (_init_shlib_tracker(knet_h) < 0) {
savederrno = errno;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to init handles traceker: %s",
strerror(savederrno));
errno = savederrno;
goto exit_fail;
}
/*
* init main locking structures
*/
if (_init_locks(knet_h)) {
savederrno = errno;
goto exit_fail;
}
/*
* init sockets
*/
if (_init_socks(knet_h)) {
savederrno = errno;
goto exit_fail;
}
/*
* allocate packet buffers
*/
if (_init_buffers(knet_h)) {
savederrno = errno;
goto exit_fail;
}
if (compress_init(knet_h)) {
savederrno = errno;
goto exit_fail;
}
/*
* create epoll fds
*/
if (_init_epolls(knet_h)) {
savederrno = errno;
goto exit_fail;
}
/*
* start transports
*/
- if (_start_transports(knet_h)) {
+ if (start_all_transports(knet_h)) {
savederrno = errno;
goto exit_fail;
}
/*
* start internal threads
*/
if (_start_threads(knet_h)) {
savederrno = errno;
goto exit_fail;
}
knet_ref++;
pthread_mutex_unlock(&handle_config_mutex);
return knet_h;
exit_fail:
pthread_mutex_unlock(&handle_config_mutex);
knet_handle_free(knet_h);
errno = savederrno;
return NULL;
}
int knet_handle_free(knet_handle_t knet_h)
{
int savederrno = 0;
savederrno = pthread_mutex_lock(&handle_config_mutex);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get handle mutex lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
if (!knet_h) {
pthread_mutex_unlock(&handle_config_mutex);
errno = EINVAL;
return -1;
}
if (!knet_h->lock_init_done) {
goto exit_nolock;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
strerror(savederrno));
pthread_mutex_unlock(&handle_config_mutex);
errno = savederrno;
return -1;
}
if (knet_h->host_head != NULL) {
savederrno = EBUSY;
log_err(knet_h, KNET_SUB_HANDLE,
"Unable to free handle: host(s) or listener(s) are still active: %s",
strerror(savederrno));
pthread_rwlock_unlock(&knet_h->global_rwlock);
pthread_mutex_unlock(&handle_config_mutex);
errno = savederrno;
return -1;
}
knet_h->fini_in_progress = 1;
pthread_rwlock_unlock(&knet_h->global_rwlock);
_stop_threads(knet_h);
- _stop_transports(knet_h);
+ stop_all_transports(knet_h);
_close_epolls(knet_h);
_destroy_buffers(knet_h);
_close_socks(knet_h);
crypto_fini(knet_h);
compress_fini(knet_h, 1);
_destroy_locks(knet_h);
exit_nolock:
free(knet_h);
knet_h = NULL;
knet_ref--;
_fini_shlib_tracker();
pthread_mutex_unlock(&handle_config_mutex);
return 0;
}
int knet_handle_enable_sock_notify(knet_handle_t knet_h,
void *sock_notify_fn_private_data,
void (*sock_notify_fn) (
void *private_data,
int datafd,
int8_t channel,
uint8_t tx_rx,
int error,
int errorno))
{
int savederrno = 0, err = 0;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (!sock_notify_fn) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
knet_h->sock_notify_fn_private_data = sock_notify_fn_private_data;
knet_h->sock_notify_fn = sock_notify_fn;
log_debug(knet_h, KNET_SUB_HANDLE, "sock_notify_fn enabled");
pthread_rwlock_unlock(&knet_h->global_rwlock);
return err;
}
int knet_handle_add_datafd(knet_handle_t knet_h, int *datafd, int8_t *channel)
{
int err = 0, savederrno = 0;
int i;
struct epoll_event ev;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (datafd == NULL) {
errno = EINVAL;
return -1;
}
if (channel == NULL) {
errno = EINVAL;
return -1;
}
if (*channel >= KNET_DATAFD_MAX) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
if (!knet_h->sock_notify_fn) {
log_err(knet_h, KNET_SUB_HANDLE, "Adding datafd requires sock notify callback enabled!");
savederrno = EINVAL;
err = -1;
goto out_unlock;
}
if (*datafd > 0) {
for (i = 0; i < KNET_DATAFD_MAX; i++) {
if ((knet_h->sockfd[i].in_use) && (knet_h->sockfd[i].sockfd[0] == *datafd)) {
log_err(knet_h, KNET_SUB_HANDLE, "requested datafd: %d already exist in index: %d", *datafd, i);
savederrno = EEXIST;
err = -1;
goto out_unlock;
}
}
}
/*
* auto allocate a channel
*/
if (*channel < 0) {
for (i = 0; i < KNET_DATAFD_MAX; i++) {
if (!knet_h->sockfd[i].in_use) {
*channel = i;
break;
}
}
if (*channel < 0) {
savederrno = EBUSY;
err = -1;
goto out_unlock;
}
} else {
if (knet_h->sockfd[*channel].in_use) {
savederrno = EBUSY;
err = -1;
goto out_unlock;
}
}
knet_h->sockfd[*channel].is_created = 0;
knet_h->sockfd[*channel].is_socket = 0;
knet_h->sockfd[*channel].has_error = 0;
if (*datafd > 0) {
int sockopt;
socklen_t sockoptlen = sizeof(sockopt);
if (_fdset_cloexec(*datafd)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to set CLOEXEC on datafd: %s",
strerror(savederrno));
goto out_unlock;
}
if (_fdset_nonblock(*datafd)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to set NONBLOCK on datafd: %s",
strerror(savederrno));
goto out_unlock;
}
knet_h->sockfd[*channel].sockfd[0] = *datafd;
knet_h->sockfd[*channel].sockfd[1] = 0;
if (!getsockopt(knet_h->sockfd[*channel].sockfd[0], SOL_SOCKET, SO_TYPE, &sockopt, &sockoptlen)) {
knet_h->sockfd[*channel].is_socket = 1;
}
} else {
if (_init_socketpair(knet_h, knet_h->sockfd[*channel].sockfd)) {
savederrno = errno;
err = -1;
goto out_unlock;
}
knet_h->sockfd[*channel].is_created = 1;
knet_h->sockfd[*channel].is_socket = 1;
*datafd = knet_h->sockfd[*channel].sockfd[0];
}
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = knet_h->sockfd[*channel].sockfd[knet_h->sockfd[*channel].is_created];
if (epoll_ctl(knet_h->send_to_links_epollfd,
EPOLL_CTL_ADD, knet_h->sockfd[*channel].sockfd[knet_h->sockfd[*channel].is_created], &ev)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to add datafd %d to linkfd epoll pool: %s",
knet_h->sockfd[*channel].sockfd[knet_h->sockfd[*channel].is_created], strerror(savederrno));
if (knet_h->sockfd[*channel].is_created) {
_close_socketpair(knet_h, knet_h->sockfd[*channel].sockfd);
}
goto out_unlock;
}
knet_h->sockfd[*channel].in_use = 1;
out_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_handle_remove_datafd(knet_handle_t knet_h, int datafd)
{
int err = 0, savederrno = 0;
int8_t channel = -1;
int i;
struct epoll_event ev;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (datafd <= 0) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
for (i = 0; i < KNET_DATAFD_MAX; i++) {
if ((knet_h->sockfd[i].in_use) &&
(knet_h->sockfd[i].sockfd[0] == datafd)) {
channel = i;
break;
}
}
if (channel < 0) {
savederrno = EINVAL;
err = -1;
goto out_unlock;
}
if (!knet_h->sockfd[channel].has_error) {
memset(&ev, 0, sizeof(struct epoll_event));
if (epoll_ctl(knet_h->send_to_links_epollfd,
EPOLL_CTL_DEL, knet_h->sockfd[channel].sockfd[knet_h->sockfd[channel].is_created], &ev)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_HANDLE, "Unable to del datafd %d from linkfd epoll pool: %s",
knet_h->sockfd[channel].sockfd[0], strerror(savederrno));
goto out_unlock;
}
}
if (knet_h->sockfd[channel].is_created) {
_close_socketpair(knet_h, knet_h->sockfd[channel].sockfd);
}
memset(&knet_h->sockfd[channel], 0, sizeof(struct knet_sock));
out_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_handle_get_datafd(knet_handle_t knet_h, const int8_t channel, int *datafd)
{
int err = 0, savederrno = 0;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if ((channel < 0) || (channel >= KNET_DATAFD_MAX)) {
errno = EINVAL;
return -1;
}
if (datafd == NULL) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
if (!knet_h->sockfd[channel].in_use) {
savederrno = EINVAL;
err = -1;
goto out_unlock;
}
*datafd = knet_h->sockfd[channel].sockfd[0];
out_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_handle_get_channel(knet_handle_t knet_h, const int datafd, int8_t *channel)
{
int err = 0, savederrno = 0;
int i;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (datafd <= 0) {
errno = EINVAL;
return -1;
}
if (channel == NULL) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
*channel = -1;
for (i = 0; i < KNET_DATAFD_MAX; i++) {
if ((knet_h->sockfd[i].in_use) &&
(knet_h->sockfd[i].sockfd[0] == datafd)) {
*channel = i;
break;
}
}
if (*channel < 0) {
savederrno = EINVAL;
err = -1;
goto out_unlock;
}
out_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_handle_enable_filter(knet_handle_t knet_h,
void *dst_host_filter_fn_private_data,
int (*dst_host_filter_fn) (
void *private_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_node_id,
int8_t *channel,
knet_node_id_t *dst_host_ids,
size_t *dst_host_ids_entries))
{
int savederrno = 0;
if (!knet_h) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
knet_h->dst_host_filter_fn_private_data = dst_host_filter_fn_private_data;
knet_h->dst_host_filter_fn = dst_host_filter_fn;
if (knet_h->dst_host_filter_fn) {
log_debug(knet_h, KNET_SUB_HANDLE, "dst_host_filter_fn enabled");
} else {
log_debug(knet_h, KNET_SUB_HANDLE, "dst_host_filter_fn disabled");
}
pthread_rwlock_unlock(&knet_h->global_rwlock);
return 0;
}
int knet_handle_setfwd(knet_handle_t knet_h, unsigned int enabled)
{
int savederrno = 0;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (enabled > 1) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
knet_h->enabled = enabled;
if (enabled) {
log_debug(knet_h, KNET_SUB_HANDLE, "Data forwarding is enabled");
} else {
log_debug(knet_h, KNET_SUB_HANDLE, "Data forwarding is disabled");
}
pthread_rwlock_unlock(&knet_h->global_rwlock);
return 0;
}
int knet_handle_pmtud_getfreq(knet_handle_t knet_h, unsigned int *interval)
{
int savederrno = 0;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (!interval) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
*interval = knet_h->pmtud_interval;
pthread_rwlock_unlock(&knet_h->global_rwlock);
return 0;
}
int knet_handle_pmtud_setfreq(knet_handle_t knet_h, unsigned int interval)
{
int savederrno = 0;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if ((!interval) || (interval > 86400)) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
knet_h->pmtud_interval = interval;
log_debug(knet_h, KNET_SUB_HANDLE, "PMTUd interval set to: %u seconds", interval);
pthread_rwlock_unlock(&knet_h->global_rwlock);
return 0;
}
int knet_handle_enable_pmtud_notify(knet_handle_t knet_h,
void *pmtud_notify_fn_private_data,
void (*pmtud_notify_fn) (
void *private_data,
unsigned int data_mtu))
{
int savederrno = 0;
if (!knet_h) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
knet_h->pmtud_notify_fn_private_data = pmtud_notify_fn_private_data;
knet_h->pmtud_notify_fn = pmtud_notify_fn;
if (knet_h->pmtud_notify_fn) {
log_debug(knet_h, KNET_SUB_HANDLE, "pmtud_notify_fn enabled");
} else {
log_debug(knet_h, KNET_SUB_HANDLE, "pmtud_notify_fn disabled");
}
pthread_rwlock_unlock(&knet_h->global_rwlock);
return 0;
}
int knet_handle_pmtud_get(knet_handle_t knet_h,
unsigned int *data_mtu)
{
int savederrno = 0;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (!data_mtu) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
*data_mtu = knet_h->data_mtu;
pthread_rwlock_unlock(&knet_h->global_rwlock);
return 0;
}
int knet_handle_crypto(knet_handle_t knet_h, struct knet_handle_crypto_cfg *knet_handle_crypto_cfg)
{
int savederrno = 0;
int err = 0;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (!knet_handle_crypto_cfg) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
crypto_fini(knet_h);
if ((!strncmp("none", knet_handle_crypto_cfg->crypto_model, 4)) ||
((!strncmp("none", knet_handle_crypto_cfg->crypto_cipher_type, 4)) &&
(!strncmp("none", knet_handle_crypto_cfg->crypto_hash_type, 4)))) {
log_debug(knet_h, KNET_SUB_CRYPTO, "crypto is not enabled");
err = 0;
goto exit_unlock;
}
if (knet_handle_crypto_cfg->private_key_len < KNET_MIN_KEY_LEN) {
log_debug(knet_h, KNET_SUB_CRYPTO, "private key len too short (min %d): %u",
KNET_MIN_KEY_LEN, knet_handle_crypto_cfg->private_key_len);
savederrno = EINVAL;
err = -1;
goto exit_unlock;
}
if (knet_handle_crypto_cfg->private_key_len > KNET_MAX_KEY_LEN) {
log_debug(knet_h, KNET_SUB_CRYPTO, "private key len too long (max %d): %u",
KNET_MAX_KEY_LEN, knet_handle_crypto_cfg->private_key_len);
savederrno = EINVAL;
err = -1;
goto exit_unlock;
}
err = crypto_init(knet_h, knet_handle_crypto_cfg);
if (err) {
err = -2;
}
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_handle_compress(knet_handle_t knet_h, struct knet_handle_compress_cfg *knet_handle_compress_cfg)
{
int savederrno = 0;
int err = 0;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (!knet_handle_compress_cfg) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
compress_fini(knet_h, 0);
err = compress_cfg(knet_h, knet_handle_compress_cfg);
savederrno = errno;
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
ssize_t knet_recv(knet_handle_t knet_h, char *buff, const size_t buff_len, const int8_t channel)
{
int savederrno = 0;
ssize_t err = 0;
struct iovec iov_in;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (buff == NULL) {
errno = EINVAL;
return -1;
}
if (buff_len <= 0) {
errno = EINVAL;
return -1;
}
if (buff_len > KNET_MAX_PACKET_SIZE) {
errno = EINVAL;
return -1;
}
if (channel < 0) {
errno = EINVAL;
return -1;
}
if (channel >= KNET_DATAFD_MAX) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
if (!knet_h->sockfd[channel].in_use) {
savederrno = EINVAL;
err = -1;
goto out_unlock;
}
memset(&iov_in, 0, sizeof(iov_in));
iov_in.iov_base = (void *)buff;
iov_in.iov_len = buff_len;
err = readv(knet_h->sockfd[channel].sockfd[0], &iov_in, 1);
savederrno = errno;
out_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
ssize_t knet_send(knet_handle_t knet_h, const char *buff, const size_t buff_len, const int8_t channel)
{
int savederrno = 0;
ssize_t err = 0;
struct iovec iov_out[1];
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (buff == NULL) {
errno = EINVAL;
return -1;
}
if (buff_len <= 0) {
errno = EINVAL;
return -1;
}
if (buff_len > KNET_MAX_PACKET_SIZE) {
errno = EINVAL;
return -1;
}
if (channel < 0) {
errno = EINVAL;
return -1;
}
if (channel >= KNET_DATAFD_MAX) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
if (!knet_h->sockfd[channel].in_use) {
savederrno = EINVAL;
err = -1;
goto out_unlock;
}
memset(iov_out, 0, sizeof(iov_out));
iov_out[0].iov_base = (void *)buff;
iov_out[0].iov_len = buff_len;
err = writev(knet_h->sockfd[channel].sockfd[0], iov_out, 1);
savederrno = errno;
out_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_handle_get_stats(knet_handle_t knet_h, struct knet_handle_stats *stats, size_t struct_size)
{
int savederrno = 0;
int err = 0;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (!stats) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
if (struct_size > sizeof(struct knet_handle_stats)) {
struct_size = sizeof(struct knet_handle_stats);
}
memmove(stats, &knet_h->stats, struct_size);
/* Tell the caller our full size in case they have an old version */
stats->size = sizeof(struct knet_handle_stats);
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_handle_clear_stats(knet_handle_t knet_h, int clear_option)
{
int savederrno = 0;
int err = 0;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (clear_option != KNET_CLEARSTATS_HANDLE_ONLY &&
clear_option != KNET_CLEARSTATS_HANDLE_AND_LINK) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_HANDLE, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
memset(&knet_h->stats, 0, sizeof(struct knet_handle_stats));
if (clear_option == KNET_CLEARSTATS_HANDLE_AND_LINK) {
_link_clear_stats(knet_h);
}
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
diff --git a/libknet/internals.h b/libknet/internals.h
index 048590aa..762c0d48 100644
--- a/libknet/internals.h
+++ b/libknet/internals.h
@@ -1,488 +1,489 @@
/*
* Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
*
* Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
* Federico Simoncelli <fsimon@kronosnet.org>
*
* This software licensed under GPL-2.0+, LGPL-2.0+
*/
#ifndef __KNET_INTERNALS_H__
#define __KNET_INTERNALS_H__
/*
* NOTE: you shouldn't need to include this header normally
*/
#include <pthread.h>
#include "libknet.h"
#include "onwire.h"
#include "compat.h"
#define KNET_DATABUFSIZE KNET_MAX_PACKET_SIZE + KNET_HEADER_ALL_SIZE
#define KNET_DATABUFSIZE_CRYPT_PAD 1024
#define KNET_DATABUFSIZE_CRYPT KNET_DATABUFSIZE + KNET_DATABUFSIZE_CRYPT_PAD
#define KNET_DATABUFSIZE_COMPRESS_PAD 1024
#define KNET_DATABUFSIZE_COMPRESS KNET_DATABUFSIZE + KNET_DATABUFSIZE_COMPRESS_PAD
#define KNET_RING_RCVBUFF 8388608
#define PCKT_FRAG_MAX UINT8_MAX
#define PCKT_RX_BUFS 512
#define KNET_EPOLL_MAX_EVENTS KNET_DATAFD_MAX
typedef void *knet_transport_link_t; /* per link transport handle */
typedef void *knet_transport_t; /* per knet_h transport handle */
struct knet_transport_ops; /* Forward because of circular dependancy */
struct knet_mmsghdr {
struct msghdr msg_hdr; /* Message header */
unsigned int msg_len; /* Number of bytes transmitted */
};
struct knet_link {
/* required */
struct sockaddr_storage src_addr;
struct sockaddr_storage dst_addr;
/* configurable */
unsigned int dynamic; /* see KNET_LINK_DYN_ define above */
uint8_t priority; /* higher priority == preferred for A/P */
unsigned long long ping_interval; /* interval */
unsigned long long pong_timeout; /* timeout */
unsigned int latency_fix; /* precision */
uint8_t pong_count; /* how many ping/pong to send/receive before link is up */
uint64_t flags;
/* status */
struct knet_link_status status;
/* internals */
uint8_t link_id;
uint8_t transport_type; /* #defined constant from API */
knet_transport_link_t transport_link; /* link_info_t from transport */
int outsock;
unsigned int configured:1; /* set to 1 if src/dst have been configured transport initialized on this link*/
unsigned int transport_connected:1; /* set to 1 if lower level transport is connected */
unsigned int latency_exp;
uint8_t received_pong;
struct timespec ping_last;
/* used by PMTUD thread as temp per-link variables and should always contain the onwire_len value! */
uint32_t proto_overhead;
struct timespec pmtud_last;
uint32_t last_ping_size;
uint32_t last_good_mtu;
uint32_t last_bad_mtu;
uint32_t last_sent_mtu;
uint32_t last_recv_mtu;
uint8_t has_valid_mtu;
};
#define KNET_CBUFFER_SIZE 4096
struct knet_host_defrag_buf {
char buf[KNET_DATABUFSIZE];
uint8_t in_use; /* 0 buffer is free, 1 is in use */
seq_num_t pckt_seq; /* identify the pckt we are receiving */
uint8_t frag_recv; /* how many frags did we receive */
uint8_t frag_map[PCKT_FRAG_MAX];/* bitmap of what we received? */
uint8_t last_first; /* special case if we receive the last fragment first */
uint16_t frag_size; /* normal frag size (not the last one) */
uint16_t last_frag_size; /* the last fragment might not be aligned with MTU size */
struct timespec last_update; /* keep time of the last pckt */
};
struct knet_host {
/* required */
knet_node_id_t host_id;
/* configurable */
uint8_t link_handler_policy;
char name[KNET_MAX_HOST_LEN];
/* status */
struct knet_host_status status;
/* internals */
char circular_buffer[KNET_CBUFFER_SIZE];
seq_num_t rx_seq_num;
seq_num_t untimed_rx_seq_num;
seq_num_t timed_rx_seq_num;
uint8_t got_data;
/* defrag/reassembly buffers */
struct knet_host_defrag_buf defrag_buf[KNET_MAX_LINK];
char circular_buffer_defrag[KNET_CBUFFER_SIZE];
/* link stuff */
struct knet_link link[KNET_MAX_LINK];
uint8_t active_link_entries;
uint8_t active_links[KNET_MAX_LINK];
struct knet_host *next;
};
struct knet_sock {
int sockfd[2]; /* sockfd[0] will always be application facing
* and sockfd[1] internal if sockpair has been created by knet */
int is_socket; /* check if it's a socket for recvmmsg usage */
int is_created; /* knet created this socket and has to clean up on exit/del */
int in_use; /* set to 1 if it's use, 0 if free */
int has_error; /* set to 1 if there were errors reading from the sock
* and socket has been removed from epoll */
};
struct knet_fd_trackers {
uint8_t transport; /* transport type (UDP/SCTP...) */
uint8_t data_type; /* internal use for transport to define what data are associated
* to this fd */
void *data; /* pointer to the data */
};
#define KNET_MAX_FDS KNET_MAX_HOST * KNET_MAX_LINK * 4
#define KNET_MAX_COMPRESS_METHODS UINT8_MAX
struct knet_handle {
knet_node_id_t host_id;
unsigned int enabled:1;
struct knet_sock sockfd[KNET_DATAFD_MAX];
int logfd;
uint8_t log_levels[KNET_MAX_SUBSYSTEMS];
int hostsockfd[2];
int dstsockfd[2];
int send_to_links_epollfd;
int recv_from_links_epollfd;
int dst_link_handler_epollfd;
unsigned int pmtud_interval;
unsigned int data_mtu; /* contains the max data size that we can send onwire
* without frags */
struct knet_host *host_head;
struct knet_host *host_index[KNET_MAX_HOST];
knet_transport_t transports[KNET_MAX_TRANSPORTS+1];
- struct knet_transport_ops *transport_ops[KNET_MAX_TRANSPORTS+1];
struct knet_fd_trackers knet_transport_fd_tracker[KNET_MAX_FDS]; /* track status for each fd handled by transports */
struct knet_handle_stats stats;
uint32_t reconnect_int;
knet_node_id_t host_ids[KNET_MAX_HOST];
size_t host_ids_entries;
struct knet_header *recv_from_sock_buf;
struct knet_header *send_to_links_buf[PCKT_FRAG_MAX];
struct knet_header *recv_from_links_buf[PCKT_RX_BUFS];
struct knet_header *pingbuf;
struct knet_header *pmtudbuf;
pthread_t send_to_links_thread;
pthread_t recv_from_links_thread;
pthread_t heartbt_thread;
pthread_t dst_link_handler_thread;
pthread_t pmtud_link_handler_thread;
int lock_init_done;
pthread_rwlock_t global_rwlock; /* global config lock */
pthread_mutex_t pmtud_mutex; /* pmtud mutex to handle conditional send/recv + timeout */
pthread_cond_t pmtud_cond; /* conditional for above */
pthread_mutex_t tx_mutex; /* used to protect knet_send_sync and TX thread */
pthread_mutex_t hb_mutex; /* used to protect heartbeat thread and seq_num broadcasting */
struct crypto_instance *crypto_instance;
size_t sec_header_size;
size_t sec_block_size;
size_t sec_hash_size;
size_t sec_salt_size;
unsigned char *send_to_links_buf_crypt[PCKT_FRAG_MAX];
unsigned char *recv_from_links_buf_crypt;
unsigned char *recv_from_links_buf_decrypt;
unsigned char *pingbuf_crypt;
unsigned char *pmtudbuf_crypt;
int compress_model;
int compress_level;
size_t compress_threshold;
void *compress_int_data[KNET_MAX_COMPRESS_METHODS]; /* for compress method private data */
unsigned char *recv_from_links_buf_decompress;
unsigned char *send_to_links_buf_compress;
seq_num_t tx_seq_num;
pthread_mutex_t tx_seq_num_mutex;
uint8_t has_loop_link;
uint8_t loop_link;
void *dst_host_filter_fn_private_data;
int (*dst_host_filter_fn) (
void *private_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_node_id,
int8_t *channel,
knet_node_id_t *dst_host_ids,
size_t *dst_host_ids_entries);
void *pmtud_notify_fn_private_data;
void (*pmtud_notify_fn) (
void *private_data,
unsigned int data_mtu);
void *host_status_change_notify_fn_private_data;
void (*host_status_change_notify_fn) (
void *private_data,
knet_node_id_t host_id,
uint8_t reachable,
uint8_t remote,
uint8_t external);
void *sock_notify_fn_private_data;
void (*sock_notify_fn) (
void *private_data,
int datafd,
int8_t channel,
uint8_t tx_rx,
int error,
int errorno);
int fini_in_progress;
};
extern pthread_rwlock_t shlib_rwlock; /* global shared lib load lock */
/*
* NOTE: every single operation must be implementend
* for every protocol.
*/
typedef struct knet_transport_ops {
/*
* transport generic information
*/
const char *transport_name;
const uint8_t transport_id;
+ const uint8_t built_in;
+
uint32_t transport_mtu_overhead;
/*
* transport init must allocate the new transport
* and perform all internal initializations
* (threads, lists, etc).
*/
int (*transport_init)(knet_handle_t knet_h);
/*
* transport free must releases _all_ resources
* allocated by tranport_init
*/
int (*transport_free)(knet_handle_t knet_h);
/*
* link operations should take care of all the
* sockets and epoll management for a given link/transport set
* transport_link_disable should return err = -1 and errno = EBUSY
* if listener is still in use, and any other errno in case
* the link cannot be disabled.
*
* set_config/clear_config are invoked in global write lock context
*/
int (*transport_link_set_config)(knet_handle_t knet_h, struct knet_link *link);
int (*transport_link_clear_config)(knet_handle_t knet_h, struct knet_link *link);
/*
* transport callback for incoming dynamic connections
* this is called in global read lock context
*/
int (*transport_link_dyn_connect)(knet_handle_t knet_h, int sockfd, struct knet_link *link);
/*
* per transport error handling of recvmmsg
* (see _handle_recv_from_links comments for details)
*/
/*
* transport_rx_sock_error is invoked when recvmmsg returns <= 0
*
* transport_rx_sock_error is invoked with both global_rdlock
*/
int (*transport_rx_sock_error)(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno);
/*
* transport_tx_sock_error is invoked with global_rwlock and
* it's invoked when sendto or sendmmsg returns =< 0
*
* it should return:
* -1 on internal error
* 0 ignore error and continue
* 1 retry
* any sleep or wait action should happen inside the transport code
*/
int (*transport_tx_sock_error)(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno);
/*
* this function is called on _every_ received packet
* to verify if the packet is data or internal protocol error handling
*
* it should return:
* -1 on error
* 0 packet is not data and we should continue the packet process loop
* 1 packet is not data and we should STOP the packet process loop
* 2 packet is data and should be parsed as such
*
* transport_rx_is_data is invoked with both global_rwlock
* and fd_tracker read lock (from RX thread)
*/
int (*transport_rx_is_data)(knet_handle_t knet_h, int sockfd, struct knet_mmsghdr *msg);
} knet_transport_ops_t;
socklen_t sockaddr_len(const struct sockaddr_storage *ss);
/**
* This is a kernel style list implementation.
*
* @author Steven Dake <sdake@redhat.com>
*/
struct knet_list_head {
struct knet_list_head *next;
struct knet_list_head *prev;
};
/**
* @def KNET_LIST_DECLARE()
* Declare and initialize a list head.
*/
#define KNET_LIST_DECLARE(name) \
struct knet_list_head name = { &(name), &(name) }
#define KNET_INIT_LIST_HEAD(ptr) do { \
(ptr)->next = (ptr); (ptr)->prev = (ptr); \
} while (0)
/**
* Initialize the list entry.
*
* Points next and prev pointers to head.
* @param head pointer to the list head
*/
static inline void knet_list_init(struct knet_list_head *head)
{
head->next = head;
head->prev = head;
}
/**
* Add this element to the list.
*
* @param element the new element to insert.
* @param head pointer to the list head
*/
static inline void knet_list_add(struct knet_list_head *element,
struct knet_list_head *head)
{
head->next->prev = element;
element->next = head->next;
element->prev = head;
head->next = element;
}
/**
* Add to the list (but at the end of the list).
*
* @param element pointer to the element to add
* @param head pointer to the list head
* @see knet_list_add()
*/
static inline void knet_list_add_tail(struct knet_list_head *element,
struct knet_list_head *head)
{
head->prev->next = element;
element->next = head;
element->prev = head->prev;
head->prev = element;
}
/**
* Delete an entry from the list.
*
* @param _remove the list item to remove
*/
static inline void knet_list_del(struct knet_list_head *_remove)
{
_remove->next->prev = _remove->prev;
_remove->prev->next = _remove->next;
}
/**
* Replace old entry by new one
* @param old: the element to be replaced
* @param new: the new element to insert
*/
static inline void knet_list_replace(struct knet_list_head *old,
struct knet_list_head *new)
{
new->next = old->next;
new->next->prev = new;
new->prev = old->prev;
new->prev->next = new;
}
/**
* Tests whether list is the last entry in list head
* @param list: the entry to test
* @param head: the head of the list
* @return boolean true/false
*/
static inline int knet_list_is_last(const struct knet_list_head *list,
const struct knet_list_head *head)
{
return list->next == head;
}
/**
* A quick test to see if the list is empty (pointing to it's self).
* @param head pointer to the list head
* @return boolean true/false
*/
static inline int32_t knet_list_empty(const struct knet_list_head *head)
{
return head->next == head;
}
/**
* Get the struct for this entry
* @param ptr: the &struct list_head pointer.
* @param type: the type of the struct this is embedded in.
* @param member: the name of the list_struct within the struct.
*/
#define knet_list_entry(ptr,type,member)\
((type *)((char *)(ptr)-(char*)(&((type *)0)->member)))
/**
* Get the first element from a list
* @param ptr: the &struct list_head pointer.
* @param type: the type of the struct this is embedded in.
* @param member: the name of the list_struct within the struct.
*/
#define knet_list_first_entry(ptr, type, member) \
knet_list_entry((ptr)->next, type, member)
/**
* Iterate over a list
* @param pos: the &struct list_head to use as a loop counter.
* @param head: the head for your list.
*/
#define knet_list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); pos = pos->next)
/**
* Iterate over a list backwards
* @param pos: the &struct list_head to use as a loop counter.
* @param head: the head for your list.
*/
#define knet_list_for_each_reverse(pos, head) \
for (pos = (head)->prev; pos != (head); pos = pos->prev)
/**
* Iterate over a list safe against removal of list entry
* @param pos: the &struct list_head to use as a loop counter.
* @param n: another &struct list_head to use as temporary storage
* @param head: the head for your list.
*/
#define knet_list_for_each_safe(pos, n, head) \
for (pos = (head)->next, n = pos->next; pos != (head); \
pos = n, n = pos->next)
/**
* Iterate over list of given type
* @param pos: the type * to use as a loop counter.
* @param head: the head for your list.
* @param member: the name of the list_struct within the struct.
*/
#define knet_list_for_each_entry(pos, head, member) \
for (pos = knet_list_entry((head)->next, typeof(*pos), member); \
&pos->member != (head); \
pos = knet_list_entry(pos->member.next, typeof(*pos), member))
#endif
diff --git a/libknet/libknet.h b/libknet/libknet.h
index 7ba4cdc4..77f2fa1f 100644
--- a/libknet/libknet.h
+++ b/libknet/libknet.h
@@ -1,1924 +1,1938 @@
/*
* Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
*
* Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
* Federico Simoncelli <fsimon@kronosnet.org>
*
* This software licensed under GPL-2.0+, LGPL-2.0+
*/
#ifndef __LIBKNET_H__
#define __LIBKNET_H__
#include <stdint.h>
#include <time.h>
#include <netinet/in.h>
/**
* @file libknet.h
* @brief kronosnet API include file
* @copyright Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
*
* Kronosnet is an advanced VPN system for High Availability applications.
*/
/*
* libknet limits
*/
/*
* Maximum number of hosts
*/
typedef uint16_t knet_node_id_t;
#define KNET_MAX_HOST 65536
/*
* Maximum number of links between 2 hosts
*/
#define KNET_MAX_LINK 8
/*
* Maximum packet size that should be written to datafd
* see knet_handle_new for details
*/
#define KNET_MAX_PACKET_SIZE 65536
/*
* Buffers used for pretty logging
* host is used to store both ip addresses and hostnames
*/
#define KNET_MAX_HOST_LEN 256
#define KNET_MAX_PORT_LEN 6
/*
* Some notifications can be generated either on TX or RX
*/
#define KNET_NOTIFY_TX 0
#define KNET_NOTIFY_RX 1
/*
* Link flags
*/
/*
* Where possible, set traffic priority to high.
* On Linux this sets the TOS to INTERACTIVE (6),
* see tc-prio(8) for more infomation
*/
#define KNET_LINK_FLAG_TRAFFICHIPRIO (1ULL << 0)
typedef struct knet_handle *knet_handle_t;
/*
* Handle structs/API calls
*/
/**
* knet_handle_new
*
* @brief create a new instance of a knet handle
*
* host_id - Each host in a knet is identified with a unique
* ID. when creating a new handle local host_id
* must be specified (0 to UINT16T_MAX are all valid).
* It is the user's responsibility to check that the value
* is unique, or bad things might happen.
*
* log_fd - Write file descriptor. If set to a value > 0, it will be used
* to write log packets from libknet to the application.
* Setting to 0 will disable logging from libknet.
* It is possible to enable logging at any given time (see logging API).
* Make sure to either read from this filedescriptor properly and/or
* mark it O_NONBLOCK, otherwise if the fd becomes full, libknet could
* block.
*
* default_log_level -
* If logfd is specified, it will initialize all subsystems to log
* at default_log_level value. (see logging API)
*
* @return
* on success, a new knet_handle_t is returned.
* on failure, NULL is returned and errno is set.
*/
knet_handle_t knet_handle_new(knet_node_id_t host_id,
int log_fd,
uint8_t default_log_level);
/**
* knet_handle_free
* @brief Destroy a knet handle, free all resources
*
* knet_h - pointer to knet_handle_t
*
* @return
* knet_handle_free returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_handle_free(knet_handle_t knet_h);
/**
* knet_handle_enable_sock_notify
* @brief Register a callback to receive socket events
*
* knet_h - pointer to knet_handle_t
*
* sock_notify_fn_private_data
* void pointer to data that can be used to identify
* the callback.
*
* sock_notify_fn
* A callback function that is invoked every time
* a socket in the datafd pool will report an error (-1)
* or an end of read (0) (see socket.7).
* This function MUST NEVER block or add substantial delays.
* The callback is invoked in an internal unlocked area
* to allow calls to knet_handle_add_datafd/knet_handle_remove_datafd
* to swap/replace the bad fd.
* if both err and errno are 0, it means that the socket
* has received a 0 byte packet (EOF?).
* The callback function must either remove the fd from knet
* (by calling knet_handle_remove_fd()) or dup a new fd in its place.
* Failure to do this can cause problems.
*
* @return
* knet_handle_enable_sock_notify returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_handle_enable_sock_notify(knet_handle_t knet_h,
void *sock_notify_fn_private_data,
void (*sock_notify_fn) (
void *private_data,
int datafd,
int8_t channel,
uint8_t tx_rx,
int error,
int errorno)); /* sorry! can't call it errno ;) */
#define KNET_DATAFD_MAX 32
/**
* knet_handle_add_datafd
*
* @brief Install a file descriptor for communication
*
* IMPORTANT: In order to add datafd to knet, knet_handle_enable_sock_notify
* _MUST_ be set and be able to handle both errors (-1) and
* 0 bytes read / write from the provided datafd.
* On read error (< 0) from datafd, the socket is automatically
* removed from polling to avoid spinning on dead sockets.
* It is safe to call knet_handle_remove_datafd even on sockets
* that have been removed.
*
* knet_h - pointer to knet_handle_t
*
* *datafd - read/write file descriptor.
* knet will read data here to send to the other hosts
* and will write data received from the network.
* Each data packet can be of max size KNET_MAX_PACKET_SIZE!
* Applications using knet_send/knet_recv will receive a
* proper error if the packet size is not within boundaries.
* Applications using their own functions to write to the
* datafd should NOT write more than KNET_MAX_PACKET_SIZE.
*
* Please refer to handle.c on how to set up a socketpair.
*
* datafd can be 0, and knet_handle_add_datafd will create a properly
* populated socket pair the same way as ping_test, or a value
* higher than 0. A negative number will return an error.
* On exit knet_handle_free will take care to cleanup the
* socketpair only if they have been created by knet_handle_add_datafd.
*
* It is possible to pass either sockets or normal fds.
* User provided datafd will be marked as non-blocking and close-on-exit.
*
* *channel - This value has the same effect of VLAN tagging.
* A negative value will auto-allocate a channel.
* Setting a value between 0 and 31 will try to allocate that
* specific channel (unless already in use).
*
* It is possible to add up to 32 datafds but be aware that each
* one of them must have a receiving end on the other host.
*
* Example:
* hostA channel 0 will be delivered to datafd on hostB channel 0
* hostA channel 1 to hostB channel 1.
*
* Each channel must have a unique file descriptor.
*
* If your application could have 2 channels on one host and one
* channel on another host, then you can use dst_host_filter
* to manipulate channel values on TX and RX.
*
* @return
* knet_handle_add_datafd returns
* @retval 0 on success,
* *datafd will be populated with a socket if the original value was 0
* or if a specific fd was set, the value is untouched.
* *channel will be populated with a channel number if the original value
* was negative or the value is untouched if a specific channel
* was requested.
*
* @retval -1 on error and errno is set.
* *datafd and *channel are untouched or empty.
*/
int knet_handle_add_datafd(knet_handle_t knet_h, int *datafd, int8_t *channel);
/**
* knet_handle_remove_datafd
* @brief Remove a file descriptor from knet
*
* knet_h - pointer to knet_handle_t
*
* datafd - file descriptor to remove.
* NOTE that if the socket/fd was created by knet_handle_add_datafd,
* the socket will be closed by libknet.
*
* @return
* knet_handle_remove_datafd returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_handle_remove_datafd(knet_handle_t knet_h, int datafd);
/**
* knet_handle_get_channel
* @brief Get the channel associated with a file descriptor
*
* knet_h - pointer to knet_handle_t
*
* datafd - get the channel associated to this datafd
*
* *channel - will contain the result
*
* @return
* knet_handle_get_channel returns
* @retval 0 on success
* and *channel will contain the result
* @retval -1 on error and errno is set.
* and *channel content is meaningless
*/
int knet_handle_get_channel(knet_handle_t knet_h, const int datafd, int8_t *channel);
/**
* knet_handle_get_datafd
* @brief Get the file descriptor associated with a channel
*
* knet_h - pointer to knet_handle_t
*
* channel - get the datafd associated to this channel
*
* *datafd - will contain the result
*
* @return
* knet_handle_get_datafd returns
* @retval 0 on success
* and *datafd will contain the results
* @retval -1 on error and errno is set.
* and *datafd content is meaningless
*/
int knet_handle_get_datafd(knet_handle_t knet_h, const int8_t channel, int *datafd);
/**
* knet_recv
* @brief Receive data from knet nodes
*
* knet_h - pointer to knet_handle_t
*
* buff - pointer to buffer to store the received data
*
* buff_len - buffer length
*
* channel - channel number
*
* @return
* knet_recv is a commodity function to wrap iovec operations
* around a socket. It returns a call to readv(2).
*/
ssize_t knet_recv(knet_handle_t knet_h,
char *buff,
const size_t buff_len,
const int8_t channel);
/**
* knet_send
* @brief Send data to knet nodes
*
* knet_h - pointer to knet_handle_t
*
* buff - pointer to the buffer of data to send
*
* buff_len - length of data to send
*
* channel - channel number
*
* @return
* knet_send is a commodity function to wrap iovec operations
* around a socket. It returns a call to writev(2).
*/
ssize_t knet_send(knet_handle_t knet_h,
const char *buff,
const size_t buff_len,
const int8_t channel);
/**
* knet_send_sync
*
* @brief Synchronously send data to knet nodes
*
* knet_h - pointer to knet_handle_t
*
* buff - pointer to the buffer of data to send
*
* buff_len - length of data to send
*
* channel - data channel to use (see knet_handle_add_datafd(3))
*
* All knet RX/TX operations are async for performance reasons.
* There are applications that might need a sync version of data
* transmission and receive errors in case of failure to deliver
* to another host.
* knet_send_sync bypasses the whole TX async layer and delivers
* data directly to the link layer, and returns errors accordingly.
* knet_send_sync allows to send only one packet to one host at
* a time. It does NOT support multiple destinations or multicast
* packets. Decision is still based on dst_host_filter_fn.
*
* @return
* knet_send_sync returns 0 on success and -1 on error.
* In addition to normal sendmmsg errors, knet_send_sync can fail
* due to:
*
* @retval ECANCELED - data forward is disabled
* @retval EFAULT - dst_host_filter fatal error
* @retval EINVAL - dst_host_filter did not provide dst_host_ids_entries on unicast pckts
* @retval E2BIG - dst_host_filter did return more than one dst_host_ids_entries on unicast pckts
* @retval ENOMSG - received unknown message type
* @retval EHOSTDOWN - unicast pckt cannot be delivered because dest host is not connected yet
* @retval ECHILD - crypto failed
* @retval EAGAIN - sendmmsg was unable to send all messages and there was no progress during retry
*/
int knet_send_sync(knet_handle_t knet_h,
const char *buff,
const size_t buff_len,
const int8_t channel);
/**
* knet_handle_enable_filter
*
* @brief install a filter to route packets
*
* knet_h - pointer to knet_handle_t
*
* dst_host_filter_fn_private_data
* void pointer to data that can be used to identify
* the callback.
*
* dst_host_filter_fn -
* is a callback function that is invoked every time
* a packet hits datafd (see knet_handle_new(3)).
* the function allows users to tell libknet where the
* packet has to be delivered.
*
* const unsigned char *outdata - is a pointer to the
* current packet
* ssize_t outdata_len - length of the above data
* uint8_t tx_rx - filter is called on tx or rx
* (KNET_NOTIFY_TX, KNET_NOTIFY_RX)
* knet_node_id_t this_host_id - host_id processing the packet
* knet_node_id_t src_host_id - host_id that generated the
* packet
* knet_node_id_t *dst_host_ids - array of KNET_MAX_HOST knet_node_id_t
* where to store the destinations
* size_t *dst_host_ids_entries - number of hosts to send the message
*
* dst_host_filter_fn should return
* -1 on error, packet is discarded.
* 0 packet is unicast and should be sent to dst_host_ids and there are
* dst_host_ids_entries in the buffer.
* 1 packet is broadcast/multicast and is sent all hosts.
* contents of dst_host_ids and dst_host_ids_entries are ignored.
* (see also kronosnetd/etherfilter.* for an example that filters based
* on ether protocol)
*
* @return
* knet_handle_enable_filter returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_handle_enable_filter(knet_handle_t knet_h,
void *dst_host_filter_fn_private_data,
int (*dst_host_filter_fn) (
void *private_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 *channel,
knet_node_id_t *dst_host_ids,
size_t *dst_host_ids_entries));
/**
* knet_handle_setfwd
*
* @brief Start packet forwarding
*
* knet_h - pointer to knet_handle_t
*
* enable - set to 1 to allow data forwarding, 0 to disable data forwarding.
*
* @return
* knet_handle_setfwd returns
* 0 on success
* -1 on error and errno is set.
*
* By default data forwarding is off and no traffic will pass through knet until
* it is set on.
*/
int knet_handle_setfwd(knet_handle_t knet_h, unsigned int enabled);
#define KNET_PMTUD_DEFAULT_INTERVAL 60
/**
* knet_handle_pmtud_setfreq
*
* @brief Set the interval between PMTUd scans
*
* knet_h - pointer to knet_handle_t
*
* interval - define the interval in seconds between PMTUd scans
* range from 1 to 86400 (24h)
*
* @return
* knet_handle_pmtud_setfreq returns
* 0 on success
* -1 on error and errno is set.
*
* default interval is 60.
*/
int knet_handle_pmtud_setfreq(knet_handle_t knet_h, unsigned int interval);
/**
* knet_handle_pmtud_getfreq
*
* @brief Get the interval between PMTUd scans
*
* knet_h - pointer to knet_handle_t
*
* interval - pointer where to store the current interval value
*
* @return
* knet_handle_pmtud_setfreq returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_handle_pmtud_getfreq(knet_handle_t knet_h, unsigned int *interval);
/**
* knet_handle_enable_pmtud_notify
*
* @brief install a callback to receive PMTUd changes
*
* knet_h - pointer to knet_handle_t
*
* pmtud_notify_fn_private_data
* void pointer to data that can be used to identify
* the callback.
*
* pmtud_notify_fn
* is a callback function that is invoked every time
* a path MTU size change is detected.
* The function allows libknet to notify the user
* of data MTU, that's the max value that can be send
* onwire without fragmentation. The data MTU will always
* be lower than real link MTU because it accounts for
* protocol overhead, knet packet header and (if configured)
* crypto overhead,
* This function MUST NEVER block or add substantial delays.
*
* @return
* knet_handle_enable_pmtud_notify returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_handle_enable_pmtud_notify(knet_handle_t knet_h,
void *pmtud_notify_fn_private_data,
void (*pmtud_notify_fn) (
void *private_data,
unsigned int data_mtu));
/**
* knet_handle_pmtud_get
*
* @brief Get the current data MTU
*
* knet_h - pointer to knet_handle_t
*
* data_mtu - pointer where to store data_mtu
*
* @return
* knet_handle_pmtud_get returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_handle_pmtud_get(knet_handle_t knet_h,
unsigned int *data_mtu);
#define KNET_MIN_KEY_LEN 256
#define KNET_MAX_KEY_LEN 4096
struct knet_handle_crypto_cfg {
char crypto_model[16];
char crypto_cipher_type[16];
char crypto_hash_type[16];
unsigned char private_key[KNET_MAX_KEY_LEN];
unsigned int private_key_len;
};
/**
* knet_handle_crypto
*
* @brief set up packet cryptographic signing & encryption
*
* knet_h - pointer to knet_handle_t
*
* knet_handle_crypto_cfg -
* pointer to a knet_handle_crypto_cfg structure
*
* crypto_model should contain the model name.
* Currently only "openssl" and "nss" are supported.
* Setting to "none" will disable crypto.
*
* crypto_cipher_type
* should contain the cipher algo name.
* It can be set to "none" to disable
* encryption.
* Currently supported by "nss" model:
* "3des", "aes128", "aes192" and "aes256".
* "openssl" model supports more modes and it strictly
* depends on the openssl build. See: EVP_get_cipherbyname
* openssl API call for details.
*
* crypto_hash_type
* should contain the hashing algo name.
* It can be set to "none" to disable
* hashing.
* Currently supported by "nss" model:
* "md5", "sha1", "sha256", "sha384" and "sha512".
* "openssl" model supports more modes and it strictly
* depends on the openssl build. See: EVP_get_digestbyname
* openssl API call for details.
*
* private_key will contain the private shared key.
* It has to be at least KNET_MIN_KEY_LEN long.
*
* private_key_len
* length of the provided private_key.
*
* Implementation notes/current limitations:
* - enabling crypto, will increase latency as packets have
* to processed.
* - enabling crypto might reduce the overall throughtput
* due to crypto data overhead.
* - re-keying is not implemented yet.
* - private/public key encryption/hashing is not currently
* planned.
* - crypto key must be the same for all hosts in the same
* knet instance.
* - it is safe to call knet_handle_crypto multiple times at runtime.
* The last config will be used.
* IMPORTANT: a call to knet_handle_crypto can fail due to:
* 1) failure to obtain locking
* 2) errors to initializing the crypto level.
* This can happen even in subsequent calls to knet_handle_crypto.
* A failure in crypto init, might leave your traffic unencrypted!
* It's best to stop data forwarding (see knet_handle_setfwd(3)), change crypto config,
* start forward again.
*
* @return
* knet_handle_crypto returns:
* @retval 0 on success
* @retval -1 on error and errno is set.
* @retval -2 on crypto subsystem initialization error. No errno is provided at the moment (yet).
*/
int knet_handle_crypto(knet_handle_t knet_h,
struct knet_handle_crypto_cfg *knet_handle_crypto_cfg);
#define KNET_COMPRESS_THRESHOLD 100
struct knet_handle_compress_cfg {
char compress_model[16];
uint32_t compress_threshold;
int compress_level;
};
/**
* knet_handle_compress
*
* @brief Set up packet compression
*
* knet_h - pointer to knet_handle_t
*
* knet_handle_compress_cfg -
* pointer to a knet_handle_compress_cfg structure
*
* compress_model should contain the mode name.
* Currently only "zlib" and "lz4" are supported.
* Setting to "none" will disable compression.
*
* compress_threshold
* tells the transmission thread to NOT compress
* any packets that are smaller than the value
* indicated. Default 100 bytes.
* Set to 0 to reset to the default.
* Set to 1 to compress everything.
* Max accepted value is KNET_MAX_PACKET_SIZE.
*
* compress_level some compression libraries allow tuning of compression
* parameters.
* For example zlib value ranges from 0 to 9 where 0 is no
* compression and 9 is max compression.
* This value is passed pristine to the compression library.
* zlib: 0 (no compression), 1 (minimal) .. 9 (max compression).
* lz4: 1 (max compression)... 9 (fastest compression).
* lz4hc: 1 (min compression) ... LZ4HC_MAX_CLEVEL (16) or LZ4HC_CLEVEL_MAX (12)
* depends on the installed version of lz4hc. libknet can detects the max
* value and will print an appropriate warning.
* lzo2: accepts only some specific values depending on the
* requested algorithm:
* 1 : lzo1x_1_compress (default)
* 11 : lzo1x_1_11_compress
* 12 : lzo1x_1_12_compress
* 15 : lzo1x_1_15_compress
* 999: lzo1x_999_compress
* every other values will use default
* lzma: 0 (minimal) .. 9 (max compression)
* bzip2: 1 (minimal) .. 9 (max compression)
* Please refer to the library man pages
* on how to be set this value, as it is passed
* unmodified to the compression algorithm where supported.
*
* Implementation notes:
* - it is possible to enable/disable compression at any time.
* - nodes can be using a different compression algorithm at any time.
* - knet does NOT implement the compression algorithm directly. it relies
* on external libraries for this functionality. Please read
* the libraries man pages to figure out which algorithm/compression
* level is best for the data you are planning to transmit.
*
* @return
* knet_handle_compress returns
* 0 on success
* -1 on error and errno is set. EINVAL means that either the model or the
* level are not supported.
*/
int knet_handle_compress(knet_handle_t knet_h,
struct knet_handle_compress_cfg *knet_handle_compress_cfg);
struct knet_handle_stats {
size_t size;
uint64_t tx_uncompressed_packets;
uint64_t tx_compressed_packets;
uint64_t tx_compressed_original_bytes;
uint64_t tx_compressed_size_bytes;
uint64_t tx_compress_time_ave;
uint64_t tx_compress_time_min;
uint64_t tx_compress_time_max;
uint64_t rx_compressed_packets;
uint64_t rx_compressed_original_bytes;
uint64_t rx_compressed_size_bytes;
uint64_t rx_compress_time_ave;
uint64_t rx_compress_time_min;
uint64_t rx_compress_time_max;
/* Overhead times, measured in usecs */
uint64_t tx_crypt_packets;
uint64_t tx_crypt_byte_overhead;
uint64_t tx_crypt_time_ave;
uint64_t tx_crypt_time_min;
uint64_t tx_crypt_time_max;
uint64_t rx_crypt_packets;
uint64_t rx_crypt_time_ave;
uint64_t rx_crypt_time_min;
uint64_t rx_crypt_time_max;
};
/**
* knet_handle_get_stats
*
* @brief Get statistics for compression & crypto
*
* knet_h - pointer to knet_handle_t
*
* knet_handle_stats
* pointer to a knet_handle_stats structure
*
* struct_size
* size of knet_handle_stats structure to allow
* for backwards compatibility. libknet will only
* copy this much data into the stats structure
* so that older callers will not get overflowed if
* new fields are added.
*
* @return
* 0 on success
* -1 on error and errno is set.
*
*/
int knet_handle_get_stats(knet_handle_t knet_h, struct knet_handle_stats *stats, size_t struct_size);
/*
* Tell knet_handle_clear_stats whether to clear just the handle stats
* or all of them.
*/
#define KNET_CLEARSTATS_HANDLE_ONLY 1
#define KNET_CLEARSTATS_HANDLE_AND_LINK 2
/**
* knet_handle_clear_stats
*
* @brief Clear knet stats, link and/or handle
*
* knet_h - pointer to knet_handle_t
*
* clear_option - Which stats to clear, must be one of
*
* KNET_CLEARSTATS_HANDLE_ONLY or
* KNET_CLEARSTATS_HANDLE_AND_LINK
*
* @return
* 0 on success
* -1 on error and errno is set.
*
*/
int knet_handle_clear_stats(knet_handle_t knet_h, int clear_option);
+
+
+struct knet_crypto_info {
+ const char *name; /* openssl,nss,etc.. */
+ uint8_t properties; /* currently unused */
+ char pad[256]; /* currently unused */
+};
+
/**
- * knet_handle_get_crypto_list
+ * knet_get_crypto_list
*
* @brief Get a list of supported crypto libraries
*
- * knet_h - pointer to knet_handle_t
- *
- * crypto_names - array of char *
- * If NULL then only the number of names is returned in num_names to
- * to allow the caller to allocate sufficient space.
+ * crypto_list - array of struct knet_crypto_info *
+ * If NULL then only the number of structs is returned in crypto_list_entries
+ * to allow the caller to allocate sufficient space.
+ * libknet does not allow more than 256 crypto methods at the moment.
+ * it is safe to allocate 256 structs to avoid calling
+ * knet_get_crypto_list twice.
*
- * num_names - returns the number of strings in crypto_names
+ * crypto_list_entries - returns the number of structs in crypto_list
*
* @return
- * knet_host_add returns
+ * knet_get_crypto_list returns
* 0 on success
* -1 on error and errno is set.
*/
-int knet_handle_get_crypto_list(knet_handle_t knet_h, const char **crypto_names, size_t *num_names);
+int knet_get_crypto_list(struct knet_crypto_info *crypto_list,
+ size_t *crypto_list_entries);
+
+
+
+struct knet_compress_info {
+ const char *name; /* bzip2, lz4, etc.. */
+ uint8_t properties; /* currently unused */
+ char pad[256]; /* currently unused */
+};
/**
- * knet_handle_get_compress_list
+ * knet_get_compress_list
*
* @brief Get a list of support compression types
*
- * knet_h - pointer to knet_handle_t
+ * compress_list - array of struct knet_compress_info *
+ * If NULL then only the number of structs is returned in compress_list_entries
+ * to allow the caller to allocate sufficient space.
+ * libknet does not allow more than 256 compress methods at the moment.
+ * it is safe to allocate 256 structs to avoid calling
+ * knet_get_compress_list twice.
*
- * compress_names - array of char *
- * If NULL then only the number of names is returned in num_names to
- * to allow the caller to allocate sufficient space.
- *
- * num_names - returns the number of strings in compres_names
+ * compress_list_entries - returns the number of structs in compress_list
*
* @return
- * knet_host_add returns
+ * knet_get_compress_list returns
* 0 on success
* -1 on error and errno is set.
*/
-int knet_handle_get_compress_list(knet_handle_t knet_h, const char **compress_names, size_t *num_names);
+int knet_get_compress_list(struct knet_compress_info *compress_list,
+ size_t *compress_list_entries);
/*
* host structs/API calls
*/
/**
* knet_host_add
*
* @brief Add a new host ID to knet
*
* knet_h - pointer to knet_handle_t
*
* host_id - each host in a knet is identified with a unique ID
* (see also knet_handle_new(3))
*
* @return
* knet_host_add returns:
* 0 on success
* -1 on error and errno is set.
*/
int knet_host_add(knet_handle_t knet_h, knet_node_id_t host_id);
/**
* knet_host_remove
*
* @brief Remove a host ID from knet
*
* knet_h - pointer to knet_handle_t
*
* host_id - each host in a knet is identified with a unique ID
* (see also knet_handle_new(3))
*
* @return
* knet_host_remove returns:
* 0 on success
* -1 on error and errno is set.
*/
int knet_host_remove(knet_handle_t knet_h, knet_node_id_t host_id);
/**
* knet_host_set_name
*
* @brief Set the name of a knet host
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* name - this name will be used for pretty logging and eventually
* search for hosts (see also knet_handle_host_get_name(2) and knet_handle_host_get_id(3)).
* Only up to KNET_MAX_HOST_LEN - 1 bytes will be accepted and
* name has to be unique for each host.
*
* @return
* knet_host_set_name returns:
* 0 on success
* -1 on error and errno is set.
*/
int knet_host_set_name(knet_handle_t knet_h, knet_node_id_t host_id,
const char *name);
/**
* knet_host_get_name_by_host_id
*
* @brief Get the name of a host given its ID
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* name - pointer to a preallocated buffer of at least size KNET_MAX_HOST_LEN
* where the current host name will be stored
* (as set by knet_host_set_name or default by knet_host_add)
*
* @return
* knet_host_get_name_by_host_id returns:
* 0 on success
* -1 on error and errno is set (name is left untouched)
*/
int knet_host_get_name_by_host_id(knet_handle_t knet_h, knet_node_id_t host_id,
char *name);
/**
* knet_host_get_id_by_host_name
*
* @brief Get the ID of a host given its name
*
* knet_h - pointer to knet_handle_t
*
* name - name to lookup, max len KNET_MAX_HOST_LEN
*
* host_id - where to store the result
*
* @return
* knet_host_get_id_by_host_name returns:
* 0 on success
* -1 on error and errno is set.
*/
int knet_host_get_id_by_host_name(knet_handle_t knet_h, const char *name,
knet_node_id_t *host_id);
/**
* knet_host_get_host_list
*
* @brief Get a list of hosts known to knet
*
* knet_h - pointer to knet_handle_t
*
* host_ids - array of at lest KNET_MAX_HOST size
*
* host_ids_entries -
* number of entries writted in host_ids
*
* @return
* knet_host_get_host_list returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_host_get_host_list(knet_handle_t knet_h,
knet_node_id_t *host_ids, size_t *host_ids_entries);
/*
* define switching policies
*/
#define KNET_LINK_POLICY_PASSIVE 0
#define KNET_LINK_POLICY_ACTIVE 1
#define KNET_LINK_POLICY_RR 2
/**
* knet_host_set_policy
*
* knet_h - pointer to knet_handle_t
*
* @brief Set the switching policy for a host's links
*
* host_id - see knet_host_add(3)
*
* policy - there are currently 3 kind of simple switching policies
* based on link configuration.
* KNET_LINK_POLICY_PASSIVE - the active link with the lowest
* priority will be used.
* if one or more active links share
* the same priority, the one with
* lowest link_id will be used.
*
* KNET_LINK_POLICY_ACTIVE - all active links will be used
* simultaneously to send traffic.
* link priority is ignored.
*
* KNET_LINK_POLICY_RR - round-robin policy, every packet
* will be send on a different active
* link.
*
* @return
* knet_host_set_policy returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_host_set_policy(knet_handle_t knet_h, knet_node_id_t host_id,
uint8_t policy);
/**
* knet_host_get_policy
*
* @brief Get the switching policy for a host's links
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* policy - will contain the current configured switching policy.
* Default is passive when creating a new host.
*
* @return
* knet_host_get_policy returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_host_get_policy(knet_handle_t knet_h, knet_node_id_t host_id,
uint8_t *policy);
/**
* knet_host_enable_status_change_notify
*
* @brief Install a callback to get host status change events
*
* knet_h - pointer to knet_handle_t
*
* host_status_change_notify_fn_private_data -
* void pointer to data that can be used to identify
* the callback
*
* host_status_change_notify_fn -
* is a callback function that is invoked every time
* there is a change in the host status.
* host status is identified by:
* - reachable, this host can send/receive data to/from host_id
* - remote, 0 if the host_id is connected locally or 1 if
* the there is one or more knet host(s) in between.
* NOTE: re-switching is NOT currently implemented,
* but this is ready for future and can avoid
* an API/ABI breakage later on.
* - external, 0 if the host_id is configured locally or 1 if
* it has been added from remote nodes config.
* NOTE: dynamic topology is NOT currently implemented,
* but this is ready for future and can avoid
* an API/ABI breakage later on.
* This function MUST NEVER block or add substantial delays.
*
* @return
* knet_host_status_change_notify returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_host_enable_status_change_notify(knet_handle_t knet_h,
void *host_status_change_notify_fn_private_data,
void (*host_status_change_notify_fn) (
void *private_data,
knet_node_id_t host_id,
uint8_t reachable,
uint8_t remote,
uint8_t external));
/*
* define host status structure for quick lookup
* struct is in flux as more stats will be added soon
*
* reachable host_id can be seen either directly connected
* or via another host_id
*
* remote 0 = node is connected locally, 1 is visible via
* via another host_id
*
* external 0 = node is configured/known locally,
* 1 host_id has been received via another host_id
*/
struct knet_host_status {
uint8_t reachable;
uint8_t remote;
uint8_t external;
/* add host statistics */
};
/**
* knet_host_status_get
*
* @brief Get the status of a host
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* status - pointer to knet_host_status struct
*
* @return
* knet_handle_pmtud_get returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_host_get_status(knet_handle_t knet_h, knet_node_id_t host_id,
struct knet_host_status *status);
/*
* link structs/API calls
*
* every host allocated/managed by knet_host_* has
* KNET_MAX_LINK structures to define the network
* paths that connect 2 hosts.
*
* Each link is identified by a link_id that has a
* values between 0 and KNET_MAX_LINK - 1.
*
* KNOWN LIMITATIONS:
*
* - let's assume the scenario where two hosts are connected
* with any number of links. link_id must match on both sides.
* If host_id 0 link_id 0 is configured to connect IP1 to IP2 and
* host_id 0 link_id 1 is configured to connect IP3 to IP4,
* host_id 1 link_id 0 _must_ connect IP2 to IP1 and likewise
* host_id 1 link_id 1 _must_ connect IP4 to IP3.
* We might be able to lift this restriction in future, by using
* other data to determine src/dst link_id, but for now, deal with it.
*/
/*
* commodity functions to convert strings to sockaddr and viceversa
*/
/**
* knet_strtoaddr
*
* @brief Convert a hostname string to an address
*
* host - IPaddr/hostname to convert
* be aware only the first IP address will be returned
* in case a hostname resolves to multiple IP
*
* port - port to connect to
*
* ss - sockaddr_storage where to store the converted data
*
* sslen - len of the sockaddr_storage
*
* @return
* knet_strtoaddr returns same error codes as getaddrinfo
*
*/
int knet_strtoaddr(const char *host, const char *port,
struct sockaddr_storage *ss, socklen_t sslen);
/**
* knet_addrtostr
*
* @brief Convert an address to a host name
*
* ss - sockaddr_storage to convert
*
* sslen - len of the sockaddr_storage
*
* host - IPaddr/hostname where to store data
* (recommended size: KNET_MAX_HOST_LEN)
*
* port - port buffer where to store data
* (recommended size: KNET_MAX_PORT_LEN)
*
* @return
* knet_strtoaddr returns same error codes as getnameinfo
*/
int knet_addrtostr(const struct sockaddr_storage *ss, socklen_t sslen,
char *addr_buf, size_t addr_buf_size,
char *port_buf, size_t port_buf_size);
#define KNET_TRANSPORT_LOOPBACK 0
#define KNET_TRANSPORT_UDP 1
#define KNET_TRANSPORT_SCTP 2
-#define KNET_MAX_TRANSPORTS 3
+#define KNET_MAX_TRANSPORTS UINT8_MAX
/*
* The Loopback transport is only valid for connections to localhost, the host
* with the same node_id specified in knet_handle_new(). Only one link of this
* type is allowed. Data sent down a LOOPBACK link will be copied directly from
* the knet send datafd to the knet receive datafd so the application must be set
* up to take data from that socket at least as often as it is sent or deadlocks
* could occur. If used, a LOOPBACK link must be the only link configured to the
* local host.
*/
struct knet_transport_info {
const char *name; /* UDP/SCTP/etc... */
uint8_t id; /* value that can be used for link_set_config */
uint8_t properties; /* currently unused */
+ char pad[256]; /* currently unused */
};
/**
- * knet_handle_get_transport_list
+ * knet_get_transport_list
*
* @brief Get a list of the transports support by this build of knet
*
- * knet_h - pointer to knet_handle_t
- *
* transport_list - an array of struct transport_info that must be
* at least of size struct transport_info * KNET_MAX_TRANSPORTS
*
* transport_list_entries - pointer to a size_t where to store how many transports
* are available in this build of libknet.
*
* @return
- * knet_handle_get_transport_list returns
+ * knet_get_transport_list returns
* 0 on success
* -1 on error and errno is set.
*/
-int knet_handle_get_transport_list(knet_handle_t knet_h,
- struct knet_transport_info *transport_list,
- size_t *transport_list_entries);
+int knet_get_transport_list(struct knet_transport_info *transport_list,
+ size_t *transport_list_entries);
/**
- * knet_handle_get_transport_name_by_id
+ * knet_get_transport_name_by_id
*
* @brief Get a transport name from its ID number
*
- * knet_h - pointer to knet_handle_t
- *
* transport - one of the KNET_TRANSPORT_xxx constants
*
* @return
- * knet_handle_get_transport_name_by_id returns:
+ * knet_get_transport_name_by_id returns:
*
* @retval pointer to the name on success or
* @retval NULL on error and errno is set.
*/
-const char *knet_handle_get_transport_name_by_id(knet_handle_t knet_h, uint8_t transport);
+const char *knet_get_transport_name_by_id(uint8_t transport);
/**
- * knet_handle_get_transport_id_by_name
+ * knet_get_transport_id_by_name
*
* @brief Get a transport ID from its name
*
- * knet_h - pointer to knet_handle_t
- *
* name - transport name (UDP/SCTP/etc)
*
* @return
- * knet_handle_get_transport_name_by_id returns:
+ * knet_get_transport_name_by_id returns:
*
* @retval KNET_MAX_TRANSPORTS on error and errno is set accordingly
* @retval KNET_TRANSPORT_xxx on success.
*/
-uint8_t knet_handle_get_transport_id_by_name(knet_handle_t knet_h, const char *name);
+uint8_t knet_get_transport_id_by_name(const char *name);
#define KNET_TRANSPORT_DEFAULT_RECONNECT_INTERVAL 1000
/**
* knet_handle_set_transport_reconnect_interval
*
* @brief Set the interval between transport attempts to reconnect a failed link
*
* knet_h - pointer to knet_handle_t
*
* msecs - milliseconds
*
* @return
* knet_handle_set_transport_reconnect_interval returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_handle_set_transport_reconnect_interval(knet_handle_t knet_h, uint32_t msecs);
/**
* knet_handle_get_transport_reconnect_interval
*
* @brief Get the interval between transport attempts to reconnect a failed link
*
* knet_h - pointer to knet_handle_t
*
* msecs - milliseconds
*
* @return
* knet_handle_get_transport_reconnect_interval returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_handle_get_transport_reconnect_interval(knet_handle_t knet_h, uint32_t *msecs);
/**
* knet_link_set_config
*
* @brief Configure the link to a host
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* link_id - see knet_link_set_config(3)
*
* transport - one of the KNET_TRANSPORT_xxx constants
*
* src_addr - sockaddr_storage that can be either IPv4 or IPv6
*
* dst_addr - sockaddr_storage that can be either IPv4 or IPv6
* this can be null if we don't know the incoming
* IP address/port and the link will remain quiet
* till the node on the other end will initiate a
* connection
*
* flags - KNET_LINK_FLAG_*
*
* @return
* knet_link_set_config returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_link_set_config(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
uint8_t transport,
struct sockaddr_storage *src_addr,
struct sockaddr_storage *dst_addr,
uint64_t flags);
/**
* knet_link_get_config
*
* @brief Get the link configutation information
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* link_id - see knet_link_set_config(3)
*
* transport - see knet_link_set_config(3)
*
* src_addr - sockaddr_storage that can be either IPv4 or IPv6
*
* dst_addr - sockaddr_storage that can be either IPv4 or IPv6
*
* dynamic - 0 if dst_addr is static or 1 if dst_addr is dynamic.
* In case of 1, dst_addr can be NULL and it will be left
* untouched.
*
* flags - KNET_LINK_FLAG_*
*
* @return
* knet_link_get_config returns
* 0 on success.
* -1 on error and errno is set.
*/
int knet_link_get_config(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
uint8_t *transport,
struct sockaddr_storage *src_addr,
struct sockaddr_storage *dst_addr,
uint8_t *dynamic,
uint64_t *flags);
/**
* knet_link_clear_config
*
* @brief Clear link information and disconnect the link
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* link_id - see knet_link_set_config(3)
*
* @return
* knet_link_clear_config returns
* 0 on success.
* -1 on error and errno is set.
*/
int knet_link_clear_config(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id);
/**
* knet_link_set_enable
*
* @brief Enable traffic on a link
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* link_id - see knet_link_set_config(3)
*
* enabled - 0 disable the link, 1 enable the link
*
* @return
* knet_link_set_enable returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_link_set_enable(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
unsigned int enabled);
/**
* knet_link_get_enable
*
* @brief Find out whether a link is enabled or not
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* link_id - see knet_link_set_config(3)
*
* enabled - 0 disable the link, 1 enable the link
*
* @return
* knet_link_get_enable returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_link_get_enable(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
unsigned int *enabled);
#define KNET_LINK_DEFAULT_PING_INTERVAL 1000 /* 1 second */
#define KNET_LINK_DEFAULT_PING_TIMEOUT 2000 /* 2 seconds */
#define KNET_LINK_DEFAULT_PING_PRECISION 2048 /* samples */
/**
* knet_link_set_ping_timers
*
* @brief Set the ping timers for a link
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* link_id - see knet_link_set_config(3)
*
* interval - specify the ping interval
*
* timeout - if no pong is received within this time,
* the link is declared dead
*
* precision - how many values of latency are used to calculate
* the average link latency (see also knet_link_get_status(3))
*
* @return
* knet_link_set_ping_timers returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_link_set_ping_timers(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
time_t interval, time_t timeout, unsigned int precision);
/**
* knet_link_get_ping_timers
*
* @brief Get the ping timers for a link
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* link_id - see knet_link_set_config(3)
*
* interval - ping interval
*
* timeout - if no pong is received within this time,
* the link is declared dead
*
* precision - how many values of latency are used to calculate
* the average link latency (see also knet_link_get_status(3))
*
* @return
* knet_link_get_ping_timers returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_link_get_ping_timers(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
time_t *interval, time_t *timeout, unsigned int *precision);
#define KNET_LINK_DEFAULT_PONG_COUNT 5
/**
* knet_link_set_pong_count
*
* @brief Set the pong count for a link
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* link_id - see knet_link_set_config(3)
*
* pong_count - how many valid ping/pongs before a link is marked UP.
* default: 5, value should be > 0
*
* @return
* knet_link_set_pong_count returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_link_set_pong_count(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
uint8_t pong_count);
/**
* knet_link_get_pong_count
*
* @brief Get the pong count for a link
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* link_id - see knet_link_set_config(3)
*
* pong_count - how many valid ping/pongs before a link is marked UP.
* default: 5, value should be > 0
*
* @return
* knet_link_get_pong_count returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_link_get_pong_count(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
uint8_t *pong_count);
/**
* knet_link_set_priority
*
* @brief Set the priority for a link
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* link_id - see knet_link_set_config(3)
*
* priority - specify the switching priority for this link
* see also knet_host_set_policy
*
* @return
* knet_link_set_priority returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_link_set_priority(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
uint8_t priority);
/**
* knet_link_get_priority
*
* @brief Get the priority for a link
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* link_id - see knet_link_set_config(3)
*
* priority - gather the switching priority for this link
* see also knet_host_set_policy
*
* @return
* knet_link_get_priority returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_link_get_priority(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
uint8_t *priority);
/**
* knet_link_get_link_list
*
* @brief Get a list of links connecting a host
*
* knet_h - pointer to knet_handle_t
*
* link_ids - array of at lest KNET_MAX_LINK size
* with the list of configured links for a certain host.
*
* link_ids_entries -
* number of entries contained in link_ids
*
* @return
* knet_link_get_link_list returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_link_get_link_list(knet_handle_t knet_h, knet_node_id_t host_id,
uint8_t *link_ids, size_t *link_ids_entries);
/*
* define link status structure for quick lookup
*
* src/dst_{ipaddr,port} strings are filled by
* getnameinfo(3) when configuring the link.
* if the link is dynamic (see knet_link_set_config(3))
* dst_ipaddr/port will contain ipaddr/port of the currently
* connected peer or "Unknown" if it was not possible
* to determine the ipaddr/port at runtime.
*
* enabled see also knet_link_set/get_enable.
*
* connected the link is connected to a peer and ping/pong traffic
* is flowing.
*
* dynconnected the link has dynamic ip on the other end, and
* we can see the other host is sending pings to us.
*
* latency average latency of this link
* see also knet_link_set/get_timeout.
*
* pong_last if the link is down, this value tells us how long
* ago this link was active. A value of 0 means that the link
* has never been active.
*
* knet_link_stats structure that contains details statistics for the link
*/
#define MAX_LINK_EVENTS 16
struct knet_link_stats {
/* onwire values */
uint64_t tx_data_packets;
uint64_t rx_data_packets;
uint64_t tx_data_bytes;
uint64_t rx_data_bytes;
uint64_t rx_ping_packets;
uint64_t tx_ping_packets;
uint64_t rx_ping_bytes;
uint64_t tx_ping_bytes;
uint64_t rx_pong_packets;
uint64_t tx_pong_packets;
uint64_t rx_pong_bytes;
uint64_t tx_pong_bytes;
uint64_t rx_pmtu_packets;
uint64_t tx_pmtu_packets;
uint64_t rx_pmtu_bytes;
uint64_t tx_pmtu_bytes;
/* Only filled in when requested */
uint64_t tx_total_packets;
uint64_t rx_total_packets;
uint64_t tx_total_bytes;
uint64_t rx_total_bytes;
uint64_t tx_total_errors;
uint64_t tx_total_retries;
uint32_t tx_pmtu_errors;
uint32_t tx_pmtu_retries;
uint32_t tx_ping_errors;
uint32_t tx_ping_retries;
uint32_t tx_pong_errors;
uint32_t tx_pong_retries;
uint32_t tx_data_errors;
uint32_t tx_data_retries;
/* measured in usecs */
uint32_t latency_min;
uint32_t latency_max;
uint32_t latency_ave;
uint32_t latency_samples;
/* how many times the link has been going up/down */
uint32_t down_count;
uint32_t up_count;
/*
* circular buffer of time_t structs collecting the history
* of up/down events on this link.
* the index indicates current/last event.
* it is safe to walk back the history by decreasing the index
*/
time_t last_up_times[MAX_LINK_EVENTS];
time_t last_down_times[MAX_LINK_EVENTS];
int8_t last_up_time_index;
int8_t last_down_time_index;
/* Always add new stats at the end */
};
struct knet_link_status {
size_t size; /* For ABI checking */
char src_ipaddr[KNET_MAX_HOST_LEN];
char src_port[KNET_MAX_PORT_LEN];
char dst_ipaddr[KNET_MAX_HOST_LEN];
char dst_port[KNET_MAX_PORT_LEN];
uint8_t enabled; /* link is configured and admin enabled for traffic */
uint8_t connected; /* link is connected for data (local view) */
uint8_t dynconnected; /* link has been activated by remote dynip */
unsigned long long latency; /* average latency computed by fix/exp */
struct timespec pong_last;
unsigned int mtu; /* current detected MTU on this link */
unsigned int proto_overhead; /* contains the size of the IP protocol, knet headers and
* crypto headers (if configured). This value is filled in
* ONLY after the first PMTUd run on that given link,
* and can change if link configuration or crypto configuration
* changes at runtime.
* WARNING: in general mtu + proto_overhead might or might
* not match the output of ifconfig mtu due to crypto
* requirements to pad packets to some specific boundaries. */
/* Link statistics */
struct knet_link_stats stats;
};
/**
* knet_link_get_status
*
* @brief Get the status (and statistics) for a link
*
* knet_h - pointer to knet_handle_t
*
* host_id - see knet_host_add(3)
*
* link_id - see knet_link_set_config(3)
*
* status - pointer to knet_link_status struct
*
* struct_size - max size of knet_link_status - allows library to
* add fields without ABI change. Returned structure
* will be truncated to this length and .size member
* indicates the full size.
*
* @return
* knet_link_get_status returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_link_get_status(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
struct knet_link_status *status, size_t struct_size);
/*
* logging structs/API calls
*/
/*
* libknet is composed of several subsystems. In order
* to easily distinguish log messages coming from different
* places, each subsystem has its own ID.
*
* 0-19 config/management
* 20-39 internal threads
* 40-59 transports
* 60-69 crypto implementations
*/
#define KNET_SUB_COMMON 0 /* common.c */
#define KNET_SUB_HANDLE 1 /* handle.c alloc/dealloc config changes */
#define KNET_SUB_HOST 2 /* host add/del/modify */
#define KNET_SUB_LISTENER 3 /* listeners add/del/modify... */
#define KNET_SUB_LINK 4 /* link add/del/modify */
#define KNET_SUB_TRANSPORT 5 /* Transport common */
#define KNET_SUB_CRYPTO 6 /* crypto.c config generic layer */
#define KNET_SUB_COMPRESS 7 /* compress.c config generic layer */
#define KNET_SUB_FILTER 19 /* allocated for users to log from dst_filter */
#define KNET_SUB_DSTCACHE 20 /* switching thread (destination cache handling) */
#define KNET_SUB_HEARTBEAT 21 /* heartbeat thread */
#define KNET_SUB_PMTUD 22 /* Path MTU Discovery thread */
#define KNET_SUB_TX 23 /* send to link thread */
#define KNET_SUB_RX 24 /* recv from link thread */
#define KNET_SUB_TRANSP_BASE 40 /* Base log level for transports */
#define KNET_SUB_TRANSP_LOOPBACK (KNET_SUB_TRANSP_BASE + KNET_TRANSPORT_LOOPBACK)
#define KNET_SUB_TRANSP_UDP (KNET_SUB_TRANSP_BASE + KNET_TRANSPORT_UDP)
#define KNET_SUB_TRANSP_SCTP (KNET_SUB_TRANSP_BASE + KNET_TRANSPORT_SCTP)
#define KNET_SUB_NSSCRYPTO 60 /* nsscrypto.c */
#define KNET_SUB_OPENSSLCRYPTO 61 /* opensslcrypto.c */
#define KNET_SUB_ZLIBCOMP 70 /* compress_zlib.c */
#define KNET_SUB_LZ4COMP 71 /* compress_lz4.c */
#define KNET_SUB_LZ4HCCOMP 72 /* compress_lz4.c */
#define KNET_SUB_LZO2COMP 73 /* compress_lzo.c */
#define KNET_SUB_LZMACOMP 74 /* compress_lzma.c */
#define KNET_SUB_BZIP2COMP 75 /* compress_bzip2.c */
-#define KNET_SUB_UNKNOWN 254
-#define KNET_MAX_SUBSYSTEMS KNET_SUB_UNKNOWN + 1
+#define KNET_SUB_UNKNOWN UINT8_MAX - 1
+#define KNET_MAX_SUBSYSTEMS UINT8_MAX
/*
* Convert between subsystem IDs and names
*/
/**
* knet_log_get_subsystem_name
*
* @brief Get a logging system name from its numeric ID
*
* @return
* returns internal name of the subsystem or "common"
*/
const char *knet_log_get_subsystem_name(uint8_t subsystem);
/**
* knet_log_get_subsystem_id
*
* @brief Get a logging system ID from its name
*
* @return
* returns internal ID of the subsystem or KNET_SUB_COMMON
*/
uint8_t knet_log_get_subsystem_id(const char *name);
/*
* 4 log levels are enough for everybody
*/
#define KNET_LOG_ERR 0 /* unrecoverable errors/conditions */
#define KNET_LOG_WARN 1 /* recoverable errors/conditions */
#define KNET_LOG_INFO 2 /* info, link up/down, config changes.. */
#define KNET_LOG_DEBUG 3
/*
* Convert between log level values and names
*/
/**
* knet_log_get_loglevel_name
*
* @brief Get a logging level name from its numeric ID
*
* @return
* returns internal name of the log level or "ERROR" for unknown values
*/
const char *knet_log_get_loglevel_name(uint8_t level);
/**
* knet_log_get_loglevel_id
*
* @brief Get a logging level ID from its name
*
* @return
* returns internal log level ID or KNET_LOG_ERR for invalid names
*/
uint8_t knet_log_get_loglevel_id(const char *name);
/*
* every log message is composed by a text message (including a trailing \n)
* and message level/subsystem IDs.
* In order to make debugging easier it is possible to send those packets
* straight to stdout/stderr (see knet_bench.c stdout option).
*/
#define KNET_MAX_LOG_MSG_SIZE 256
struct knet_log_msg {
char msg[KNET_MAX_LOG_MSG_SIZE - (sizeof(uint8_t)*2)];
uint8_t subsystem; /* KNET_SUB_* */
uint8_t msglevel; /* KNET_LOG_* */
};
/**
* knet_log_set_log_level
*
* @brief Set the logging level for a subsystem
*
* knet_h - same as above
*
* subsystem - same as above
*
* level - same as above
*
* knet_log_set_loglevel allows fine control of log levels by subsystem.
* See also knet_handle_new for defaults.
*
* @return
* knet_log_set_loglevel returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_log_set_loglevel(knet_handle_t knet_h, uint8_t subsystem,
uint8_t level);
/**
* knet_log_get_log_level
*
* @brief Get the logging level for a subsystem
*
* knet_h - same as above
*
* subsystem - same as above
*
* level - same as above
*
* @return
* knet_log_get_loglevel returns
* 0 on success
* -1 on error and errno is set.
*/
int knet_log_get_loglevel(knet_handle_t knet_h, uint8_t subsystem,
uint8_t *level);
#endif
diff --git a/libknet/links.c b/libknet/links.c
index 8d7bfe77..88bbfc84 100644
--- a/libknet/links.c
+++ b/libknet/links.c
@@ -1,1087 +1,1079 @@
/*
* Copyright (C) 2012-2017 Red Hat, Inc. All rights reserved.
*
* Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
* Federico Simoncelli <fsimon@kronosnet.org>
*
* This software licensed under GPL-2.0+, LGPL-2.0+
*/
#include "config.h"
#include <errno.h>
#include <netdb.h>
#include <string.h>
#include <pthread.h>
#include "internals.h"
#include "logging.h"
#include "links.h"
#include "transports.h"
#include "host.h"
int _link_updown(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
unsigned int enabled, unsigned int connected)
{
struct knet_link *link = &knet_h->host_index[host_id]->link[link_id];
if ((link->status.enabled == enabled) &&
(link->status.connected == connected))
return 0;
link->status.enabled = enabled;
link->status.connected = connected;
_host_dstcache_update_async(knet_h, knet_h->host_index[host_id]);
if ((link->status.dynconnected) &&
(!link->status.connected))
link->status.dynconnected = 0;
if (connected) {
time(&link->status.stats.last_up_times[link->status.stats.last_up_time_index]);
link->status.stats.up_count++;
if (++link->status.stats.last_up_time_index > MAX_LINK_EVENTS) {
link->status.stats.last_up_time_index = 0;
}
} else {
time(&link->status.stats.last_down_times[link->status.stats.last_down_time_index]);
link->status.stats.down_count++;
if (++link->status.stats.last_down_time_index > MAX_LINK_EVENTS) {
link->status.stats.last_down_time_index = 0;
}
}
return 0;
}
void _link_clear_stats(knet_handle_t knet_h)
{
struct knet_host *host;
struct knet_link *link;
uint32_t host_id;
uint8_t link_id;
for (host_id = 0; host_id < KNET_MAX_HOST; host_id++) {
host = knet_h->host_index[host_id];
if (!host) {
continue;
}
for (link_id = 0; link_id < KNET_MAX_LINK; link_id++) {
link = &host->link[link_id];
memset(&link->status.stats, 0, sizeof(struct knet_link_stats));
}
}
}
int knet_link_set_config(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
uint8_t transport,
struct sockaddr_storage *src_addr,
struct sockaddr_storage *dst_addr,
uint64_t flags)
{
int savederrno = 0, err = 0, i;
struct knet_host *host;
struct knet_link *link;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (link_id >= KNET_MAX_LINK) {
errno = EINVAL;
return -1;
}
if (!src_addr) {
errno = EINVAL;
return -1;
}
if (transport >= KNET_MAX_TRANSPORTS) {
errno = EINVAL;
return -1;
}
- if (!knet_h->transport_ops[transport]) {
- errno = EINVAL;
- return -1;
- }
-
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_LINK, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
if (transport == KNET_TRANSPORT_LOOPBACK && knet_h->host_id != host_id) {
log_err(knet_h, KNET_SUB_LINK, "Cannot create loopback link to remote node");
err = -1;
savederrno = EINVAL;
goto exit_unlock;
}
if (knet_h->host_id == host_id && knet_h->has_loop_link) {
log_err(knet_h, KNET_SUB_LINK, "Cannot create more than 1 link when loopback is active");
err = -1;
savederrno = EINVAL;
goto exit_unlock;
}
host = knet_h->host_index[host_id];
if (!host) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "Unable to find host %u: %s",
host_id, strerror(savederrno));
goto exit_unlock;
}
if (transport == KNET_TRANSPORT_LOOPBACK && knet_h->host_id == host_id) {
for (i=0; i<KNET_MAX_LINK; i++) {
if (host->link[i].configured) {
log_err(knet_h, KNET_SUB_LINK, "Cannot add loopback link when other links are already configured.");
err = -1;
savederrno = EINVAL;
goto exit_unlock;
}
}
}
link = &host->link[link_id];
if (link->configured != 0) {
err =-1;
savederrno = EBUSY;
log_err(knet_h, KNET_SUB_LINK, "Host %u link %u is currently configured: %s",
host_id, link_id, strerror(savederrno));
goto exit_unlock;
}
if (link->status.enabled != 0) {
err =-1;
savederrno = EBUSY;
log_err(knet_h, KNET_SUB_LINK, "Host %u link %u is currently in use: %s",
host_id, link_id, strerror(savederrno));
goto exit_unlock;
}
memmove(&link->src_addr, src_addr, sizeof(struct sockaddr_storage));
err = knet_addrtostr(src_addr, sizeof(struct sockaddr_storage),
link->status.src_ipaddr, KNET_MAX_HOST_LEN,
link->status.src_port, KNET_MAX_PORT_LEN);
if (err) {
if (err == EAI_SYSTEM) {
savederrno = errno;
log_warn(knet_h, KNET_SUB_LINK,
"Unable to resolve host: %u link: %u source addr/port: %s",
host_id, link_id, strerror(savederrno));
} else {
savederrno = EINVAL;
log_warn(knet_h, KNET_SUB_LINK,
"Unable to resolve host: %u link: %u source addr/port: %s",
host_id, link_id, gai_strerror(err));
}
err = -1;
goto exit_unlock;
}
if (!dst_addr) {
link->dynamic = KNET_LINK_DYNIP;
} else {
link->dynamic = KNET_LINK_STATIC;
memmove(&link->dst_addr, dst_addr, sizeof(struct sockaddr_storage));
err = knet_addrtostr(dst_addr, sizeof(struct sockaddr_storage),
link->status.dst_ipaddr, KNET_MAX_HOST_LEN,
link->status.dst_port, KNET_MAX_PORT_LEN);
if (err) {
if (err == EAI_SYSTEM) {
savederrno = errno;
log_warn(knet_h, KNET_SUB_LINK,
"Unable to resolve host: %u link: %u destination addr/port: %s",
host_id, link_id, strerror(savederrno));
} else {
savederrno = EINVAL;
log_warn(knet_h, KNET_SUB_LINK,
"Unable to resolve host: %u link: %u destination addr/port: %s",
host_id, link_id, gai_strerror(err));
}
err = -1;
goto exit_unlock;
}
}
- link->transport_type = transport;
- link->transport_connected = 0;
- link->proto_overhead = knet_h->transport_ops[link->transport_type]->transport_mtu_overhead;
link->pong_count = KNET_LINK_DEFAULT_PONG_COUNT;
link->has_valid_mtu = 0;
link->ping_interval = KNET_LINK_DEFAULT_PING_INTERVAL * 1000; /* microseconds */
link->pong_timeout = KNET_LINK_DEFAULT_PING_TIMEOUT * 1000; /* microseconds */
link->latency_fix = KNET_LINK_DEFAULT_PING_PRECISION;
link->latency_exp = KNET_LINK_DEFAULT_PING_PRECISION - \
((link->ping_interval * KNET_LINK_DEFAULT_PING_PRECISION) / 8000000);
link->flags = flags;
- if (knet_h->transport_ops[link->transport_type]->transport_link_set_config(knet_h, link) < 0) {
+ if (transport_link_set_config(knet_h, link, transport) < 0) {
savederrno = errno;
err = -1;
goto exit_unlock;
}
link->configured = 1;
log_debug(knet_h, KNET_SUB_LINK, "host: %u link: %u is configured",
host_id, link_id);
if (transport == KNET_TRANSPORT_LOOPBACK) {
knet_h->has_loop_link = 1;
knet_h->loop_link = link_id;
host->status.reachable = 1;
}
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_link_get_config(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
uint8_t *transport,
struct sockaddr_storage *src_addr,
struct sockaddr_storage *dst_addr,
uint8_t *dynamic,
uint64_t *flags)
{
int savederrno = 0, err = 0;
struct knet_host *host;
struct knet_link *link;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (link_id >= KNET_MAX_LINK) {
errno = EINVAL;
return -1;
}
if (!src_addr) {
errno = EINVAL;
return -1;
}
if (!dynamic) {
errno = EINVAL;
return -1;
}
if (!transport) {
errno = EINVAL;
return -1;
}
if (!flags) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_LINK, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
host = knet_h->host_index[host_id];
if (!host) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "Unable to find host %u: %s",
host_id, strerror(savederrno));
goto exit_unlock;
}
link = &host->link[link_id];
if (!link->configured) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "host %u link %u is not configured: %s",
host_id, link_id, strerror(savederrno));
goto exit_unlock;
}
if ((link->dynamic == KNET_LINK_STATIC) && (!dst_addr)) {
savederrno = EINVAL;
err = -1;
goto exit_unlock;
}
memmove(src_addr, &link->src_addr, sizeof(struct sockaddr_storage));
*transport = link->transport_type;
*flags = link->flags;
if (link->dynamic == KNET_LINK_STATIC) {
*dynamic = 0;
memmove(dst_addr, &link->dst_addr, sizeof(struct sockaddr_storage));
} else {
*dynamic = 1;
}
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_link_clear_config(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id)
{
int savederrno = 0, err = 0;
struct knet_host *host;
struct knet_link *link;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (link_id >= KNET_MAX_LINK) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_LINK, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
host = knet_h->host_index[host_id];
if (!host) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "Unable to find host %u: %s",
host_id, strerror(savederrno));
goto exit_unlock;
}
link = &host->link[link_id];
if (link->configured != 1) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "Host %u link %u is not configured: %s",
host_id, link_id, strerror(savederrno));
goto exit_unlock;
}
if (link->status.enabled != 0) {
err = -1;
savederrno = EBUSY;
log_err(knet_h, KNET_SUB_LINK, "Host %u link %u is currently in use: %s",
host_id, link_id, strerror(savederrno));
goto exit_unlock;
}
- if ((knet_h->transport_ops[link->transport_type]->transport_link_clear_config(knet_h, link) < 0) &&
+ if ((transport_link_clear_config(knet_h, link) < 0) &&
(errno != EBUSY)) {
savederrno = errno;
err = -1;
goto exit_unlock;
}
memset(link, 0, sizeof(struct knet_link));
link->link_id = link_id;
if (knet_h->has_loop_link && link_id == knet_h->loop_link) {
knet_h->has_loop_link = 0;
if (host->active_link_entries == 0) {
host->status.reachable = 0;
}
}
log_debug(knet_h, KNET_SUB_LINK, "host: %u link: %u config has been wiped",
host_id, link_id);
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_link_set_enable(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
unsigned int enabled)
{
int savederrno = 0, err = 0;
struct knet_host *host;
struct knet_link *link;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (link_id >= KNET_MAX_LINK) {
errno = EINVAL;
return -1;
}
if (enabled > 1) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_LINK, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
host = knet_h->host_index[host_id];
if (!host) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "Unable to find host %u: %s",
host_id, strerror(savederrno));
goto exit_unlock;
}
link = &host->link[link_id];
if (!link->configured) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "host %u link %u is not configured: %s",
host_id, link_id, strerror(savederrno));
goto exit_unlock;
}
if (link->status.enabled == enabled) {
err = 0;
goto exit_unlock;
}
err = _link_updown(knet_h, host_id, link_id, enabled, link->status.connected);
savederrno = errno;
if (enabled) {
goto exit_unlock;
}
log_debug(knet_h, KNET_SUB_LINK, "host: %u link: %u is disabled",
host_id, link_id);
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_link_get_enable(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
unsigned int *enabled)
{
int savederrno = 0, err = 0;
struct knet_host *host;
struct knet_link *link;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (link_id >= KNET_MAX_LINK) {
errno = EINVAL;
return -1;
}
if (!enabled) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_LINK, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
host = knet_h->host_index[host_id];
if (!host) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "Unable to find host %u: %s",
host_id, strerror(savederrno));
goto exit_unlock;
}
link = &host->link[link_id];
if (!link->configured) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "host %u link %u is not configured: %s",
host_id, link_id, strerror(savederrno));
goto exit_unlock;
}
*enabled = link->status.enabled;
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_link_set_pong_count(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
uint8_t pong_count)
{
int savederrno = 0, err = 0;
struct knet_host *host;
struct knet_link *link;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (link_id >= KNET_MAX_LINK) {
errno = EINVAL;
return -1;
}
if (pong_count < 1) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_LINK, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
host = knet_h->host_index[host_id];
if (!host) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "Unable to find host %u: %s",
host_id, strerror(savederrno));
goto exit_unlock;
}
link = &host->link[link_id];
if (!link->configured) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "host %u link %u is not configured: %s",
host_id, link_id, strerror(savederrno));
goto exit_unlock;
}
link->pong_count = pong_count;
log_debug(knet_h, KNET_SUB_LINK,
"host: %u link: %u pong count update: %u",
host_id, link_id, link->pong_count);
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_link_get_pong_count(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
uint8_t *pong_count)
{
int savederrno = 0, err = 0;
struct knet_host *host;
struct knet_link *link;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (link_id >= KNET_MAX_LINK) {
errno = EINVAL;
return -1;
}
if (!pong_count) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_LINK, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
host = knet_h->host_index[host_id];
if (!host) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "Unable to find host %u: %s",
host_id, strerror(savederrno));
goto exit_unlock;
}
link = &host->link[link_id];
if (!link->configured) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "host %u link %u is not configured: %s",
host_id, link_id, strerror(savederrno));
goto exit_unlock;
}
*pong_count = link->pong_count;
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_link_set_ping_timers(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
time_t interval, time_t timeout, unsigned int precision)
{
int savederrno = 0, err = 0;
struct knet_host *host;
struct knet_link *link;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (link_id >= KNET_MAX_LINK) {
errno = EINVAL;
return -1;
}
if (!interval) {
errno = EINVAL;
return -1;
}
if (!timeout) {
errno = EINVAL;
return -1;
}
if (!precision) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_LINK, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
host = knet_h->host_index[host_id];
if (!host) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "Unable to find host %u: %s",
host_id, strerror(savederrno));
goto exit_unlock;
}
link = &host->link[link_id];
if (!link->configured) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "host %u link %u is not configured: %s",
host_id, link_id, strerror(savederrno));
goto exit_unlock;
}
link->ping_interval = interval * 1000; /* microseconds */
link->pong_timeout = timeout * 1000; /* microseconds */
link->latency_fix = precision;
link->latency_exp = precision - \
((link->ping_interval * precision) / 8000000);
log_debug(knet_h, KNET_SUB_LINK,
"host: %u link: %u timeout update - interval: %llu timeout: %llu precision: %u",
host_id, link_id, link->ping_interval, link->pong_timeout, precision);
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_link_get_ping_timers(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
time_t *interval, time_t *timeout, unsigned int *precision)
{
int savederrno = 0, err = 0;
struct knet_host *host;
struct knet_link *link;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (link_id >= KNET_MAX_LINK) {
errno = EINVAL;
return -1;
}
if (!interval) {
errno = EINVAL;
return -1;
}
if (!timeout) {
errno = EINVAL;
return -1;
}
if (!precision) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_LINK, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
host = knet_h->host_index[host_id];
if (!host) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "Unable to find host %u: %s",
host_id, strerror(savederrno));
goto exit_unlock;
}
link = &host->link[link_id];
if (!link->configured) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "host %u link %u is not configured: %s",
host_id, link_id, strerror(savederrno));
goto exit_unlock;
}
*interval = link->ping_interval / 1000; /* microseconds */
*timeout = link->pong_timeout / 1000;
*precision = link->latency_fix;
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_link_set_priority(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
uint8_t priority)
{
int savederrno = 0, err = 0;
struct knet_host *host;
struct knet_link *link;
uint8_t old_priority;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (link_id >= KNET_MAX_LINK) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_LINK, "Unable to get write lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
host = knet_h->host_index[host_id];
if (!host) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "Unable to find host %u: %s",
host_id, strerror(savederrno));
goto exit_unlock;
}
link = &host->link[link_id];
if (!link->configured) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "host %u link %u is not configured: %s",
host_id, link_id, strerror(savederrno));
goto exit_unlock;
}
old_priority = link->priority;
if (link->priority == priority) {
err = 0;
goto exit_unlock;
}
link->priority = priority;
if (_host_dstcache_update_sync(knet_h, host)) {
savederrno = errno;
log_debug(knet_h, KNET_SUB_LINK,
"Unable to update link priority (host: %u link: %u priority: %u): %s",
host_id, link_id, link->priority, strerror(savederrno));
link->priority = old_priority;
err = -1;
goto exit_unlock;
}
log_debug(knet_h, KNET_SUB_LINK,
"host: %u link: %u priority set to: %u",
host_id, link_id, link->priority);
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_link_get_priority(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
uint8_t *priority)
{
int savederrno = 0, err = 0;
struct knet_host *host;
struct knet_link *link;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (link_id >= KNET_MAX_LINK) {
errno = EINVAL;
return -1;
}
if (!priority) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_LINK, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
host = knet_h->host_index[host_id];
if (!host) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "Unable to find host %u: %s",
host_id, strerror(savederrno));
goto exit_unlock;
}
link = &host->link[link_id];
if (!link->configured) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "host %u link %u is not configured: %s",
host_id, link_id, strerror(savederrno));
goto exit_unlock;
}
*priority = link->priority;
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_link_get_link_list(knet_handle_t knet_h, knet_node_id_t host_id,
uint8_t *link_ids, size_t *link_ids_entries)
{
int savederrno = 0, err = 0, i, count = 0;
struct knet_host *host;
struct knet_link *link;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (!link_ids) {
errno = EINVAL;
return -1;
}
if (!link_ids_entries) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_LINK, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
host = knet_h->host_index[host_id];
if (!host) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "Unable to find host %u: %s",
host_id, strerror(savederrno));
goto exit_unlock;
}
for (i = 0; i < KNET_MAX_LINK; i++) {
link = &host->link[i];
if (!link->configured) {
continue;
}
link_ids[count] = i;
count++;
}
*link_ids_entries = count;
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
int knet_link_get_status(knet_handle_t knet_h, knet_node_id_t host_id, uint8_t link_id,
struct knet_link_status *status, size_t struct_size)
{
int savederrno = 0, err = 0;
struct knet_host *host;
struct knet_link *link;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (link_id >= KNET_MAX_LINK) {
errno = EINVAL;
return -1;
}
if (!status) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_LINK, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
host = knet_h->host_index[host_id];
if (!host) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "Unable to find host %u: %s",
host_id, strerror(savederrno));
goto exit_unlock;
}
link = &host->link[link_id];
if (!link->configured) {
err = -1;
savederrno = EINVAL;
log_err(knet_h, KNET_SUB_LINK, "host %u link %u is not configured: %s",
host_id, link_id, strerror(savederrno));
goto exit_unlock;
}
memmove(status, &link->status, struct_size);
/* Calculate totals - no point in doing this on-the-fly */
status->stats.rx_total_packets =
status->stats.rx_data_packets +
status->stats.rx_ping_packets +
status->stats.rx_pong_packets +
status->stats.rx_pmtu_packets;
status->stats.tx_total_packets =
status->stats.tx_data_packets +
status->stats.tx_ping_packets +
status->stats.tx_pong_packets +
status->stats.tx_pmtu_packets;
status->stats.rx_total_bytes =
status->stats.rx_data_bytes +
status->stats.rx_ping_bytes +
status->stats.rx_pong_bytes +
status->stats.rx_pmtu_bytes;
status->stats.tx_total_bytes =
status->stats.tx_data_bytes +
status->stats.tx_ping_bytes +
status->stats.tx_pong_bytes +
status->stats.tx_pmtu_bytes;
status->stats.tx_total_errors =
status->stats.tx_data_errors +
status->stats.tx_ping_errors +
status->stats.tx_pong_errors +
status->stats.tx_pmtu_errors;
status->stats.tx_total_retries =
status->stats.tx_data_retries +
status->stats.tx_ping_retries +
status->stats.tx_pong_retries +
status->stats.tx_pmtu_retries;
/* Tell the caller our full size in case they have an old version */
status->size = sizeof(struct knet_link_status);
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
diff --git a/libknet/man/Makefile.am b/libknet/man/Makefile.am
index 8f826f64..1f9fe794 100644
--- a/libknet/man/Makefile.am
+++ b/libknet/man/Makefile.am
@@ -1,87 +1,87 @@
#
# Copyright (C) 2017 Red Hat, Inc. All rights reserved.
#
# Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
# Federico Simoncelli <fsimon@kronosnet.org>
#
# This software licensed under GPL-2.0+, LGPL-2.0+
#
MAINTAINERCLEANFILES = Makefile.in
include $(top_srcdir)/build-aux/check.mk
dist_man_MANS = \
knet_addrtostr.3 \
knet_handle_add_datafd.3 \
knet_handle_clear_stats.3 \
knet_handle_compress.3 \
knet_handle_crypto.3 \
knet_handle_enable_filter.3 \
knet_handle_enable_pmtud_notify.3 \
knet_handle_enable_sock_notify.3 \
knet_handle_free.3 \
knet_handle_get_channel.3 \
- knet_handle_get_compress_list.3 \
- knet_handle_get_crypto_list.3 \
+ knet_get_compress_list.3 \
+ knet_get_crypto_list.3 \
knet_handle_get_datafd.3 \
knet_handle_get_stats.3 \
- knet_handle_get_transport_id_by_name.3 \
- knet_handle_get_transport_list.3 \
- knet_handle_get_transport_name_by_id.3 \
+ knet_get_transport_id_by_name.3 \
+ knet_get_transport_list.3 \
+ knet_get_transport_name_by_id.3 \
knet_handle_get_transport_reconnect_interval.3 \
knet_handle_new.3 \
knet_handle_pmtud_get.3 \
knet_handle_pmtud_getfreq.3 \
knet_handle_pmtud_setfreq.3 \
knet_handle_remove_datafd.3 \
knet_handle_setfwd.3 \
knet_handle_set_transport_reconnect_interval.3 \
knet_host_add.3 \
knet_host_enable_status_change_notify.3 \
knet_host_get_host_list.3 \
knet_host_get_id_by_host_name.3 \
knet_host_get_name_by_host_id.3 \
knet_host_get_policy.3 \
knet_host_get_status.3 \
knet_host_remove.3 \
knet_host_set_name.3 \
knet_host_set_policy.3 \
knet_link_clear_config.3 \
knet_link_get_config.3 \
knet_link_get_enable.3 \
knet_link_get_link_list.3 \
knet_link_get_ping_timers.3 \
knet_link_get_pong_count.3 \
knet_link_get_priority.3 \
knet_link_get_status.3 \
knet_link_set_config.3 \
knet_link_set_enable.3 \
knet_link_set_ping_timers.3 \
knet_link_set_pong_count.3 \
knet_link_set_priority.3 \
knet_log_get_loglevel.3 \
knet_log_get_loglevel_id.3 \
knet_log_get_loglevel_name.3 \
knet_log_get_subsystem_id.3 \
knet_log_get_subsystem_name.3 \
knet_log_set_loglevel.3 \
knet_recv.3 \
knet_send.3 \
knet_send_sync.3 \
knet_strtoaddr.3 \
libknet.h.3
update-man-pages: doxyfile.stamp
doxyfile.stamp: Doxyfile
if MANPAGEUPDATES
$(DOXYGEN) Doxyfile
$(DOXY2MAN) -o $(abs_srcdir) -s 3 --short-pkg @PACKAGE_NAME@ --pkg "Kronosnet Programmer's Manual" $(builddir)/xml/libknet_8h.xml
else
@echo this system does not have doxy2man or doxygen installed. Unable to update man pages automatically.
endif
touch doxyfile.stamp
clean-local:
rm -rf doxyfile.stamp xml
diff --git a/libknet/man/knet_addrtostr.3 b/libknet/man/knet_addrtostr.3
index 30da4c62..9e473ea2 100644
--- a/libknet/man/knet_addrtostr.3
+++ b/libknet/man/knet_addrtostr.3
@@ -1,42 +1,42 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_addrtostr 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_addrtostr 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_addrtostr \- Convert an address to a host name.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_addrtostr\fP(
\fBconst struct sockaddr_storage *\fP\fIss\fP,
\fBsocklen_t \fP\fIsslen\fP,
\fBchar *\fP\fIaddr_buf\fP,
\fBsize_t \fP\fIaddr_buf_size\fP,
\fBchar *\fP\fIport_buf\fP,
\fBsize_t \fP\fIport_buf_size\fP
);
.fi
.SH DESCRIPTION
.PP
knet_addrtostr
.PP
ss - sockaddr_storage to convert
.PP
sslen - len of the sockaddr_storage
.PP
host - IPaddr/hostname where to store data (recommended size: KNET_MAX_HOST_LEN)
.PP
port - port buffer where to store data (recommended size: KNET_MAX_PORT_LEN)
.SH RETURN VALUE
.PP
knet_strtoaddr returns same error codes as getnameinfo
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_get_compress_list.3 b/libknet/man/knet_get_compress_list.3
new file mode 100644
index 00000000..2c87d231
--- /dev/null
+++ b/libknet/man/knet_get_compress_list.3
@@ -0,0 +1,50 @@
+.\" File automatically generated by doxy2man0.2
+.\" Generation date: Mon Nov 13 2017
+.TH knet_get_compress_list 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
+.SH "NAME"
+knet_get_compress_list \- Get a list of support compression types.
+.SH SYNOPSIS
+.nf
+.B #include <libknet.h>
+.sp
+\fBint knet_get_compress_list\fP(
+ \fBstruct knet_compress_info *\fP\fIcompress_list\fP,
+ \fBsize_t *\fP\fIcompress_list_entries\fP
+);
+.fi
+.SH DESCRIPTION
+.PP
+knet_get_compress_list
+.PP
+compress_list - array of struct knet_compress_info * If NULL then only the number of structs is returned in compress_list_entries to allow the caller to allocate sufficient space. libknet does not allow more than 256 compress methods at the moment. it is safe to allocate 256 structs to avoid calling knet_get_compress_list twice.
+.PP
+compress_list_entries - returns the number of structs in compress_list
+.SH STRUCTURES
+.SS ""
+.PP
+.sp
+.sp
+.RS
+.nf
+\fB
+struct knet_compress_info {
+ const char *\fIname\fP;
+ uint8_t \fIproperties\fP;
+ char \fIpad\fP;
+};
+\fP
+.fi
+.RE
+.SH RETURN VALUE
+.PP
+knet_get_compress_list returns 0 on success -1 on error and errno is set.
+.SH SEE ALSO
+.PP
+.nh
+.ad l
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+.ad
+.hy
+.SH COPYRIGHT
+.PP
+Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_get_crypto_list.3 b/libknet/man/knet_get_crypto_list.3
new file mode 100644
index 00000000..ae20ce2b
--- /dev/null
+++ b/libknet/man/knet_get_crypto_list.3
@@ -0,0 +1,50 @@
+.\" File automatically generated by doxy2man0.2
+.\" Generation date: Mon Nov 13 2017
+.TH knet_get_crypto_list 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
+.SH "NAME"
+knet_get_crypto_list \- Get a list of supported crypto libraries.
+.SH SYNOPSIS
+.nf
+.B #include <libknet.h>
+.sp
+\fBint knet_get_crypto_list\fP(
+ \fBstruct knet_crypto_info *\fP\fIcrypto_list\fP,
+ \fBsize_t *\fP\fIcrypto_list_entries\fP
+);
+.fi
+.SH DESCRIPTION
+.PP
+knet_get_crypto_list
+.PP
+crypto_list - array of struct knet_crypto_info * If NULL then only the number of structs is returned in crypto_list_entries to allow the caller to allocate sufficient space. libknet does not allow more than 256 crypto methods at the moment. it is safe to allocate 256 structs to avoid calling knet_get_crypto_list twice.
+.PP
+crypto_list_entries - returns the number of structs in crypto_list
+.SH STRUCTURES
+.SS ""
+.PP
+.sp
+.sp
+.RS
+.nf
+\fB
+struct knet_crypto_info {
+ const char *\fIname\fP;
+ uint8_t \fIproperties\fP;
+ char \fIpad\fP;
+};
+\fP
+.fi
+.RE
+.SH RETURN VALUE
+.PP
+knet_get_crypto_list returns 0 on success -1 on error and errno is set.
+.SH SEE ALSO
+.PP
+.nh
+.ad l
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+.ad
+.hy
+.SH COPYRIGHT
+.PP
+Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_get_transport_id_by_name.3 b/libknet/man/knet_get_transport_id_by_name.3
new file mode 100644
index 00000000..ff210bf9
--- /dev/null
+++ b/libknet/man/knet_get_transport_id_by_name.3
@@ -0,0 +1,39 @@
+.\" File automatically generated by doxy2man0.2
+.\" Generation date: Mon Nov 13 2017
+.TH knet_get_transport_id_by_name 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
+.SH "NAME"
+knet_get_transport_id_by_name \- Get a transport ID from its name.
+.SH SYNOPSIS
+.nf
+.B #include <libknet.h>
+.sp
+\fBuint8_t knet_get_transport_id_by_name\fP(
+ \fBconst char *\fP\fIname\fP
+);
+.fi
+.SH DESCRIPTION
+.PP
+knet_get_transport_id_by_name
+.PP
+name - transport name (UDP/SCTP/etc)
+.SH RETURN VALUE
+.PP
+knet_get_transport_name_by_id returns:
+.TP
+.B KNET_MAX_TRANSPORTS
+on error and errno is set accordingly
+
+.TP
+.B KNET_TRANSPORT_xxx
+on success.
+
+.SH SEE ALSO
+.PP
+.nh
+.ad l
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+.ad
+.hy
+.SH COPYRIGHT
+.PP
+Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_get_transport_list.3 b/libknet/man/knet_get_transport_list.3
new file mode 100644
index 00000000..0a980eeb
--- /dev/null
+++ b/libknet/man/knet_get_transport_list.3
@@ -0,0 +1,51 @@
+.\" File automatically generated by doxy2man0.2
+.\" Generation date: Mon Nov 13 2017
+.TH knet_get_transport_list 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
+.SH "NAME"
+knet_get_transport_list \- Get a list of the transports support by this build of knet.
+.SH SYNOPSIS
+.nf
+.B #include <libknet.h>
+.sp
+\fBint knet_get_transport_list\fP(
+ \fBstruct knet_transport_info *\fP\fItransport_list\fP,
+ \fBsize_t *\fP\fItransport_list_entries\fP
+);
+.fi
+.SH DESCRIPTION
+.PP
+knet_get_transport_list
+.PP
+transport_list - an array of struct transport_info that must be at least of size struct transport_info * KNET_MAX_TRANSPORTS
+.PP
+transport_list_entries - pointer to a size_t where to store how many transports are available in this build of libknet.
+.SH STRUCTURES
+.SS ""
+.PP
+.sp
+.sp
+.RS
+.nf
+\fB
+struct knet_transport_info {
+ const char *\fIname\fP;
+ uint8_t \fIid\fP;
+ uint8_t \fIproperties\fP;
+ char \fIpad\fP;
+};
+\fP
+.fi
+.RE
+.SH RETURN VALUE
+.PP
+knet_get_transport_list returns 0 on success -1 on error and errno is set.
+.SH SEE ALSO
+.PP
+.nh
+.ad l
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+.ad
+.hy
+.SH COPYRIGHT
+.PP
+Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_get_transport_name_by_id.3 b/libknet/man/knet_get_transport_name_by_id.3
new file mode 100644
index 00000000..2a633a33
--- /dev/null
+++ b/libknet/man/knet_get_transport_name_by_id.3
@@ -0,0 +1,39 @@
+.\" File automatically generated by doxy2man0.2
+.\" Generation date: Mon Nov 13 2017
+.TH knet_get_transport_name_by_id 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
+.SH "NAME"
+knet_get_transport_name_by_id \- Get a transport name from its ID number.
+.SH SYNOPSIS
+.nf
+.B #include <libknet.h>
+.sp
+\fBconst char * knet_get_transport_name_by_id\fP(
+ \fBuint8_t \fP\fItransport\fP
+);
+.fi
+.SH DESCRIPTION
+.PP
+knet_get_transport_name_by_id
+.PP
+transport - one of the KNET_TRANSPORT_xxx constants
+.SH RETURN VALUE
+.PP
+knet_get_transport_name_by_id returns:
+.TP
+.B pointer
+to the name on success or
+
+.TP
+.B NULL
+on error and errno is set.
+
+.SH SEE ALSO
+.PP
+.nh
+.ad l
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+.ad
+.hy
+.SH COPYRIGHT
+.PP
+Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_add_datafd.3 b/libknet/man/knet_handle_add_datafd.3
index 906e1f88..8615e310 100644
--- a/libknet/man/knet_handle_add_datafd.3
+++ b/libknet/man/knet_handle_add_datafd.3
@@ -1,61 +1,61 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_add_datafd 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_add_datafd 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_add_datafd \- Install a file descriptor for communication.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_add_datafd\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBint *\fP\fIdatafd\fP,
\fBint8_t *\fP\fIchannel\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_add_datafd
.PP
IMPORTANT: In order to add datafd to knet, knet_handle_enable_sock_notify MUST be set and be able to handle both errors (-1) and 0 bytes read / write from the provided datafd. On read error (< 0) from datafd, the socket is automatically removed from polling to avoid spinning on dead sockets. It is safe to call knet_handle_remove_datafd even on sockets that have been removed.
.PP
knet_h - pointer to knet_handle_t
.PP
*datafd - read/write file descriptor. knet will read data here to send to the other hosts and will write data received from the network. Each data packet can be of max size KNET_MAX_PACKET_SIZE! Applications using knet_send/knet_recv will receive a proper error if the packet size is not within boundaries. Applications using their own functions to write to the datafd should NOT write more than KNET_MAX_PACKET_SIZE.
.PP
Please refer to handle.c on how to set up a socketpair.
.PP
datafd can be 0, and knet_handle_add_datafd will create a properly populated socket pair the same way as ping_test, or a value higher than 0. A negative number will return an error. On exit knet_handle_free will take care to cleanup the socketpair only if they have been created by knet_handle_add_datafd.
.PP
It is possible to pass either sockets or normal fds. User provided datafd will be marked as non-blocking and close-on-exit.
.PP
*channel - This value has the same effect of VLAN tagging. A negative value will auto-allocate a channel. Setting a value between 0 and 31 will try to allocate that specific channel (unless already in use).
.PP
It is possible to add up to 32 datafds but be aware that each one of them must have a receiving end on the other host.
.PP
Example: hostA channel 0 will be delivered to datafd on hostB channel 0 hostA channel 1 to hostB channel 1.
.PP
Each channel must have a unique file descriptor.
.PP
If your application could have 2 channels on one host and one channel on another host, then you can use dst_host_filter to manipulate channel values on TX and RX.
.SH RETURN VALUE
.PP
knet_handle_add_datafd returns
.TP
.B 0
on success, *datafd will be populated with a socket if the original value was 0 or if a specific fd was set, the value is untouched. *channel will be populated with a channel number if the original value was negative or the value is untouched if a specific channel was requested.
.TP
.B -1
on error and errno is set. *datafd and *channel are untouched or empty.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_clear_stats.3 b/libknet/man/knet_handle_clear_stats.3
index 8fbdda59..3ec484f4 100644
--- a/libknet/man/knet_handle_clear_stats.3
+++ b/libknet/man/knet_handle_clear_stats.3
@@ -1,36 +1,36 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_clear_stats 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_clear_stats 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_clear_stats \- Clear knet stats, link and/or handle.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_clear_stats\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBint \fP\fIclear_option\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_clear_stats
.PP
knet_h - pointer to knet_handle_t
.PP
clear_option - Which stats to clear, must be one of
.PP
KNET_CLEARSTATS_HANDLE_ONLY or KNET_CLEARSTATS_HANDLE_AND_LINK
.SH RETURN VALUE
.PP
0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_compress.3 b/libknet/man/knet_handle_compress.3
index f5d01dc5..cf510dae 100644
--- a/libknet/man/knet_handle_compress.3
+++ b/libknet/man/knet_handle_compress.3
@@ -1,58 +1,58 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_compress 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_compress 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_compress \- Set up packet compression.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_compress\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBstruct knet_handle_compress_cfg *\fP\fIknet_handle_compress_cfg\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_compress
.PP
knet_h - pointer to knet_handle_t
.PP
knet_handle_compress_cfg - pointer to a knet_handle_compress_cfg structure
.PP
compress_model should contain the mode name. Currently only "zlib" and "lz4" are supported. Setting to "none" will disable compression.
.PP
compress_threshold tells the transmission thread to NOT compress any packets that are smaller than the value indicated. Default 100 bytes. Set to 0 to reset to the default. Set to 1 to compress everything. Max accepted value is KNET_MAX_PACKET_SIZE.
.PP
compress_level some compression libraries allow tuning of compression parameters. For example zlib value ranges from 0 to 9 where 0 is no compression and 9 is max compression. This value is passed pristine to the compression library. zlib: 0 (no compression), 1 (minimal) .. 9 (max compression). lz4: 1 (max compression)... 9 (fastest compression). lz4hc: 1 (min compression) ... LZ4HC_MAX_CLEVEL (16) or LZ4HC_CLEVEL_MAX (12) depends on the installed version of lz4hc. libknet can detects the max value and will print an appropriate warning. lzo2: accepts only some specific values depending on the requested algorithm: 1 : lzo1x_1_compress (default) 11 : lzo1x_1_11_compress 12 : lzo1x_1_12_compress 15 : lzo1x_1_15_compress 999: lzo1x_999_compress every other values will use default lzma: 0 (minimal) .. 9 (max compression) bzip2: 1 (minimal) .. 9 (max compression) Please refer to the library man pages on how to be set this value, as it is passed unmodified to the compression algorithm where supported.
.PP
knet does NOT implement the compression algorithm directly. it relies on external libraries for this functionality. Please read the libraries man pages to figure out which algorithm/compression level is best for the data you are planning to transmit.
.SH STRUCTURES
.SS ""
.PP
.sp
.sp
.RS
.nf
\fB
struct knet_handle_compress_cfg {
char \fIcompress_model\fP;
uint32_t \fIcompress_threshold\fP;
int \fIcompress_level\fP;
};
\fP
.fi
.RE
.SH RETURN VALUE
.PP
knet_handle_compress returns 0 on success -1 on error and errno is set. EINVAL means that either the model or the level are not supported.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_crypto.3 b/libknet/man/knet_handle_crypto.3
index 7479fdbc..2cefab9d 100644
--- a/libknet/man/knet_handle_crypto.3
+++ b/libknet/man/knet_handle_crypto.3
@@ -1,76 +1,76 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_crypto 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_crypto 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_crypto \- set up packet cryptographic signing & encryption
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_crypto\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBstruct knet_handle_crypto_cfg *\fP\fIknet_handle_crypto_cfg\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_crypto
.PP
knet_h - pointer to knet_handle_t
.PP
knet_handle_crypto_cfg - pointer to a knet_handle_crypto_cfg structure
.PP
crypto_model should contain the model name. Currently only "openssl" and "nss" are supported. Setting to "none" will disable crypto.
.PP
crypto_cipher_type should contain the cipher algo name. It can be set to "none" to disable encryption. Currently supported by "nss" model: "3des", "aes128", "aes192" and "aes256". "openssl" model supports more modes and it strictly depends on the openssl build. See: EVP_get_cipherbyname openssl API call for details.
.PP
crypto_hash_type should contain the hashing algo name. It can be set to "none" to disable hashing. Currently supported by "nss" model: "md5", "sha1", "sha256", "sha384" and "sha512". "openssl" model supports more modes and it strictly depends on the openssl build. See: EVP_get_digestbyname openssl API call for details.
.PP
private_key will contain the private shared key. It has to be at least KNET_MIN_KEY_LEN long.
.PP
private_key_len length of the provided private_key.
.PP
it is safe to call knet_handle_crypto multiple times at runtime. The last config will be used. IMPORTANT: a call to knet_handle_crypto can fail due to: 1) failure to obtain locking 2) errors to initializing the crypto level. This can happen even in subsequent calls to knet_handle_crypto. A failure in crypto init, might leave your traffic unencrypted! It's best to stop data forwarding (see knet_handle_setfwd(3)), change crypto config, start forward again.
.SH STRUCTURES
.SS ""
.PP
.sp
.sp
.RS
.nf
\fB
struct knet_handle_crypto_cfg {
char \fIcrypto_model\fP;
char \fIcrypto_cipher_type\fP;
char \fIcrypto_hash_type\fP;
unsigned char \fIprivate_key\fP;
unsigned int \fIprivate_key_len\fP;
};
\fP
.fi
.RE
.SH RETURN VALUE
.PP
knet_handle_crypto returns:
.TP
.B 0
on success
.TP
.B -1
on error and errno is set.
.TP
.B -2
on crypto subsystem initialization error. No errno is provided at the moment (yet).
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_enable_filter.3 b/libknet/man/knet_handle_enable_filter.3
index c0f0426d..d737fdae 100644
--- a/libknet/man/knet_handle_enable_filter.3
+++ b/libknet/man/knet_handle_enable_filter.3
@@ -1,41 +1,41 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_enable_filter 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_enable_filter 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_enable_filter \- install a filter to route packets
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_enable_filter\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBvoid *\fP\fIdst_host_filter_fn_private_data\fP,
\fBint(*)(void *private_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 *channel, knet_node_id_t *dst_host_ids, size_t *dst_host_ids_entries) \fP\fIdst_host_filter_fn\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_enable_filter
.PP
knet_h - pointer to knet_handle_t
.PP
dst_host_filter_fn_private_data void pointer to data that can be used to identify the callback.
.PP
dst_host_filter_fn - is a callback function that is invoked every time a packet hits datafd (see knet_handle_new(3)). the function allows users to tell libknet where the packet has to be delivered.
.PP
const unsigned char *outdata - is a pointer to the current packet ssize_t outdata_len - length of the above data uint8_t tx_rx - filter is called on tx or rx (KNET_NOTIFY_TX, KNET_NOTIFY_RX) knet_node_id_t this_host_id - host_id processing the packet knet_node_id_t src_host_id - host_id that generated the packet knet_node_id_t *dst_host_ids - array of KNET_MAX_HOST knet_node_id_t where to store the destinations size_t *dst_host_ids_entries - number of hosts to send the message
.PP
dst_host_filter_fn should return -1 on error, packet is discarded. 0 packet is unicast and should be sent to dst_host_ids and there are dst_host_ids_entries in the buffer. 1 packet is broadcast/multicast and is sent all hosts. contents of dst_host_ids and dst_host_ids_entries are ignored. (see also kronosnetd/etherfilter.* for an example that filters based on ether protocol)
.SH RETURN VALUE
.PP
knet_handle_enable_filter returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_enable_pmtud_notify.3 b/libknet/man/knet_handle_enable_pmtud_notify.3
index 3c61c56b..19d2b787 100644
--- a/libknet/man/knet_handle_enable_pmtud_notify.3
+++ b/libknet/man/knet_handle_enable_pmtud_notify.3
@@ -1,37 +1,37 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_enable_pmtud_notify 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_enable_pmtud_notify 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_enable_pmtud_notify \- install a callback to receive PMTUd changes
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_enable_pmtud_notify\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBvoid *\fP\fIpmtud_notify_fn_private_data\fP,
\fBvoid(*)(void *private_data, unsigned int data_mtu) \fP\fIpmtud_notify_fn\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_enable_pmtud_notify
.PP
knet_h - pointer to knet_handle_t
.PP
pmtud_notify_fn_private_data void pointer to data that can be used to identify the callback.
.PP
pmtud_notify_fn is a callback function that is invoked every time a path MTU size change is detected. The function allows libknet to notify the user of data MTU, that's the max value that can be send onwire without fragmentation. The data MTU will always be lower than real link MTU because it accounts for protocol overhead, knet packet header and (if configured) crypto overhead, This function MUST NEVER block or add substantial delays.
.SH RETURN VALUE
.PP
knet_handle_enable_pmtud_notify returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_enable_sock_notify.3 b/libknet/man/knet_handle_enable_sock_notify.3
index 47797739..01fe8e35 100644
--- a/libknet/man/knet_handle_enable_sock_notify.3
+++ b/libknet/man/knet_handle_enable_sock_notify.3
@@ -1,35 +1,35 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_enable_sock_notify 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_enable_sock_notify 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_enable_sock_notify \- Register a callback to receive socket events.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_enable_sock_notify\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBvoid *\fP\fIsock_notify_fn_private_data\fP,
\fBvoid(*)(void *private_data, int datafd, int8_t channel, uint8_t tx_rx, int error, int errorno) \fP\fIsock_notify_fn\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_enable_sock_notify knet_h - pointer to knet_handle_t
.PP
sock_notify_fn_private_data void pointer to data that can be used to identify the callback.
.PP
sock_notify_fn A callback function that is invoked every time a socket in the datafd pool will report an error (-1) or an end of read (0) (see socket.7). This function MUST NEVER block or add substantial delays. The callback is invoked in an internal unlocked area to allow calls to knet_handle_add_datafd/knet_handle_remove_datafd to swap/replace the bad fd. if both err and errno are 0, it means that the socket has received a 0 byte packet (EOF?). The callback function must either remove the fd from knet (by calling knet_handle_remove_fd()) or dup a new fd in its place. Failure to do this can cause problems.
.SH RETURN VALUE
.PP
knet_handle_enable_sock_notify returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_free.3 b/libknet/man/knet_handle_free.3
index 48482ccc..e79cca61 100644
--- a/libknet/man/knet_handle_free.3
+++ b/libknet/man/knet_handle_free.3
@@ -1,29 +1,29 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_free 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_free 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_free \- Destroy a knet handle, free all resources.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_free\fP(
\fBknet_handle_t \fP\fIknet_h\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_free knet_h - pointer to knet_handle_t
.SH RETURN VALUE
.PP
knet_handle_free returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_get_channel.3 b/libknet/man/knet_handle_get_channel.3
index a6143f48..83a1a734 100644
--- a/libknet/man/knet_handle_get_channel.3
+++ b/libknet/man/knet_handle_get_channel.3
@@ -1,43 +1,43 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_get_channel 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_get_channel 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_get_channel \- Get the channel associated with a file descriptor.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_get_channel\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBconst int \fP\fIdatafd\fP,
\fBint8_t *\fP\fIchannel\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_get_channel knet_h - pointer to knet_handle_t
.PP
datafd - get the channel associated to this datafd
.PP
*channel - will contain the result
.SH RETURN VALUE
.PP
knet_handle_get_channel returns
.TP
.B 0
on success and *channel will contain the result
.TP
.B -1
on error and errno is set. and *channel content is meaningless
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_get_compress_list.3 b/libknet/man/knet_handle_get_compress_list.3
deleted file mode 100644
index daaf0b32..00000000
--- a/libknet/man/knet_handle_get_compress_list.3
+++ /dev/null
@@ -1,37 +0,0 @@
-.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_get_compress_list 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
-.SH "NAME"
-knet_handle_get_compress_list \- Get a list of support compression types.
-.SH SYNOPSIS
-.nf
-.B #include <libknet.h>
-.sp
-\fBint knet_handle_get_compress_list\fP(
- \fBknet_handle_t \fP\fIknet_h\fP,
- \fBconst char **\fP\fIcompress_names\fP,
- \fBsize_t *\fP\fInum_names\fP
-);
-.fi
-.SH DESCRIPTION
-.PP
-knet_handle_get_compress_list
-.PP
-knet_h - pointer to knet_handle_t
-.PP
-compress_names - array of char * If NULL then only the number of names is returned in num_names to to allow the caller to allocate sufficient space.
-.PP
-num_names - returns the number of strings in compres_names
-.SH RETURN VALUE
-.PP
-knet_host_add returns 0 on success -1 on error and errno is set.
-.SH SEE ALSO
-.PP
-.nh
-.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
-.ad
-.hy
-.SH COPYRIGHT
-.PP
-Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_get_crypto_list.3 b/libknet/man/knet_handle_get_crypto_list.3
deleted file mode 100644
index 66644d3b..00000000
--- a/libknet/man/knet_handle_get_crypto_list.3
+++ /dev/null
@@ -1,37 +0,0 @@
-.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_get_crypto_list 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
-.SH "NAME"
-knet_handle_get_crypto_list \- Get a list of supported crypto libraries.
-.SH SYNOPSIS
-.nf
-.B #include <libknet.h>
-.sp
-\fBint knet_handle_get_crypto_list\fP(
- \fBknet_handle_t \fP\fIknet_h\fP,
- \fBconst char **\fP\fIcrypto_names\fP,
- \fBsize_t *\fP\fInum_names\fP
-);
-.fi
-.SH DESCRIPTION
-.PP
-knet_handle_get_crypto_list
-.PP
-knet_h - pointer to knet_handle_t
-.PP
-crypto_names - array of char * If NULL then only the number of names is returned in num_names to to allow the caller to allocate sufficient space.
-.PP
-num_names - returns the number of strings in crypto_names
-.SH RETURN VALUE
-.PP
-knet_host_add returns 0 on success -1 on error and errno is set.
-.SH SEE ALSO
-.PP
-.nh
-.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
-.ad
-.hy
-.SH COPYRIGHT
-.PP
-Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_get_datafd.3 b/libknet/man/knet_handle_get_datafd.3
index 3e94f313..79b126a9 100644
--- a/libknet/man/knet_handle_get_datafd.3
+++ b/libknet/man/knet_handle_get_datafd.3
@@ -1,43 +1,43 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_get_datafd 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_get_datafd 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_get_datafd \- Get the file descriptor associated with a channel.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_get_datafd\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBconst int8_t \fP\fIchannel\fP,
\fBint *\fP\fIdatafd\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_get_datafd knet_h - pointer to knet_handle_t
.PP
channel - get the datafd associated to this channel
.PP
*datafd - will contain the result
.SH RETURN VALUE
.PP
knet_handle_get_datafd returns
.TP
.B 0
on success and *datafd will contain the results
.TP
.B -1
on error and errno is set. and *datafd content is meaningless
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_get_stats.3 b/libknet/man/knet_handle_get_stats.3
index cb3fa879..60f60ac3 100644
--- a/libknet/man/knet_handle_get_stats.3
+++ b/libknet/man/knet_handle_get_stats.3
@@ -1,73 +1,73 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_get_stats 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_get_stats 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_get_stats \- Get statistics for compression & crypto.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_get_stats\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBstruct knet_handle_stats *\fP\fIstats\fP,
\fBsize_t \fP\fIstruct_size\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_get_stats
.PP
knet_h - pointer to knet_handle_t
.PP
knet_handle_stats pointer to a knet_handle_stats structure
.PP
struct_size size of knet_handle_stats structure to allow for backwards compatibility. libknet will only copy this much data into the stats structure so that older callers will not get overflowed if new fields are added.
.SH STRUCTURES
.SS ""
.PP
.sp
.sp
.RS
.nf
\fB
struct knet_handle_stats {
size_t \fIsize\fP;
uint64_t \fItx_uncompressed_packets\fP;
uint64_t \fItx_compressed_packets\fP;
uint64_t \fItx_compressed_original_bytes\fP;
uint64_t \fItx_compressed_size_bytes\fP;
uint64_t \fItx_compress_time_ave\fP;
uint64_t \fItx_compress_time_min\fP;
uint64_t \fItx_compress_time_max\fP;
uint64_t \fIrx_compressed_packets\fP;
uint64_t \fIrx_compressed_original_bytes\fP;
uint64_t \fIrx_compressed_size_bytes\fP;
uint64_t \fIrx_compress_time_ave\fP;
uint64_t \fIrx_compress_time_min\fP;
uint64_t \fIrx_compress_time_max\fP;
uint64_t \fItx_crypt_packets\fP;
uint64_t \fItx_crypt_byte_overhead\fP;
uint64_t \fItx_crypt_time_ave\fP;
uint64_t \fItx_crypt_time_min\fP;
uint64_t \fItx_crypt_time_max\fP;
uint64_t \fIrx_crypt_packets\fP;
uint64_t \fIrx_crypt_time_ave\fP;
uint64_t \fIrx_crypt_time_min\fP;
uint64_t \fIrx_crypt_time_max\fP;
};
\fP
.fi
.RE
.SH RETURN VALUE
.PP
0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_get_transport_id_by_name.3 b/libknet/man/knet_handle_get_transport_id_by_name.3
deleted file mode 100644
index 01063e32..00000000
--- a/libknet/man/knet_handle_get_transport_id_by_name.3
+++ /dev/null
@@ -1,42 +0,0 @@
-.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_get_transport_id_by_name 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
-.SH "NAME"
-knet_handle_get_transport_id_by_name \- Get a transport ID from its name.
-.SH SYNOPSIS
-.nf
-.B #include <libknet.h>
-.sp
-\fBuint8_t knet_handle_get_transport_id_by_name\fP(
- \fBknet_handle_t \fP\fIknet_h\fP,
- \fBconst char *\fP\fIname\fP
-);
-.fi
-.SH DESCRIPTION
-.PP
-knet_handle_get_transport_id_by_name
-.PP
-knet_h - pointer to knet_handle_t
-.PP
-name - transport name (UDP/SCTP/etc)
-.SH RETURN VALUE
-.PP
-knet_handle_get_transport_name_by_id returns:
-.TP
-.B KNET_MAX_TRANSPORTS
-on error and errno is set accordingly
-
-.TP
-.B KNET_TRANSPORT_xxx
-on success.
-
-.SH SEE ALSO
-.PP
-.nh
-.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
-.ad
-.hy
-.SH COPYRIGHT
-.PP
-Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_get_transport_list.3 b/libknet/man/knet_handle_get_transport_list.3
deleted file mode 100644
index d1d8b832..00000000
--- a/libknet/man/knet_handle_get_transport_list.3
+++ /dev/null
@@ -1,53 +0,0 @@
-.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_get_transport_list 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
-.SH "NAME"
-knet_handle_get_transport_list \- Get a list of the transports support by this build of knet.
-.SH SYNOPSIS
-.nf
-.B #include <libknet.h>
-.sp
-\fBint knet_handle_get_transport_list\fP(
- \fBknet_handle_t \fP\fIknet_h\fP,
- \fBstruct knet_transport_info *\fP\fItransport_list\fP,
- \fBsize_t *\fP\fItransport_list_entries\fP
-);
-.fi
-.SH DESCRIPTION
-.PP
-knet_handle_get_transport_list
-.PP
-knet_h - pointer to knet_handle_t
-.PP
-transport_list - an array of struct transport_info that must be at least of size struct transport_info * KNET_MAX_TRANSPORTS
-.PP
-transport_list_entries - pointer to a size_t where to store how many transports are available in this build of libknet.
-.SH STRUCTURES
-.SS ""
-.PP
-.sp
-.sp
-.RS
-.nf
-\fB
-struct knet_transport_info {
- const char *\fIname\fP;
- uint8_t \fIid\fP;
- uint8_t \fIproperties\fP;
-};
-\fP
-.fi
-.RE
-.SH RETURN VALUE
-.PP
-knet_handle_get_transport_list returns 0 on success -1 on error and errno is set.
-.SH SEE ALSO
-.PP
-.nh
-.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
-.ad
-.hy
-.SH COPYRIGHT
-.PP
-Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_get_transport_name_by_id.3 b/libknet/man/knet_handle_get_transport_name_by_id.3
deleted file mode 100644
index f825c61b..00000000
--- a/libknet/man/knet_handle_get_transport_name_by_id.3
+++ /dev/null
@@ -1,42 +0,0 @@
-.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_get_transport_name_by_id 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
-.SH "NAME"
-knet_handle_get_transport_name_by_id \- Get a transport name from its ID number.
-.SH SYNOPSIS
-.nf
-.B #include <libknet.h>
-.sp
-\fBconst char * knet_handle_get_transport_name_by_id\fP(
- \fBknet_handle_t \fP\fIknet_h\fP,
- \fBuint8_t \fP\fItransport\fP
-);
-.fi
-.SH DESCRIPTION
-.PP
-knet_handle_get_transport_name_by_id
-.PP
-knet_h - pointer to knet_handle_t
-.PP
-transport - one of the KNET_TRANSPORT_xxx constants
-.SH RETURN VALUE
-.PP
-knet_handle_get_transport_name_by_id returns:
-.TP
-.B pointer
-to the name on success or
-
-.TP
-.B NULL
-on error and errno is set.
-
-.SH SEE ALSO
-.PP
-.nh
-.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
-.ad
-.hy
-.SH COPYRIGHT
-.PP
-Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_get_transport_reconnect_interval.3 b/libknet/man/knet_handle_get_transport_reconnect_interval.3
index 73bdd060..d480699b 100644
--- a/libknet/man/knet_handle_get_transport_reconnect_interval.3
+++ b/libknet/man/knet_handle_get_transport_reconnect_interval.3
@@ -1,34 +1,34 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_get_transport_reconnect_interval 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_get_transport_reconnect_interval 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_get_transport_reconnect_interval \- Get the interval between transport attempts to reconnect a failed link.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_get_transport_reconnect_interval\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBuint32_t *\fP\fImsecs\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_get_transport_reconnect_interval
.PP
knet_h - pointer to knet_handle_t
.PP
msecs - milliseconds
.SH RETURN VALUE
.PP
knet_handle_get_transport_reconnect_interval returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_new.3 b/libknet/man/knet_handle_new.3
index 485611d7..89310476 100644
--- a/libknet/man/knet_handle_new.3
+++ b/libknet/man/knet_handle_new.3
@@ -1,37 +1,37 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_new 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_new 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_new \- create a new instance of a knet handle
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBknet_handle_t knet_handle_new\fP(
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBint \fP\fIlog_fd\fP,
\fBuint8_t \fP\fIdefault_log_level\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_new
.PP
host_id - Each host in a knet is identified with a unique ID. when creating a new handle local host_id must be specified (0 to UINT16T_MAX are all valid). It is the user's responsibility to check that the value is unique, or bad things might happen.
.PP
log_fd - Write file descriptor. If set to a value > 0, it will be used to write log packets from libknet to the application. Setting to 0 will disable logging from libknet. It is possible to enable logging at any given time (see logging API). Make sure to either read from this filedescriptor properly and/or mark it O_NONBLOCK, otherwise if the fd becomes full, libknet could block.
.PP
default_log_level - If logfd is specified, it will initialize all subsystems to log at default_log_level value. (see logging API)
.SH RETURN VALUE
.PP
on success, a new knet_handle_t is returned. on failure, NULL is returned and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_pmtud_get.3 b/libknet/man/knet_handle_pmtud_get.3
index 49a200c6..a5aae540 100644
--- a/libknet/man/knet_handle_pmtud_get.3
+++ b/libknet/man/knet_handle_pmtud_get.3
@@ -1,34 +1,34 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_pmtud_get 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_pmtud_get 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_pmtud_get \- Get the current data MTU.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_pmtud_get\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBunsigned int *\fP\fIdata_mtu\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_pmtud_get
.PP
knet_h - pointer to knet_handle_t
.PP
data_mtu - pointer where to store data_mtu
.SH RETURN VALUE
.PP
knet_handle_pmtud_get returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_pmtud_getfreq.3 b/libknet/man/knet_handle_pmtud_getfreq.3
index cd9ef62f..47d417d1 100644
--- a/libknet/man/knet_handle_pmtud_getfreq.3
+++ b/libknet/man/knet_handle_pmtud_getfreq.3
@@ -1,34 +1,34 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_pmtud_getfreq 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_pmtud_getfreq 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_pmtud_getfreq \- Get the interval between PMTUd scans.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_pmtud_getfreq\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBunsigned int *\fP\fIinterval\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_pmtud_getfreq
.PP
knet_h - pointer to knet_handle_t
.PP
interval - pointer where to store the current interval value
.SH RETURN VALUE
.PP
knet_handle_pmtud_setfreq returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_pmtud_setfreq.3 b/libknet/man/knet_handle_pmtud_setfreq.3
index 3c99af5a..a6f54d1d 100644
--- a/libknet/man/knet_handle_pmtud_setfreq.3
+++ b/libknet/man/knet_handle_pmtud_setfreq.3
@@ -1,36 +1,36 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_pmtud_setfreq 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_pmtud_setfreq 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_pmtud_setfreq \- Set the interval between PMTUd scans.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_pmtud_setfreq\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBunsigned int \fP\fIinterval\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_pmtud_setfreq
.PP
knet_h - pointer to knet_handle_t
.PP
interval - define the interval in seconds between PMTUd scans range from 1 to 86400 (24h)
.PP
default interval is 60.
.SH RETURN VALUE
.PP
knet_handle_pmtud_setfreq returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_remove_datafd.3 b/libknet/man/knet_handle_remove_datafd.3
index 6add15b2..d5da2f5f 100644
--- a/libknet/man/knet_handle_remove_datafd.3
+++ b/libknet/man/knet_handle_remove_datafd.3
@@ -1,32 +1,32 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_remove_datafd 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_remove_datafd 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_remove_datafd \- Remove a file descriptor from knet.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_remove_datafd\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBint \fP\fIdatafd\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_remove_datafd knet_h - pointer to knet_handle_t
.PP
datafd - file descriptor to remove. NOTE that if the socket/fd was created by knet_handle_add_datafd, the socket will be closed by libknet.
.SH RETURN VALUE
.PP
knet_handle_remove_datafd returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_set_transport_reconnect_interval.3 b/libknet/man/knet_handle_set_transport_reconnect_interval.3
index 2297280a..c7199390 100644
--- a/libknet/man/knet_handle_set_transport_reconnect_interval.3
+++ b/libknet/man/knet_handle_set_transport_reconnect_interval.3
@@ -1,34 +1,34 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_set_transport_reconnect_interval 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_set_transport_reconnect_interval 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_set_transport_reconnect_interval \- Set the interval between transport attempts to reconnect a failed link.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_set_transport_reconnect_interval\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBuint32_t \fP\fImsecs\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_set_transport_reconnect_interval
.PP
knet_h - pointer to knet_handle_t
.PP
msecs - milliseconds
.SH RETURN VALUE
.PP
knet_handle_set_transport_reconnect_interval returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_handle_setfwd.3 b/libknet/man/knet_handle_setfwd.3
index 8aa90966..0b155a4c 100644
--- a/libknet/man/knet_handle_setfwd.3
+++ b/libknet/man/knet_handle_setfwd.3
@@ -1,36 +1,36 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_handle_setfwd 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_handle_setfwd 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_handle_setfwd \- Start packet forwarding.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_handle_setfwd\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBunsigned int \fP\fIenabled\fP
);
.fi
.SH DESCRIPTION
.PP
knet_handle_setfwd
.PP
knet_h - pointer to knet_handle_t
.PP
enable - set to 1 to allow data forwarding, 0 to disable data forwarding.
.PP
By default data forwarding is off and no traffic will pass through knet until it is set on.
.SH RETURN VALUE
.PP
knet_handle_setfwd returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_host_add.3 b/libknet/man/knet_host_add.3
index c6b1f0a1..15206612 100644
--- a/libknet/man/knet_host_add.3
+++ b/libknet/man/knet_host_add.3
@@ -1,34 +1,34 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_host_add 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_host_add 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_host_add \- Add a new host ID to knet.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_host_add\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP
);
.fi
.SH DESCRIPTION
.PP
knet_host_add
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - each host in a knet is identified with a unique ID (see also knet_handle_new(3))
.SH RETURN VALUE
.PP
knet_host_add returns: 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_host_enable_status_change_notify.3 b/libknet/man/knet_host_enable_status_change_notify.3
index 032ee788..ee36ef9c 100644
--- a/libknet/man/knet_host_enable_status_change_notify.3
+++ b/libknet/man/knet_host_enable_status_change_notify.3
@@ -1,37 +1,37 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_host_enable_status_change_notify 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_host_enable_status_change_notify 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_host_enable_status_change_notify \- Install a callback to get host status change events.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_host_enable_status_change_notify\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBvoid *\fP\fIhost_status_change_notify_fn_private_data\fP,
\fBvoid(*)(void *private_data, knet_node_id_t host_id, uint8_t reachable, uint8_t remote, uint8_t external) \fP\fIhost_status_change_notify_fn\fP
);
.fi
.SH DESCRIPTION
.PP
knet_host_enable_status_change_notify
.PP
knet_h - pointer to knet_handle_t
.PP
host_status_change_notify_fn_private_data - void pointer to data that can be used to identify the callback
.PP
external, 0 if the host_id is configured locally or 1 if it has been added from remote nodes config. NOTE: dynamic topology is NOT currently implemented, but this is ready for future and can avoid an API/ABI breakage later on. This function MUST NEVER block or add substantial delays.
.SH RETURN VALUE
.PP
knet_host_status_change_notify returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_host_get_host_list.3 b/libknet/man/knet_host_get_host_list.3
index fc618795..8b5b3468 100644
--- a/libknet/man/knet_host_get_host_list.3
+++ b/libknet/man/knet_host_get_host_list.3
@@ -1,37 +1,37 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_host_get_host_list 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_host_get_host_list 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_host_get_host_list \- Get a list of hosts known to knet.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_host_get_host_list\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t *\fP\fIhost_ids\fP,
\fBsize_t *\fP\fIhost_ids_entries\fP
);
.fi
.SH DESCRIPTION
.PP
knet_host_get_host_list
.PP
knet_h - pointer to knet_handle_t
.PP
host_ids - array of at lest KNET_MAX_HOST size
.PP
host_ids_entries - number of entries writted in host_ids
.SH RETURN VALUE
.PP
knet_host_get_host_list returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_host_get_id_by_host_name.3 b/libknet/man/knet_host_get_id_by_host_name.3
index bdd7260b..a1b44023 100644
--- a/libknet/man/knet_host_get_id_by_host_name.3
+++ b/libknet/man/knet_host_get_id_by_host_name.3
@@ -1,37 +1,37 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_host_get_id_by_host_name 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_host_get_id_by_host_name 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_host_get_id_by_host_name \- Get the ID of a host given its name.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_host_get_id_by_host_name\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBconst char *\fP\fIname\fP,
\fBknet_node_id_t *\fP\fIhost_id\fP
);
.fi
.SH DESCRIPTION
.PP
knet_host_get_id_by_host_name
.PP
knet_h - pointer to knet_handle_t
.PP
name - name to lookup, max len KNET_MAX_HOST_LEN
.PP
host_id - where to store the result
.SH RETURN VALUE
.PP
knet_host_get_id_by_host_name returns: 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_host_get_name_by_host_id.3 b/libknet/man/knet_host_get_name_by_host_id.3
index 3868b198..396ffc5d 100644
--- a/libknet/man/knet_host_get_name_by_host_id.3
+++ b/libknet/man/knet_host_get_name_by_host_id.3
@@ -1,37 +1,37 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_host_get_name_by_host_id 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_host_get_name_by_host_id 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_host_get_name_by_host_id \- Get the name of a host given its ID.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_host_get_name_by_host_id\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBchar *\fP\fIname\fP
);
.fi
.SH DESCRIPTION
.PP
knet_host_get_name_by_host_id
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
name - pointer to a preallocated buffer of at least size KNET_MAX_HOST_LEN where the current host name will be stored (as set by knet_host_set_name or default by knet_host_add)
.SH RETURN VALUE
.PP
knet_host_get_name_by_host_id returns: 0 on success -1 on error and errno is set (name is left untouched)
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_host_get_policy.3 b/libknet/man/knet_host_get_policy.3
index 71483e7e..53771396 100644
--- a/libknet/man/knet_host_get_policy.3
+++ b/libknet/man/knet_host_get_policy.3
@@ -1,37 +1,37 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_host_get_policy 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_host_get_policy 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_host_get_policy \- Get the switching policy for a host's links.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_host_get_policy\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t *\fP\fIpolicy\fP
);
.fi
.SH DESCRIPTION
.PP
knet_host_get_policy
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
policy - will contain the current configured switching policy. Default is passive when creating a new host.
.SH RETURN VALUE
.PP
knet_host_get_policy returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_host_get_status.3 b/libknet/man/knet_host_get_status.3
index fe5a1d98..5cb5631d 100644
--- a/libknet/man/knet_host_get_status.3
+++ b/libknet/man/knet_host_get_status.3
@@ -1,53 +1,53 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_host_get_status 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_host_get_status 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_host_get_status \- Get the status of a host.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_host_get_status\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBstruct knet_host_status *\fP\fIstatus\fP
);
.fi
.SH DESCRIPTION
.PP
knet_host_status_get
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
status - pointer to knet_host_status struct
.SH STRUCTURES
.SS ""
.PP
.sp
.sp
.RS
.nf
\fB
struct knet_host_status {
uint8_t \fIreachable\fP;
uint8_t \fIremote\fP;
uint8_t \fIexternal\fP;
};
\fP
.fi
.RE
.SH RETURN VALUE
.PP
knet_handle_pmtud_get returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_host_remove.3 b/libknet/man/knet_host_remove.3
index 7827eb76..ffe836ec 100644
--- a/libknet/man/knet_host_remove.3
+++ b/libknet/man/knet_host_remove.3
@@ -1,34 +1,34 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_host_remove 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_host_remove 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_host_remove \- Remove a host ID from knet.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_host_remove\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP
);
.fi
.SH DESCRIPTION
.PP
knet_host_remove
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - each host in a knet is identified with a unique ID (see also knet_handle_new(3))
.SH RETURN VALUE
.PP
knet_host_remove returns: 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_host_set_name.3 b/libknet/man/knet_host_set_name.3
index c435161f..47569e3d 100644
--- a/libknet/man/knet_host_set_name.3
+++ b/libknet/man/knet_host_set_name.3
@@ -1,37 +1,37 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_host_set_name 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_host_set_name 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_host_set_name \- Set the name of a knet host.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_host_set_name\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBconst char *\fP\fIname\fP
);
.fi
.SH DESCRIPTION
.PP
knet_host_set_name
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
name - this name will be used for pretty logging and eventually search for hosts (see also knet_handle_host_get_name(2) and knet_handle_host_get_id(3)). Only up to KNET_MAX_HOST_LEN - 1 bytes will be accepted and name has to be unique for each host.
.SH RETURN VALUE
.PP
knet_host_set_name returns: 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_host_set_policy.3 b/libknet/man/knet_host_set_policy.3
index 9f0945dc..14ed83e7 100644
--- a/libknet/man/knet_host_set_policy.3
+++ b/libknet/man/knet_host_set_policy.3
@@ -1,41 +1,41 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_host_set_policy 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_host_set_policy 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_host_set_policy \- Set the switching policy for a host's links.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_host_set_policy\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t \fP\fIpolicy\fP
);
.fi
.SH DESCRIPTION
.PP
knet_host_set_policy
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
policy - there are currently 3 kind of simple switching policies based on link configuration. KNET_LINK_POLICY_PASSIVE - the active link with the lowest priority will be used. if one or more active links share the same priority, the one with lowest link_id will be used.
.PP
KNET_LINK_POLICY_ACTIVE - all active links will be used simultaneously to send traffic. link priority is ignored.
.PP
KNET_LINK_POLICY_RR - round-robin policy, every packet will be send on a different active link.
.SH RETURN VALUE
.PP
knet_host_set_policy returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_link_clear_config.3 b/libknet/man/knet_link_clear_config.3
index ca319da3..bc432ac9 100644
--- a/libknet/man/knet_link_clear_config.3
+++ b/libknet/man/knet_link_clear_config.3
@@ -1,37 +1,37 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_link_clear_config 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_link_clear_config 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_link_clear_config \- Clear link information and disconnect the link.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_link_clear_config\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t \fP\fIlink_id\fP
);
.fi
.SH DESCRIPTION
.PP
knet_link_clear_config
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
link_id - see knet_link_set_config(3)
.SH RETURN VALUE
.PP
knet_link_clear_config returns 0 on success. -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_link_get_config.3 b/libknet/man/knet_link_get_config.3
index af3d62e5..640be213 100644
--- a/libknet/man/knet_link_get_config.3
+++ b/libknet/man/knet_link_get_config.3
@@ -1,52 +1,52 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_link_get_config 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_link_get_config 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_link_get_config \- Get the link configutation information.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_link_get_config\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t \fP\fIlink_id\fP,
\fBuint8_t *\fP\fItransport\fP,
\fBstruct sockaddr_storage *\fP\fIsrc_addr\fP,
\fBstruct sockaddr_storage *\fP\fIdst_addr\fP,
\fBuint8_t *\fP\fIdynamic\fP,
\fBuint64_t *\fP\fIflags\fP
);
.fi
.SH DESCRIPTION
.PP
knet_link_get_config
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
link_id - see knet_link_set_config(3)
.PP
transport - see knet_link_set_config(3)
.PP
src_addr - sockaddr_storage that can be either IPv4 or IPv6
.PP
dst_addr - sockaddr_storage that can be either IPv4 or IPv6
.PP
dynamic - 0 if dst_addr is static or 1 if dst_addr is dynamic. In case of 1, dst_addr can be NULL and it will be left untouched.
.PP
flags - KNET_LINK_FLAG_*
.SH RETURN VALUE
.PP
knet_link_get_config returns 0 on success. -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_link_get_enable.3 b/libknet/man/knet_link_get_enable.3
index 7ca14d52..9e49868e 100644
--- a/libknet/man/knet_link_get_enable.3
+++ b/libknet/man/knet_link_get_enable.3
@@ -1,40 +1,40 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_link_get_enable 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_link_get_enable 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_link_get_enable \- Find out whether a link is enabled or not.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_link_get_enable\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t \fP\fIlink_id\fP,
\fBunsigned int *\fP\fIenabled\fP
);
.fi
.SH DESCRIPTION
.PP
knet_link_get_enable
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
link_id - see knet_link_set_config(3)
.PP
enabled - 0 disable the link, 1 enable the link
.SH RETURN VALUE
.PP
knet_link_get_enable returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_link_get_link_list.3 b/libknet/man/knet_link_get_link_list.3
index 207a4988..a88392aa 100644
--- a/libknet/man/knet_link_get_link_list.3
+++ b/libknet/man/knet_link_get_link_list.3
@@ -1,38 +1,38 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_link_get_link_list 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_link_get_link_list 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_link_get_link_list \- Get a list of links connecting a host.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_link_get_link_list\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t *\fP\fIlink_ids\fP,
\fBsize_t *\fP\fIlink_ids_entries\fP
);
.fi
.SH DESCRIPTION
.PP
knet_link_get_link_list
.PP
knet_h - pointer to knet_handle_t
.PP
link_ids - array of at lest KNET_MAX_LINK size with the list of configured links for a certain host.
.PP
link_ids_entries - number of entries contained in link_ids
.SH RETURN VALUE
.PP
knet_link_get_link_list returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_link_get_ping_timers.3 b/libknet/man/knet_link_get_ping_timers.3
index 658499d9..b7a5edf4 100644
--- a/libknet/man/knet_link_get_ping_timers.3
+++ b/libknet/man/knet_link_get_ping_timers.3
@@ -1,46 +1,46 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_link_get_ping_timers 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_link_get_ping_timers 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_link_get_ping_timers \- Get the ping timers for a link.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_link_get_ping_timers\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t \fP\fIlink_id\fP,
\fBtime_t *\fP\fIinterval\fP,
\fBtime_t *\fP\fItimeout\fP,
\fBunsigned int *\fP\fIprecision\fP
);
.fi
.SH DESCRIPTION
.PP
knet_link_get_ping_timers
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
link_id - see knet_link_set_config(3)
.PP
interval - ping interval
.PP
timeout - if no pong is received within this time, the link is declared dead
.PP
precision - how many values of latency are used to calculate the average link latency (see also knet_link_get_status(3))
.SH RETURN VALUE
.PP
knet_link_get_ping_timers returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_link_get_pong_count.3 b/libknet/man/knet_link_get_pong_count.3
index 0d0995c2..102c81b8 100644
--- a/libknet/man/knet_link_get_pong_count.3
+++ b/libknet/man/knet_link_get_pong_count.3
@@ -1,40 +1,40 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_link_get_pong_count 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_link_get_pong_count 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_link_get_pong_count \- Get the pong count for a link.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_link_get_pong_count\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t \fP\fIlink_id\fP,
\fBuint8_t *\fP\fIpong_count\fP
);
.fi
.SH DESCRIPTION
.PP
knet_link_get_pong_count
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
link_id - see knet_link_set_config(3)
.PP
pong_count - how many valid ping/pongs before a link is marked UP. default: 5, value should be > 0
.SH RETURN VALUE
.PP
knet_link_get_pong_count returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_link_get_priority.3 b/libknet/man/knet_link_get_priority.3
index eee0348d..d2d49902 100644
--- a/libknet/man/knet_link_get_priority.3
+++ b/libknet/man/knet_link_get_priority.3
@@ -1,40 +1,40 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_link_get_priority 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_link_get_priority 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_link_get_priority \- Get the priority for a link.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_link_get_priority\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t \fP\fIlink_id\fP,
\fBuint8_t *\fP\fIpriority\fP
);
.fi
.SH DESCRIPTION
.PP
knet_link_get_priority
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
link_id - see knet_link_set_config(3)
.PP
priority - gather the switching priority for this link see also knet_host_set_policy
.SH RETURN VALUE
.PP
knet_link_get_priority returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_link_get_status.3 b/libknet/man/knet_link_get_status.3
index 7dc20c7c..b9b89c49 100644
--- a/libknet/man/knet_link_get_status.3
+++ b/libknet/man/knet_link_get_status.3
@@ -1,69 +1,69 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_link_get_status 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_link_get_status 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_link_get_status \- Get the status (and statistics) for a link.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_link_get_status\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t \fP\fIlink_id\fP,
\fBstruct knet_link_status *\fP\fIstatus\fP,
\fBsize_t \fP\fIstruct_size\fP
);
.fi
.SH DESCRIPTION
.PP
knet_link_get_status
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
link_id - see knet_link_set_config(3)
.PP
status - pointer to knet_link_status struct
.PP
struct_size - max size of knet_link_status - allows library to add fields without ABI change. Returned structure will be truncated to this length and .size member indicates the full size.
.SH STRUCTURES
.SS ""
.PP
.sp
.sp
.RS
.nf
\fB
struct knet_link_status {
size_t \fIsize\fP;
char \fIsrc_ipaddr\fP;
char \fIsrc_port\fP;
char \fIdst_ipaddr\fP;
char \fIdst_port\fP;
uint8_t \fIenabled\fP;
uint8_t \fIconnected\fP;
uint8_t \fIdynconnected\fP;
unsigned long long \fIlatency\fP;
struct timespec \fIpong_last\fP;
unsigned int \fImtu\fP;
unsigned int \fIproto_overhead\fP;
struct knet_link_stats \fIstats\fP;
};
\fP
.fi
.RE
.SH RETURN VALUE
.PP
knet_link_get_status returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_link_set_config.3 b/libknet/man/knet_link_set_config.3
index 43bf24b6..aaa54fdc 100644
--- a/libknet/man/knet_link_set_config.3
+++ b/libknet/man/knet_link_set_config.3
@@ -1,49 +1,49 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_link_set_config 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_link_set_config 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_link_set_config \- Configure the link to a host.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_link_set_config\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t \fP\fIlink_id\fP,
\fBuint8_t \fP\fItransport\fP,
\fBstruct sockaddr_storage *\fP\fIsrc_addr\fP,
\fBstruct sockaddr_storage *\fP\fIdst_addr\fP,
\fBuint64_t \fP\fIflags\fP
);
.fi
.SH DESCRIPTION
.PP
knet_link_set_config
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
link_id - see knet_link_set_config(3)
.PP
transport - one of the KNET_TRANSPORT_xxx constants
.PP
src_addr - sockaddr_storage that can be either IPv4 or IPv6
.PP
dst_addr - sockaddr_storage that can be either IPv4 or IPv6 this can be null if we don't know the incoming IP address/port and the link will remain quiet till the node on the other end will initiate a connection
.PP
flags - KNET_LINK_FLAG_*
.SH RETURN VALUE
.PP
knet_link_set_config returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_link_set_enable.3 b/libknet/man/knet_link_set_enable.3
index 46854552..ac66ea52 100644
--- a/libknet/man/knet_link_set_enable.3
+++ b/libknet/man/knet_link_set_enable.3
@@ -1,40 +1,40 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_link_set_enable 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_link_set_enable 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_link_set_enable \- Enable traffic on a link.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_link_set_enable\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t \fP\fIlink_id\fP,
\fBunsigned int \fP\fIenabled\fP
);
.fi
.SH DESCRIPTION
.PP
knet_link_set_enable
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
link_id - see knet_link_set_config(3)
.PP
enabled - 0 disable the link, 1 enable the link
.SH RETURN VALUE
.PP
knet_link_set_enable returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_link_set_ping_timers.3 b/libknet/man/knet_link_set_ping_timers.3
index 7a333ae9..ea32bb5d 100644
--- a/libknet/man/knet_link_set_ping_timers.3
+++ b/libknet/man/knet_link_set_ping_timers.3
@@ -1,46 +1,46 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_link_set_ping_timers 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_link_set_ping_timers 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_link_set_ping_timers \- Set the ping timers for a link.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_link_set_ping_timers\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t \fP\fIlink_id\fP,
\fBtime_t \fP\fIinterval\fP,
\fBtime_t \fP\fItimeout\fP,
\fBunsigned int \fP\fIprecision\fP
);
.fi
.SH DESCRIPTION
.PP
knet_link_set_ping_timers
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
link_id - see knet_link_set_config(3)
.PP
interval - specify the ping interval
.PP
timeout - if no pong is received within this time, the link is declared dead
.PP
precision - how many values of latency are used to calculate the average link latency (see also knet_link_get_status(3))
.SH RETURN VALUE
.PP
knet_link_set_ping_timers returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_link_set_pong_count.3 b/libknet/man/knet_link_set_pong_count.3
index 063a4eab..b4e27213 100644
--- a/libknet/man/knet_link_set_pong_count.3
+++ b/libknet/man/knet_link_set_pong_count.3
@@ -1,40 +1,40 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_link_set_pong_count 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_link_set_pong_count 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_link_set_pong_count \- Set the pong count for a link.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_link_set_pong_count\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t \fP\fIlink_id\fP,
\fBuint8_t \fP\fIpong_count\fP
);
.fi
.SH DESCRIPTION
.PP
knet_link_set_pong_count
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
link_id - see knet_link_set_config(3)
.PP
pong_count - how many valid ping/pongs before a link is marked UP. default: 5, value should be > 0
.SH RETURN VALUE
.PP
knet_link_set_pong_count returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_link_set_priority.3 b/libknet/man/knet_link_set_priority.3
index 52aa5b82..f8c7e284 100644
--- a/libknet/man/knet_link_set_priority.3
+++ b/libknet/man/knet_link_set_priority.3
@@ -1,40 +1,40 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_link_set_priority 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_link_set_priority 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_link_set_priority \- Set the priority for a link.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_link_set_priority\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBknet_node_id_t \fP\fIhost_id\fP,
\fBuint8_t \fP\fIlink_id\fP,
\fBuint8_t \fP\fIpriority\fP
);
.fi
.SH DESCRIPTION
.PP
knet_link_set_priority
.PP
knet_h - pointer to knet_handle_t
.PP
host_id - see knet_host_add(3)
.PP
link_id - see knet_link_set_config(3)
.PP
priority - specify the switching priority for this link see also knet_host_set_policy
.SH RETURN VALUE
.PP
knet_link_set_priority returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_log_get_loglevel.3 b/libknet/man/knet_log_get_loglevel.3
index 508ba09e..6cfb9199 100644
--- a/libknet/man/knet_log_get_loglevel.3
+++ b/libknet/man/knet_log_get_loglevel.3
@@ -1,37 +1,37 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_log_get_loglevel 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_log_get_loglevel 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_log_get_loglevel \- Get the logging level for a subsystem.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_log_get_loglevel\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBuint8_t \fP\fIsubsystem\fP,
\fBuint8_t *\fP\fIlevel\fP
);
.fi
.SH DESCRIPTION
.PP
knet_log_get_log_level
.PP
knet_h - same as above
.PP
subsystem - same as above
.PP
level - same as above
.SH RETURN VALUE
.PP
knet_log_get_loglevel returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_log_get_loglevel_id.3 b/libknet/man/knet_log_get_loglevel_id.3
index d7b8d9e9..96828386 100644
--- a/libknet/man/knet_log_get_loglevel_id.3
+++ b/libknet/man/knet_log_get_loglevel_id.3
@@ -1,29 +1,29 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_log_get_loglevel_id 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_log_get_loglevel_id 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_log_get_loglevel_id \- Get a logging level ID from its name.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBuint8_t knet_log_get_loglevel_id\fP(
\fBconst char *\fP\fIname\fP
);
.fi
.SH DESCRIPTION
.PP
knet_log_get_loglevel_id
.SH RETURN VALUE
.PP
returns internal log level ID or KNET_LOG_ERR for invalid names
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_log_get_loglevel_name.3 b/libknet/man/knet_log_get_loglevel_name.3
index eacc537f..9caeb532 100644
--- a/libknet/man/knet_log_get_loglevel_name.3
+++ b/libknet/man/knet_log_get_loglevel_name.3
@@ -1,29 +1,29 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_log_get_loglevel_name 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_log_get_loglevel_name 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_log_get_loglevel_name \- Get a logging level name from its numeric ID.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBconst char * knet_log_get_loglevel_name\fP(
\fBuint8_t \fP\fIlevel\fP
);
.fi
.SH DESCRIPTION
.PP
knet_log_get_loglevel_name
.SH RETURN VALUE
.PP
returns internal name of the log level or "ERROR" for unknown values
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_log_get_subsystem_id.3 b/libknet/man/knet_log_get_subsystem_id.3
index 877a2788..dd4b8e6c 100644
--- a/libknet/man/knet_log_get_subsystem_id.3
+++ b/libknet/man/knet_log_get_subsystem_id.3
@@ -1,29 +1,29 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_log_get_subsystem_id 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_log_get_subsystem_id 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_log_get_subsystem_id \- Get a logging system ID from its name.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBuint8_t knet_log_get_subsystem_id\fP(
\fBconst char *\fP\fIname\fP
);
.fi
.SH DESCRIPTION
.PP
knet_log_get_subsystem_id
.SH RETURN VALUE
.PP
returns internal ID of the subsystem or KNET_SUB_COMMON
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_log_get_subsystem_name.3 b/libknet/man/knet_log_get_subsystem_name.3
index 17665c47..a0569fa6 100644
--- a/libknet/man/knet_log_get_subsystem_name.3
+++ b/libknet/man/knet_log_get_subsystem_name.3
@@ -1,29 +1,29 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_log_get_subsystem_name 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_log_get_subsystem_name 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_log_get_subsystem_name \- Get a logging system name from its numeric ID.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBconst char * knet_log_get_subsystem_name\fP(
\fBuint8_t \fP\fIsubsystem\fP
);
.fi
.SH DESCRIPTION
.PP
knet_log_get_subsystem_name
.SH RETURN VALUE
.PP
returns internal name of the subsystem or "common"
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_log_set_loglevel.3 b/libknet/man/knet_log_set_loglevel.3
index 72254a2a..83aadaae 100644
--- a/libknet/man/knet_log_set_loglevel.3
+++ b/libknet/man/knet_log_set_loglevel.3
@@ -1,39 +1,39 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_log_set_loglevel 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_log_set_loglevel 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_log_set_loglevel \- Set the logging level for a subsystem.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_log_set_loglevel\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBuint8_t \fP\fIsubsystem\fP,
\fBuint8_t \fP\fIlevel\fP
);
.fi
.SH DESCRIPTION
.PP
knet_log_set_log_level
.PP
knet_h - same as above
.PP
subsystem - same as above
.PP
level - same as above
.PP
knet_log_set_loglevel allows fine control of log levels by subsystem. See also knet_handle_new for defaults.
.SH RETURN VALUE
.PP
knet_log_set_loglevel returns 0 on success -1 on error and errno is set.
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_recv.3 b/libknet/man/knet_recv.3
index fe139377..e98991fb 100644
--- a/libknet/man/knet_recv.3
+++ b/libknet/man/knet_recv.3
@@ -1,38 +1,38 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_recv 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_recv 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_recv \- Receive data from knet nodes.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBssize_t knet_recv\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBchar *\fP\fIbuff\fP,
\fBconst size_t \fP\fIbuff_len\fP,
\fBconst int8_t \fP\fIchannel\fP
);
.fi
.SH DESCRIPTION
.PP
knet_recv knet_h - pointer to knet_handle_t
.PP
buff - pointer to buffer to store the received data
.PP
buff_len - buffer length
.PP
channel - channel number
.SH RETURN VALUE
.PP
knet_recv is a commodity function to wrap iovec operations around a socket. It returns a call to readv(2).
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_send.3 b/libknet/man/knet_send.3
index 85d1278f..bd2b8122 100644
--- a/libknet/man/knet_send.3
+++ b/libknet/man/knet_send.3
@@ -1,38 +1,38 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_send 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_send 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_send \- Send data to knet nodes.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBssize_t knet_send\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBconst char *\fP\fIbuff\fP,
\fBconst size_t \fP\fIbuff_len\fP,
\fBconst int8_t \fP\fIchannel\fP
);
.fi
.SH DESCRIPTION
.PP
knet_send knet_h - pointer to knet_handle_t
.PP
buff - pointer to the buffer of data to send
.PP
buff_len - length of data to send
.PP
channel - channel number
.SH RETURN VALUE
.PP
knet_send is a commodity function to wrap iovec operations around a socket. It returns a call to writev(2).
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_send_sync.3 b/libknet/man/knet_send_sync.3
index 36e4c53b..0fdccf68 100644
--- a/libknet/man/knet_send_sync.3
+++ b/libknet/man/knet_send_sync.3
@@ -1,74 +1,74 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_send_sync 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_send_sync 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_send_sync \- Synchronously send data to knet nodes.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_send_sync\fP(
\fBknet_handle_t \fP\fIknet_h\fP,
\fBconst char *\fP\fIbuff\fP,
\fBconst size_t \fP\fIbuff_len\fP,
\fBconst int8_t \fP\fIchannel\fP
);
.fi
.SH DESCRIPTION
.PP
knet_send_sync
.PP
knet_h - pointer to knet_handle_t
.PP
buff - pointer to the buffer of data to send
.PP
buff_len - length of data to send
.PP
channel - data channel to use (see knet_handle_add_datafd(3))
.PP
All knet RX/TX operations are async for performance reasons. There are applications that might need a sync version of data transmission and receive errors in case of failure to deliver to another host. knet_send_sync bypasses the whole TX async layer and delivers data directly to the link layer, and returns errors accordingly. knet_send_sync allows to send only one packet to one host at a time. It does NOT support multiple destinations or multicast packets. Decision is still based on dst_host_filter_fn.
.SH RETURN VALUE
.PP
knet_send_sync returns 0 on success and -1 on error. In addition to normal sendmmsg errors, knet_send_sync can fail due to:
.TP
.B ECANCELED
- data forward is disabled
.TP
.B EFAULT
- dst_host_filter fatal error
.TP
.B EINVAL
- dst_host_filter did not provide dst_host_ids_entries on unicast pckts
.TP
.B E2BIG
- dst_host_filter did return more than one dst_host_ids_entries on unicast pckts
.TP
.B ENOMSG
- received unknown message type
.TP
.B EHOSTDOWN
- unicast pckt cannot be delivered because dest host is not connected yet
.TP
.B ECHILD
- crypto failed
.TP
.B EAGAIN
- sendmmsg was unable to send all messages and there was no progress during retry
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/knet_strtoaddr.3 b/libknet/man/knet_strtoaddr.3
index 02b71012..02153f92 100644
--- a/libknet/man/knet_strtoaddr.3
+++ b/libknet/man/knet_strtoaddr.3
@@ -1,40 +1,40 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH knet_strtoaddr 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH knet_strtoaddr 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
knet_strtoaddr \- Convert a hostname string to an address.
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.sp
\fBint knet_strtoaddr\fP(
\fBconst char *\fP\fIhost\fP,
\fBconst char *\fP\fIport\fP,
\fBstruct sockaddr_storage *\fP\fIss\fP,
\fBsocklen_t \fP\fIsslen\fP
);
.fi
.SH DESCRIPTION
.PP
knet_strtoaddr
.PP
host - IPaddr/hostname to convert be aware only the first IP address will be returned in case a hostname resolves to multiple IP
.PP
port - port to connect to
.PP
ss - sockaddr_storage where to store the converted data
.PP
sslen - len of the sockaddr_storage
.SH RETURN VALUE
.PP
knet_strtoaddr returns same error codes as getaddrinfo
.SH SEE ALSO
.PP
.nh
.ad l
-\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIlibknet.h\fP(3), \fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/man/libknet.h.3 b/libknet/man/libknet.h.3
index 5cdfd598..6b5c0d21 100644
--- a/libknet/man/libknet.h.3
+++ b/libknet/man/libknet.h.3
@@ -1,210 +1,241 @@
.\" File automatically generated by doxy2man0.2
-.\" Generation date: Tue Nov 7 2017
-.TH libknet.h 3 2017-11-07 "kronosnet" "Kronosnet Programmer's Manual"
+.\" Generation date: Mon Nov 13 2017
+.TH libknet.h 3 2017-11-13 "kronosnet" "Kronosnet Programmer's Manual"
.SH "NAME"
libknet.h \- kronosnet API include file
.SH SYNOPSIS
.nf
.B #include <libknet.h>
.fi
.SH DESCRIPTION
.PP
Kronosnet is an advanced VPN system for High Availability applications.
.PP
.sp
.RS
.nf
\fB
int knet_addrtostr(const struct sockaddr_storage *, socklen_t, char *, size_t, char *, size_t);
+int knet_get_compress_list(struct knet_compress_info *, size_t *);
+int knet_get_crypto_list(struct knet_crypto_info *, size_t *);
+uint8_t knet_get_transport_id_by_name(const char *);
+int knet_get_transport_list(struct knet_transport_info *, size_t *);
+const char *knet_get_transport_name_by_id(uint8_t);
int knet_handle_add_datafd(knet_handle_t, int *, int8_t *);
int knet_handle_clear_stats(knet_handle_t, int);
int knet_handle_compress(knet_handle_t, struct knet_handle_compress_cfg *);
int knet_handle_crypto(knet_handle_t, struct knet_handle_crypto_cfg *);
int knet_handle_enable_filter(knet_handle_t, void *, int(*)(void *private_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 *channel, knet_node_id_t *dst_host_ids, size_t *dst_host_ids_entries));
int knet_handle_enable_pmtud_notify(knet_handle_t, void *, void(*)(void *private_data, unsigned int data_mtu));
int knet_handle_enable_sock_notify(knet_handle_t, void *, void(*)(void *private_data, int datafd, int8_t channel, uint8_t tx_rx, int error, int errorno));
int knet_handle_free(knet_handle_t);
int knet_handle_get_channel(knet_handle_t, const int, int8_t *);
-int knet_handle_get_compress_list(knet_handle_t, const char **, size_t *);
-int knet_handle_get_crypto_list(knet_handle_t, const char **, size_t *);
int knet_handle_get_datafd(knet_handle_t, const int8_t, int *);
int knet_handle_get_stats(knet_handle_t, struct knet_handle_stats *, size_t);
-uint8_t knet_handle_get_transport_id_by_name(knet_handle_t, const char *);
-int knet_handle_get_transport_list(knet_handle_t, struct knet_transport_info *, size_t *);
-const char *knet_handle_get_transport_name_by_id(knet_handle_t, uint8_t);
int knet_handle_get_transport_reconnect_interval(knet_handle_t, uint32_t *);
knet_handle_t knet_handle_new(knet_node_id_t, int, uint8_t);
int knet_handle_pmtud_get(knet_handle_t, unsigned int *);
int knet_handle_pmtud_getfreq(knet_handle_t, unsigned int *);
int knet_handle_pmtud_setfreq(knet_handle_t, unsigned int);
int knet_handle_remove_datafd(knet_handle_t, int);
int knet_handle_set_transport_reconnect_interval(knet_handle_t, uint32_t);
int knet_handle_setfwd(knet_handle_t, unsigned int);
int knet_host_add(knet_handle_t, knet_node_id_t);
int knet_host_enable_status_change_notify(knet_handle_t, void *, void(*)(void *private_data, knet_node_id_t host_id, uint8_t reachable, uint8_t remote, uint8_t external));
int knet_host_get_host_list(knet_handle_t, knet_node_id_t *, size_t *);
int knet_host_get_id_by_host_name(knet_handle_t, const char *, knet_node_id_t *);
int knet_host_get_name_by_host_id(knet_handle_t, knet_node_id_t, char *);
int knet_host_get_policy(knet_handle_t, knet_node_id_t, uint8_t *);
int knet_host_get_status(knet_handle_t, knet_node_id_t, struct knet_host_status *);
int knet_host_remove(knet_handle_t, knet_node_id_t);
int knet_host_set_name(knet_handle_t, knet_node_id_t, const char *);
int knet_host_set_policy(knet_handle_t, knet_node_id_t, uint8_t);
int knet_link_clear_config(knet_handle_t, knet_node_id_t, uint8_t);
int knet_link_get_config(knet_handle_t, knet_node_id_t, uint8_t, uint8_t *, struct sockaddr_storage *, struct sockaddr_storage *, uint8_t *, uint64_t *);
int knet_link_get_enable(knet_handle_t, knet_node_id_t, uint8_t, unsigned int *);
int knet_link_get_link_list(knet_handle_t, knet_node_id_t, uint8_t *, size_t *);
int knet_link_get_ping_timers(knet_handle_t, knet_node_id_t, uint8_t, time_t *, time_t *, unsigned int *);
int knet_link_get_pong_count(knet_handle_t, knet_node_id_t, uint8_t, uint8_t *);
int knet_link_get_priority(knet_handle_t, knet_node_id_t, uint8_t, uint8_t *);
int knet_link_get_status(knet_handle_t, knet_node_id_t, uint8_t, struct knet_link_status *, size_t);
int knet_link_set_config(knet_handle_t, knet_node_id_t, uint8_t, uint8_t, struct sockaddr_storage *, struct sockaddr_storage *, uint64_t);
int knet_link_set_enable(knet_handle_t, knet_node_id_t, uint8_t, unsigned int);
int knet_link_set_ping_timers(knet_handle_t, knet_node_id_t, uint8_t, time_t, time_t, unsigned int);
int knet_link_set_pong_count(knet_handle_t, knet_node_id_t, uint8_t, uint8_t);
int knet_link_set_priority(knet_handle_t, knet_node_id_t, uint8_t, uint8_t);
int knet_log_get_loglevel(knet_handle_t, uint8_t, uint8_t *);
uint8_t knet_log_get_loglevel_id(const char *);
const char *knet_log_get_loglevel_name(uint8_t);
uint8_t knet_log_get_subsystem_id(const char *);
const char *knet_log_get_subsystem_name(uint8_t);
int knet_log_set_loglevel(knet_handle_t, uint8_t, uint8_t);
ssize_t knet_recv(knet_handle_t, char *, const size_t, const int8_t);
ssize_t knet_send(knet_handle_t, const char *, const size_t, const int8_t);
int knet_send_sync(knet_handle_t, const char *, const size_t, const int8_t);
int knet_strtoaddr(const char *, const char *, struct sockaddr_storage *, socklen_t);
\fP
.fi
.RE
.SS ""
.PP
.sp
.sp
.RS
.nf
\fB
-struct knet_handle_compress_cfg {
- char \fIcompress_model\fP;
- uint32_t \fIcompress_threshold\fP;
- int \fIcompress_level\fP;
+struct knet_handle_crypto_cfg {
+ char \fIcrypto_model\fP;
+ char \fIcrypto_cipher_type\fP;
+ char \fIcrypto_hash_type\fP;
+ unsigned char \fIprivate_key\fP;
+ unsigned int \fIprivate_key_len\fP;
};
\fP
.fi
.RE
.SS ""
.PP
.sp
.sp
.RS
.nf
\fB
-struct knet_link_status {
- size_t \fIsize\fP;
- char \fIsrc_ipaddr\fP;
- char \fIsrc_port\fP;
- char \fIdst_ipaddr\fP;
- char \fIdst_port\fP;
- uint8_t \fIenabled\fP;
- uint8_t \fIconnected\fP;
- uint8_t \fIdynconnected\fP;
- unsigned long long \fIlatency\fP;
- struct timespec \fIpong_last\fP;
- unsigned int \fImtu\fP;
- unsigned int \fIproto_overhead\fP;
- struct knet_link_stats \fIstats\fP;
+struct knet_transport_info {
+ const char *\fIname\fP;
+ uint8_t \fIid\fP;
+ uint8_t \fIproperties\fP;
+ char \fIpad\fP;
+};
+\fP
+.fi
+.RE
+.SS ""
+.PP
+.sp
+.sp
+.RS
+.nf
+\fB
+struct knet_host_status {
+ uint8_t \fIreachable\fP;
+ uint8_t \fIremote\fP;
+ uint8_t \fIexternal\fP;
};
\fP
.fi
.RE
.SS ""
.PP
.sp
.sp
.RS
.nf
\fB
struct knet_handle_stats {
size_t \fIsize\fP;
uint64_t \fItx_uncompressed_packets\fP;
uint64_t \fItx_compressed_packets\fP;
uint64_t \fItx_compressed_original_bytes\fP;
uint64_t \fItx_compressed_size_bytes\fP;
uint64_t \fItx_compress_time_ave\fP;
uint64_t \fItx_compress_time_min\fP;
uint64_t \fItx_compress_time_max\fP;
uint64_t \fIrx_compressed_packets\fP;
uint64_t \fIrx_compressed_original_bytes\fP;
uint64_t \fIrx_compressed_size_bytes\fP;
uint64_t \fIrx_compress_time_ave\fP;
uint64_t \fIrx_compress_time_min\fP;
uint64_t \fIrx_compress_time_max\fP;
uint64_t \fItx_crypt_packets\fP;
uint64_t \fItx_crypt_byte_overhead\fP;
uint64_t \fItx_crypt_time_ave\fP;
uint64_t \fItx_crypt_time_min\fP;
uint64_t \fItx_crypt_time_max\fP;
uint64_t \fIrx_crypt_packets\fP;
uint64_t \fIrx_crypt_time_ave\fP;
uint64_t \fIrx_crypt_time_min\fP;
uint64_t \fIrx_crypt_time_max\fP;
};
\fP
.fi
.RE
.SS ""
.PP
.sp
.sp
.RS
.nf
\fB
-struct knet_handle_crypto_cfg {
- char \fIcrypto_model\fP;
- char \fIcrypto_cipher_type\fP;
- char \fIcrypto_hash_type\fP;
- unsigned char \fIprivate_key\fP;
- unsigned int \fIprivate_key_len\fP;
+struct knet_link_status {
+ size_t \fIsize\fP;
+ char \fIsrc_ipaddr\fP;
+ char \fIsrc_port\fP;
+ char \fIdst_ipaddr\fP;
+ char \fIdst_port\fP;
+ uint8_t \fIenabled\fP;
+ uint8_t \fIconnected\fP;
+ uint8_t \fIdynconnected\fP;
+ unsigned long long \fIlatency\fP;
+ struct timespec \fIpong_last\fP;
+ unsigned int \fImtu\fP;
+ unsigned int \fIproto_overhead\fP;
+ struct knet_link_stats \fIstats\fP;
};
\fP
.fi
.RE
.SS ""
.PP
.sp
.sp
.RS
.nf
\fB
-struct knet_transport_info {
+struct knet_handle_compress_cfg {
+ char \fIcompress_model\fP;
+ uint32_t \fIcompress_threshold\fP;
+ int \fIcompress_level\fP;
+};
+\fP
+.fi
+.RE
+.SS ""
+.PP
+.sp
+.sp
+.RS
+.nf
+\fB
+struct knet_crypto_info {
const char *\fIname\fP;
- uint8_t \fIid\fP;
uint8_t \fIproperties\fP;
+ char \fIpad\fP;
};
\fP
.fi
.RE
.SS ""
.PP
.sp
.sp
.RS
.nf
\fB
-struct knet_host_status {
- uint8_t \fIreachable\fP;
- uint8_t \fIremote\fP;
- uint8_t \fIexternal\fP;
+struct knet_compress_info {
+ const char *\fIname\fP;
+ uint8_t \fIproperties\fP;
+ char \fIpad\fP;
};
\fP
.fi
.RE
.SH SEE ALSO
.PP
.nh
.ad l
-\fIknet_addrtostr\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_compress_list\fP(3), \fIknet_handle_get_crypto_list\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_id_by_name\fP(3), \fIknet_handle_get_transport_list\fP(3), \fIknet_handle_get_transport_name_by_id\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
+\fIknet_addrtostr\fP(3), \fIknet_get_compress_list\fP(3), \fIknet_get_crypto_list\fP(3), \fIknet_get_transport_id_by_name\fP(3), \fIknet_get_transport_list\fP(3), \fIknet_get_transport_name_by_id\fP(3), \fIknet_handle_add_datafd\fP(3), \fIknet_handle_clear_stats\fP(3), \fIknet_handle_compress\fP(3), \fIknet_handle_crypto\fP(3), \fIknet_handle_enable_filter\fP(3), \fIknet_handle_enable_pmtud_notify\fP(3), \fIknet_handle_enable_sock_notify\fP(3), \fIknet_handle_free\fP(3), \fIknet_handle_get_channel\fP(3), \fIknet_handle_get_datafd\fP(3), \fIknet_handle_get_stats\fP(3), \fIknet_handle_get_transport_reconnect_interval\fP(3), \fIknet_handle_new\fP(3), \fIknet_handle_pmtud_get\fP(3), \fIknet_handle_pmtud_getfreq\fP(3), \fIknet_handle_pmtud_setfreq\fP(3), \fIknet_handle_remove_datafd\fP(3), \fIknet_handle_set_transport_reconnect_interval\fP(3), \fIknet_handle_setfwd\fP(3), \fIknet_host_add\fP(3), \fIknet_host_enable_status_change_notify\fP(3), \fIknet_host_get_host_list\fP(3), \fIknet_host_get_id_by_host_name\fP(3), \fIknet_host_get_name_by_host_id\fP(3), \fIknet_host_get_policy\fP(3), \fIknet_host_get_status\fP(3), \fIknet_host_remove\fP(3), \fIknet_host_set_name\fP(3), \fIknet_host_set_policy\fP(3), \fIknet_link_clear_config\fP(3), \fIknet_link_get_config\fP(3), \fIknet_link_get_enable\fP(3), \fIknet_link_get_link_list\fP(3), \fIknet_link_get_ping_timers\fP(3), \fIknet_link_get_pong_count\fP(3), \fIknet_link_get_priority\fP(3), \fIknet_link_get_status\fP(3), \fIknet_link_set_config\fP(3), \fIknet_link_set_enable\fP(3), \fIknet_link_set_ping_timers\fP(3), \fIknet_link_set_pong_count\fP(3), \fIknet_link_set_priority\fP(3), \fIknet_log_get_loglevel\fP(3), \fIknet_log_get_loglevel_id\fP(3), \fIknet_log_get_loglevel_name\fP(3), \fIknet_log_get_subsystem_id\fP(3), \fIknet_log_get_subsystem_name\fP(3), \fIknet_log_set_loglevel\fP(3), \fIknet_recv\fP(3), \fIknet_send\fP(3), \fIknet_send_sync\fP(3), \fIknet_strtoaddr\fP(3)
.ad
.hy
.SH COPYRIGHT
.PP
Copyright (C) 2010-2017 Red Hat, Inc. All rights reserved.
diff --git a/libknet/tests/api-check.mk b/libknet/tests/api-check.mk
index 65f8d150..1a95b4ad 100644
--- a/libknet/tests/api-check.mk
+++ b/libknet/tests/api-check.mk
@@ -1,250 +1,254 @@
#
# 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+
#
api_checks = \
api_knet_handle_new_test \
api_knet_handle_free_test \
api_knet_handle_compress_test \
api_knet_handle_crypto_test \
api_knet_handle_setfwd_test \
api_knet_handle_enable_filter_test \
api_knet_handle_enable_sock_notify_test \
api_knet_handle_add_datafd_test \
api_knet_handle_remove_datafd_test \
api_knet_handle_get_channel_test \
api_knet_handle_get_datafd_test \
api_knet_handle_get_stats_test \
- api_knet_handle_get_crypto_list_test \
- api_knet_handle_get_compress_list_test \
+ api_knet_get_crypto_list_test \
+ api_knet_get_compress_list_test \
api_knet_handle_clear_stats_test \
- api_knet_handle_get_transport_list_test \
- api_knet_handle_get_transport_name_by_id_test \
- api_knet_handle_get_transport_id_by_name_test \
+ api_knet_get_transport_list_test \
+ api_knet_get_transport_name_by_id_test \
+ api_knet_get_transport_id_by_name_test \
api_knet_handle_set_transport_reconnect_interval_test \
api_knet_handle_get_transport_reconnect_interval_test \
api_knet_recv_test \
api_knet_send_test \
+ api_knet_send_crypto_test \
api_knet_send_compress_test \
api_knet_send_sync_test \
api_knet_send_loopback_test \
api_knet_handle_pmtud_setfreq_test \
api_knet_handle_pmtud_getfreq_test \
api_knet_handle_enable_pmtud_notify_test \
api_knet_handle_pmtud_get_test \
api_knet_host_add_test \
api_knet_host_remove_test \
api_knet_host_set_name_test \
api_knet_host_get_name_by_host_id_test \
api_knet_host_get_id_by_host_name_test \
api_knet_host_get_host_list_test \
api_knet_host_set_policy_test \
api_knet_host_get_policy_test \
api_knet_host_get_status_test \
api_knet_host_enable_status_change_notify_test \
api_knet_log_get_subsystem_name_test \
api_knet_log_get_subsystem_id_test \
api_knet_log_get_loglevel_name_test \
api_knet_log_get_loglevel_id_test \
api_knet_log_set_loglevel_test \
api_knet_log_get_loglevel_test \
api_knet_strtoaddr_test \
api_knet_addrtostr_test \
api_knet_link_set_config_test \
api_knet_link_clear_config_test \
api_knet_link_get_config_test \
api_knet_link_set_ping_timers_test \
api_knet_link_get_ping_timers_test \
api_knet_link_set_pong_count_test \
api_knet_link_get_pong_count_test \
api_knet_link_set_priority_test \
api_knet_link_get_priority_test \
api_knet_link_set_enable_test \
api_knet_link_get_enable_test \
api_knet_link_get_link_list_test \
api_knet_link_get_status_test
api_knet_handle_new_test_SOURCES = api_knet_handle_new.c \
test-common.c
api_knet_handle_free_test_SOURCES = api_knet_handle_free.c \
test-common.c
api_knet_handle_new_limit_test_SOURCES = api_knet_handle_new_limit.c \
test-common.c
api_knet_handle_compress_test_SOURCES = api_knet_handle_compress.c \
test-common.c
api_knet_handle_crypto_test_SOURCES = api_knet_handle_crypto.c \
test-common.c
api_knet_handle_setfwd_test_SOURCES = api_knet_handle_setfwd.c \
test-common.c
api_knet_handle_enable_filter_test_SOURCES = api_knet_handle_enable_filter.c \
test-common.c
api_knet_handle_enable_sock_notify_test_SOURCES = api_knet_handle_enable_sock_notify.c \
test-common.c
api_knet_handle_add_datafd_test_SOURCES = api_knet_handle_add_datafd.c \
test-common.c
api_knet_handle_remove_datafd_test_SOURCES = api_knet_handle_remove_datafd.c \
test-common.c
api_knet_handle_get_channel_test_SOURCES = api_knet_handle_get_channel.c \
test-common.c
api_knet_handle_get_datafd_test_SOURCES = api_knet_handle_get_datafd.c \
test-common.c
api_knet_handle_get_stats_test_SOURCES = api_knet_handle_get_stats.c \
- test-common.c
+ test-common.c
-api_knet_handle_get_crypto_list_test_SOURCES = api_knet_handle_get_crypto_list.c \
- test-common.c
+api_knet_get_crypto_list_test_SOURCES = api_knet_get_crypto_list.c \
+ test-common.c
-api_knet_handle_get_compress_list_test_SOURCES = api_knet_handle_get_compress_list.c \
+api_knet_get_compress_list_test_SOURCES = api_knet_get_compress_list.c \
test-common.c
api_knet_handle_clear_stats_test_SOURCES = api_knet_handle_clear_stats.c \
test-common.c
-api_knet_handle_get_transport_list_test_SOURCES = api_knet_handle_get_transport_list.c \
- test-common.c
+api_knet_get_transport_list_test_SOURCES = api_knet_get_transport_list.c \
+ test-common.c
-api_knet_handle_get_transport_name_by_id_test_SOURCES = api_knet_handle_get_transport_name_by_id.c \
- test-common.c
+api_knet_get_transport_name_by_id_test_SOURCES = api_knet_get_transport_name_by_id.c \
+ test-common.c
-api_knet_handle_get_transport_id_by_name_test_SOURCES = api_knet_handle_get_transport_id_by_name.c \
- test-common.c
+api_knet_get_transport_id_by_name_test_SOURCES = api_knet_get_transport_id_by_name.c \
+ test-common.c
api_knet_handle_set_transport_reconnect_interval_test_SOURCES = api_knet_handle_set_transport_reconnect_interval.c \
test-common.c
api_knet_handle_get_transport_reconnect_interval_test_SOURCES = api_knet_handle_get_transport_reconnect_interval.c \
test-common.c
api_knet_recv_test_SOURCES = api_knet_recv.c \
test-common.c
api_knet_send_test_SOURCES = api_knet_send.c \
test-common.c
api_knet_send_compress_test_SOURCES = api_knet_send_compress.c \
test-common.c
+api_knet_send_crypto_test_SOURCES = api_knet_send_crypto.c \
+ test-common.c
+
api_knet_send_loopback_test_SOURCES = api_knet_send_loopback.c \
test-common.c
api_knet_send_sync_test_SOURCES = api_knet_send_sync.c \
test-common.c
api_knet_handle_pmtud_setfreq_test_SOURCES = api_knet_handle_pmtud_setfreq.c \
test-common.c
api_knet_handle_pmtud_getfreq_test_SOURCES = api_knet_handle_pmtud_getfreq.c \
test-common.c
api_knet_handle_enable_pmtud_notify_test_SOURCES = api_knet_handle_enable_pmtud_notify.c \
test-common.c
api_knet_handle_pmtud_get_test_SOURCES = api_knet_handle_pmtud_get.c \
test-common.c
api_knet_host_add_test_SOURCES = api_knet_host_add.c \
test-common.c
api_knet_host_remove_test_SOURCES = api_knet_host_remove.c \
test-common.c
api_knet_host_set_name_test_SOURCES = api_knet_host_set_name.c \
test-common.c
api_knet_host_get_name_by_host_id_test_SOURCES = api_knet_host_get_name_by_host_id.c \
test-common.c
api_knet_host_get_id_by_host_name_test_SOURCES = api_knet_host_get_id_by_host_name.c \
test-common.c
api_knet_host_get_host_list_test_SOURCES = api_knet_host_get_host_list.c \
test-common.c
api_knet_host_set_policy_test_SOURCES = api_knet_host_set_policy.c \
test-common.c
api_knet_host_get_policy_test_SOURCES = api_knet_host_get_policy.c \
test-common.c
api_knet_host_get_status_test_SOURCES = api_knet_host_get_status.c \
test-common.c
api_knet_host_enable_status_change_notify_test_SOURCES = api_knet_host_enable_status_change_notify.c \
test-common.c
api_knet_log_get_subsystem_name_test_SOURCES = api_knet_log_get_subsystem_name.c \
test-common.c
api_knet_log_get_subsystem_id_test_SOURCES = api_knet_log_get_subsystem_id.c \
test-common.c
api_knet_log_get_loglevel_name_test_SOURCES = api_knet_log_get_loglevel_name.c \
test-common.c
api_knet_log_get_loglevel_id_test_SOURCES = api_knet_log_get_loglevel_id.c \
test-common.c
api_knet_log_set_loglevel_test_SOURCES = api_knet_log_set_loglevel.c \
test-common.c
api_knet_log_get_loglevel_test_SOURCES = api_knet_log_get_loglevel.c \
test-common.c
api_knet_strtoaddr_test_SOURCES = api_knet_strtoaddr.c
api_knet_addrtostr_test_SOURCES = api_knet_addrtostr.c
api_knet_link_set_config_test_SOURCES = api_knet_link_set_config.c \
test-common.c
api_knet_link_clear_config_test_SOURCES = api_knet_link_clear_config.c \
test-common.c
api_knet_link_get_config_test_SOURCES = api_knet_link_get_config.c \
test-common.c
api_knet_link_set_ping_timers_test_SOURCES = api_knet_link_set_ping_timers.c \
test-common.c
api_knet_link_get_ping_timers_test_SOURCES = api_knet_link_get_ping_timers.c \
test-common.c
api_knet_link_set_pong_count_test_SOURCES = api_knet_link_set_pong_count.c \
test-common.c
api_knet_link_get_pong_count_test_SOURCES = api_knet_link_get_pong_count.c \
test-common.c
api_knet_link_set_priority_test_SOURCES = api_knet_link_set_priority.c \
test-common.c
api_knet_link_get_priority_test_SOURCES = api_knet_link_get_priority.c \
test-common.c
api_knet_link_set_enable_test_SOURCES = api_knet_link_set_enable.c \
test-common.c
api_knet_link_get_enable_test_SOURCES = api_knet_link_get_enable.c \
test-common.c
api_knet_link_get_link_list_test_SOURCES = api_knet_link_get_link_list.c \
test-common.c
api_knet_link_get_status_test_SOURCES = api_knet_link_get_status.c \
test-common.c
diff --git a/libknet/tests/api_knet_get_compress_list.c b/libknet/tests/api_knet_get_compress_list.c
new file mode 100644
index 00000000..47828874
--- /dev/null
+++ b/libknet/tests/api_knet_get_compress_list.c
@@ -0,0 +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 "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
new file mode 100644
index 00000000..b4ab2da4
--- /dev/null
+++ b/libknet/tests/api_knet_get_crypto_list.c
@@ -0,0 +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 "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
new file mode 100644
index 00000000..feaed822
--- /dev/null
+++ b/libknet/tests/api_knet_get_transport_id_by_name.c
@@ -0,0 +1,56 @@
+/*
+ * 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
new file mode 100644
index 00000000..35b98a4d
--- /dev/null
+++ b/libknet/tests/api_knet_get_transport_list.c
@@ -0,0 +1,71 @@
+/*
+ * 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
new file mode 100644
index 00000000..58e01bc9
--- /dev/null
+++ b/libknet/tests/api_knet_get_transport_name_by_id.c
@@ -0,0 +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)
+{
+ 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_get_compress_list.c b/libknet/tests/api_knet_handle_get_compress_list.c
deleted file mode 100644
index 77544d8c..00000000
--- a/libknet/tests/api_knet_handle_get_compress_list.c
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * 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];
- const char *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_handle_get_compress_list with incorrect knet_h\n");
-
- if (!knet_handle_get_compress_list(NULL, compress_list, &compress_list_entries) || (errno != EINVAL)) {
- printf("knet_handle_get_compress_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_handle_get_compress_list with no entries_list\n");
-
- if ((!knet_handle_get_compress_list(knet_h, compress_list, NULL)) || (errno != EINVAL)) {
- printf("knet_handle_get_compress_list accepted invalid list_entries 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_compress_list with no compress_list (get number of entries)\n");
-
- if (knet_handle_get_compress_list(knet_h, NULL, &compress_list_entries) < 0) {
- printf("knet_handle_get_compress_list returned error instead of number of entries: %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_compress_list with valid data\n");
-
- if (knet_handle_get_compress_list(knet_h, compress_list, &compress_list_entries1) < 0) {
- printf("knet_handle_get_compress_list failed: %s\n", strerror(errno));
- knet_handle_free(knet_h);
- flush_logs(logfds[0], stdout);
- close_logpipes(logfds);
- exit(FAIL);
- }
-
- if (compress_list_entries != compress_list_entries1) {
- printf("knet_handle_get_compress_list returned a different number of entries: %d, %d\n",
- (int)compress_list_entries, (int)compress_list_entries1);
- knet_handle_free(knet_h);
- flush_logs(logfds[0], stdout);
- close_logpipes(logfds);
- exit(FAIL);
- }
-
- for (i=0; i<compress_list_entries; i++) {
- printf("Detected compress: %s\n", compress_list[i]);
- }
-
- 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_crypto_list.c b/libknet/tests/api_knet_handle_get_crypto_list.c
deleted file mode 100644
index e994decc..00000000
--- a/libknet/tests/api_knet_handle_get_crypto_list.c
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * 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];
- const char *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 incorrect knet_h\n");
-
- if (!knet_handle_get_crypto_list(NULL, crypto_list, &crypto_list_entries) || (errno != EINVAL)) {
- printf("knet_handle_get_crypto_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_handle_get_crypto_list with no entries_list\n");
-
- if ((!knet_handle_get_crypto_list(knet_h, crypto_list, NULL)) || (errno != EINVAL)) {
- printf("knet_handle_get_crypto_list accepted invalid list_entries 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_crypto_list with no crypto_list (get number of entries)\n");
-
- if (knet_handle_get_crypto_list(knet_h, NULL, &crypto_list_entries) < 0) {
- printf("knet_handle_get_crypto_list returned error instead of number of entries: %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_crypto_list with valid data\n");
-
- if (knet_handle_get_crypto_list(knet_h, crypto_list, &crypto_list_entries1) < 0) {
- printf("knet_handle_get_crypto_list failed: %s\n", strerror(errno));
- knet_handle_free(knet_h);
- flush_logs(logfds[0], stdout);
- close_logpipes(logfds);
- exit(FAIL);
- }
-
- if (crypto_list_entries != crypto_list_entries1) {
- printf("knet_handle_get_crypto_list returned a different number of entries: %d, %d\n",
- (int)crypto_list_entries, (int)crypto_list_entries1);
- knet_handle_free(knet_h);
- flush_logs(logfds[0], stdout);
- close_logpipes(logfds);
- exit(FAIL);
- }
-
- for (i=0; i<crypto_list_entries; i++) {
- printf("Detected crypto: %s\n", crypto_list[i]);
- }
-
- 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_id_by_name.c b/libknet/tests/api_knet_handle_get_transport_id_by_name.c
deleted file mode 100644
index ef326873..00000000
--- a/libknet/tests/api_knet_handle_get_transport_id_by_name.c
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * 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 id;
-
- printf("Test knet_handle_get_transport_id_by_name with incorrect knet_h\n");
-
- if ((knet_handle_get_transport_id_by_name(NULL, "UDP") != KNET_MAX_TRANSPORTS) || (errno != EINVAL)) {
- printf("knet_handle_get_transport_id_by_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);
- }
-
- printf("Test knet_handle_get_transport_id_by_name with no name\n");
-
- if ((knet_handle_get_transport_id_by_name(knet_h, NULL) != KNET_MAX_TRANSPORTS) || (errno != EINVAL)) {
- printf("knet_handle_get_transport_id_by_name 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_handle_get_transport_id_by_name with incorrect name\n");
-
- if ((knet_handle_get_transport_id_by_name(knet_h, "ARP") != KNET_MAX_TRANSPORTS) || (errno != EINVAL)) {
- printf("knet_handle_get_transport_id_by_name 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_handle_get_transport_id_by_name with correct values\n");
-
- id = knet_handle_get_transport_id_by_name(knet_h, "UDP");
- if (id != KNET_TRANSPORT_UDP) {
- printf("knet_handle_get_transport_id_by_name 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_list.c b/libknet/tests/api_knet_handle_get_transport_list.c
deleted file mode 100644
index e4f3bd64..00000000
--- a/libknet/tests/api_knet_handle_get_transport_list.c
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * 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_transport_info transport_list[KNET_MAX_TRANSPORTS];
- size_t transport_list_entries;
- size_t i, expected_count;
-
- memset(transport_list, 0, sizeof(transport_list));
-
- printf("Test knet_handle_get_transport_list with incorrect knet_h\n");
-
- if (!knet_handle_get_transport_list(NULL, transport_list, &transport_list_entries) || (errno != EINVAL)) {
- printf("knet_handle_get_transport_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_handle_get_transport_list with no transport_list\n");
-
- if ((!knet_handle_get_transport_list(knet_h, NULL, &transport_list_entries)) || (errno != EINVAL)) {
- printf("knet_handle_get_transport_list 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_transport_list with no channel\n");
-
- if ((!knet_handle_get_transport_list(knet_h, transport_list, NULL)) || (errno != EINVAL)) {
- printf("knet_handle_get_transport_list accepted invalid transport_list_entries 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_list with valid data\n");
-
- if (knet_handle_get_transport_list(knet_h, transport_list, &transport_list_entries) < 0) {
- printf("knet_handle_get_transport_list failed: %s\n", strerror(errno));
- knet_handle_free(knet_h);
- flush_logs(logfds[0], stdout);
- close_logpipes(logfds);
- 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);
- }
-
- expected_count = KNET_MAX_TRANSPORTS;
-#ifndef HAVE_NETINET_SCTP_H
- expected_count--;
-#endif
-
- if (transport_list_entries != expected_count) {
- printf("Error! expected: %zu transports, got: %zu\n", expected_count, transport_list_entries);
- 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_name_by_id.c b/libknet/tests/api_knet_handle_get_transport_name_by_id.c
deleted file mode 100644
index f315407b..00000000
--- a/libknet/tests/api_knet_handle_get_transport_name_by_id.c
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * 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];
- const char *name = NULL;
-
- printf("Test knet_handle_get_transport_name_by_id with incorrect knet_h\n");
-
- if ((knet_handle_get_transport_name_by_id(NULL, KNET_TRANSPORT_UDP) != NULL) || (errno != EINVAL)) {
- printf("knet_handle_get_transport_name_by_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);
- }
-
- printf("Test knet_handle_get_transport_name_by_id with incorrect transport\n");
-
- if ((knet_handle_get_transport_name_by_id(knet_h, KNET_MAX_TRANSPORTS) != NULL) || (errno != EINVAL)) {
- printf("knet_handle_get_transport_name_by_id 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_handle_get_transport_name_by_id with correct values\n");
-
- name = knet_handle_get_transport_name_by_id(knet_h, KNET_TRANSPORT_UDP);
- if (!name) {
- printf("knet_handle_get_transport_name_by_id 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 (strcmp(name, "UDP")) {
- printf("knet_handle_get_transport_name_by_id failed to get UDP transport name\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_link_set_config.c b/libknet/tests/api_knet_link_set_config.c
index b23dc149..d55899cd 100644
--- a/libknet/tests/api_knet_link_set_config.c
+++ b/libknet/tests/api_knet_link_set_config.c
@@ -1,273 +1,273 @@
/*
* 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+1, &src, &dst, 0)) || (errno != EINVAL)) {
+ 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_send_crypto.c b/libknet/tests/api_knet_send_crypto.c
new file mode 100644
index 00000000..4e0242e7
--- /dev/null
+++ b/libknet/tests/api_knet_send_crypto.c
@@ -0,0 +1,257 @@
+/*
+ * 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);
+ }
+
+ while(knet_h->host_index[1]->status.reachable != 1) {
+ printf("waiting host to be reachable\n");
+ sleep(1);
+ }
+
+ 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);
+
+ sleep(1);
+
+ 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_crypt_packets != 0 ||
+ stats.rx_crypt_packets != 0) {
+
+ printf("stats look wrong: s/b all 0 for model 'none' tx_packets: %" PRIu64 " rx_packets: %" PRIu64 "\n",
+ stats.tx_crypt_packets,
+ stats.rx_crypt_packets);
+ }
+ } else {
+ 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();
+
+ test("none");
+
+#ifdef BUILDCRYPTONSS
+ test("nss");
+#endif
+#ifdef BUILDCRYPTOOPENSSL
+ test("openssl");
+#endif
+
+ return PASS;
+}
diff --git a/libknet/tests/knet_bench.c b/libknet/tests/knet_bench.c
index a26637eb..477b7357 100644
--- a/libknet/tests/knet_bench.c
+++ b/libknet/tests/knet_bench.c
@@ -1,1026 +1,1026 @@
/*
* 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 "transports.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 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 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");
}
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 *cryptocfg = NULL, *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: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 '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]);
}
}
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;
}
cleanup_all();
return PASS;
}
diff --git a/libknet/threads_heartbeat.c b/libknet/threads_heartbeat.c
index a5122590..bc684025 100644
--- a/libknet/threads_heartbeat.c
+++ b/libknet/threads_heartbeat.c
@@ -1,173 +1,174 @@
/*
* Copyright (C) 2015-2017 Red Hat, Inc. All rights reserved.
*
* Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
* Federico Simoncelli <fsimon@kronosnet.org>
*
* This software licensed under GPL-2.0+, LGPL-2.0+
*/
#include "config.h"
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <pthread.h>
#include <time.h>
#include "crypto.h"
#include "links.h"
#include "logging.h"
+#include "transports.h"
#include "threads_common.h"
#include "threads_heartbeat.h"
static void _link_down(knet_handle_t knet_h, struct knet_host *dst_host, struct knet_link *dst_link)
{
memset(&dst_link->pmtud_last, 0, sizeof(struct timespec));
dst_link->received_pong = 0;
dst_link->status.pong_last.tv_nsec = 0;
if (dst_link->status.connected == 1) {
log_info(knet_h, KNET_SUB_LINK, "host: %u link: %u is down",
dst_host->host_id, dst_link->link_id);
_link_updown(knet_h, dst_host->host_id, dst_link->link_id, dst_link->status.enabled, 0);
}
}
static void _handle_check_each(knet_handle_t knet_h, struct knet_host *dst_host, struct knet_link *dst_link, int timed)
{
int err = 0, savederrno = 0;
int len;
ssize_t outlen = KNET_HEADER_PING_SIZE;
struct timespec clock_now, pong_last;
unsigned long long diff_ping;
unsigned char *outbuf = (unsigned char *)knet_h->pingbuf;
if (dst_link->transport_connected == 0) {
_link_down(knet_h, dst_host, dst_link);
return;
}
/* caching last pong to avoid race conditions */
pong_last = dst_link->status.pong_last;
if (clock_gettime(CLOCK_MONOTONIC, &clock_now) != 0) {
log_debug(knet_h, KNET_SUB_HEARTBEAT, "Unable to get monotonic clock");
return;
}
timespec_diff(dst_link->ping_last, clock_now, &diff_ping);
if ((diff_ping >= (dst_link->ping_interval * 1000llu)) || (!timed)) {
memmove(&knet_h->pingbuf->khp_ping_time[0], &clock_now, sizeof(struct timespec));
knet_h->pingbuf->khp_ping_link = dst_link->link_id;
if (pthread_mutex_lock(&knet_h->tx_seq_num_mutex)) {
log_debug(knet_h, KNET_SUB_HEARTBEAT, "Unable to get seq mutex lock");
return;
}
knet_h->pingbuf->khp_ping_seq_num = htons(knet_h->tx_seq_num);
pthread_mutex_unlock(&knet_h->tx_seq_num_mutex);
knet_h->pingbuf->khp_ping_timed = timed;
if (knet_h->crypto_instance) {
if (crypto_encrypt_and_sign(knet_h,
(const unsigned char *)knet_h->pingbuf,
outlen,
knet_h->pingbuf_crypt,
&outlen) < 0) {
log_debug(knet_h, KNET_SUB_HEARTBEAT, "Unable to crypto ping packet");
return;
}
outbuf = knet_h->pingbuf_crypt;
}
retry:
len = sendto(dst_link->outsock, outbuf, outlen,
MSG_DONTWAIT | MSG_NOSIGNAL, (struct sockaddr *) &dst_link->dst_addr,
sizeof(struct sockaddr_storage));
savederrno = errno;
dst_link->ping_last = clock_now;
dst_link->status.stats.tx_ping_packets++;
dst_link->status.stats.tx_ping_bytes += outlen;
if (len != outlen) {
- err = knet_h->transport_ops[dst_link->transport_type]->transport_tx_sock_error(knet_h, dst_link->outsock, len, savederrno);
+ err = transport_tx_sock_error(knet_h, dst_link->transport_type, dst_link->outsock, len, savederrno);
switch(err) {
case -1: /* unrecoverable error */
log_debug(knet_h, KNET_SUB_HEARTBEAT,
"Unable to send ping (sock: %d) packet (sendto): %d %s. recorded src ip: %s src port: %s dst ip: %s dst port: %s",
dst_link->outsock, savederrno, strerror(savederrno),
dst_link->status.src_ipaddr, dst_link->status.src_port,
dst_link->status.dst_ipaddr, dst_link->status.dst_port);
dst_link->status.stats.tx_ping_errors++;
break;
case 0:
break;
case 1:
dst_link->status.stats.tx_ping_retries++;
goto retry;
break;
}
} else {
dst_link->last_ping_size = outlen;
}
}
timespec_diff(pong_last, clock_now, &diff_ping);
if ((pong_last.tv_nsec) &&
(diff_ping >= (dst_link->pong_timeout * 1000llu))) {
_link_down(knet_h, dst_host, dst_link);
}
}
void _send_pings(knet_handle_t knet_h, int timed)
{
struct knet_host *dst_host;
int link_idx;
if (pthread_mutex_lock(&knet_h->hb_mutex)) {
log_debug(knet_h, KNET_SUB_HEARTBEAT, "Unable to get hb mutex lock");
return;
}
for (dst_host = knet_h->host_head; dst_host != NULL; dst_host = dst_host->next) {
for (link_idx = 0; link_idx < KNET_MAX_LINK; link_idx++) {
if ((dst_host->link[link_idx].status.enabled != 1) ||
(dst_host->link[link_idx].transport_type == KNET_TRANSPORT_LOOPBACK ) ||
((dst_host->link[link_idx].dynamic == KNET_LINK_DYNIP) &&
(dst_host->link[link_idx].status.dynconnected != 1)))
continue;
_handle_check_each(knet_h, dst_host, &dst_host->link[link_idx], timed);
}
}
pthread_mutex_unlock(&knet_h->hb_mutex);
}
void *_handle_heartbt_thread(void *data)
{
knet_handle_t knet_h = (knet_handle_t) data;
/* preparing ping buffer */
knet_h->pingbuf->kh_version = KNET_HEADER_VERSION;
knet_h->pingbuf->kh_type = KNET_HEADER_TYPE_PING;
knet_h->pingbuf->kh_node = htons(knet_h->host_id);
while (!shutdown_in_progress(knet_h)) {
usleep(KNET_THREADS_TIMERES);
if (pthread_rwlock_rdlock(&knet_h->global_rwlock) != 0) {
log_debug(knet_h, KNET_SUB_HEARTBEAT, "Unable to get read lock");
continue;
}
_send_pings(knet_h, 1);
pthread_rwlock_unlock(&knet_h->global_rwlock);
}
return NULL;
}
diff --git a/libknet/threads_pmtud.c b/libknet/threads_pmtud.c
index e239162a..c6caf4b2 100644
--- a/libknet/threads_pmtud.c
+++ b/libknet/threads_pmtud.c
@@ -1,409 +1,410 @@
/*
* Copyright (C) 2015-2017 Red Hat, Inc. All rights reserved.
*
* Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
* Federico Simoncelli <fsimon@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 "crypto.h"
#include "links.h"
#include "host.h"
#include "logging.h"
+#include "transports.h"
#include "threads_common.h"
#include "threads_pmtud.h"
static int _handle_check_link_pmtud(knet_handle_t knet_h, struct knet_host *dst_host, struct knet_link *dst_link)
{
int err, ret, savederrno, mutex_retry_limit, failsafe;
size_t onwire_len; /* current packet onwire size */
size_t overhead_len; /* onwire packet overhead (protocol based) */
size_t max_mtu_len; /* max mtu for protocol */
size_t data_len; /* how much data we can send in the packet
* generally would be onwire_len - overhead_len
* needs to be adjusted for crypto
*/
size_t pad_len; /* crypto packet pad size, needs to move into crypto.c callbacks */
ssize_t len; /* len of what we were able to sendto onwire */
struct timespec ts;
unsigned char *outbuf = (unsigned char *)knet_h->pmtudbuf;
mutex_retry_limit = 0;
failsafe = 0;
pad_len = 0;
dst_link->last_bad_mtu = 0;
knet_h->pmtudbuf->khp_pmtud_link = dst_link->link_id;
switch (dst_link->dst_addr.ss_family) {
case AF_INET6:
max_mtu_len = KNET_PMTUD_SIZE_V6;
overhead_len = KNET_PMTUD_OVERHEAD_V6 + dst_link->proto_overhead;
dst_link->last_good_mtu = dst_link->last_ping_size + overhead_len;
break;
case AF_INET:
max_mtu_len = KNET_PMTUD_SIZE_V4;
overhead_len = KNET_PMTUD_OVERHEAD_V4 + dst_link->proto_overhead;
dst_link->last_good_mtu = dst_link->last_ping_size + overhead_len;
break;
default:
log_debug(knet_h, KNET_SUB_PMTUD, "PMTUD aborted, unknown protocol");
return -1;
break;
}
/*
* discovery starts from the top because kernel will
* refuse to send packets > current iface mtu.
* this saves us some time and network bw.
*/
onwire_len = max_mtu_len;
restart:
/*
* prevent a race when interface mtu is changed _exactly_ during
* the discovery process and it's complex to detect. Easier
* to wait the next loop.
* 30 is not an arbitrary value. To bisect from 576 to 128000 doesn't
* take more than 18/19 steps.
*/
if (failsafe == 30) {
log_err(knet_h, KNET_SUB_PMTUD,
"Aborting PMTUD process: Too many attempts. MTU might have changed during discovery.");
return -1;
} else {
failsafe++;
}
data_len = onwire_len - overhead_len;
if (knet_h->crypto_instance) {
if (knet_h->sec_block_size) {
pad_len = knet_h->sec_block_size - (data_len % knet_h->sec_block_size);
if (pad_len == knet_h->sec_block_size) {
pad_len = 0;
}
data_len = data_len + pad_len;
}
data_len = data_len + (knet_h->sec_hash_size + knet_h->sec_salt_size + knet_h->sec_block_size);
if (knet_h->sec_block_size) {
while (data_len + overhead_len >= max_mtu_len) {
data_len = data_len - knet_h->sec_block_size;
}
}
if (dst_link->last_bad_mtu) {
while (data_len + overhead_len >= dst_link->last_bad_mtu) {
data_len = data_len - (knet_h->sec_hash_size + knet_h->sec_salt_size + knet_h->sec_block_size);
}
}
if (data_len < (knet_h->sec_hash_size + knet_h->sec_salt_size + knet_h->sec_block_size) + 1) {
log_debug(knet_h, KNET_SUB_PMTUD, "Aborting PMTUD process: link mtu smaller than crypto header detected (link might have been disconnected)");
return -1;
}
onwire_len = data_len + overhead_len;
knet_h->pmtudbuf->khp_pmtud_size = onwire_len;
if (crypto_encrypt_and_sign(knet_h,
(const unsigned char *)knet_h->pmtudbuf,
data_len - (knet_h->sec_hash_size + knet_h->sec_salt_size + knet_h->sec_block_size),
knet_h->pmtudbuf_crypt,
(ssize_t *)&data_len) < 0) {
log_debug(knet_h, KNET_SUB_PMTUD, "Unable to crypto pmtud packet");
return -1;
}
outbuf = knet_h->pmtudbuf_crypt;
} else {
knet_h->pmtudbuf->khp_pmtud_size = onwire_len;
}
/* link has gone down, aborting pmtud */
if (dst_link->status.connected != 1) {
log_debug(knet_h, KNET_SUB_PMTUD, "PMTUD detected host (%u) link (%u) has been disconnected", dst_host->host_id, dst_link->link_id);
return -1;
}
if (dst_link->transport_connected != 1) {
log_debug(knet_h, KNET_SUB_PMTUD, "PMTUD detected host (%u) link (%u) has been disconnected", dst_host->host_id, dst_link->link_id);
return -1;
}
if (pthread_mutex_lock(&knet_h->pmtud_mutex) != 0) {
log_debug(knet_h, KNET_SUB_PMTUD, "Unable to get mutex lock");
return -1;
}
retry:
len = sendto(dst_link->outsock, outbuf, data_len,
MSG_DONTWAIT | MSG_NOSIGNAL, (struct sockaddr *) &dst_link->dst_addr,
sizeof(struct sockaddr_storage));
savederrno = errno;
- err = knet_h->transport_ops[dst_link->transport_type]->transport_tx_sock_error(knet_h, dst_link->outsock, len, savederrno);
+ err = transport_tx_sock_error(knet_h, dst_link->transport_type, dst_link->outsock, len, savederrno);
switch(err) {
case -1: /* unrecoverable error */
log_debug(knet_h, KNET_SUB_PMTUD, "Unable to send pmtu packet (sendto): %d %s", savederrno, strerror(savederrno));
pthread_mutex_unlock(&knet_h->pmtud_mutex);
dst_link->status.stats.tx_pmtu_errors++;
return -1;
case 0: /* ignore error and continue */
break;
case 1: /* retry to send those same data */
dst_link->status.stats.tx_pmtu_retries++;
goto retry;
break;
}
if (len != (ssize_t )data_len) {
if (savederrno == EMSGSIZE) {
dst_link->last_bad_mtu = onwire_len;
} else {
log_debug(knet_h, KNET_SUB_PMTUD, "Unable to send pmtu packet len: %zu err: %s", onwire_len, strerror(savederrno));
}
} else {
dst_link->last_sent_mtu = onwire_len;
dst_link->last_recv_mtu = 0;
dst_link->status.stats.tx_pmtu_packets++;
dst_link->status.stats.tx_pmtu_bytes += data_len;
if (clock_gettime(CLOCK_REALTIME, &ts) < 0) {
log_debug(knet_h, KNET_SUB_PMTUD, "Unable to get current time: %s", strerror(errno));
pthread_mutex_unlock(&knet_h->pmtud_mutex);
return -1;
}
/*
* Set an artibrary 2 seconds timeout to receive a PMTUd reply
* perhaps this should be configurable but:
* 1) too short timeout can cause instability since MTU value
* influeces link status
* 2) too high timeout slows down the MTU detection process for
* small MTU
*
* Another option is to make the PMTUd process less influent
* in link status detection but that could cause data packet loss
* without link up/down changes
*/
ts.tv_sec += 2;
ret = pthread_cond_timedwait(&knet_h->pmtud_cond, &knet_h->pmtud_mutex, &ts);
if (shutdown_in_progress(knet_h)) {
pthread_mutex_unlock(&knet_h->pmtud_mutex);
log_debug(knet_h, KNET_SUB_PMTUD, "PMTUD aborted. shutdown in progress");
return -1;
}
if ((ret != 0) && (ret != ETIMEDOUT)) {
pthread_mutex_unlock(&knet_h->pmtud_mutex);
if (mutex_retry_limit == 3) {
log_debug(knet_h, KNET_SUB_PMTUD, "PMTUD aborted, unable to get mutex lock");
return -1;
}
mutex_retry_limit++;
goto restart;
}
if ((dst_link->last_recv_mtu != onwire_len) || (ret)) {
dst_link->last_bad_mtu = onwire_len;
} else {
int found_mtu = 0;
if (knet_h->sec_block_size) {
if ((onwire_len + knet_h->sec_block_size >= max_mtu_len) ||
((dst_link->last_bad_mtu) && (dst_link->last_bad_mtu <= (onwire_len + knet_h->sec_block_size)))) {
found_mtu = 1;
}
} else {
if ((onwire_len == max_mtu_len) ||
((dst_link->last_bad_mtu) && (dst_link->last_bad_mtu == (onwire_len + 1)))) {
found_mtu = 1;
}
}
if (found_mtu) {
/*
* account for IP overhead, knet headers and crypto in PMTU calculation
*/
dst_link->status.mtu = onwire_len - dst_link->status.proto_overhead;
pthread_mutex_unlock(&knet_h->pmtud_mutex);
return 0;
}
dst_link->last_good_mtu = onwire_len;
}
}
onwire_len = (dst_link->last_good_mtu + dst_link->last_bad_mtu) / 2;
pthread_mutex_unlock(&knet_h->pmtud_mutex);
goto restart;
}
static int _handle_check_pmtud(knet_handle_t knet_h, struct knet_host *dst_host, struct knet_link *dst_link, unsigned int *min_mtu)
{
uint8_t saved_valid_pmtud;
unsigned int saved_pmtud;
struct timespec clock_now;
unsigned long long diff_pmtud, interval;
interval = knet_h->pmtud_interval * 1000000000llu; /* nanoseconds */
if (clock_gettime(CLOCK_MONOTONIC, &clock_now) != 0) {
log_debug(knet_h, KNET_SUB_PMTUD, "Unable to get monotonic clock");
return 0;
}
timespec_diff(dst_link->pmtud_last, clock_now, &diff_pmtud);
if (diff_pmtud < interval) {
*min_mtu = dst_link->status.mtu;
return dst_link->has_valid_mtu;
}
switch (dst_link->dst_addr.ss_family) {
case AF_INET6:
dst_link->status.proto_overhead = KNET_PMTUD_OVERHEAD_V6 + dst_link->proto_overhead + KNET_HEADER_ALL_SIZE + knet_h->sec_header_size;
break;
case AF_INET:
dst_link->status.proto_overhead = KNET_PMTUD_OVERHEAD_V4 + dst_link->proto_overhead + KNET_HEADER_ALL_SIZE + knet_h->sec_header_size;
break;
}
saved_pmtud = dst_link->status.mtu;
saved_valid_pmtud = dst_link->has_valid_mtu;
log_debug(knet_h, KNET_SUB_PMTUD, "Starting PMTUD for host: %u link: %u", dst_host->host_id, dst_link->link_id);
if (_handle_check_link_pmtud(knet_h, dst_host, dst_link) < 0) {
dst_link->has_valid_mtu = 0;
} else {
dst_link->has_valid_mtu = 1;
switch (dst_link->dst_addr.ss_family) {
case AF_INET6:
if (((dst_link->status.mtu + dst_link->status.proto_overhead) < KNET_PMTUD_MIN_MTU_V6) ||
((dst_link->status.mtu + dst_link->status.proto_overhead) > KNET_PMTUD_SIZE_V6)) {
log_debug(knet_h, KNET_SUB_PMTUD,
"PMTUD detected an IPv6 MTU out of bound value (%u) for host: %u link: %u.",
dst_link->status.mtu + dst_link->status.proto_overhead, dst_host->host_id, dst_link->link_id);
dst_link->has_valid_mtu = 0;
}
break;
case AF_INET:
if (((dst_link->status.mtu + dst_link->status.proto_overhead) < KNET_PMTUD_MIN_MTU_V4) ||
((dst_link->status.mtu + dst_link->status.proto_overhead) > KNET_PMTUD_SIZE_V4)) {
log_debug(knet_h, KNET_SUB_PMTUD,
"PMTUD detected an IPv4 MTU out of bound value (%u) for host: %u link: %u.",
dst_link->status.mtu + dst_link->status.proto_overhead, dst_host->host_id, dst_link->link_id);
dst_link->has_valid_mtu = 0;
}
break;
}
if (dst_link->has_valid_mtu) {
if ((saved_pmtud) && (saved_pmtud != dst_link->status.mtu)) {
log_info(knet_h, KNET_SUB_PMTUD, "PMTUD link change for host: %u link: %u from %u to %u",
dst_host->host_id, dst_link->link_id, saved_pmtud, dst_link->status.mtu);
}
log_debug(knet_h, KNET_SUB_PMTUD, "PMTUD completed for host: %u link: %u current link mtu: %u",
dst_host->host_id, dst_link->link_id, dst_link->status.mtu);
if (dst_link->status.mtu < *min_mtu) {
*min_mtu = dst_link->status.mtu;
}
dst_link->pmtud_last = clock_now;
}
}
if (saved_valid_pmtud != dst_link->has_valid_mtu) {
_host_dstcache_update_sync(knet_h, dst_host);
}
return dst_link->has_valid_mtu;
}
void *_handle_pmtud_link_thread(void *data)
{
knet_handle_t knet_h = (knet_handle_t) data;
struct knet_host *dst_host;
struct knet_link *dst_link;
int link_idx;
unsigned int min_mtu, have_mtu;
unsigned int lower_mtu;
knet_h->data_mtu = KNET_PMTUD_MIN_MTU_V4 - KNET_HEADER_ALL_SIZE - knet_h->sec_header_size;
/* preparing pmtu buffer */
knet_h->pmtudbuf->kh_version = KNET_HEADER_VERSION;
knet_h->pmtudbuf->kh_type = KNET_HEADER_TYPE_PMTUD;
knet_h->pmtudbuf->kh_node = htons(knet_h->host_id);
while (!shutdown_in_progress(knet_h)) {
usleep(KNET_THREADS_TIMERES);
if (pthread_rwlock_rdlock(&knet_h->global_rwlock) != 0) {
log_debug(knet_h, KNET_SUB_PMTUD, "Unable to get read lock");
continue;
}
lower_mtu = KNET_PMTUD_SIZE_V4;
min_mtu = KNET_PMTUD_SIZE_V4 - KNET_HEADER_ALL_SIZE - knet_h->sec_header_size;
have_mtu = 0;
for (dst_host = knet_h->host_head; dst_host != NULL; dst_host = dst_host->next) {
for (link_idx = 0; link_idx < KNET_MAX_LINK; link_idx++) {
dst_link = &dst_host->link[link_idx];
if ((dst_link->status.enabled != 1) ||
(dst_link->status.connected != 1) ||
(dst_host->link[link_idx].transport_type == KNET_TRANSPORT_LOOPBACK) ||
(!dst_link->last_ping_size) ||
((dst_link->dynamic == KNET_LINK_DYNIP) &&
(dst_link->status.dynconnected != 1)))
continue;
if (_handle_check_pmtud(knet_h, dst_host, dst_link, &min_mtu)) {
have_mtu = 1;
if (min_mtu < lower_mtu) {
lower_mtu = min_mtu;
}
}
}
}
if (have_mtu) {
if (knet_h->data_mtu != lower_mtu) {
knet_h->data_mtu = lower_mtu;
log_info(knet_h, KNET_SUB_PMTUD, "Global data MTU changed to: %u", knet_h->data_mtu);
if (knet_h->pmtud_notify_fn) {
knet_h->pmtud_notify_fn(knet_h->pmtud_notify_fn_private_data,
knet_h->data_mtu);
}
}
}
pthread_rwlock_unlock(&knet_h->global_rwlock);
}
return NULL;
}
diff --git a/libknet/threads_rx.c b/libknet/threads_rx.c
index 12d6a171..95b23c39 100644
--- a/libknet/threads_rx.c
+++ b/libknet/threads_rx.c
@@ -1,820 +1,821 @@
/*
* Copyright (C) 2012-2017 Red Hat, Inc. All rights reserved.
*
* Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
* Federico Simoncelli <fsimon@kronosnet.org>
*
* This software licensed under GPL-2.0+, LGPL-2.0+
*/
#include "config.h"
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/uio.h>
#include <pthread.h>
#include "compat.h"
#include "compress.h"
#include "crypto.h"
#include "host.h"
#include "links.h"
#include "logging.h"
#include "transports.h"
+#include "transport_common.h"
#include "threads_common.h"
#include "threads_heartbeat.h"
#include "threads_rx.h"
#include "netutils.h"
/*
* RECV
*/
/*
* return 1 if a > b
* return -1 if b > a
* return 0 if they are equal
*/
static inline int timecmp(struct timespec a, struct timespec b)
{
if (a.tv_sec != b.tv_sec) {
if (a.tv_sec > b.tv_sec) {
return 1;
} else {
return -1;
}
} else {
if (a.tv_nsec > b.tv_nsec) {
return 1;
} else if (a.tv_nsec < b.tv_nsec) {
return -1;
} else {
return 0;
}
}
}
/*
* this functions needs to return an index (0 to 7)
* to a knet_host_defrag_buf. (-1 on errors)
*/
static int find_pckt_defrag_buf(knet_handle_t knet_h, struct knet_header *inbuf)
{
struct knet_host *src_host = knet_h->host_index[inbuf->kh_node];
int i, oldest;
/*
* check if there is a buffer already in use handling the same seq_num
*/
for (i = 0; i < KNET_MAX_LINK; i++) {
if (src_host->defrag_buf[i].in_use) {
if (src_host->defrag_buf[i].pckt_seq == inbuf->khp_data_seq_num) {
return i;
}
}
}
/*
* If there is no buffer that's handling the current seq_num
* either it's new or it's been reclaimed already.
* check if it's been reclaimed/seen before using the defrag circular
* buffer. If the pckt has been seen before, the buffer expired (ETIME)
* and there is no point to try to defrag it again.
*/
if (!_seq_num_lookup(src_host, inbuf->khp_data_seq_num, 1, 0)) {
errno = ETIME;
return -1;
}
/*
* register the pckt as seen
*/
_seq_num_set(src_host, inbuf->khp_data_seq_num, 1);
/*
* see if there is a free buffer
*/
for (i = 0; i < KNET_MAX_LINK; i++) {
if (!src_host->defrag_buf[i].in_use) {
return i;
}
}
/*
* at this point, there are no free buffers, the pckt is new
* and we need to reclaim a buffer, and we will take the one
* with the oldest timestamp. It's as good as any.
*/
oldest = 0;
for (i = 0; i < KNET_MAX_LINK; i++) {
if (timecmp(src_host->defrag_buf[i].last_update, src_host->defrag_buf[oldest].last_update) < 0) {
oldest = i;
}
}
src_host->defrag_buf[oldest].in_use = 0;
return oldest;
}
static int pckt_defrag(knet_handle_t knet_h, struct knet_header *inbuf, ssize_t *len)
{
struct knet_host_defrag_buf *defrag_buf;
int defrag_buf_idx;
defrag_buf_idx = find_pckt_defrag_buf(knet_h, inbuf);
if (defrag_buf_idx < 0) {
if (errno == ETIME) {
log_debug(knet_h, KNET_SUB_RX, "Defrag buffer expired");
}
return 1;
}
defrag_buf = &knet_h->host_index[inbuf->kh_node]->defrag_buf[defrag_buf_idx];
/*
* if the buf is not is use, then make sure it's clean
*/
if (!defrag_buf->in_use) {
memset(defrag_buf, 0, sizeof(struct knet_host_defrag_buf));
defrag_buf->in_use = 1;
defrag_buf->pckt_seq = inbuf->khp_data_seq_num;
}
/*
* update timestamp on the buffer
*/
clock_gettime(CLOCK_MONOTONIC, &defrag_buf->last_update);
/*
* check if we already received this fragment
*/
if (defrag_buf->frag_map[inbuf->khp_data_frag_seq]) {
/*
* if we have received this fragment and we didn't clear the buffer
* it means that we don't have all fragments yet
*/
return 1;
}
/*
* we need to handle the last packet with gloves due to its different size
*/
if (inbuf->khp_data_frag_seq == inbuf->khp_data_frag_num) {
defrag_buf->last_frag_size = *len;
/*
* in the event when the last packet arrives first,
* we still don't know the offset vs the other fragments (based on MTU),
* so we store the fragment at the end of the buffer where it's safe
* and take a copy of the len so that we can restore its offset later.
* remember we can't use the local MTU for this calculation because pMTU
* can be asymettric between the same hosts.
*/
if (!defrag_buf->frag_size) {
defrag_buf->last_first = 1;
memmove(defrag_buf->buf + (KNET_MAX_PACKET_SIZE - *len),
inbuf->khp_data_userdata,
*len);
}
} else {
defrag_buf->frag_size = *len;
}
memmove(defrag_buf->buf + ((inbuf->khp_data_frag_seq - 1) * defrag_buf->frag_size),
inbuf->khp_data_userdata, *len);
defrag_buf->frag_recv++;
defrag_buf->frag_map[inbuf->khp_data_frag_seq] = 1;
/*
* check if we received all the fragments
*/
if (defrag_buf->frag_recv == inbuf->khp_data_frag_num) {
/*
* special case the last pckt
*/
if (defrag_buf->last_first) {
memmove(defrag_buf->buf + ((inbuf->khp_data_frag_num - 1) * defrag_buf->frag_size),
defrag_buf->buf + (KNET_MAX_PACKET_SIZE - defrag_buf->last_frag_size),
defrag_buf->last_frag_size);
}
/*
* recalculate packet lenght
*/
*len = ((inbuf->khp_data_frag_num - 1) * defrag_buf->frag_size) + defrag_buf->last_frag_size;
/*
* copy the pckt back in the user data
*/
memmove(inbuf->khp_data_userdata, defrag_buf->buf, *len);
/*
* free this buffer
*/
defrag_buf->in_use = 0;
return 0;
}
return 1;
}
static void _parse_recv_from_links(knet_handle_t knet_h, int sockfd, const struct knet_mmsghdr *msg)
{
int err = 0, savederrno = 0;
ssize_t outlen;
struct knet_host *src_host;
struct knet_link *src_link;
unsigned long long latency_last;
knet_node_id_t dst_host_ids[KNET_MAX_HOST];
size_t dst_host_ids_entries = 0;
int bcast = 1;
struct timespec recvtime;
struct knet_header *inbuf = msg->msg_hdr.msg_iov->iov_base;
unsigned char *outbuf = (unsigned char *)msg->msg_hdr.msg_iov->iov_base;
ssize_t len = msg->msg_len;
struct knet_hostinfo *knet_hostinfo;
struct iovec iov_out[1];
int8_t channel;
struct sockaddr_storage pckt_src;
seq_num_t recv_seq_num;
int wipe_bufs = 0;
if (knet_h->crypto_instance) {
struct timespec start_time;
struct timespec end_time;
uint64_t crypt_time;
clock_gettime(CLOCK_MONOTONIC, &start_time);
if (crypto_authenticate_and_decrypt(knet_h,
(unsigned char *)inbuf,
len,
knet_h->recv_from_links_buf_decrypt,
&outlen) < 0) {
log_debug(knet_h, KNET_SUB_RX, "Unable to decrypt/auth packet");
return;
}
clock_gettime(CLOCK_MONOTONIC, &end_time);
timespec_diff(start_time, end_time, &crypt_time);
if (crypt_time < knet_h->stats.rx_crypt_time_min) {
knet_h->stats.rx_crypt_time_min = crypt_time;
}
if (crypt_time > knet_h->stats.rx_crypt_time_max) {
knet_h->stats.rx_crypt_time_max = crypt_time;
}
knet_h->stats.rx_crypt_time_ave =
(knet_h->stats.rx_crypt_time_ave * knet_h->stats.rx_crypt_packets +
crypt_time) / (knet_h->stats.rx_crypt_packets+1);
knet_h->stats.rx_crypt_packets++;
len = outlen;
inbuf = (struct knet_header *)knet_h->recv_from_links_buf_decrypt;
}
if (len < (ssize_t)(KNET_HEADER_SIZE + 1)) {
log_debug(knet_h, KNET_SUB_RX, "Packet is too short: %ld", (long)len);
return;
}
if (inbuf->kh_version != KNET_HEADER_VERSION) {
log_debug(knet_h, KNET_SUB_RX, "Packet version does not match");
return;
}
inbuf->kh_node = ntohs(inbuf->kh_node);
src_host = knet_h->host_index[inbuf->kh_node];
if (src_host == NULL) { /* host not found */
log_debug(knet_h, KNET_SUB_RX, "Unable to find source host for this packet");
return;
}
src_link = NULL;
src_link = src_host->link +
(inbuf->khp_ping_link % KNET_MAX_LINK);
if ((inbuf->kh_type & KNET_HEADER_TYPE_PMSK) != 0) {
if (src_link->dynamic == KNET_LINK_DYNIP) {
/*
* cpyaddrport will only copy address and port of the incoming
* packet and strip extra bits such as flow and scopeid
*/
cpyaddrport(&pckt_src, msg->msg_hdr.msg_name);
if (cmpaddr(&src_link->dst_addr, sockaddr_len(&src_link->dst_addr),
&pckt_src, sockaddr_len(&pckt_src)) != 0) {
log_debug(knet_h, KNET_SUB_RX, "host: %u link: %u appears to have changed ip address",
src_host->host_id, src_link->link_id);
memmove(&src_link->dst_addr, &pckt_src, sizeof(struct sockaddr_storage));
if (knet_addrtostr(&src_link->dst_addr, sockaddr_len(msg->msg_hdr.msg_name),
src_link->status.dst_ipaddr, KNET_MAX_HOST_LEN,
src_link->status.dst_port, KNET_MAX_PORT_LEN) != 0) {
log_debug(knet_h, KNET_SUB_RX, "Unable to resolve ???");
snprintf(src_link->status.dst_ipaddr, KNET_MAX_HOST_LEN - 1, "Unknown!!!");
snprintf(src_link->status.dst_port, KNET_MAX_PORT_LEN - 1, "??");
} else {
log_info(knet_h, KNET_SUB_RX,
"host: %u link: %u new connection established from: %s %s",
src_host->host_id, src_link->link_id,
src_link->status.dst_ipaddr, src_link->status.dst_port);
}
}
/*
* transport has already accepted the connection here
* otherwise we would not be receiving packets
*/
- knet_h->transport_ops[src_link->transport_type]->transport_link_dyn_connect(knet_h, sockfd, src_link);
+ transport_link_dyn_connect(knet_h, sockfd, src_link);
}
}
switch (inbuf->kh_type) {
case KNET_HEADER_TYPE_HOST_INFO:
case KNET_HEADER_TYPE_DATA:
/*
* TODO: should we accept data even if we can't reply to the other node?
* how would that work with SCTP and guaranteed delivery?
*/
if (!src_host->status.reachable) {
log_debug(knet_h, KNET_SUB_RX, "Source host %u not reachable yet", src_host->host_id);
//return;
}
inbuf->khp_data_seq_num = ntohs(inbuf->khp_data_seq_num);
channel = inbuf->khp_data_channel;
src_host->got_data = 1;
if (src_link) {
src_link->status.stats.rx_data_packets++;
src_link->status.stats.rx_data_bytes += len;
}
if (!_seq_num_lookup(src_host, inbuf->khp_data_seq_num, 0, 0)) {
if (src_host->link_handler_policy != KNET_LINK_POLICY_ACTIVE) {
log_debug(knet_h, KNET_SUB_RX, "Packet has already been delivered");
}
return;
}
if (inbuf->khp_data_frag_num > 1) {
/*
* len as received from the socket also includes extra stuff
* that the defrag code doesn't care about. So strip it
* here and readd only for repadding once we are done
* defragging
*/
len = len - KNET_HEADER_DATA_SIZE;
if (pckt_defrag(knet_h, inbuf, &len)) {
return;
}
len = len + KNET_HEADER_DATA_SIZE;
}
if (inbuf->khp_data_compress) {
ssize_t decmp_outlen = KNET_DATABUFSIZE_COMPRESS;
struct timespec start_time;
struct timespec end_time;
uint64_t compress_time;
clock_gettime(CLOCK_MONOTONIC, &start_time);
err = decompress(knet_h, inbuf->khp_data_compress,
(const unsigned char *)inbuf->khp_data_userdata,
len - KNET_HEADER_DATA_SIZE,
knet_h->recv_from_links_buf_decompress,
&decmp_outlen);
if (!err) {
/* Collect stats */
clock_gettime(CLOCK_MONOTONIC, &end_time);
timespec_diff(start_time, end_time, &compress_time);
if (compress_time < knet_h->stats.rx_compress_time_min) {
knet_h->stats.rx_compress_time_min = compress_time;
}
if (compress_time > knet_h->stats.rx_compress_time_max) {
knet_h->stats.rx_compress_time_max = compress_time;
}
knet_h->stats.rx_compress_time_ave =
(knet_h->stats.rx_compress_time_ave * knet_h->stats.rx_compressed_packets +
compress_time) / (knet_h->stats.rx_compressed_packets+1);
knet_h->stats.rx_compressed_packets++;
knet_h->stats.rx_compressed_original_bytes += decmp_outlen;
knet_h->stats.rx_compressed_size_bytes += len - KNET_HEADER_SIZE;
memmove(inbuf->khp_data_userdata, knet_h->recv_from_links_buf_decompress, decmp_outlen);
len = decmp_outlen + KNET_HEADER_DATA_SIZE;
} else {
log_warn(knet_h, KNET_SUB_COMPRESS, "Unable to decompress packet (%d): %s",
err, strerror(errno));
return;
}
}
if (inbuf->kh_type == KNET_HEADER_TYPE_DATA) {
if (knet_h->enabled != 1) /* data forward is disabled */
break;
if (knet_h->dst_host_filter_fn) {
size_t host_idx;
int found = 0;
bcast = knet_h->dst_host_filter_fn(
knet_h->dst_host_filter_fn_private_data,
(const unsigned char *)inbuf->khp_data_userdata,
len - KNET_HEADER_DATA_SIZE,
KNET_NOTIFY_RX,
knet_h->host_id,
inbuf->kh_node,
&channel,
dst_host_ids,
&dst_host_ids_entries);
if (bcast < 0) {
log_debug(knet_h, KNET_SUB_RX, "Error from dst_host_filter_fn: %d", bcast);
return;
}
if ((!bcast) && (!dst_host_ids_entries)) {
log_debug(knet_h, KNET_SUB_RX, "Message is unicast but no dst_host_ids_entries");
return;
}
/* check if we are dst for this packet */
if (!bcast) {
for (host_idx = 0; host_idx < dst_host_ids_entries; host_idx++) {
if (dst_host_ids[host_idx] == knet_h->host_id) {
found = 1;
break;
}
}
if (!found) {
log_debug(knet_h, KNET_SUB_RX, "Packet is not for us");
return;
}
}
}
}
if (inbuf->kh_type == KNET_HEADER_TYPE_DATA) {
if (!knet_h->sockfd[channel].in_use) {
log_debug(knet_h, KNET_SUB_RX,
"received packet for channel %d but there is no local sock connected",
channel);
return;
}
memset(iov_out, 0, sizeof(iov_out));
iov_out[0].iov_base = (void *) inbuf->khp_data_userdata;
iov_out[0].iov_len = len - KNET_HEADER_DATA_SIZE;
outlen = writev(knet_h->sockfd[channel].sockfd[knet_h->sockfd[channel].is_created], iov_out, 1);
if (outlen <= 0) {
knet_h->sock_notify_fn(knet_h->sock_notify_fn_private_data,
knet_h->sockfd[channel].sockfd[0],
channel,
KNET_NOTIFY_RX,
outlen,
errno);
return;
}
if ((size_t)outlen == iov_out[0].iov_len) {
_seq_num_set(src_host, inbuf->khp_data_seq_num, 0);
}
} else { /* HOSTINFO */
knet_hostinfo = (struct knet_hostinfo *)inbuf->khp_data_userdata;
if (knet_hostinfo->khi_bcast == KNET_HOSTINFO_UCAST) {
bcast = 0;
knet_hostinfo->khi_dst_node_id = ntohs(knet_hostinfo->khi_dst_node_id);
}
if (!_seq_num_lookup(src_host, inbuf->khp_data_seq_num, 0, 0)) {
return;
}
_seq_num_set(src_host, inbuf->khp_data_seq_num, 0);
switch(knet_hostinfo->khi_type) {
case KNET_HOSTINFO_TYPE_LINK_UP_DOWN:
break;
case KNET_HOSTINFO_TYPE_LINK_TABLE:
break;
default:
log_warn(knet_h, KNET_SUB_RX, "Receiving unknown host info message from host %u", src_host->host_id);
break;
}
}
break;
case KNET_HEADER_TYPE_PING:
outlen = KNET_HEADER_PING_SIZE;
inbuf->kh_type = KNET_HEADER_TYPE_PONG;
inbuf->kh_node = htons(knet_h->host_id);
recv_seq_num = ntohs(inbuf->khp_ping_seq_num);
src_link->status.stats.rx_ping_packets++;
src_link->status.stats.rx_ping_bytes += len;
wipe_bufs = 0;
if (!inbuf->khp_ping_timed) {
/*
* we might be receiving this message from all links, but we want
* to process it only the first time
*/
if (recv_seq_num != src_host->untimed_rx_seq_num) {
/*
* cache the untimed seq num
*/
src_host->untimed_rx_seq_num = recv_seq_num;
/*
* if the host has received data in between
* untimed ping, then we don't need to wipe the bufs
*/
if (src_host->got_data) {
src_host->got_data = 0;
wipe_bufs = 0;
} else {
wipe_bufs = 1;
}
}
_seq_num_lookup(src_host, recv_seq_num, 0, wipe_bufs);
} else {
/*
* pings always arrives in bursts over all the link
* catch the first of them to cache the seq num and
* avoid duplicate processing
*/
if (recv_seq_num != src_host->timed_rx_seq_num) {
src_host->timed_rx_seq_num = recv_seq_num;
if (recv_seq_num == 0) {
_seq_num_lookup(src_host, recv_seq_num, 0, 1);
}
}
}
if (knet_h->crypto_instance) {
if (crypto_encrypt_and_sign(knet_h,
(const unsigned char *)inbuf,
len,
knet_h->recv_from_links_buf_crypt,
&outlen) < 0) {
log_debug(knet_h, KNET_SUB_RX, "Unable to encrypt pong packet");
break;
}
outbuf = knet_h->recv_from_links_buf_crypt;
}
retry_pong:
len = sendto(src_link->outsock, outbuf, outlen, MSG_DONTWAIT | MSG_NOSIGNAL,
(struct sockaddr *) &src_link->dst_addr,
sizeof(struct sockaddr_storage));
savederrno = errno;
if (len != outlen) {
- err = knet_h->transport_ops[src_link->transport_type]->transport_tx_sock_error(knet_h, src_link->outsock, len, savederrno);
+ err = transport_tx_sock_error(knet_h, src_link->transport_type, src_link->outsock, len, savederrno);
switch(err) {
case -1: /* unrecoverable error */
log_debug(knet_h, KNET_SUB_RX,
"Unable to send pong reply (sock: %d) packet (sendto): %d %s. recorded src ip: %s src port: %s dst ip: %s dst port: %s",
src_link->outsock, errno, strerror(errno),
src_link->status.src_ipaddr, src_link->status.src_port,
src_link->status.dst_ipaddr, src_link->status.dst_port);
src_link->status.stats.tx_pong_errors++;
break;
case 0: /* ignore error and continue */
break;
case 1: /* retry to send those same data */
src_link->status.stats.tx_pong_retries++;
goto retry_pong;
break;
}
}
src_link->status.stats.tx_pong_packets++;
src_link->status.stats.tx_pong_bytes += outlen;
break;
case KNET_HEADER_TYPE_PONG:
src_link->status.stats.rx_pong_packets++;
src_link->status.stats.rx_pong_bytes += len;
clock_gettime(CLOCK_MONOTONIC, &src_link->status.pong_last);
memmove(&recvtime, &inbuf->khp_ping_time[0], sizeof(struct timespec));
timespec_diff(recvtime,
src_link->status.pong_last, &latency_last);
src_link->status.latency =
((src_link->status.latency * src_link->latency_exp) +
((latency_last / 1000llu) *
(src_link->latency_fix - src_link->latency_exp))) /
src_link->latency_fix;
if (src_link->status.latency < src_link->pong_timeout) {
if (!src_link->status.connected) {
if (src_link->received_pong >= src_link->pong_count) {
log_info(knet_h, KNET_SUB_RX, "host: %u link: %u is up",
src_host->host_id, src_link->link_id);
_link_updown(knet_h, src_host->host_id, src_link->link_id, src_link->status.enabled, 1);
} else {
src_link->received_pong++;
log_debug(knet_h, KNET_SUB_RX, "host: %u link: %u received pong: %u",
src_host->host_id, src_link->link_id, src_link->received_pong);
}
}
}
/* Calculate latency stats */
if (src_link->status.latency > src_link->status.stats.latency_max) {
src_link->status.stats.latency_max = src_link->status.latency;
}
if (src_link->status.latency < src_link->status.stats.latency_min) {
src_link->status.stats.latency_min = src_link->status.latency;
}
src_link->status.stats.latency_ave =
(src_link->status.stats.latency_ave * src_link->status.stats.latency_samples +
src_link->status.latency) / (src_link->status.stats.latency_samples+1);
src_link->status.stats.latency_samples++;
break;
case KNET_HEADER_TYPE_PMTUD:
src_link->status.stats.rx_pmtu_packets++;
src_link->status.stats.rx_pmtu_bytes += len;
outlen = KNET_HEADER_PMTUD_SIZE;
inbuf->kh_type = KNET_HEADER_TYPE_PMTUD_REPLY;
inbuf->kh_node = htons(knet_h->host_id);
if (knet_h->crypto_instance) {
if (crypto_encrypt_and_sign(knet_h,
(const unsigned char *)inbuf,
len,
knet_h->recv_from_links_buf_crypt,
&outlen) < 0) {
log_debug(knet_h, KNET_SUB_RX, "Unable to encrypt PMTUd reply packet");
break;
}
outbuf = knet_h->recv_from_links_buf_crypt;
}
retry_pmtud:
len = sendto(src_link->outsock, outbuf, outlen, MSG_DONTWAIT | MSG_NOSIGNAL,
(struct sockaddr *) &src_link->dst_addr,
sizeof(struct sockaddr_storage));
if (len != outlen) {
- err = knet_h->transport_ops[src_link->transport_type]->transport_tx_sock_error(knet_h, src_link->outsock, len, savederrno);
+ err = transport_tx_sock_error(knet_h, src_link->transport_type, src_link->outsock, len, savederrno);
switch(err) {
case -1: /* unrecoverable error */
log_debug(knet_h, KNET_SUB_RX,
"Unable to send PMTUd reply (sock: %d) packet (sendto): %d %s. recorded src ip: %s src port: %s dst ip: %s dst port: %s",
src_link->outsock, errno, strerror(errno),
src_link->status.src_ipaddr, src_link->status.src_port,
src_link->status.dst_ipaddr, src_link->status.dst_port);
src_link->status.stats.tx_pmtu_errors++;
break;
case 0: /* ignore error and continue */
src_link->status.stats.tx_pmtu_errors++;
break;
case 1: /* retry to send those same data */
src_link->status.stats.tx_pmtu_retries++;
goto retry_pmtud;
break;
}
}
break;
case KNET_HEADER_TYPE_PMTUD_REPLY:
src_link->status.stats.rx_pmtu_packets++;
src_link->status.stats.rx_pmtu_bytes += len;
if (pthread_mutex_lock(&knet_h->pmtud_mutex) != 0) {
log_debug(knet_h, KNET_SUB_RX, "Unable to get mutex lock");
break;
}
src_link->last_recv_mtu = inbuf->khp_pmtud_size;
pthread_cond_signal(&knet_h->pmtud_cond);
pthread_mutex_unlock(&knet_h->pmtud_mutex);
break;
default:
return;
}
}
static void _handle_recv_from_links(knet_handle_t knet_h, int sockfd, struct knet_mmsghdr *msg)
{
int err, savederrno;
int i, msg_recv, transport;
if (pthread_rwlock_rdlock(&knet_h->global_rwlock) != 0) {
log_debug(knet_h, KNET_SUB_RX, "Unable to get global read lock");
return;
}
if (_is_valid_fd(knet_h, sockfd) < 1) {
/*
* this is normal if a fd got an event and before we grab the read lock
* and the link is removed by another thread
*/
goto exit_unlock;
}
transport = knet_h->knet_transport_fd_tracker[sockfd].transport;
/*
* reset msg_namelen to buffer size because after recvmmsg
* each msg_namelen will contain sizeof sockaddr_in or sockaddr_in6
*/
for (i = 0; i < PCKT_RX_BUFS; i++) {
msg[i].msg_hdr.msg_namelen = sizeof(struct sockaddr_storage);
}
msg_recv = _recvmmsg(sockfd, &msg[0], PCKT_RX_BUFS, MSG_DONTWAIT | MSG_NOSIGNAL);
savederrno = errno;
/*
* WARNING: man page for recvmmsg is wrong. Kernel implementation here:
* recvmmsg can return:
* -1 on error
* 0 if the previous run of recvmmsg recorded an error on the socket
* N number of messages (see exception below).
*
* If there is an error from recvmsg after receiving a frame or more, the recvmmsg
* loop is interrupted, error recorded in the socket (getsockopt(SO_ERROR) and
* it will be visibile in the next run.
*
* Need to be careful how we handle errors at this stage.
*
* error messages need to be handled on a per transport/protocol base
* at this point we have different layers of error handling
* - msg_recv < 0 -> error from this run
* msg_recv = 0 -> error from previous run and error on socket needs to be cleared
* - per-transport message data
* example: msg[i].msg_hdr.msg_flags & MSG_NOTIFICATION or msg_len for SCTP == EOF,
* but for UDP it is perfectly legal to receive a 0 bytes message.. go figure
* - NOTE: on SCTP MSG_NOTIFICATION we get msg_recv == PCKT_FRAG_MAX messages and no
* errno set. That means the error api needs to be able to abort the loop below.
*/
if (msg_recv <= 0) {
- knet_h->transport_ops[transport]->transport_rx_sock_error(knet_h, sockfd, msg_recv, savederrno);
+ transport_rx_sock_error(knet_h, transport, sockfd, msg_recv, savederrno);
goto exit_unlock;
}
for (i = 0; i < msg_recv; i++) {
- err = knet_h->transport_ops[transport]->transport_rx_is_data(knet_h, sockfd, &msg[i]);
+ err = transport_rx_is_data(knet_h, transport, sockfd, &msg[i]);
/*
* TODO: make this section silent once we are confident
* all protocols packet handlers are good
*/
switch(err) {
case -1: /* on error */
log_debug(knet_h, KNET_SUB_RX, "Transport reported error parsing packet");
goto exit_unlock;
break;
case 0: /* packet is not data and we should continue the packet process loop */
log_debug(knet_h, KNET_SUB_RX, "Transport reported no data, continue");
break;
case 1: /* packet is not data and we should STOP the packet process loop */
log_debug(knet_h, KNET_SUB_RX, "Transport reported no data, stop");
goto exit_unlock;
break;
case 2: /* packet is data and should be parsed as such */
_parse_recv_from_links(knet_h, sockfd, &msg[i]);
break;
}
}
exit_unlock:
pthread_rwlock_unlock(&knet_h->global_rwlock);
}
void *_handle_recv_from_links_thread(void *data)
{
int i, nev;
knet_handle_t knet_h = (knet_handle_t) data;
struct epoll_event events[KNET_EPOLL_MAX_EVENTS];
struct sockaddr_storage address[PCKT_RX_BUFS];
struct knet_mmsghdr msg[PCKT_RX_BUFS];
struct iovec iov_in[PCKT_RX_BUFS];
memset(&msg, 0, sizeof(msg));
for (i = 0; i < PCKT_RX_BUFS; i++) {
iov_in[i].iov_base = (void *)knet_h->recv_from_links_buf[i];
iov_in[i].iov_len = KNET_DATABUFSIZE;
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;
}
while (!shutdown_in_progress(knet_h)) {
nev = epoll_wait(knet_h->recv_from_links_epollfd, events, KNET_EPOLL_MAX_EVENTS, -1);
for (i = 0; i < nev; i++) {
_handle_recv_from_links(knet_h, events[i].data.fd, msg);
}
}
return NULL;
}
diff --git a/libknet/threads_tx.c b/libknet/threads_tx.c
index 969f6c03..d065502d 100644
--- a/libknet/threads_tx.c
+++ b/libknet/threads_tx.c
@@ -1,736 +1,737 @@
/*
* Copyright (C) 2012-2017 Red Hat, Inc. All rights reserved.
*
* Authors: Fabio M. Di Nitto <fabbione@kronosnet.org>
* Federico Simoncelli <fsimon@kronosnet.org>
*
* This software licensed under GPL-2.0+, LGPL-2.0+
*/
#include "config.h"
#include <math.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/uio.h>
#include <errno.h>
#include "compat.h"
#include "compress.h"
#include "crypto.h"
#include "host.h"
#include "link.h"
#include "logging.h"
#include "transports.h"
+#include "transport_common.h"
#include "threads_common.h"
#include "threads_heartbeat.h"
#include "threads_tx.h"
#include "netutils.h"
/*
* SEND
*/
static int _dispatch_to_links(knet_handle_t knet_h, struct knet_host *dst_host, struct knet_mmsghdr *msg, int msgs_to_send)
{
int link_idx, msg_idx, sent_msgs, prev_sent, progress;
int err = 0, savederrno = 0;
unsigned int i;
struct knet_mmsghdr *cur;
struct knet_link *cur_link;
for (link_idx = 0; link_idx < dst_host->active_link_entries; link_idx++) {
sent_msgs = 0;
prev_sent = 0;
progress = 1;
cur_link = &dst_host->link[dst_host->active_links[link_idx]];
if (cur_link->transport_type == KNET_TRANSPORT_LOOPBACK) {
continue;
}
msg_idx = 0;
while (msg_idx < msgs_to_send) {
msg[msg_idx].msg_hdr.msg_name = &cur_link->dst_addr;
/* Cast for Linux/BSD compatibility */
for (i=0; i<(unsigned int)msg[msg_idx].msg_hdr.msg_iovlen; i++) {
cur_link->status.stats.tx_data_bytes += msg[msg_idx].msg_hdr.msg_iov[i].iov_len;
}
cur_link->status.stats.tx_data_packets++;
msg_idx++;
}
retry:
cur = &msg[prev_sent];
sent_msgs = _sendmmsg(dst_host->link[dst_host->active_links[link_idx]].outsock,
&cur[0], msgs_to_send - prev_sent, MSG_DONTWAIT | MSG_NOSIGNAL);
savederrno = errno;
- err = knet_h->transport_ops[dst_host->link[dst_host->active_links[link_idx]].transport_type]->transport_tx_sock_error(knet_h, dst_host->link[dst_host->active_links[link_idx]].outsock, sent_msgs, savederrno);
+ err = transport_tx_sock_error(knet_h, dst_host->link[dst_host->active_links[link_idx]].transport_type, dst_host->link[dst_host->active_links[link_idx]].outsock, sent_msgs, savederrno);
switch(err) {
case -1: /* unrecoverable error */
cur_link->status.stats.tx_data_errors++;
goto out_unlock;
break;
case 0: /* ignore error and continue */
break;
case 1: /* retry to send those same data */
cur_link->status.stats.tx_data_retries++;
goto retry;
break;
}
prev_sent = prev_sent + sent_msgs;
if ((sent_msgs >= 0) && (prev_sent < msgs_to_send)) {
if ((sent_msgs) || (progress)) {
if (sent_msgs) {
progress = 1;
} else {
progress = 0;
}
#ifdef DEBUG
log_debug(knet_h, KNET_SUB_TX, "Unable to send all (%d/%d) data packets to host %s (%u) link %s:%s (%u)",
sent_msgs, msg_idx,
dst_host->name, dst_host->host_id,
dst_host->link[dst_host->active_links[link_idx]].status.dst_ipaddr,
dst_host->link[dst_host->active_links[link_idx]].status.dst_port,
dst_host->link[dst_host->active_links[link_idx]].link_id);
#endif
goto retry;
}
if (!progress) {
savederrno = EAGAIN;
err = -1;
goto out_unlock;
}
}
if ((dst_host->link_handler_policy == KNET_LINK_POLICY_RR) &&
(dst_host->active_link_entries > 1)) {
uint8_t cur_link_id = dst_host->active_links[0];
memmove(&dst_host->active_links[0], &dst_host->active_links[1], KNET_MAX_LINK - 1);
dst_host->active_links[dst_host->active_link_entries - 1] = cur_link_id;
break;
}
}
out_unlock:
errno = savederrno;
return err;
}
static int _parse_recv_from_sock(knet_handle_t knet_h, size_t inlen, int8_t channel, int is_sync)
{
size_t outlen, frag_len;
struct knet_host *dst_host;
knet_node_id_t dst_host_ids_temp[KNET_MAX_HOST];
size_t dst_host_ids_entries_temp = 0;
knet_node_id_t dst_host_ids[KNET_MAX_HOST];
size_t dst_host_ids_entries = 0;
int bcast = 1;
struct knet_hostinfo *knet_hostinfo;
struct iovec iov_out[PCKT_FRAG_MAX][2];
int iovcnt_out = 2;
uint8_t frag_idx;
unsigned int temp_data_mtu;
size_t host_idx;
int send_mcast = 0;
struct knet_header *inbuf;
int savederrno = 0;
int err = 0;
seq_num_t tx_seq_num;
struct knet_mmsghdr msg[PCKT_FRAG_MAX];
int msgs_to_send, msg_idx;
unsigned int i;
int j;
int send_local = 0;
int data_compressed = 0;
size_t uncrypted_frag_size;
inbuf = knet_h->recv_from_sock_buf;
if ((knet_h->enabled != 1) &&
(inbuf->kh_type != KNET_HEADER_TYPE_HOST_INFO)) { /* data forward is disabled */
log_debug(knet_h, KNET_SUB_TX, "Received data packet but forwarding is disabled");
savederrno = ECANCELED;
err = -1;
goto out_unlock;
}
/*
* move this into a separate function to expand on
* extra switching rules
*/
switch(inbuf->kh_type) {
case KNET_HEADER_TYPE_DATA:
if (knet_h->dst_host_filter_fn) {
bcast = knet_h->dst_host_filter_fn(
knet_h->dst_host_filter_fn_private_data,
(const unsigned char *)inbuf->khp_data_userdata,
inlen,
KNET_NOTIFY_TX,
knet_h->host_id,
knet_h->host_id,
&channel,
dst_host_ids_temp,
&dst_host_ids_entries_temp);
if (bcast < 0) {
log_debug(knet_h, KNET_SUB_TX, "Error from dst_host_filter_fn: %d", bcast);
savederrno = EFAULT;
err = -1;
goto out_unlock;
}
if ((!bcast) && (!dst_host_ids_entries_temp)) {
log_debug(knet_h, KNET_SUB_TX, "Message is unicast but no dst_host_ids_entries");
savederrno = EINVAL;
err = -1;
goto out_unlock;
}
}
/* Send to localhost if appropriate and enabled */
if (knet_h->has_loop_link) {
send_local = 0;
if (bcast) {
send_local = 1;
} else {
for (i=0; i< dst_host_ids_entries_temp; i++) {
if (dst_host_ids_temp[i] == knet_h->host_id) {
send_local = 1;
}
}
}
if (send_local) {
const unsigned char *buf = inbuf->khp_data_userdata;
ssize_t buflen = inlen;
struct knet_link *local_link;
local_link = knet_h->host_index[knet_h->host_id]->link;
local_retry:
err = write(knet_h->sockfd[channel].sockfd[knet_h->sockfd[channel].is_created], buf, buflen);
if (err < 0) {
log_err(knet_h, KNET_SUB_TRANSP_LOOPBACK, "send local failed. error=%s\n", strerror(errno));
local_link->status.stats.tx_data_errors++;
}
if (err > 0 && err < buflen) {
log_debug(knet_h, KNET_SUB_TRANSP_LOOPBACK, "send local incomplete=%d bytes of %zu\n", err, inlen);
local_link->status.stats.tx_data_retries++;
buf += err;
buflen -= err;
usleep(KNET_THREADS_TIMERES / 16);
goto local_retry;
}
if (err == buflen) {
local_link->status.stats.tx_data_packets++;
local_link->status.stats.tx_data_bytes += inlen;
}
}
}
break;
case KNET_HEADER_TYPE_HOST_INFO:
knet_hostinfo = (struct knet_hostinfo *)inbuf->khp_data_userdata;
if (knet_hostinfo->khi_bcast == KNET_HOSTINFO_UCAST) {
bcast = 0;
dst_host_ids_temp[0] = knet_hostinfo->khi_dst_node_id;
dst_host_ids_entries_temp = 1;
knet_hostinfo->khi_dst_node_id = htons(knet_hostinfo->khi_dst_node_id);
}
break;
default:
log_warn(knet_h, KNET_SUB_TX, "Receiving unknown messages from socket");
savederrno = ENOMSG;
err = -1;
goto out_unlock;
break;
}
if (is_sync) {
if ((bcast) ||
((!bcast) && (dst_host_ids_entries_temp > 1))) {
log_debug(knet_h, KNET_SUB_TX, "knet_send_sync is only supported with unicast packets for one destination");
savederrno = E2BIG;
err = -1;
goto out_unlock;
}
}
/*
* check destinations hosts before spending time
* in fragmenting/encrypting packets to save
* time processing data for unreachable hosts.
* for unicast, also remap the destination data
* to skip unreachable hosts.
*/
if (!bcast) {
dst_host_ids_entries = 0;
for (host_idx = 0; host_idx < dst_host_ids_entries_temp; host_idx++) {
dst_host = knet_h->host_index[dst_host_ids_temp[host_idx]];
if (!dst_host) {
continue;
}
if (!(dst_host->host_id == knet_h->host_id &&
knet_h->has_loop_link) &&
dst_host->status.reachable) {
dst_host_ids[dst_host_ids_entries] = dst_host_ids_temp[host_idx];
dst_host_ids_entries++;
}
}
if (!dst_host_ids_entries) {
savederrno = EHOSTDOWN;
err = -1;
goto out_unlock;
}
} else {
send_mcast = 0;
for (dst_host = knet_h->host_head; dst_host != NULL; dst_host = dst_host->next) {
if (!(dst_host->host_id == knet_h->host_id &&
knet_h->has_loop_link) &&
dst_host->status.reachable) {
send_mcast = 1;
break;
}
}
if (!send_mcast) {
savederrno = EHOSTDOWN;
err = -1;
goto out_unlock;
}
}
if (!knet_h->data_mtu) {
/*
* using MIN_MTU_V4 for data mtu is not completely accurate but safe enough
*/
log_debug(knet_h, KNET_SUB_TX,
"Received data packet but data MTU is still unknown."
" Packet might not be delivered."
" Assuming mininum IPv4 mtu (%d)",
KNET_PMTUD_MIN_MTU_V4);
temp_data_mtu = KNET_PMTUD_MIN_MTU_V4;
} else {
/*
* take a copy of the mtu to avoid value changing under
* our feet while we are sending a fragmented pckt
*/
temp_data_mtu = knet_h->data_mtu;
}
/*
* compress data
*/
if ((knet_h->compress_model > 0) && (inlen > knet_h->compress_threshold)) {
size_t cmp_outlen = KNET_DATABUFSIZE_COMPRESS;
struct timespec start_time;
struct timespec end_time;
uint64_t compress_time;
clock_gettime(CLOCK_MONOTONIC, &start_time);
err = compress(knet_h,
(const unsigned char *)inbuf->khp_data_userdata, inlen,
knet_h->send_to_links_buf_compress, (ssize_t *)&cmp_outlen);
if (err < 0) {
log_warn(knet_h, KNET_SUB_COMPRESS, "Compression failed (%d): %s", err, strerror(errno));
} else {
/* Collect stats */
clock_gettime(CLOCK_MONOTONIC, &end_time);
timespec_diff(start_time, end_time, &compress_time);
if (compress_time < knet_h->stats.tx_compress_time_min) {
knet_h->stats.tx_compress_time_min = compress_time;
}
if (compress_time > knet_h->stats.tx_compress_time_max) {
knet_h->stats.tx_compress_time_max = compress_time;
}
knet_h->stats.tx_compress_time_ave =
(unsigned long long)(knet_h->stats.tx_compress_time_ave * knet_h->stats.tx_compressed_packets +
compress_time) / (knet_h->stats.tx_compressed_packets+1);
knet_h->stats.tx_compressed_packets++;
knet_h->stats.tx_compressed_original_bytes += inlen;
knet_h->stats.tx_compressed_size_bytes += cmp_outlen;
if (cmp_outlen < inlen) {
memmove(inbuf->khp_data_userdata, knet_h->send_to_links_buf_compress, cmp_outlen);
inlen = cmp_outlen;
data_compressed = 1;
}
}
}
if ((knet_h->compress_model > 0) && (inlen <= knet_h->compress_threshold)) {
knet_h->stats.tx_uncompressed_packets++;
}
/*
* prepare the outgoing buffers
*/
frag_len = inlen;
frag_idx = 0;
inbuf->khp_data_bcast = bcast;
inbuf->khp_data_frag_num = ceil((float)inlen / temp_data_mtu);
inbuf->khp_data_channel = channel;
if (data_compressed) {
inbuf->khp_data_compress = knet_h->compress_model;
} else {
inbuf->khp_data_compress = 0;
}
if (pthread_mutex_lock(&knet_h->tx_seq_num_mutex)) {
log_debug(knet_h, KNET_SUB_TX, "Unable to get seq mutex lock");
goto out_unlock;
}
knet_h->tx_seq_num++;
/*
* force seq_num 0 to detect a node that has crashed and rejoining
* the knet instance. seq_num 0 will clear the buffers in the RX
* thread
*/
if (knet_h->tx_seq_num == 0) {
knet_h->tx_seq_num++;
}
/*
* cache the value in locked context
*/
tx_seq_num = knet_h->tx_seq_num;
inbuf->khp_data_seq_num = htons(knet_h->tx_seq_num);
pthread_mutex_unlock(&knet_h->tx_seq_num_mutex);
/*
* forcefully broadcast a ping to all nodes every SEQ_MAX / 8
* pckts.
* this solves 2 problems:
* 1) on TX socket overloads we generate extra pings to keep links alive
* 2) in 3+ nodes setup, where all the traffic is flowing between node 1 and 2,
* node 3+ will be able to keep in sync on the TX seq_num even without
* receiving traffic or pings in betweens. This avoids issues with
* rollover of the circular buffer
*/
if (tx_seq_num % (SEQ_MAX / 8) == 0) {
_send_pings(knet_h, 0);
}
if (inbuf->khp_data_frag_num > 1) {
while (frag_idx < inbuf->khp_data_frag_num) {
/*
* set the iov_base
*/
iov_out[frag_idx][0].iov_base = (void *)knet_h->send_to_links_buf[frag_idx];
iov_out[frag_idx][0].iov_len = KNET_HEADER_DATA_SIZE;
iov_out[frag_idx][1].iov_base = inbuf->khp_data_userdata + (temp_data_mtu * frag_idx);
/*
* set the len
*/
if (frag_len > temp_data_mtu) {
iov_out[frag_idx][1].iov_len = temp_data_mtu;
} else {
iov_out[frag_idx][1].iov_len = frag_len;
}
/*
* copy the frag info on all buffers
*/
knet_h->send_to_links_buf[frag_idx]->kh_type = inbuf->kh_type;
knet_h->send_to_links_buf[frag_idx]->khp_data_seq_num = inbuf->khp_data_seq_num;
knet_h->send_to_links_buf[frag_idx]->khp_data_frag_num = inbuf->khp_data_frag_num;
knet_h->send_to_links_buf[frag_idx]->khp_data_bcast = inbuf->khp_data_bcast;
knet_h->send_to_links_buf[frag_idx]->khp_data_channel = inbuf->khp_data_channel;
knet_h->send_to_links_buf[frag_idx]->khp_data_compress = inbuf->khp_data_compress;
frag_len = frag_len - temp_data_mtu;
frag_idx++;
}
iovcnt_out = 2;
} else {
iov_out[frag_idx][0].iov_base = (void *)inbuf;
iov_out[frag_idx][0].iov_len = frag_len + KNET_HEADER_DATA_SIZE;
iovcnt_out = 1;
}
if (knet_h->crypto_instance) {
struct timespec start_time;
struct timespec end_time;
uint64_t crypt_time;
frag_idx = 0;
while (frag_idx < inbuf->khp_data_frag_num) {
clock_gettime(CLOCK_MONOTONIC, &start_time);
if (crypto_encrypt_and_signv(
knet_h,
iov_out[frag_idx], iovcnt_out,
knet_h->send_to_links_buf_crypt[frag_idx],
(ssize_t *)&outlen) < 0) {
log_debug(knet_h, KNET_SUB_TX, "Unable to encrypt packet");
savederrno = ECHILD;
err = -1;
goto out_unlock;
}
clock_gettime(CLOCK_MONOTONIC, &end_time);
timespec_diff(start_time, end_time, &crypt_time);
if (crypt_time < knet_h->stats.tx_crypt_time_min) {
knet_h->stats.tx_crypt_time_min = crypt_time;
}
if (crypt_time > knet_h->stats.tx_crypt_time_max) {
knet_h->stats.tx_crypt_time_max = crypt_time;
}
knet_h->stats.tx_crypt_time_ave =
(knet_h->stats.tx_crypt_time_ave * knet_h->stats.tx_crypt_packets +
crypt_time) / (knet_h->stats.tx_crypt_packets+1);
uncrypted_frag_size = 0;
for (j=0; j < iovcnt_out; j++) {
uncrypted_frag_size += iov_out[frag_idx][j].iov_len;
}
knet_h->stats.tx_crypt_byte_overhead += (outlen - uncrypted_frag_size);
knet_h->stats.tx_crypt_packets++;
iov_out[frag_idx][0].iov_base = knet_h->send_to_links_buf_crypt[frag_idx];
iov_out[frag_idx][0].iov_len = outlen;
frag_idx++;
}
iovcnt_out = 1;
}
memset(&msg, 0, sizeof(msg));
msgs_to_send = inbuf->khp_data_frag_num;
msg_idx = 0;
while (msg_idx < msgs_to_send) {
msg[msg_idx].msg_hdr.msg_namelen = sizeof(struct sockaddr_storage);
msg[msg_idx].msg_hdr.msg_iov = &iov_out[msg_idx][0];
msg[msg_idx].msg_hdr.msg_iovlen = iovcnt_out;
msg_idx++;
}
if (!bcast) {
for (host_idx = 0; host_idx < dst_host_ids_entries; host_idx++) {
dst_host = knet_h->host_index[dst_host_ids[host_idx]];
err = _dispatch_to_links(knet_h, dst_host, &msg[0], msgs_to_send);
savederrno = errno;
if (err) {
goto out_unlock;
}
}
} else {
for (dst_host = knet_h->host_head; dst_host != NULL; dst_host = dst_host->next) {
if (dst_host->status.reachable) {
err = _dispatch_to_links(knet_h, dst_host, &msg[0], msgs_to_send);
savederrno = errno;
if (err) {
goto out_unlock;
}
}
}
}
out_unlock:
errno = savederrno;
return err;
}
int knet_send_sync(knet_handle_t knet_h, const char *buff, const size_t buff_len, const int8_t channel)
{
int savederrno = 0, err = 0;
if (!knet_h) {
errno = EINVAL;
return -1;
}
if (buff == NULL) {
errno = EINVAL;
return -1;
}
if (buff_len <= 0) {
errno = EINVAL;
return -1;
}
if (buff_len > KNET_MAX_PACKET_SIZE) {
errno = EINVAL;
return -1;
}
if (channel < 0) {
errno = EINVAL;
return -1;
}
if (channel >= KNET_DATAFD_MAX) {
errno = EINVAL;
return -1;
}
savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_TX, "Unable to get read lock: %s",
strerror(savederrno));
errno = savederrno;
return -1;
}
if (!knet_h->sockfd[channel].in_use) {
savederrno = EINVAL;
err = -1;
goto out;
}
savederrno = pthread_mutex_lock(&knet_h->tx_mutex);
if (savederrno) {
log_err(knet_h, KNET_SUB_TX, "Unable to get TX mutex lock: %s",
strerror(savederrno));
err = -1;
goto out;
}
knet_h->recv_from_sock_buf->kh_type = KNET_HEADER_TYPE_DATA;
memmove(knet_h->recv_from_sock_buf->khp_data_userdata, buff, buff_len);
err = _parse_recv_from_sock(knet_h, buff_len, channel, 1);
savederrno = errno;
pthread_mutex_unlock(&knet_h->tx_mutex);
out:
pthread_rwlock_unlock(&knet_h->global_rwlock);
errno = savederrno;
return err;
}
static void _handle_send_to_links(knet_handle_t knet_h, struct msghdr *msg, int sockfd, int8_t channel, int type)
{
ssize_t inlen = 0;
int savederrno = 0, docallback = 0;
if ((channel >= 0) &&
(channel < KNET_DATAFD_MAX) &&
(!knet_h->sockfd[channel].is_socket)) {
inlen = readv(sockfd, msg->msg_iov, 1);
} else {
inlen = recvmsg(sockfd, msg, MSG_DONTWAIT | MSG_NOSIGNAL);
}
if (inlen == 0) {
savederrno = 0;
docallback = 1;
goto out;
}
if (inlen < 0) {
savederrno = errno;
docallback = 1;
goto out;
}
knet_h->recv_from_sock_buf->kh_type = type;
_parse_recv_from_sock(knet_h, inlen, channel, 0);
out:
if (inlen < 0) {
struct epoll_event ev;
memset(&ev, 0, sizeof(struct epoll_event));
if (epoll_ctl(knet_h->send_to_links_epollfd,
EPOLL_CTL_DEL, knet_h->sockfd[channel].sockfd[knet_h->sockfd[channel].is_created], &ev)) {
log_err(knet_h, KNET_SUB_TX, "Unable to del datafd %d from linkfd epoll pool: %s",
knet_h->sockfd[channel].sockfd[0], strerror(savederrno));
} else {
knet_h->sockfd[channel].has_error = 1;
}
}
if (docallback) {
knet_h->sock_notify_fn(knet_h->sock_notify_fn_private_data,
knet_h->sockfd[channel].sockfd[0],
channel,
KNET_NOTIFY_TX,
inlen,
savederrno);
}
}
void *_handle_send_to_links_thread(void *data)
{
knet_handle_t knet_h = (knet_handle_t) data;
struct epoll_event events[KNET_EPOLL_MAX_EVENTS];
int i, nev, type;
int8_t channel;
struct iovec iov_in;
struct msghdr msg;
struct sockaddr_storage address;
memset(&iov_in, 0, sizeof(iov_in));
iov_in.iov_base = (void *)knet_h->recv_from_sock_buf->khp_data_userdata;
iov_in.iov_len = KNET_MAX_PACKET_SIZE;
memset(&msg, 0, sizeof(struct msghdr));
msg.msg_name = &address;
msg.msg_namelen = sizeof(struct sockaddr_storage);
msg.msg_iov = &iov_in;
msg.msg_iovlen = 1;
knet_h->recv_from_sock_buf->kh_version = KNET_HEADER_VERSION;
knet_h->recv_from_sock_buf->khp_data_frag_seq = 0;
knet_h->recv_from_sock_buf->kh_node = htons(knet_h->host_id);
for (i = 0; i < PCKT_FRAG_MAX; i++) {
knet_h->send_to_links_buf[i]->kh_version = KNET_HEADER_VERSION;
knet_h->send_to_links_buf[i]->khp_data_frag_seq = i + 1;
knet_h->send_to_links_buf[i]->kh_node = htons(knet_h->host_id);
}
while (!shutdown_in_progress(knet_h)) {
nev = epoll_wait(knet_h->send_to_links_epollfd, events, KNET_EPOLL_MAX_EVENTS + 1, -1);
if (pthread_rwlock_rdlock(&knet_h->global_rwlock) != 0) {
log_debug(knet_h, KNET_SUB_TX, "Unable to get read lock");
continue;
}
for (i = 0; i < nev; i++) {
if (events[i].data.fd == knet_h->hostsockfd[0]) {
type = KNET_HEADER_TYPE_HOST_INFO;
channel = -1;
} else {
type = KNET_HEADER_TYPE_DATA;
for (channel = 0; channel < KNET_DATAFD_MAX; channel++) {
if ((knet_h->sockfd[channel].in_use) &&
(knet_h->sockfd[channel].sockfd[knet_h->sockfd[channel].is_created] == events[i].data.fd)) {
break;
}
}
if (channel >= KNET_DATAFD_MAX) {
log_debug(knet_h, KNET_SUB_TX, "No available channels");
continue; /* channel not found */
}
}
if (pthread_mutex_lock(&knet_h->tx_mutex) != 0) {
log_debug(knet_h, KNET_SUB_TX, "Unable to get mutex lock");
continue;
}
_handle_send_to_links(knet_h, &msg, events[i].data.fd, channel, type);
pthread_mutex_unlock(&knet_h->tx_mutex);
}
pthread_rwlock_unlock(&knet_h->global_rwlock);
}
return NULL;
}
diff --git a/libknet/transport_common.c b/libknet/transport_common.c
index 2b0887a1..7269d585 100644
--- a/libknet/transport_common.c
+++ b/libknet/transport_common.c
@@ -1,547 +1,348 @@
/*
* 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 "transports.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);
}
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) {
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) {
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 */
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;
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;
}
-
-/*
- * public api
- */
-
-int knet_handle_get_transport_list(knet_handle_t knet_h,
- struct knet_transport_info *transport_list,
- size_t *transport_list_entries)
-{
- int err = 0, savederrno = 0;
- int i, count;
-
- if (!knet_h) {
- errno = EINVAL;
- return -1;
- }
-
- if (!transport_list) {
- errno = EINVAL;
- return -1;
- }
-
- if (!transport_list_entries) {
- errno = EINVAL;
- return -1;
- }
-
- savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
- if (savederrno) {
- log_err(knet_h, KNET_SUB_HANDLE, "Unable to get read lock: %s",
- strerror(savederrno));
- errno = savederrno;
- return -1;
- }
-
- count = 0;
-
- /*
- * we could potentially build this struct
- * at knet_handle_new init time, but
- * let's keep it dynamic in case at somepoint
- * we need to init transports dynamically
- * at runtime vs init time.
- */
-
- for (i=0; i<KNET_MAX_TRANSPORTS; i++) {
- if (knet_h->transport_ops[i]) {
- transport_list[count].name = knet_h->transport_ops[i]->transport_name;
- transport_list[count].id = knet_h->transport_ops[i]->transport_id;
- count++;
- }
- }
-
- *transport_list_entries = count;
-
- pthread_rwlock_unlock(&knet_h->global_rwlock);
-
- return err;
-}
-
-const char *knet_handle_get_transport_name_by_id(knet_handle_t knet_h, uint8_t transport)
-{
- int savederrno = 0;
- const char *name = NULL;
-
- if (!knet_h) {
- errno = EINVAL;
- return name;
- }
-
- if (transport >= KNET_MAX_TRANSPORTS) {
- errno = EINVAL;
- return name;
- }
-
- savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
- if (savederrno) {
- log_err(knet_h, KNET_SUB_HANDLE, "Unable to get read lock: %s",
- strerror(savederrno));
- errno = savederrno;
- return name;
- }
-
- if (knet_h->transport_ops[transport]) {
- name = knet_h->transport_ops[transport]->transport_name;
- } else {
- savederrno = ENOENT;
- }
-
- pthread_rwlock_unlock(&knet_h->global_rwlock);
- errno = savederrno;
- return name;
-}
-
-uint8_t knet_handle_get_transport_id_by_name(knet_handle_t knet_h, const char *name)
-{
- int savederrno = 0;
- uint8_t err = KNET_MAX_TRANSPORTS;
- int i;
-
- if (!knet_h) {
- errno = EINVAL;
- return err;
- }
-
- if (!name) {
- errno = EINVAL;
- return err;
- }
-
- savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
- if (savederrno) {
- log_err(knet_h, KNET_SUB_HANDLE, "Unable to get read lock: %s",
- strerror(savederrno));
- errno = savederrno;
- return err;
- }
-
- for (i=0; i<KNET_MAX_TRANSPORTS; i++) {
- if (knet_h->transport_ops[i]) {
- if (!strcmp(knet_h->transport_ops[i]->transport_name, name)) {
- err = knet_h->transport_ops[i]->transport_id;
- break;
- }
- }
- }
-
- if (err == KNET_MAX_TRANSPORTS) {
- savederrno = EINVAL;
- }
-
- pthread_rwlock_unlock(&knet_h->global_rwlock);
- errno = savederrno;
- return err;
-}
-
-int knet_handle_set_transport_reconnect_interval(knet_handle_t knet_h, uint32_t msecs)
-{
- int savederrno = 0;
-
- if (!knet_h) {
- errno = EINVAL;
- return -1;
- }
-
- if (!msecs) {
- errno = EINVAL;
- return -1;
- }
-
- if (msecs < 1000) {
- log_warn(knet_h, KNET_SUB_HANDLE, "reconnect internval below 1 sec (%u msecs) might be too aggressive", msecs);
- }
-
- if (msecs > 60000) {
- log_warn(knet_h, KNET_SUB_HANDLE, "reconnect internval above 1 minute (%u msecs) could cause long delays in network convergiance", msecs);
- }
-
- savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
- if (savederrno) {
- log_err(knet_h, KNET_SUB_HANDLE, "Unable to get read lock: %s",
- strerror(savederrno));
- errno = savederrno;
- return -1;
- }
-
- knet_h->reconnect_int = msecs;
-
- pthread_rwlock_unlock(&knet_h->global_rwlock);
- return 0;
-}
-
-int knet_handle_get_transport_reconnect_interval(knet_handle_t knet_h, uint32_t *msecs)
-{
- int savederrno = 0;
-
- if (!knet_h) {
- errno = EINVAL;
- return -1;
- }
-
- if (!msecs) {
- errno = EINVAL;
- return -1;
- }
-
- savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
- if (savederrno) {
- log_err(knet_h, KNET_SUB_HANDLE, "Unable to get read lock: %s",
- strerror(savederrno));
- errno = savederrno;
- return -1;
- }
-
- *msecs = knet_h->reconnect_int;
-
- pthread_rwlock_unlock(&knet_h->global_rwlock);
- return 0;
-}
diff --git a/libknet/transports.h b/libknet/transport_common.h
similarity index 80%
copy from libknet/transports.h
copy to libknet/transport_common.h
index a5158fdd..8637641d 100644
--- a/libknet/transports.h
+++ b/libknet/transport_common.h
@@ -1,28 +1,24 @@
/*
* 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_TRANSPORTS_H__
-#define __KNET_TRANSPORTS_H__
-
-knet_transport_ops_t *get_udp_transport(void);
-knet_transport_ops_t *get_sctp_transport(void);
-knet_transport_ops_t *get_loopback_transport(void);
+#ifndef __KNET_TRANSPORT_COMMON_H__
+#define __KNET_TRANSPORT_COMMON_H__
int _configure_common_socket(knet_handle_t knet_h, int sock, uint64_t flags, const char *type);
int _configure_transport_socket(knet_handle_t knet_h, int sock, struct sockaddr_storage *address, uint64_t flags, const char *type);
int _init_socketpair(knet_handle_t knet_h, int *sock);
void _close_socketpair(knet_handle_t knet_h, int *sock);
int _set_fd_tracker(knet_handle_t knet_h, int sockfd, uint8_t transport, uint8_t data_type, void *data);
int _is_valid_fd(knet_handle_t knet_h, int sockfd);
int _sendmmsg(int sockfd, struct knet_mmsghdr *msgvec, unsigned int vlen, unsigned int flags);
int _recvmmsg(int sockfd, struct knet_mmsghdr *msgvec, unsigned int vlen, unsigned int flags);
#endif
diff --git a/libknet/transport_loopback.c b/libknet/transport_loopback.c
index a26ce758..a996edb8 100644
--- a/libknet/transport_loopback.c
+++ b/libknet/transport_loopback.c
@@ -1,93 +1,73 @@
/*
* Copyright (C) 2017 Red Hat, Inc. All rights reserved.
*
* Author: Christine Caulfield <ccaulfie@redhat.com>
*
* This software licensed under GPL-2.0+, LGPL-2.0+
*/
#include "config.h"
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include "libknet.h"
#include "compat.h"
#include "host.h"
#include "link.h"
#include "logging.h"
#include "common.h"
#include "transports.h"
+#include "transport_loopback.h"
#include "threads_common.h"
-#define KNET_PMTUD_LOOPBACK_OVERHEAD 0
-
/* This is just a file of empty calls as the actual loopback is in threads_tx.c as a special case
when receiving a packet from the localhost */
-static int loopback_transport_link_set_config(knet_handle_t knet_h, struct knet_link *kn_link)
+int loopback_transport_link_set_config(knet_handle_t knet_h, struct knet_link *kn_link)
{
return 0;
}
-static int loopback_transport_link_clear_config(knet_handle_t knet_h, struct knet_link *kn_link)
+int loopback_transport_link_clear_config(knet_handle_t knet_h, struct knet_link *kn_link)
{
return 0;
}
-static int loopback_transport_free(knet_handle_t knet_h)
+int loopback_transport_free(knet_handle_t knet_h)
{
return 0;
}
-static int loopback_transport_init(knet_handle_t knet_h)
+int loopback_transport_init(knet_handle_t knet_h)
{
return 0;
}
-static int loopback_transport_rx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno)
+int loopback_transport_rx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno)
{
return 0;
}
-static int loopback_transport_tx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno)
+int loopback_transport_tx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno)
{
return 0;
}
-static int loopback_transport_rx_is_data(knet_handle_t knet_h, int sockfd, struct knet_mmsghdr *msg)
+int loopback_transport_rx_is_data(knet_handle_t knet_h, int sockfd, struct knet_mmsghdr *msg)
{
return 0;
}
-static int loopback_transport_link_dyn_connect(knet_handle_t knet_h, int sockfd, struct knet_link *kn_link)
+int loopback_transport_link_dyn_connect(knet_handle_t knet_h, int sockfd, struct knet_link *kn_link)
{
return 0;
}
-
-static knet_transport_ops_t loopback_transport_ops = {
- .transport_name = "LOOPBACK",
- .transport_id = KNET_TRANSPORT_LOOPBACK,
- .transport_mtu_overhead = KNET_PMTUD_LOOPBACK_OVERHEAD,
- .transport_init = loopback_transport_init,
- .transport_free = loopback_transport_free,
- .transport_link_set_config = loopback_transport_link_set_config,
- .transport_link_clear_config = loopback_transport_link_clear_config,
- .transport_link_dyn_connect = loopback_transport_link_dyn_connect,
- .transport_rx_sock_error = loopback_transport_rx_sock_error,
- .transport_tx_sock_error = loopback_transport_tx_sock_error,
- .transport_rx_is_data = loopback_transport_rx_is_data,
-};
-
-knet_transport_ops_t *get_loopback_transport()
-{
- return &loopback_transport_ops;
-}
diff --git a/libknet/transport_loopback.h b/libknet/transport_loopback.h
new file mode 100644
index 00000000..647a19c7
--- /dev/null
+++ b/libknet/transport_loopback.h
@@ -0,0 +1,27 @@
+/*
+ * 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 "internals.h"
+
+#ifndef __KNET_TRANSPORT_LOOPBACK_H__
+#define __KNET_TRANSPORT_LOOPBACK_H__
+
+#define KNET_PMTUD_LOOPBACK_OVERHEAD 0
+
+int loopback_transport_link_set_config(knet_handle_t knet_h, struct knet_link *kn_link);
+int loopback_transport_link_clear_config(knet_handle_t knet_h, struct knet_link *kn_link);
+int loopback_transport_free(knet_handle_t knet_h);
+int loopback_transport_init(knet_handle_t knet_h);
+int loopback_transport_rx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno);
+int loopback_transport_tx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno);
+int loopback_transport_rx_is_data(knet_handle_t knet_h, int sockfd, struct knet_mmsghdr *msg);
+int loopback_transport_link_dyn_connect(knet_handle_t knet_h, int sockfd, struct knet_link *kn_link);
+
+#endif
diff --git a/libknet/transport_sctp.c b/libknet/transport_sctp.c
index 2fed9183..4ebe74a5 100644
--- a/libknet/transport_sctp.c
+++ b/libknet/transport_sctp.c
@@ -1,1448 +1,1417 @@
/*
* Copyright (C) 2016-2017 Red Hat, Inc. All rights reserved.
*
* Author: Christine Caulfield <ccaulfie@redhat.com>
*
* This software licensed under GPL-2.0+, LGPL-2.0+
*/
#include "config.h"
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include "compat.h"
#include "host.h"
#include "links.h"
#include "logging.h"
#include "common.h"
-#include "transports.h"
+#include "transport_common.h"
#include "threads_common.h"
#ifdef HAVE_NETINET_SCTP_H
#include <netinet/sctp.h>
-
-/*
- * https://en.wikipedia.org/wiki/SCTP_packet_structure
- */
-#define KNET_PMTUD_SCTP_OVERHEAD_COMMON 12
-#define KNET_PMTUD_SCTP_OVERHEAD_DATA_CHUNK 16
-#define KNET_PMTUD_SCTP_OVERHEAD KNET_PMTUD_SCTP_OVERHEAD_COMMON + KNET_PMTUD_SCTP_OVERHEAD_DATA_CHUNK
+#include "transport_sctp.h"
typedef struct sctp_handle_info {
struct knet_list_head listen_links_list;
struct knet_list_head connect_links_list;
int connect_epollfd;
int connectsockfd[2];
int listen_epollfd;
int listensockfd[2];
pthread_t connect_thread;
pthread_t listen_thread;
} sctp_handle_info_t;
/*
* use by fd_tracker data type
*/
#define SCTP_NO_LINK_INFO 0
#define SCTP_LISTENER_LINK_INFO 1
#define SCTP_ACCEPTED_LINK_INFO 2
#define SCTP_CONNECT_LINK_INFO 3
/*
* this value is per listener
*/
#define MAX_ACCEPTED_SOCKS 256
typedef struct sctp_listen_link_info {
struct knet_list_head list;
int listen_sock;
int accepted_socks[MAX_ACCEPTED_SOCKS];
struct sockaddr_storage src_address;
int on_listener_epoll;
int on_rx_epoll;
} sctp_listen_link_info_t;
typedef struct sctp_accepted_link_info {
char mread_buf[KNET_DATABUFSIZE];
ssize_t mread_len;
sctp_listen_link_info_t *link_info;
} sctp_accepted_link_info_t ;
typedef struct sctp_connect_link_info {
struct knet_list_head list;
sctp_listen_link_info_t *listener;
struct knet_link *link;
struct sockaddr_storage dst_address;
int connect_sock;
int on_connected_epoll;
int on_rx_epoll;
int close_sock;
} sctp_connect_link_info_t;
/*
* socket handling functions
*
* those functions do NOT perform locking. locking
* should be handled in the right context from callers
*/
/*
* sockets are removed from rx_epoll from callers
* see also error handling functions
*/
static int _close_connect_socket(knet_handle_t knet_h, struct knet_link *kn_link)
{
int err = 0, savederrno = 0;
sctp_connect_link_info_t *info = kn_link->transport_link;
sctp_handle_info_t *handle_info = knet_h->transports[KNET_TRANSPORT_SCTP];
struct epoll_event ev;
if (info->on_connected_epoll) {
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLOUT;
ev.data.fd = info->connect_sock;
if (epoll_ctl(handle_info->connect_epollfd, EPOLL_CTL_DEL, info->connect_sock, &ev)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to remove connected socket from the epoll pool: %s",
strerror(errno));
goto exit_error;
}
info->on_connected_epoll = 0;
}
exit_error:
if (info->connect_sock != -1) {
if (_set_fd_tracker(knet_h, info->connect_sock, KNET_MAX_TRANSPORTS, SCTP_NO_LINK_INFO, NULL) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to set fd tracker: %s",
strerror(savederrno));
goto exit_error;
}
close(info->connect_sock);
info->connect_sock = -1;
}
errno = savederrno;
return err;
}
static int _enable_sctp_notifications(knet_handle_t knet_h, int sock, const char *type)
{
int err = 0, savederrno = 0;
struct sctp_event_subscribe events;
memset(&events, 0, sizeof (events));
events.sctp_data_io_event = 1;
events.sctp_association_event = 1;
events.sctp_send_failure_event = 1;
events.sctp_address_event = 1;
events.sctp_peer_error_event = 1;
events.sctp_shutdown_event = 1;
if (setsockopt(sock, IPPROTO_SCTP, SCTP_EVENTS, &events, sizeof (events)) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to enable %s events: %s",
type, strerror(savederrno));
}
errno = savederrno;
return err;
}
static int _configure_sctp_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;
int level;
#ifdef SOL_SCTP
level = SOL_SCTP;
#else
level = IPPROTO_SCTP;
#endif
if (_configure_transport_socket(knet_h, sock, address, flags, type) < 0) {
savederrno = errno;
err = -1;
goto exit_error;
}
value = 1;
if (setsockopt(sock, level, SCTP_NODELAY, &value, sizeof(value)) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSPORT, "Unable to set sctp nodelay: %s",
strerror(savederrno));
goto exit_error;
}
if (_enable_sctp_notifications(knet_h, sock, type) < 0) {
savederrno = errno;
err = -1;
}
exit_error:
errno = savederrno;
return err;
}
static int _reconnect_socket(knet_handle_t knet_h, struct knet_link *kn_link)
{
int err = 0, savederrno = 0;
sctp_connect_link_info_t *info = kn_link->transport_link;
sctp_handle_info_t *handle_info = knet_h->transports[KNET_TRANSPORT_SCTP];
struct epoll_event ev;
if (connect(info->connect_sock, (struct sockaddr *)&kn_link->dst_addr, sockaddr_len(&kn_link->dst_addr)) < 0) {
if ((errno != EALREADY) && (errno != EINPROGRESS) && (errno != EISCONN)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to connect SCTP socket %d: %s",
info->connect_sock, strerror(savederrno));
goto exit_error;
}
}
if (!info->on_connected_epoll) {
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLOUT;
ev.data.fd = info->connect_sock;
if (epoll_ctl(handle_info->connect_epollfd, EPOLL_CTL_ADD, info->connect_sock, &ev)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to add send/recv to epoll pool: %s",
strerror(savederrno));
goto exit_error;
}
info->on_connected_epoll = 1;
}
exit_error:
errno = savederrno;
return err;
}
static int _create_connect_socket(knet_handle_t knet_h, struct knet_link *kn_link)
{
int err = 0, savederrno = 0;
sctp_connect_link_info_t *info = kn_link->transport_link;
sctp_handle_info_t *handle_info = knet_h->transports[KNET_TRANSPORT_SCTP];
struct epoll_event ev;
int connect_sock;
connect_sock = socket(kn_link->dst_addr.ss_family, SOCK_STREAM, IPPROTO_SCTP);
if (connect_sock < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to create send/recv socket: %s",
strerror(savederrno));
goto exit_error;
}
if (_configure_sctp_socket(knet_h, connect_sock, &kn_link->dst_addr, kn_link->flags, "SCTP connect") < 0) {
savederrno = errno;
err = -1;
goto exit_error;
}
if (_set_fd_tracker(knet_h, connect_sock, KNET_TRANSPORT_SCTP, SCTP_CONNECT_LINK_INFO, info) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to set fd tracker: %s",
strerror(savederrno));
goto exit_error;
}
info->connect_sock = connect_sock;
info->close_sock = 0;
if (_reconnect_socket(knet_h, kn_link) < 0) {
savederrno = errno;
err = -1;
goto exit_error;
}
exit_error:
if (err) {
if (info->on_connected_epoll) {
epoll_ctl(handle_info->connect_epollfd, EPOLL_CTL_DEL, connect_sock, &ev);
}
if (connect_sock >= 0) {
close(connect_sock);
}
}
errno = savederrno;
return err;
}
-static int sctp_transport_tx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno)
+int sctp_transport_tx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno)
{
sctp_connect_link_info_t *connect_info = knet_h->knet_transport_fd_tracker[sockfd].data;
sctp_accepted_link_info_t *accepted_info = knet_h->knet_transport_fd_tracker[sockfd].data;
sctp_listen_link_info_t *listen_info;
if (recv_err < 0) {
switch (knet_h->knet_transport_fd_tracker[sockfd].data_type) {
case SCTP_CONNECT_LINK_INFO:
if (connect_info->link->transport_connected == 0) {
return -1;
}
break;
case SCTP_ACCEPTED_LINK_INFO:
listen_info = accepted_info->link_info;
if (listen_info->listen_sock != sockfd) {
if (listen_info->on_rx_epoll == 0) {
return -1;
}
}
break;
}
if (recv_errno == EAGAIN) {
#ifdef DEBUG
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Sock: %d is overloaded. Slowing TX down", sockfd);
#endif
/* Don't hold onto the lock while sleeping */
pthread_rwlock_unlock(&knet_h->global_rwlock);
usleep(KNET_THREADS_TIMERES / 16);
pthread_rwlock_rdlock(&knet_h->global_rwlock);
return 1;
}
return -1;
}
return 0;
}
/*
* socket error management functions
*
* both called with global read lock.
*
* NOTE: we need to remove the fd from the epoll as soon as possible
* even before we notify the respective thread to take care of it
* because scheduling can make it so that this thread will overload
* and the threads supposed to take care of the error will never
* be able to take action.
* we CANNOT handle FDs here diretly (close/reconnect/etc) due
* to locking context. We need to delegate that to their respective
* management threads within global write lock.
*
* this function is called from:
* - RX thread with recv_err <= 0 directly on recvmmsg error
* - transport_rx_is_data when msg_len == 0 (recv_err = 1)
* - transport_rx_is_data on notification (recv_err = 2)
*
* basically this small abouse of recv_err is to detect notifications
* generated by sockets created by listen().
*/
-static int sctp_transport_rx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno)
+int sctp_transport_rx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno)
{
struct epoll_event ev;
sctp_connect_link_info_t *connect_info = knet_h->knet_transport_fd_tracker[sockfd].data;
sctp_accepted_link_info_t *accepted_info = knet_h->knet_transport_fd_tracker[sockfd].data;
sctp_listen_link_info_t *listen_info;
sctp_handle_info_t *handle_info = knet_h->transports[KNET_TRANSPORT_SCTP];
switch (knet_h->knet_transport_fd_tracker[sockfd].data_type) {
case SCTP_CONNECT_LINK_INFO:
/*
* all connect link have notifications enabled
* and we accept only data from notification and
* generic recvmmsg errors.
*
* Errors generated by msg_len 0 can be ignored because
* they follow a notification (double notification)
*/
if (recv_err != 1) {
connect_info->link->transport_connected = 0;
if (connect_info->on_rx_epoll) {
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = sockfd;
if (epoll_ctl(knet_h->recv_from_links_epollfd, EPOLL_CTL_DEL, sockfd, &ev)) {
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to remove EOFed socket from epoll pool: %s",
strerror(errno));
return -1;
}
connect_info->on_rx_epoll = 0;
}
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Notifying connect thread that sockfd %d received an error", sockfd);
if (sendto(handle_info->connectsockfd[1], &sockfd, sizeof(int), MSG_DONTWAIT | MSG_NOSIGNAL, NULL, 0) != sizeof(int)) {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to notify connect thread: %s", strerror(errno));
}
}
break;
case SCTP_ACCEPTED_LINK_INFO:
listen_info = accepted_info->link_info;
if (listen_info->listen_sock != sockfd) {
if (recv_err != 1) {
if (listen_info->on_rx_epoll) {
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = sockfd;
if (epoll_ctl(knet_h->recv_from_links_epollfd, EPOLL_CTL_DEL, sockfd, &ev)) {
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to remove EOFed socket from epoll pool: %s",
strerror(errno));
return -1;
}
listen_info->on_rx_epoll = 0;
}
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Notifying listen thread that sockfd %d received an error", sockfd);
if (sendto(handle_info->listensockfd[1], &sockfd, sizeof(int), MSG_DONTWAIT | MSG_NOSIGNAL, NULL, 0) != sizeof(int)) {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to notify listen thread: %s", strerror(errno));
}
}
} else {
/*
* this means the listen() socket has generated
* a notification. now what? :-)
*/
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Received stray notification for listen() socket %d", sockfd);
}
break;
default:
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Received unknown notification? %d", sockfd);
break;
}
/*
* Under RX pressure we need to give time to IPC to pick up the message
*/
/* Don't hold onto the lock while sleeping */
pthread_rwlock_unlock(&knet_h->global_rwlock);
usleep(KNET_THREADS_TIMERES / 2);
pthread_rwlock_rdlock(&knet_h->global_rwlock);
return 0;
}
/*
* NOTE: sctp_transport_rx_is_data is called with global rdlock
* delegate any FD error management to sctp_transport_rx_sock_error
* and keep this code to parsing incoming data only
*/
-static int sctp_transport_rx_is_data(knet_handle_t knet_h, int sockfd, struct knet_mmsghdr *msg)
+int sctp_transport_rx_is_data(knet_handle_t knet_h, int sockfd, struct knet_mmsghdr *msg)
{
size_t i;
struct iovec *iov = msg->msg_hdr.msg_iov;
size_t iovlen = msg->msg_hdr.msg_iovlen;
struct sctp_assoc_change *sac;
union sctp_notification *snp;
sctp_accepted_link_info_t *info = knet_h->knet_transport_fd_tracker[sockfd].data;
if (!(msg->msg_hdr.msg_flags & MSG_NOTIFICATION)) {
if (msg->msg_len == 0) {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "received 0 bytes len packet: %d", sockfd);
/*
* NOTE: with event notification enabled, we receive error twice:
* 1) from the event notification
* 2) followed by a 0 byte msg_len
*
* This is generally not a problem if not for causing extra
* handling for the same issue. Should we drop notifications
* and keep the code generic (handle all errors via msg_len = 0)
* or keep the duplication as safety measure, or drop msg_len = 0
* handling (what about sockets without events enabled?)
*/
sctp_transport_rx_sock_error(knet_h, sockfd, 1, 0);
return 1;
}
/*
* missing MSG_EOR has to be treated as a short read
* from the socket and we need to fill in the mread buf
* while we wait for MSG_EOR
*/
if (!(msg->msg_hdr.msg_flags & MSG_EOR)) {
/*
* copy the incoming data into mread_buf + mread_len (incremental)
* and increase mread_len
*/
memmove(info->mread_buf + info->mread_len, iov->iov_base, msg->msg_len);
info->mread_len = info->mread_len + msg->msg_len;
return 0;
}
/*
* got EOR.
* if mread_len is > 0 we are completing a packet from short reads
* complete reassembling the packet in mread_buf, copy it back in the iov
* and set the iov/msg len numbers (size) correctly
*/
if (info->mread_len) {
/*
* add last fragment to mread_buf
*/
memmove(info->mread_buf + info->mread_len, iov->iov_base, msg->msg_len);
info->mread_len = info->mread_len + msg->msg_len;
/*
* move all back into the iovec
*/
memmove(iov->iov_base, info->mread_buf, info->mread_len);
msg->msg_len = info->mread_len;
info->mread_len = 0;
}
return 2;
}
if (!(msg->msg_hdr.msg_flags & MSG_EOR)) {
return 1;
}
for (i=0; i< iovlen; i++) {
snp = iov[i].iov_base;
switch (snp->sn_header.sn_type) {
case SCTP_ASSOC_CHANGE:
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "[event] sctp assoc change");
sac = &snp->sn_assoc_change;
if (sac->sac_state == SCTP_COMM_LOST) {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "[event] sctp assoc change: comm_lost");
sctp_transport_rx_sock_error(knet_h, sockfd, 2, 0);
}
break;
case SCTP_SHUTDOWN_EVENT:
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "[event] sctp shutdown event");
sctp_transport_rx_sock_error(knet_h, sockfd, 2, 0);
break;
case SCTP_SEND_FAILED:
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "[event] sctp send failed");
break;
case SCTP_PEER_ADDR_CHANGE:
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "[event] sctp peer addr change");
break;
case SCTP_REMOTE_ERROR:
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "[event] sctp remote error");
break;
default:
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "[event] unknown sctp event type: %hu\n", snp->sn_header.sn_type);
break;
}
}
return 0;
}
/*
* connect / outgoing socket management thread
*/
/*
* _handle_connected_sctp* are called with a global write lock
* from the connect_thread
*/
static void _handle_connected_sctp(knet_handle_t knet_h, int connect_sock)
{
int err;
struct epoll_event ev;
unsigned int status, len = sizeof(status);
sctp_handle_info_t *handle_info = knet_h->transports[KNET_TRANSPORT_SCTP];
sctp_connect_link_info_t *info = knet_h->knet_transport_fd_tracker[connect_sock].data;
struct knet_link *kn_link = info->link;
err = getsockopt(connect_sock, SOL_SOCKET, SO_ERROR, &status, &len);
if (err) {
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "SCTP getsockopt() on connecting socket %d failed: %s",
connect_sock, strerror(errno));
return;
}
if (info->close_sock) {
if (_close_connect_socket(knet_h, kn_link) < 0) {
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to close sock %d from _handle_connected_sctp: %s", connect_sock, strerror(errno));
return;
}
info->close_sock = 0;
if (_create_connect_socket(knet_h, kn_link) < 0) {
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to recreate connecting sock! %s", strerror(errno));
return;
}
}
if (status) {
log_info(knet_h, KNET_SUB_TRANSP_SCTP, "SCTP connect on %d to %s port %s failed: %s",
connect_sock, kn_link->status.dst_ipaddr, kn_link->status.dst_port,
strerror(status));
/*
* No need to create a new socket if connect failed,
* just retry connect
*/
_reconnect_socket(knet_h, info->link);
return;
}
/*
* Connected - Remove us from the connect epoll
*/
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLOUT;
ev.data.fd = connect_sock;
if (epoll_ctl(handle_info->connect_epollfd, EPOLL_CTL_DEL, connect_sock, &ev)) {
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to remove connected socket %d from epoll pool: %s",
connect_sock, strerror(errno));
}
info->on_connected_epoll = 0;
kn_link->transport_connected = 1;
kn_link->outsock = info->connect_sock;
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = connect_sock;
if (epoll_ctl(knet_h->recv_from_links_epollfd, EPOLL_CTL_ADD, connect_sock, &ev)) {
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to add connected socket to epoll pool: %s",
strerror(errno));
}
info->on_rx_epoll = 1;
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "SCTP handler fd %d now connected to %s port %s",
connect_sock,
kn_link->status.dst_ipaddr, kn_link->status.dst_port);
}
static void _handle_connected_sctp_errors(knet_handle_t knet_h)
{
int sockfd = -1;
sctp_handle_info_t *handle_info = knet_h->transports[KNET_TRANSPORT_SCTP];
sctp_connect_link_info_t *info;
if (recv(handle_info->connectsockfd[0], &sockfd, sizeof(int), MSG_DONTWAIT | MSG_NOSIGNAL) != sizeof(int)) {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Short read on connectsockfd");
return;
}
if (_is_valid_fd(knet_h, sockfd) < 1) {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Received stray notification for connected socket fd error");
return;
}
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Processing connected error on socket: %d", sockfd);
info = knet_h->knet_transport_fd_tracker[sockfd].data;
info->close_sock = 1;
info->link->transport_connected = 0;
_reconnect_socket(knet_h, info->link);
}
static void *_sctp_connect_thread(void *data)
{
int savederrno;
int i, nev;
knet_handle_t knet_h = (knet_handle_t) data;
sctp_handle_info_t *handle_info = knet_h->transports[KNET_TRANSPORT_SCTP];
struct epoll_event events[KNET_EPOLL_MAX_EVENTS];
while (!shutdown_in_progress(knet_h)) {
nev = epoll_wait(handle_info->connect_epollfd, events, KNET_EPOLL_MAX_EVENTS, -1);
if (nev < 0) {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "SCTP connect handler EPOLL ERROR: %s",
strerror(errno));
continue;
}
/*
* Sort out which FD has a connection
*/
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to get write lock: %s",
strerror(savederrno));
continue;
}
/*
* minor optimization: deduplicate events
*
* in some cases we can receive multiple notifcations
* of the same FD having issues or need handling.
* It's enough to process it once even tho it's safe
* to handle them multiple times.
*/
for (i = 0; i < nev; i++) {
if (events[i].data.fd == handle_info->connectsockfd[0]) {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Received notification from rx_error for connected socket");
_handle_connected_sctp_errors(knet_h);
} else {
if (_is_valid_fd(knet_h, events[i].data.fd) == 1) {
_handle_connected_sctp(knet_h, events[i].data.fd);
} else {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Received stray notification for dead fd %d\n", events[i].data.fd);
}
}
}
pthread_rwlock_unlock(&knet_h->global_rwlock);
/*
* this thread can generate events for itself.
* we need to sleep in between loops to allow other threads
* to be scheduled
*/
usleep(knet_h->reconnect_int * 1000);
}
return NULL;
}
/*
* listen/incoming connections management thread
*/
/*
* Listener received a new connection
* called with a write lock from main thread
*/
static void _handle_incoming_sctp(knet_handle_t knet_h, int listen_sock)
{
int err = 0, savederrno = 0;
int new_fd;
int i = -1;
sctp_listen_link_info_t *info = knet_h->knet_transport_fd_tracker[listen_sock].data;
struct epoll_event ev;
struct sockaddr_storage ss;
socklen_t sock_len = sizeof(ss);
char addr_str[KNET_MAX_HOST_LEN];
char port_str[KNET_MAX_PORT_LEN];
sctp_accepted_link_info_t *accept_info = NULL;
new_fd = accept(listen_sock, (struct sockaddr *)&ss, &sock_len);
if (new_fd < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Incoming: accept error: %s", strerror(errno));
goto exit_error;
}
if (knet_addrtostr(&ss, sizeof(ss),
addr_str, KNET_MAX_HOST_LEN,
port_str, KNET_MAX_PORT_LEN) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Incoming: unable to gather socket info");
goto exit_error;
}
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Incoming: received connection from: %s port: %s",
addr_str, port_str);
/*
* Keep a track of all accepted FDs
*/
for (i=0; i<MAX_ACCEPTED_SOCKS; i++) {
if (info->accepted_socks[i] == -1) {
info->accepted_socks[i] = new_fd;
break;
}
}
if (i == MAX_ACCEPTED_SOCKS) {
errno = EBUSY;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Incoming: too many connections!");
goto exit_error;
}
if (_configure_common_socket(knet_h, new_fd, 0, "SCTP incoming") < 0) { /* Inherit flags from listener? */
savederrno = errno;
err = -1;
goto exit_error;
}
if (_enable_sctp_notifications(knet_h, new_fd, "Incoming connection") < 0) {
savederrno = errno;
err = -1;
goto exit_error;
}
accept_info = malloc(sizeof(sctp_accepted_link_info_t));
if (!accept_info) {
savederrno = errno;
err = -1;
goto exit_error;
}
memset(accept_info, 0, sizeof(sctp_accepted_link_info_t));
accept_info->link_info = info;
if (_set_fd_tracker(knet_h, new_fd, KNET_TRANSPORT_SCTP, SCTP_ACCEPTED_LINK_INFO, accept_info) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to set fd tracker: %s",
strerror(errno));
goto exit_error;
}
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = new_fd;
if (epoll_ctl(knet_h->recv_from_links_epollfd, EPOLL_CTL_ADD, new_fd, &ev)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Incoming: unable to add accepted socket %d to epoll pool: %s",
new_fd, strerror(errno));
goto exit_error;
}
info->on_rx_epoll = 1;
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Incoming: accepted new fd %d for %s/%s (listen fd: %d). index: %d",
new_fd, addr_str, port_str, info->listen_sock, i);
exit_error:
if (err) {
if ((i >= 0) || (i < MAX_ACCEPTED_SOCKS)) {
info->accepted_socks[i] = -1;
}
_set_fd_tracker(knet_h, new_fd, KNET_MAX_TRANSPORTS, SCTP_NO_LINK_INFO, NULL);
free(accept_info);
close(new_fd);
}
errno = savederrno;
return;
}
/*
* Listen thread received a notification of a bad socket that needs closing
* called with a write lock from main thread
*/
static void _handle_listen_sctp_errors(knet_handle_t knet_h)
{
int sockfd = -1;
sctp_handle_info_t *handle_info = knet_h->transports[KNET_TRANSPORT_SCTP];
sctp_accepted_link_info_t *accept_info;
sctp_listen_link_info_t *info;
struct knet_host *host;
int link_idx;
int i;
if (recv(handle_info->listensockfd[0], &sockfd, sizeof(int), MSG_DONTWAIT | MSG_NOSIGNAL) != sizeof(int)) {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Short read on listensockfd");
return;
}
if (_is_valid_fd(knet_h, sockfd) < 1) {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Received stray notification for listen socket fd error");
return;
}
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Processing listen error on socket: %d", sockfd);
accept_info = knet_h->knet_transport_fd_tracker[sockfd].data;
info = accept_info->link_info;
/*
* clear all links using this accepted socket as
* outbound dynamically connected socket
*/
for (host = knet_h->host_head; host != NULL; host = host->next) {
for (link_idx = 0; link_idx < KNET_MAX_LINK; link_idx++) {
if ((host->link[link_idx].dynamic == KNET_LINK_DYNIP) &&
(host->link[link_idx].outsock == sockfd)) {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Found dynamic connection on host %d link %d (%d)",
host->host_id, link_idx, sockfd);
host->link[link_idx].status.dynconnected = 0;
host->link[link_idx].transport_connected = 0;
host->link[link_idx].outsock = 0;
memset(&host->link[link_idx].dst_addr, 0, sizeof(struct sockaddr_storage));
}
}
}
for (i=0; i<MAX_ACCEPTED_SOCKS; i++) {
if (sockfd == info->accepted_socks[i]) {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Closing accepted socket %d", sockfd);
_set_fd_tracker(knet_h, sockfd, KNET_MAX_TRANSPORTS, SCTP_NO_LINK_INFO, NULL);
info->accepted_socks[i] = -1;
free(accept_info);
close(sockfd);
}
}
}
static void *_sctp_listen_thread(void *data)
{
int savederrno;
int i, nev;
knet_handle_t knet_h = (knet_handle_t) data;
sctp_handle_info_t *handle_info = knet_h->transports[KNET_TRANSPORT_SCTP];
struct epoll_event events[KNET_EPOLL_MAX_EVENTS];
while (!shutdown_in_progress(knet_h)) {
nev = epoll_wait(handle_info->listen_epollfd, events, KNET_EPOLL_MAX_EVENTS, -1);
if (nev < 0) {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "SCTP listen handler EPOLL ERROR: %s",
strerror(errno));
continue;
}
savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
if (savederrno) {
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to get write lock: %s",
strerror(savederrno));
continue;
}
/*
* Sort out which FD has an incoming connection
*/
for (i = 0; i < nev; i++) {
if (events[i].data.fd == handle_info->listensockfd[0]) {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Received notification from rx_error for listener/accepted socket");
_handle_listen_sctp_errors(knet_h);
} else {
if (_is_valid_fd(knet_h, events[i].data.fd) == 1) {
_handle_incoming_sctp(knet_h, events[i].data.fd);
} else {
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Received listen notification from invalid socket");
}
}
}
pthread_rwlock_unlock(&knet_h->global_rwlock);
}
return NULL;
}
/*
* sctp_link_listener_start/stop are called in global write lock
* context from set_config and clear_config.
*/
static sctp_listen_link_info_t *sctp_link_listener_start(knet_handle_t knet_h, struct knet_link *kn_link)
{
int err = 0, savederrno = 0;
int listen_sock = -1;
struct epoll_event ev;
sctp_listen_link_info_t *info = NULL;
sctp_handle_info_t *handle_info = knet_h->transports[KNET_TRANSPORT_SCTP];
/*
* Only allocate a new listener if src address is different
*/
knet_list_for_each_entry(info, &handle_info->listen_links_list, list) {
if (memcmp(&info->src_address, &kn_link->src_addr, sizeof(struct sockaddr_storage)) == 0) {
return info;
}
}
info = malloc(sizeof(sctp_listen_link_info_t));
if (!info) {
err = -1;
goto exit_error;
}
memset(info, 0, sizeof(sctp_listen_link_info_t));
memset(info->accepted_socks, -1, sizeof(info->accepted_socks));
memmove(&info->src_address, &kn_link->src_addr, sizeof(struct sockaddr_storage));
listen_sock = socket(kn_link->src_addr.ss_family, SOCK_STREAM, IPPROTO_SCTP);
if (listen_sock < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to create listener socket: %s",
strerror(savederrno));
goto exit_error;
}
if (_configure_sctp_socket(knet_h, listen_sock, &kn_link->src_addr, kn_link->flags, "SCTP listener") < 0) {
savederrno = errno;
err = -1;
goto exit_error;
}
if (bind(listen_sock, (struct sockaddr *)&kn_link->src_addr, sockaddr_len(&kn_link->src_addr)) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to bind listener socket: %s",
strerror(savederrno));
goto exit_error;
}
if (listen(listen_sock, 5) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to listen on listener socket: %s",
strerror(savederrno));
goto exit_error;
}
if (_set_fd_tracker(knet_h, listen_sock, KNET_TRANSPORT_SCTP, SCTP_LISTENER_LINK_INFO, info) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to set fd tracker: %s",
strerror(savederrno));
goto exit_error;
}
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = listen_sock;
if (epoll_ctl(handle_info->listen_epollfd, EPOLL_CTL_ADD, listen_sock, &ev)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to add listener to epoll pool: %s",
strerror(savederrno));
goto exit_error;
}
info->on_listener_epoll = 1;
info->listen_sock = listen_sock;
knet_list_add(&info->list, &handle_info->listen_links_list);
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "Listening on fd %d for %s:%s", listen_sock, kn_link->status.src_ipaddr, kn_link->status.src_port);
exit_error:
if (err) {
if (info->on_listener_epoll) {
epoll_ctl(handle_info->listen_epollfd, EPOLL_CTL_DEL, listen_sock, &ev);
}
if (listen_sock >= 0) {
close(listen_sock);
}
if (info) {
free(info);
info = NULL;
}
}
errno = savederrno;
return info;
}
static int sctp_link_listener_stop(knet_handle_t knet_h, struct knet_link *kn_link)
{
int err = 0, savederrno = 0;
int found = 0, i;
struct knet_host *host;
int link_idx;
sctp_handle_info_t *handle_info = knet_h->transports[KNET_TRANSPORT_SCTP];
sctp_connect_link_info_t *this_link_info = kn_link->transport_link;
sctp_listen_link_info_t *info = this_link_info->listener;
sctp_connect_link_info_t *link_info;
struct epoll_event ev;
for (host = knet_h->host_head; host != NULL; host = host->next) {
for (link_idx = 0; link_idx < KNET_MAX_LINK; link_idx++) {
if (&host->link[link_idx] == kn_link)
continue;
link_info = host->link[link_idx].transport_link;
if ((link_info) &&
(link_info->listener == info) &&
(host->link[link_idx].status.enabled == 1)) {
found = 1;
break;
}
}
}
if (found) {
this_link_info->listener = NULL;
log_debug(knet_h, KNET_SUB_TRANSP_SCTP, "SCTP listener socket %d still in use", info->listen_sock);
savederrno = EBUSY;
err = -1;
goto exit_error;
}
if (info->on_listener_epoll) {
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = info->listen_sock;
if (epoll_ctl(handle_info->listen_epollfd, EPOLL_CTL_DEL, info->listen_sock, &ev)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to remove listener to epoll pool: %s",
strerror(savederrno));
goto exit_error;
}
info->on_listener_epoll = 0;
}
if (_set_fd_tracker(knet_h, info->listen_sock, KNET_MAX_TRANSPORTS, SCTP_NO_LINK_INFO, NULL) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to set fd tracker: %s",
strerror(savederrno));
goto exit_error;
}
close(info->listen_sock);
for (i=0; i< MAX_ACCEPTED_SOCKS; i++) {
if (info->accepted_socks[i] > -1) {
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = info->accepted_socks[i];
if (epoll_ctl(knet_h->recv_from_links_epollfd, EPOLL_CTL_DEL, info->accepted_socks[i], &ev)) {
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to remove EOFed socket from epoll pool: %s",
strerror(errno));
}
info->on_rx_epoll = 0;
free(knet_h->knet_transport_fd_tracker[info->accepted_socks[i]].data);
close(info->accepted_socks[i]);
if (_set_fd_tracker(knet_h, info->accepted_socks[i], KNET_MAX_TRANSPORTS, SCTP_NO_LINK_INFO, NULL) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to set fd tracker: %s",
strerror(savederrno));
goto exit_error;
}
info->accepted_socks[i] = -1;
}
}
knet_list_del(&info->list);
free(info);
this_link_info->listener = NULL;
exit_error:
errno = savederrno;
return err;
}
/*
* Links config/clear. Both called with global wrlock from link_set_config/clear_config
*/
-static int sctp_transport_link_set_config(knet_handle_t knet_h, struct knet_link *kn_link)
+int sctp_transport_link_set_config(knet_handle_t knet_h, struct knet_link *kn_link)
{
int savederrno = 0, err = 0;
sctp_connect_link_info_t *info;
sctp_handle_info_t *handle_info = knet_h->transports[KNET_TRANSPORT_SCTP];
info = malloc(sizeof(sctp_connect_link_info_t));
if (!info) {
goto exit_error;
}
memset(info, 0, sizeof(sctp_connect_link_info_t));
kn_link->transport_link = info;
info->link = kn_link;
memmove(&info->dst_address, &kn_link->dst_addr, sizeof(struct sockaddr_storage));
info->on_connected_epoll = 0;
info->connect_sock = -1;
info->listener = sctp_link_listener_start(knet_h, kn_link);
if (!info->listener) {
savederrno = errno;
err = -1;
goto exit_error;
}
if (kn_link->dynamic == KNET_LINK_STATIC) {
if (_create_connect_socket(knet_h, kn_link) < 0) {
savederrno = errno;
err = -1;
goto exit_error;
}
kn_link->outsock = info->connect_sock;
}
knet_list_add(&info->list, &handle_info->connect_links_list);
exit_error:
if (err) {
if (info) {
if (info->connect_sock) {
close(info->connect_sock);
}
if (info->listener) {
sctp_link_listener_stop(knet_h, kn_link);
}
kn_link->transport_link = NULL;
free(info);
}
}
errno = savederrno;
return err;
}
/*
* called with global wrlock
*/
-static int sctp_transport_link_clear_config(knet_handle_t knet_h, struct knet_link *kn_link)
+int sctp_transport_link_clear_config(knet_handle_t knet_h, struct knet_link *kn_link)
{
int err = 0, savederrno = 0;
sctp_connect_link_info_t *info;
struct epoll_event ev;
if (!kn_link) {
errno = EINVAL;
return -1;
}
info = kn_link->transport_link;
if (!info) {
errno = EINVAL;
return -1;
}
if ((sctp_link_listener_stop(knet_h, kn_link) <0) && (errno != EBUSY)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to remove listener trasport: %s",
strerror(savederrno));
goto exit_error;
}
if (info->on_rx_epoll) {
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = info->connect_sock;
if (epoll_ctl(knet_h->recv_from_links_epollfd, EPOLL_CTL_DEL, info->connect_sock, &ev)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to remove connected socket from epoll pool: %s",
strerror(savederrno));
goto exit_error;
}
info->on_rx_epoll = 0;
}
if (_close_connect_socket(knet_h, kn_link) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to close connected socket: %s",
strerror(savederrno));
goto exit_error;
}
knet_list_del(&info->list);
free(info);
kn_link->transport_link = NULL;
exit_error:
errno = savederrno;
return err;
}
/*
* transport_free and transport_init are
* called only from knet_handle_new and knet_handle_free.
* all resources (hosts/links) should have been already freed at this point
* and they are called in a write locked context, hence they
* don't need their own locking.
*/
-static int sctp_transport_free(knet_handle_t knet_h)
+int sctp_transport_free(knet_handle_t knet_h)
{
sctp_handle_info_t *handle_info;
void *thread_status;
struct epoll_event ev;
if (!knet_h->transports[KNET_TRANSPORT_SCTP]) {
errno = EINVAL;
return -1;
}
handle_info = knet_h->transports[KNET_TRANSPORT_SCTP];
/*
* keep it here while we debug list usage and such
*/
if (!knet_list_empty(&handle_info->listen_links_list)) {
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Internal error. listen links list is not empty");
}
if (!knet_list_empty(&handle_info->connect_links_list)) {
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Internal error. connect links list is not empty");
}
if (handle_info->listen_thread) {
pthread_cancel(handle_info->listen_thread);
pthread_join(handle_info->listen_thread, &thread_status);
}
if (handle_info->connect_thread) {
pthread_cancel(handle_info->connect_thread);
pthread_join(handle_info->connect_thread, &thread_status);
}
if (handle_info->listensockfd[0] >= 0) {
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = handle_info->listensockfd[0];
epoll_ctl(handle_info->listen_epollfd, EPOLL_CTL_DEL, handle_info->listensockfd[0], &ev);
}
if (handle_info->connectsockfd[0] >= 0) {
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = handle_info->connectsockfd[0];
epoll_ctl(handle_info->connect_epollfd, EPOLL_CTL_DEL, handle_info->connectsockfd[0], &ev);
}
_close_socketpair(knet_h, handle_info->connectsockfd);
_close_socketpair(knet_h, handle_info->listensockfd);
if (handle_info->listen_epollfd >= 0) {
close(handle_info->listen_epollfd);
}
if (handle_info->connect_epollfd >= 0) {
close(handle_info->connect_epollfd);
}
free(handle_info);
knet_h->transports[KNET_TRANSPORT_SCTP] = NULL;
return 0;
}
-static int sctp_transport_init(knet_handle_t knet_h)
+int sctp_transport_init(knet_handle_t knet_h)
{
int err = 0, savederrno = 0;
sctp_handle_info_t *handle_info;
struct epoll_event ev;
if (knet_h->transports[KNET_TRANSPORT_SCTP]) {
errno = EEXIST;
return -1;
}
handle_info = malloc(sizeof(sctp_handle_info_t));
if (!handle_info) {
return -1;
}
memset(handle_info, 0,sizeof(sctp_handle_info_t));
knet_h->transports[KNET_TRANSPORT_SCTP] = handle_info;
knet_list_init(&handle_info->listen_links_list);
knet_list_init(&handle_info->connect_links_list);
handle_info->listen_epollfd = epoll_create(KNET_EPOLL_MAX_EVENTS + 1);
if (handle_info->listen_epollfd < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to create epoll listen fd: %s",
strerror(savederrno));
goto exit_fail;
}
if (_fdset_cloexec(handle_info->listen_epollfd)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to set CLOEXEC on listen_epollfd: %s",
strerror(savederrno));
goto exit_fail;
}
handle_info->connect_epollfd = epoll_create(KNET_EPOLL_MAX_EVENTS + 1);
if (handle_info->connect_epollfd < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to create epoll connect fd: %s",
strerror(savederrno));
goto exit_fail;
}
if (_fdset_cloexec(handle_info->connect_epollfd)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to set CLOEXEC on connect_epollfd: %s",
strerror(savederrno));
goto exit_fail;
}
if (_init_socketpair(knet_h, handle_info->connectsockfd) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to init connect socketpair: %s",
strerror(savederrno));
goto exit_fail;
}
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = handle_info->connectsockfd[0];
if (epoll_ctl(handle_info->connect_epollfd, EPOLL_CTL_ADD, handle_info->connectsockfd[0], &ev)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to add connectsockfd[0] to connect epoll pool: %s",
strerror(savederrno));
goto exit_fail;
}
if (_init_socketpair(knet_h, handle_info->listensockfd) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to init listen socketpair: %s",
strerror(savederrno));
goto exit_fail;
}
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = handle_info->listensockfd[0];
if (epoll_ctl(handle_info->listen_epollfd, EPOLL_CTL_ADD, handle_info->listensockfd[0], &ev)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to add listensockfd[0] to listen epoll pool: %s",
strerror(savederrno));
goto exit_fail;
}
/*
* Start connect & listener threads
*/
savederrno = pthread_create(&handle_info->listen_thread, 0, _sctp_listen_thread, (void *) knet_h);
if (savederrno) {
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to start sctp listen thread: %s",
strerror(savederrno));
goto exit_fail;
}
savederrno = pthread_create(&handle_info->connect_thread, 0, _sctp_connect_thread, (void *) knet_h);
if (savederrno) {
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_SCTP, "Unable to start sctp connect thread: %s",
strerror(savederrno));
goto exit_fail;
}
exit_fail:
if (err < 0) {
sctp_transport_free(knet_h);
}
errno = savederrno;
return err;
}
-static int sctp_transport_link_dyn_connect(knet_handle_t knet_h, int sockfd, struct knet_link *kn_link)
+int sctp_transport_link_dyn_connect(knet_handle_t knet_h, int sockfd, struct knet_link *kn_link)
{
kn_link->outsock = sockfd;
kn_link->status.dynconnected = 1;
kn_link->transport_connected = 1;
return 0;
}
-
-static knet_transport_ops_t sctp_transport_ops = {
- .transport_name = "SCTP",
- .transport_id = KNET_TRANSPORT_SCTP,
- .transport_mtu_overhead = KNET_PMTUD_SCTP_OVERHEAD,
- .transport_init = sctp_transport_init,
- .transport_free = sctp_transport_free,
- .transport_link_set_config = sctp_transport_link_set_config,
- .transport_link_clear_config = sctp_transport_link_clear_config,
- .transport_link_dyn_connect = sctp_transport_link_dyn_connect,
- .transport_rx_sock_error = sctp_transport_rx_sock_error,
- .transport_tx_sock_error = sctp_transport_tx_sock_error,
- .transport_rx_is_data = sctp_transport_rx_is_data,
-};
-
-knet_transport_ops_t *get_sctp_transport()
-{
-
- return &sctp_transport_ops;
-}
-#else // HAVE_NETINET_SCTP_H
-knet_transport_ops_t *get_sctp_transport()
-{
- return NULL;
-}
#endif
diff --git a/libknet/transport_sctp.h b/libknet/transport_sctp.h
new file mode 100644
index 00000000..efc04774
--- /dev/null
+++ b/libknet/transport_sctp.h
@@ -0,0 +1,37 @@
+/*
+ * 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 "internals.h"
+
+#ifndef __KNET_TRANSPORT_SCTP_H__
+#define __KNET_TRANSPORT_SCTP_H__
+
+/*
+ * https://en.wikipedia.org/wiki/SCTP_packet_structure
+ */
+
+#define KNET_PMTUD_SCTP_OVERHEAD_COMMON 12
+#define KNET_PMTUD_SCTP_OVERHEAD_DATA_CHUNK 16
+#define KNET_PMTUD_SCTP_OVERHEAD KNET_PMTUD_SCTP_OVERHEAD_COMMON + KNET_PMTUD_SCTP_OVERHEAD_DATA_CHUNK
+
+#ifdef HAVE_NETINET_SCTP_H
+
+int sctp_transport_link_set_config(knet_handle_t knet_h, struct knet_link *kn_link);
+int sctp_transport_link_clear_config(knet_handle_t knet_h, struct knet_link *kn_link);
+int sctp_transport_free(knet_handle_t knet_h);
+int sctp_transport_init(knet_handle_t knet_h);
+int sctp_transport_rx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno);
+int sctp_transport_tx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno);
+int sctp_transport_rx_is_data(knet_handle_t knet_h, int sockfd, struct knet_mmsghdr *msg);
+int sctp_transport_link_dyn_connect(knet_handle_t knet_h, int sockfd, struct knet_link *kn_link);
+
+#endif
+
+#endif
diff --git a/libknet/transport_udp.c b/libknet/transport_udp.c
index d5dd7058..2ad0392c 100644
--- a/libknet/transport_udp.c
+++ b/libknet/transport_udp.c
@@ -1,416 +1,396 @@
/*
* Copyright (C) 2016-2017 Red Hat, Inc. All rights reserved.
*
* Author: Christine Caulfield <ccaulfie@redhat.com>
*
* This software licensed under GPL-2.0+, LGPL-2.0+
*/
#include "config.h"
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#if defined (IP_RECVERR) || defined (IPV6_RECVERR)
#include <linux/errqueue.h>
#endif
#include "libknet.h"
#include "compat.h"
#include "host.h"
#include "link.h"
#include "logging.h"
#include "common.h"
-#include "transports.h"
+#include "transport_common.h"
+#include "transport_udp.h"
#include "threads_common.h"
-#define KNET_PMTUD_UDP_OVERHEAD 8
-
typedef struct udp_handle_info {
struct knet_list_head links_list;
} udp_handle_info_t;
typedef struct udp_link_info {
struct knet_list_head list;
struct sockaddr_storage local_address;
int socket_fd;
int on_epoll;
} udp_link_info_t;
-static int udp_transport_link_set_config(knet_handle_t knet_h, struct knet_link *kn_link)
+int udp_transport_link_set_config(knet_handle_t knet_h, struct knet_link *kn_link)
{
int err = 0, savederrno = 0;
int sock = -1;
struct epoll_event ev;
udp_link_info_t *info;
udp_handle_info_t *handle_info = knet_h->transports[KNET_TRANSPORT_UDP];
#if defined (IP_RECVERR) || defined (IPV6_RECVERR)
int value;
#endif
/*
* Only allocate a new link if the local address is different
*/
knet_list_for_each_entry(info, &handle_info->links_list, list) {
if (memcmp(&info->local_address, &kn_link->src_addr, sizeof(struct sockaddr_storage)) == 0) {
log_debug(knet_h, KNET_SUB_TRANSP_UDP, "Re-using existing UDP socket for new link");
kn_link->outsock = info->socket_fd;
kn_link->transport_link = info;
kn_link->transport_connected = 1;
return 0;
}
}
info = malloc(sizeof(udp_link_info_t));
if (!info) {
err = -1;
goto exit_error;
}
sock = socket(kn_link->src_addr.ss_family, SOCK_DGRAM, 0);
if (sock < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_LISTENER, "Unable to create listener socket: %s",
strerror(savederrno));
goto exit_error;
}
if (_configure_transport_socket(knet_h, sock, &kn_link->src_addr, kn_link->flags, "UDP") < 0) {
savederrno = errno;
err = -1;
goto exit_error;
}
#ifdef IP_RECVERR
if (kn_link->src_addr.ss_family == AF_INET) {
value = 1;
if (setsockopt(sock, SOL_IP, IP_RECVERR, &value, sizeof(value)) <0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_UDP, "Unable to set RECVERR on socket: %s",
strerror(savederrno));
goto exit_error;
}
}
#endif
#ifdef IPV6_RECVERR
if (kn_link->src_addr.ss_family == AF_INET6) {
value = 1;
if (setsockopt(sock, SOL_IPV6, IPV6_RECVERR, &value, sizeof(value)) <0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_UDP, "Unable to set RECVERR on socket: %s",
strerror(savederrno));
goto exit_error;
}
}
#endif
if (bind(sock, (struct sockaddr *)&kn_link->src_addr, sockaddr_len(&kn_link->src_addr))) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_UDP, "Unable to bind listener socket: %s",
strerror(savederrno));
goto exit_error;
}
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = sock;
if (epoll_ctl(knet_h->recv_from_links_epollfd, EPOLL_CTL_ADD, sock, &ev)) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_UDP, "Unable to add listener to epoll pool: %s",
strerror(savederrno));
goto exit_error;
}
info->on_epoll = 1;
if (_set_fd_tracker(knet_h, sock, KNET_TRANSPORT_UDP, 0, info) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_UDP, "Unable to set fd tracker: %s",
strerror(savederrno));
goto exit_error;
}
memmove(&info->local_address, &kn_link->src_addr, sizeof(struct sockaddr_storage));
info->socket_fd = sock;
knet_list_add(&info->list, &handle_info->links_list);
kn_link->outsock = sock;
kn_link->transport_link = info;
kn_link->transport_connected = 1;
exit_error:
if (err) {
if (info) {
if (info->on_epoll) {
epoll_ctl(knet_h->recv_from_links_epollfd, EPOLL_CTL_DEL, sock, &ev);
}
free(info);
}
if (sock >= 0) {
close(sock);
}
}
errno = savederrno;
return err;
}
-static int udp_transport_link_clear_config(knet_handle_t knet_h, struct knet_link *kn_link)
+int udp_transport_link_clear_config(knet_handle_t knet_h, struct knet_link *kn_link)
{
int err = 0, savederrno = 0;
int found = 0;
struct knet_host *host;
int link_idx;
udp_link_info_t *info = kn_link->transport_link;
struct epoll_event ev;
for (host = knet_h->host_head; host != NULL; host = host->next) {
for (link_idx = 0; link_idx < KNET_MAX_LINK; link_idx++) {
if (&host->link[link_idx] == kn_link)
continue;
if ((host->link[link_idx].transport_link == info) &&
(host->link[link_idx].status.enabled == 1)) {
found = 1;
break;
}
}
}
if (found) {
log_debug(knet_h, KNET_SUB_TRANSP_UDP, "UDP socket %d still in use", info->socket_fd);
savederrno = EBUSY;
err = -1;
goto exit_error;
}
if (info->on_epoll) {
memset(&ev, 0, sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = info->socket_fd;
if (epoll_ctl(knet_h->recv_from_links_epollfd, EPOLL_CTL_DEL, info->socket_fd, &ev) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_UDP, "Unable to remove UDP socket from epoll poll: %s",
strerror(errno));
goto exit_error;
}
info->on_epoll = 0;
}
if (_set_fd_tracker(knet_h, info->socket_fd, KNET_MAX_TRANSPORTS, 0, NULL) < 0) {
savederrno = errno;
err = -1;
log_err(knet_h, KNET_SUB_TRANSP_UDP, "Unable to set fd tracker: %s",
strerror(savederrno));
goto exit_error;
}
close(info->socket_fd);
knet_list_del(&info->list);
free(kn_link->transport_link);
exit_error:
errno = savederrno;
return err;
}
-static int udp_transport_free(knet_handle_t knet_h)
+int udp_transport_free(knet_handle_t knet_h)
{
udp_handle_info_t *handle_info;
if (!knet_h->transports[KNET_TRANSPORT_UDP]) {
errno = EINVAL;
return -1;
}
handle_info = knet_h->transports[KNET_TRANSPORT_UDP];
/*
* keep it here while we debug list usage and such
*/
if (!knet_list_empty(&handle_info->links_list)) {
log_err(knet_h, KNET_SUB_TRANSP_UDP, "Internal error. handle list is not empty");
return -1;
}
free(handle_info);
knet_h->transports[KNET_TRANSPORT_UDP] = NULL;
return 0;
}
-static int udp_transport_init(knet_handle_t knet_h)
+int udp_transport_init(knet_handle_t knet_h)
{
udp_handle_info_t *handle_info;
if (knet_h->transports[KNET_TRANSPORT_UDP]) {
errno = EEXIST;
return -1;
}
handle_info = malloc(sizeof(udp_handle_info_t));
if (!handle_info) {
return -1;
}
memset(handle_info, 0, sizeof(udp_handle_info_t));
knet_h->transports[KNET_TRANSPORT_UDP] = handle_info;
knet_list_init(&handle_info->links_list);
return 0;
}
#if defined (IP_RECVERR) || defined (IPV6_RECVERR)
static int read_errs_from_sock(knet_handle_t knet_h, int sockfd)
{
int err = 0, savederrno = 0;
int got_err = 0;
char buffer[1024];
struct iovec iov;
struct msghdr msg;
struct cmsghdr *cmsg;
struct sock_extended_err *sock_err;
struct icmphdr icmph;
struct sockaddr_storage remote;
struct sockaddr_storage *origin;
char addr_str[KNET_MAX_HOST_LEN];
char port_str[KNET_MAX_PORT_LEN];
iov.iov_base = &icmph;
iov.iov_len = sizeof(icmph);
msg.msg_name = (void*)&remote;
msg.msg_namelen = sizeof(remote);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_flags = 0;
msg.msg_control = buffer;
msg.msg_controllen = sizeof(buffer);
for (;;) {
err = recvmsg(sockfd, &msg, MSG_ERRQUEUE);
savederrno = errno;
if (err < 0) {
if (!got_err) {
errno = savederrno;
return -1;
} else {
return 0;
}
}
got_err = 1;
for (cmsg = CMSG_FIRSTHDR(&msg);cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
if (((cmsg->cmsg_level == SOL_IP) && (cmsg->cmsg_type == IP_RECVERR)) ||
((cmsg->cmsg_level == SOL_IPV6 && (cmsg->cmsg_type == IPV6_RECVERR)))) {
sock_err = (struct sock_extended_err*)(void *)CMSG_DATA(cmsg);
if (sock_err) {
switch (sock_err->ee_origin) {
case 0: /* no origin */
case 1: /* local source (EMSGSIZE) */
/*
* those errors are way too noisy
*/
break;
case 2: /* ICMP */
case 3: /* ICMP6 */
origin = (struct sockaddr_storage *)(void *)SO_EE_OFFENDER(sock_err);
if (knet_addrtostr(origin, sizeof(origin),
addr_str, KNET_MAX_HOST_LEN,
port_str, KNET_MAX_PORT_LEN) < 0) {
log_debug(knet_h, KNET_SUB_TRANSP_UDP, "Received ICMP error from unknown source: %s", strerror(sock_err->ee_errno));
} else {
log_debug(knet_h, KNET_SUB_TRANSP_UDP, "Received ICMP error from %s: %s", addr_str, strerror(sock_err->ee_errno));
}
break;
}
} else {
log_debug(knet_h, KNET_SUB_TRANSP_UDP, "No data in MSG_ERRQUEUE");
}
}
}
}
}
#else
static int read_errs_from_sock(knet_handle_t knet_h, int sockfd)
{
return 0;
}
#endif
-static int udp_transport_rx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno)
+int udp_transport_rx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno)
{
if (recv_errno == EAGAIN) {
read_errs_from_sock(knet_h, sockfd);
}
return 0;
}
-static int udp_transport_tx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno)
+int udp_transport_tx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno)
{
if (recv_err < 0) {
if (recv_errno == EMSGSIZE) {
return 0;
}
if ((recv_errno == ENOBUFS) || (recv_errno == EAGAIN)) {
#ifdef DEBUG
log_debug(knet_h, KNET_SUB_TRANSP_UDP, "Sock: %d is overloaded. Slowing TX down", sockfd);
#endif
usleep(KNET_THREADS_TIMERES / 16);
} else {
read_errs_from_sock(knet_h, sockfd);
}
return 1;
}
return 0;
}
-static int udp_transport_rx_is_data(knet_handle_t knet_h, int sockfd, struct knet_mmsghdr *msg)
+int udp_transport_rx_is_data(knet_handle_t knet_h, int sockfd, struct knet_mmsghdr *msg)
{
if (msg->msg_len == 0)
return 0;
return 2;
}
-static int udp_transport_link_dyn_connect(knet_handle_t knet_h, int sockfd, struct knet_link *kn_link)
+int udp_transport_link_dyn_connect(knet_handle_t knet_h, int sockfd, struct knet_link *kn_link)
{
kn_link->status.dynconnected = 1;
return 0;
}
-
-static knet_transport_ops_t udp_transport_ops = {
- .transport_name = "UDP",
- .transport_id = KNET_TRANSPORT_UDP,
- .transport_mtu_overhead = KNET_PMTUD_UDP_OVERHEAD,
- .transport_init = udp_transport_init,
- .transport_free = udp_transport_free,
- .transport_link_set_config = udp_transport_link_set_config,
- .transport_link_clear_config = udp_transport_link_clear_config,
- .transport_link_dyn_connect = udp_transport_link_dyn_connect,
- .transport_rx_sock_error = udp_transport_rx_sock_error,
- .transport_tx_sock_error = udp_transport_tx_sock_error,
- .transport_rx_is_data = udp_transport_rx_is_data,
-};
-
-knet_transport_ops_t *get_udp_transport()
-{
- return &udp_transport_ops;
-}
diff --git a/libknet/transport_udp.h b/libknet/transport_udp.h
new file mode 100644
index 00000000..5c95a1ff
--- /dev/null
+++ b/libknet/transport_udp.h
@@ -0,0 +1,27 @@
+/*
+ * 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 "internals.h"
+
+#ifndef __KNET_TRANSPORT_UDP_H__
+#define __KNET_TRANSPORT_UDP_H__
+
+#define KNET_PMTUD_UDP_OVERHEAD 8
+
+int udp_transport_link_set_config(knet_handle_t knet_h, struct knet_link *kn_link);
+int udp_transport_link_clear_config(knet_handle_t knet_h, struct knet_link *kn_link);
+int udp_transport_free(knet_handle_t knet_h);
+int udp_transport_init(knet_handle_t knet_h);
+int udp_transport_rx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno);
+int udp_transport_tx_sock_error(knet_handle_t knet_h, int sockfd, int recv_err, int recv_errno);
+int udp_transport_rx_is_data(knet_handle_t knet_h, int sockfd, struct knet_mmsghdr *msg);
+int udp_transport_link_dyn_connect(knet_handle_t knet_h, int sockfd, struct knet_link *kn_link);
+
+#endif
diff --git a/libknet/transports.c b/libknet/transports.c
new file mode 100644
index 00000000..7cc52f2a
--- /dev/null
+++ b/libknet/transports.c
@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 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 "transports.h"
+#include "transport_loopback.h"
+#include "transport_udp.h"
+#include "transport_sctp.h"
+
+#define empty_module 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
+
+knet_transport_ops_t transport_modules_cmd[] = {
+ { "LOOPBACK", KNET_TRANSPORT_LOOPBACK, 1, KNET_PMTUD_LOOPBACK_OVERHEAD, loopback_transport_init, loopback_transport_free, loopback_transport_link_set_config, loopback_transport_link_clear_config, loopback_transport_link_dyn_connect, loopback_transport_rx_sock_error, loopback_transport_tx_sock_error, loopback_transport_rx_is_data },
+ { "UDP", KNET_TRANSPORT_UDP, 1, KNET_PMTUD_UDP_OVERHEAD, udp_transport_init, udp_transport_free, udp_transport_link_set_config, udp_transport_link_clear_config, udp_transport_link_dyn_connect, udp_transport_rx_sock_error, udp_transport_tx_sock_error, udp_transport_rx_is_data },
+ { "SCTP", KNET_TRANSPORT_SCTP,
+#ifdef HAVE_NETINET_SCTP_H
+ 1, KNET_PMTUD_SCTP_OVERHEAD, sctp_transport_init, sctp_transport_free, sctp_transport_link_set_config, sctp_transport_link_clear_config, sctp_transport_link_dyn_connect, sctp_transport_rx_sock_error, sctp_transport_tx_sock_error, sctp_transport_rx_is_data },
+#else
+empty_module
+#endif
+ { NULL, KNET_MAX_TRANSPORTS, empty_module
+};
+
+/*
+ * transport wrappers
+ */
+
+int start_all_transports(knet_handle_t knet_h)
+{
+ int idx = 0, savederrno = 0, err = 0;
+
+ while (transport_modules_cmd[idx].transport_name != NULL) {
+ if (transport_modules_cmd[idx].built_in) {
+ if (transport_modules_cmd[idx].transport_init(knet_h) < 0) {
+ savederrno = errno;
+ log_err(knet_h, KNET_SUB_HANDLE,
+ "Failed to allocate transport handle for %s: %s",
+ transport_modules_cmd[idx].transport_name,
+ strerror(savederrno));
+ err = -1;
+ goto out;
+ }
+ }
+ idx++;
+ }
+
+out:
+ errno = savederrno;
+ return err;
+}
+
+void stop_all_transports(knet_handle_t knet_h)
+{
+ int idx = 0;
+
+ while (transport_modules_cmd[idx].transport_name != NULL) {
+ if (transport_modules_cmd[idx].built_in) {
+ transport_modules_cmd[idx].transport_free(knet_h);
+ }
+ idx++;
+ }
+}
+
+int transport_link_set_config(knet_handle_t knet_h, struct knet_link *kn_link, uint8_t transport)
+{
+ if (!transport_modules_cmd[transport].built_in) {
+ errno = EINVAL;
+ return -1;
+ }
+ kn_link->transport_connected = 0;
+ kn_link->transport_type = transport;
+ kn_link->proto_overhead = transport_modules_cmd[transport].transport_mtu_overhead;
+ return transport_modules_cmd[transport].transport_link_set_config(knet_h, kn_link);
+}
+
+int transport_link_clear_config(knet_handle_t knet_h, struct knet_link *kn_link)
+{
+ return transport_modules_cmd[kn_link->transport_type].transport_link_clear_config(knet_h, kn_link);
+}
+
+int transport_link_dyn_connect(knet_handle_t knet_h, int sockfd, struct knet_link *kn_link)
+{
+ return transport_modules_cmd[kn_link->transport_type].transport_link_dyn_connect(knet_h, sockfd, kn_link);
+}
+
+int transport_rx_sock_error(knet_handle_t knet_h, uint8_t transport, int sockfd, int recv_err, int recv_errno)
+{
+ return transport_modules_cmd[transport].transport_rx_sock_error(knet_h, sockfd, recv_err, recv_errno);
+}
+
+int transport_tx_sock_error(knet_handle_t knet_h, uint8_t transport, int sockfd, int recv_err, int recv_errno)
+{
+ return transport_modules_cmd[transport].transport_tx_sock_error(knet_h, sockfd, recv_err, recv_errno);
+}
+
+int transport_rx_is_data(knet_handle_t knet_h, uint8_t transport, int sockfd, struct knet_mmsghdr *msg)
+{
+ return transport_modules_cmd[transport].transport_rx_is_data(knet_h, sockfd, msg);
+}
+
+/*
+ * public api
+ */
+
+int knet_get_transport_list(struct knet_transport_info *transport_list,
+ size_t *transport_list_entries)
+{
+ int err = 0;
+ int idx = 0;
+ int outidx = 0;
+
+ if (!transport_list_entries) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ while (transport_modules_cmd[idx].transport_name != NULL) {
+ if (transport_modules_cmd[idx].built_in) {
+ if (transport_list) {
+ transport_list[outidx].name = transport_modules_cmd[idx].transport_name;
+ transport_list[outidx].id = transport_modules_cmd[idx].transport_id;
+ }
+ outidx++;
+ }
+ idx++;
+ }
+
+ *transport_list_entries = outidx;
+
+ return err;
+}
+
+const char *knet_get_transport_name_by_id(uint8_t transport)
+{
+ int savederrno = 0;
+ const char *name = NULL;
+
+ if (transport == KNET_MAX_TRANSPORTS) {
+ errno = EINVAL;
+ return name;
+ }
+
+ if ((transport_modules_cmd[transport].transport_name) &&
+ (transport_modules_cmd[transport].built_in)) {
+ name = transport_modules_cmd[transport].transport_name;
+ } else {
+ savederrno = ENOENT;
+ }
+
+ errno = savederrno;
+ return name;
+}
+
+uint8_t knet_get_transport_id_by_name(const char *name)
+{
+ int savederrno = 0;
+ uint8_t err = KNET_MAX_TRANSPORTS;
+ int i, found;
+
+ if (!name) {
+ errno = EINVAL;
+ return err;
+ }
+
+ i = 0;
+ found = 0;
+ while (transport_modules_cmd[i].transport_name != NULL) {
+ if (transport_modules_cmd[i].built_in) {
+ if (!strcmp(transport_modules_cmd[i].transport_name, name)) {
+ err = transport_modules_cmd[i].transport_id;
+ found = 1;
+ break;
+ }
+ }
+ i++;
+ }
+
+ if (!found) {
+ savederrno = EINVAL;
+ }
+
+ errno = savederrno;
+ return err;
+}
+
+int knet_handle_set_transport_reconnect_interval(knet_handle_t knet_h, uint32_t msecs)
+{
+ int savederrno = 0;
+
+ if (!knet_h) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if (!msecs) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if (msecs < 1000) {
+ log_warn(knet_h, KNET_SUB_HANDLE, "reconnect internval below 1 sec (%u msecs) might be too aggressive", msecs);
+ }
+
+ if (msecs > 60000) {
+ log_warn(knet_h, KNET_SUB_HANDLE, "reconnect internval above 1 minute (%u msecs) could cause long delays in network convergiance", msecs);
+ }
+
+ savederrno = pthread_rwlock_wrlock(&knet_h->global_rwlock);
+ if (savederrno) {
+ log_err(knet_h, KNET_SUB_HANDLE, "Unable to get read lock: %s",
+ strerror(savederrno));
+ errno = savederrno;
+ return -1;
+ }
+
+ knet_h->reconnect_int = msecs;
+
+ pthread_rwlock_unlock(&knet_h->global_rwlock);
+ return 0;
+}
+
+int knet_handle_get_transport_reconnect_interval(knet_handle_t knet_h, uint32_t *msecs)
+{
+ int savederrno = 0;
+
+ if (!knet_h) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if (!msecs) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ savederrno = pthread_rwlock_rdlock(&knet_h->global_rwlock);
+ if (savederrno) {
+ log_err(knet_h, KNET_SUB_HANDLE, "Unable to get read lock: %s",
+ strerror(savederrno));
+ errno = savederrno;
+ return -1;
+ }
+
+ *msecs = knet_h->reconnect_int;
+
+ pthread_rwlock_unlock(&knet_h->global_rwlock);
+ return 0;
+}
diff --git a/libknet/transports.h b/libknet/transports.h
index a5158fdd..448bf605 100644
--- a/libknet/transports.h
+++ b/libknet/transports.h
@@ -1,28 +1,22 @@
/*
* 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_TRANSPORTS_H__
#define __KNET_TRANSPORTS_H__
-knet_transport_ops_t *get_udp_transport(void);
-knet_transport_ops_t *get_sctp_transport(void);
-knet_transport_ops_t *get_loopback_transport(void);
+int start_all_transports(knet_handle_t knet_h);
+void stop_all_transports(knet_handle_t knet_h);
-int _configure_common_socket(knet_handle_t knet_h, int sock, uint64_t flags, const char *type);
-int _configure_transport_socket(knet_handle_t knet_h, int sock, struct sockaddr_storage *address, uint64_t flags, const char *type);
-
-int _init_socketpair(knet_handle_t knet_h, int *sock);
-void _close_socketpair(knet_handle_t knet_h, int *sock);
-
-int _set_fd_tracker(knet_handle_t knet_h, int sockfd, uint8_t transport, uint8_t data_type, void *data);
-int _is_valid_fd(knet_handle_t knet_h, int sockfd);
-
-int _sendmmsg(int sockfd, struct knet_mmsghdr *msgvec, unsigned int vlen, unsigned int flags);
-int _recvmmsg(int sockfd, struct knet_mmsghdr *msgvec, unsigned int vlen, unsigned int flags);
+int transport_link_set_config(knet_handle_t knet_h, struct knet_link *kn_link, uint8_t transport);
+int transport_link_clear_config(knet_handle_t knet_h, struct knet_link *kn_link);
+int transport_link_dyn_connect(knet_handle_t knet_h, int sockfd, struct knet_link *kn_link);
+int transport_rx_sock_error(knet_handle_t knet_h, uint8_t transport, int sockfd, int recv_err, int recv_errno);
+int transport_tx_sock_error(knet_handle_t knet_h, uint8_t transport, int sockfd, int recv_err, int recv_errno);
+int transport_rx_is_data(knet_handle_t knet_h, uint8_t transport, int sockfd, struct knet_mmsghdr *msg);
#endif

File Metadata

Mime Type
text/x-diff
Expires
Mon, Apr 21, 8:13 PM (4 h, 43 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
1664871
Default Alt Text
(727 KB)

Event Timeline