No OneTemporary
Actions

Size

26 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/libknet/compress.c b/libknet/compress.c
	index 536b0439..c7c0d0e6 100644
	--- a/libknet/compress.c
	+++ b/libknet/compress.c
	@@ -1,481 +1,481 @@
	/*
	* Copyright (C) 2017-2018 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 "compress_model.h"
	#include "logging.h"
	#include "threads_common.h"
	#include "common.h"

	/*
	* internal module switch data
	*/

	/*
	* DO NOT CHANGE MODEL_ID HERE OR ONWIRE COMPATIBILITY
	* WILL BREAK!
	*
	* Always add new items before the last NULL.
	*/

	-compress_model_t compress_modules_cmds[] = {
	+static compress_model_t compress_modules_cmds[] = {
	{ "none" , 0, 0, 0, NULL },
	{ "zlib" , 1, WITH_COMPRESS_ZLIB , 0, NULL },
	{ "lz4" , 2, WITH_COMPRESS_LZ4 , 0, NULL },
	{ "lz4hc", 3, WITH_COMPRESS_LZ4 , 0, NULL },
	{ "lzo2" , 4, WITH_COMPRESS_LZO2 , 0, NULL },
	{ "lzma" , 5, WITH_COMPRESS_LZMA , 0, NULL },
	{ "bzip2", 6, WITH_COMPRESS_BZIP2, 0, NULL },
	{ NULL, 255, 0, 0, NULL }
	};

	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)
	{
	if (compress_modules_cmds[compress_model].ops->val_level != NULL) {
	return compress_modules_cmds[compress_model].ops->val_level(knet_h, compress_level);
	}
	return 0;
	}

	/*
	* 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].ops->is_init == NULL) {
	if (knet_h->compress_int_data[cmp_model] != NULL) {
	return 1;
	}
	} else {
	if (compress_modules_cmds[cmp_model].ops->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) {
	compress_modules_cmds[cmp_model].ops = load_module (knet_h, "compress", compress_modules_cmds[cmp_model].model_name);
	if (!compress_modules_cmds[cmp_model].ops) {
	clock_gettime(CLOCK_MONOTONIC, &last_load_failure);
	return -1;
	}
	if (compress_modules_cmds[cmp_model].ops->abi_ver != KNET_COMPRESS_MODEL_ABI) {
	log_err(knet_h, KNET_SUB_COMPRESS,
	"ABI mismatch loading module %s. knet ver: %d, module ver: %d",
	compress_modules_cmds[cmp_model].model_name, KNET_COMPRESS_MODEL_ABI,
	compress_modules_cmds[cmp_model].ops->abi_ver);
	errno = EINVAL;
	return -1;
	}
	compress_modules_cmds[cmp_model].loaded = 1;
	}

	if (compress_modules_cmds[cmp_model].ops->init != NULL) {
	if (compress_modules_cmds[cmp_model].ops->init(knet_h, cmp_model) < 0) {
	return -1;
	}
	} else {
	knet_h->compress_int_data[cmp_model] = (void *)&"1";
	}

	return 0;
	}

	static int compress_lib_test(knet_handle_t knet_h)
	{
	int savederrno = 0;
	unsigned char src[KNET_DATABUFSIZE];
	unsigned char dst[KNET_DATABUFSIZE_COMPRESS];
	ssize_t dst_comp_len = KNET_DATABUFSIZE_COMPRESS, dst_decomp_len = KNET_DATABUFSIZE;
	unsigned int i;

	memset(src, 0, KNET_DATABUFSIZE);
	memset(dst, 0, KNET_DATABUFSIZE_COMPRESS);

	/*
	* NOTE: we cannot use compress and decompress API calls due to locking
	* so we need to call directly into the modules
	*/

	if (compress_modules_cmds[knet_h->compress_model].ops->compress(knet_h, src, KNET_DATABUFSIZE, dst, &dst_comp_len) < 0) {
	savederrno = errno;
	log_err(knet_h, KNET_SUB_COMPRESS, "Unable to compress test buffer. Please check your compression settings: %s", strerror(savederrno));
	errno = savederrno;
	return -1;
	}

	if (compress_modules_cmds[knet_h->compress_model].ops->decompress(knet_h, dst, dst_comp_len, src, &dst_decomp_len) < 0) {
	savederrno = errno;
	log_err(knet_h, KNET_SUB_COMPRESS, "Unable to decompress test buffer. Please check your compression settings: %s", strerror(savederrno));
	errno = savederrno;
	return -1;
	}

	for (i = 0; i < KNET_DATABUFSIZE; i++) {
	if (src[i] != 0) {
	log_err(knet_h, KNET_SUB_COMPRESS, "Decompressed buffer contains incorrect data");
	errno = EINVAL;
	return -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;
	}

	knet_h->compress_model = cmp_model;
	knet_h->compress_level = knet_handle_compress_cfg->compress_level;

	if (compress_lib_test(knet_h) < 0) {
	savederrno = errno;
	err = -1;
	goto out_unlock;
	}

	out_unlock:
	pthread_rwlock_unlock(&shlib_rwlock);
	}

	if (err) {
	knet_h->compress_model = 0;
	knet_h->compress_level = 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].ops->fini != NULL) {
	compress_modules_cmds[idx].ops->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].ops->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].ops->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_get_compress_list(struct knet_compress_info compress_list, size_t compress_list_entries)
	{
	int err = 0;
	int idx = 0;
	int outidx = 0;

	if (!compress_list_entries) {
	errno = EINVAL;
	return -1;
	}

	while (compress_modules_cmds[idx].model_name != NULL) {
	if (compress_modules_cmds[idx].built_in) {
	if (compress_list) {
	compress_list[outidx].name = compress_modules_cmds[idx].model_name;
	}
	outidx++;
	}
	idx++;
	}
	*compress_list_entries = outidx;

	return err;
	}
	diff --git a/libknet/crypto.c b/libknet/crypto.c
	index 43c21994..6b1ead7d 100644
	--- a/libknet/crypto.c
	+++ b/libknet/crypto.c
	@@ -1,212 +1,212 @@
	/*
	* Copyright (C) 2012-2018 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_model.h"
	#include "internals.h"
	#include "logging.h"
	#include "common.h"

	/*
	* internal module switch data
	*/

	-crypto_model_t crypto_modules_cmds[] = {
	+static crypto_model_t crypto_modules_cmds[] = {
	{ "nss", WITH_CRYPTO_NSS, 0, NULL },
	{ "openssl", WITH_CRYPTO_OPENSSL, 0, NULL },
	{ NULL, 0, 0, NULL }
	};

	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].ops->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].ops->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].ops->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) {
	crypto_modules_cmds[model].ops = load_module (knet_h, "crypto", crypto_modules_cmds[model].model_name);
	if (!crypto_modules_cmds[model].ops) {
	savederrno = errno;
	log_err(knet_h, KNET_SUB_CRYPTO, "Unable to load %s lib", crypto_modules_cmds[model].model_name);
	goto out_err;
	}
	if (crypto_modules_cmds[model].ops->abi_ver != KNET_CRYPTO_MODEL_ABI) {
	log_err(knet_h, KNET_SUB_CRYPTO,
	"ABI mismatch loading module %s. knet ver: %d, module ver: %d",
	crypto_modules_cmds[model].model_name, KNET_CRYPTO_MODEL_ABI,
	crypto_modules_cmds[model].ops->abi_ver);
	savederrno = EINVAL;
	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);
	savederrno = ENOMEM;
	goto out_err;
	}

	/*
	* if crypto_modules_cmds.ops->init fails, it is expected that
	* it will clean everything by itself.
	* crypto_modules_cmds.ops->fini is not invoked on error.
	*/
	knet_h->crypto_instance->model = model;
	if (crypto_modules_cmds[knet_h->crypto_instance->model].ops->init(knet_h, knet_handle_crypto_cfg)) {
	savederrno = errno;
	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);
	errno = savederrno;
	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].ops->fini != NULL) {
	crypto_modules_cmds[model].ops->fini(knet_h);
	}
	free(knet_h->crypto_instance);
	knet_h->crypto_instance = NULL;
	}

	pthread_rwlock_unlock(&shlib_rwlock);
	return;
	}

	int knet_get_crypto_list(struct knet_crypto_info crypto_list, size_t crypto_list_entries)
	{
	int err = 0;
	int idx = 0;
	int outidx = 0;

	if (!crypto_list_entries) {
	errno = EINVAL;
	return -1;
	}

	while (crypto_modules_cmds[idx].model_name != NULL) {
	if (crypto_modules_cmds[idx].built_in) {
	if (crypto_list) {
	crypto_list[outidx].name = crypto_modules_cmds[idx].model_name;
	}
	outidx++;
	}
	idx++;
	}
	*crypto_list_entries = outidx;

	return err;
	}
	diff --git a/libknet/transports.c b/libknet/transports.c
	index e7f1196a..67ebc6ef 100644
	--- a/libknet/transports.c
	+++ b/libknet/transports.c
	@@ -1,268 +1,268 @@
	/*
	* Copyright (C) 2017-2018 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"
	#include "threads_common.h"

	#define empty_module 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL },

	-knet_transport_ops_t transport_modules_cmd[KNET_MAX_TRANSPORTS] = {
	+static knet_transport_ops_t transport_modules_cmd[KNET_MAX_TRANSPORTS] = {
	{ "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 = get_global_wrlock(knet_h);
	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;
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 26, 7:14 PM (1 d, 12 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1959509
Default Alt Text: (26 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions