corosync/exec/totemudp.c

/*
 * Copyright (c) 2005 MontaVista Software, Inc.
 * Copyright (c) 2006-2018 Red Hat, Inc.
 *
 * All rights reserved.
 *
 * Author: Steven Dake (sdake@redhat.com)

 * This software licensed under BSD license, the text of which follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * - Neither the name of the MontaVista Software, Inc. nor the names of its
 *   contributors may be used to endorse or promote products derived from this
 *   software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <config.h>

#include <assert.h>
#include <pthread.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netdb.h>
#include <sys/un.h>
#include <sys/ioctl.h>
#include <sys/param.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sched.h>
#include <time.h>
#include <sys/time.h>
#include <sys/poll.h>
#include <sys/uio.h>
#include <limits.h>

#include <corosync/sq.h>
#include <corosync/swab.h>
#include <qb/qbdefs.h>
#include <qb/qbloop.h>
#define LOGSYS_UTILS_ONLY 1
#include <corosync/logsys.h>
#include "totemudp.h"

#include "util.h"

#ifndef MSG_NOSIGNAL
#define MSG_NOSIGNAL 0
#endif

#define MCAST_SOCKET_BUFFER_SIZE (TRANSMITS_ALLOWED * FRAME_SIZE_MAX)
#define NETIF_STATE_REPORT_UP		1
#define NETIF_STATE_REPORT_DOWN		2

#define BIND_STATE_UNBOUND	0
#define BIND_STATE_REGULAR	1
#define BIND_STATE_LOOPBACK	2

struct totemudp_member {
	struct qb_list_head list;
	struct totem_ip_address member;
};

struct totemudp_socket {
	int mcast_recv;
	int mcast_send;
	int token;
	/*
	 * Socket used for local multicast delivery. We don't rely on multicast
	 * loop and rather this UNIX DGRAM socket is used. Socket is created by
	 * socketpair call and they are used in same way as pipe (so [0] is read
	 * end and [1] is write end)
	 */
	int local_mcast_loop[2];
};

struct totemudp_instance {
	qb_loop_t *totemudp_poll_handle;

	struct totem_interface *totem_interface;

	int netif_state_report;

	int netif_bind_state;

	void *context;

	int (*totemudp_deliver_fn) (
		void *context,
		const void *msg,
		unsigned int msg_len,
		const struct sockaddr_storage *system_from);

	int (*totemudp_iface_change_fn) (
		void *context,
		const struct totem_ip_address *iface_address,
		unsigned int ring_no);

	void (*totemudp_target_set_completed) (void *context);

	/*
	 * Function and data used to log messages
	 */
	int totemudp_log_level_security;

	int totemudp_log_level_error;

	int totemudp_log_level_warning;

	int totemudp_log_level_notice;

	int totemudp_log_level_debug;

	int totemudp_subsys_id;

	void (*totemudp_log_printf) (
		int level,
		int subsys,
		const char *function,
		const char *file,
		int line,
		const char *format,
		...)__attribute__((format(printf, 6, 7)));

	void *udp_context;

	struct qb_list_head member_list;

	char iov_buffer[UDP_RECEIVE_FRAME_SIZE_MAX + 1];

	char iov_buffer_flush[UDP_RECEIVE_FRAME_SIZE_MAX + 1];

	struct iovec totemudp_iov_recv;

	struct iovec totemudp_iov_recv_flush;

	struct totemudp_socket totemudp_sockets;

	struct totem_ip_address mcast_address;

	int stats_sent;

	int stats_recv;

	int stats_delv;

	int stats_remcasts;

	int stats_orf_token;

	struct timeval stats_tv_start;

	struct totem_ip_address my_id;

	int firstrun;

	qb_loop_timer_handle timer_netif_check_timeout;

	unsigned int my_memb_entries;

	int flushing;

	struct totem_config *totem_config;

	totemsrp_stats_t *stats;

	struct totem_ip_address token_target;
};

struct work_item {
	const void *msg;
	unsigned int msg_len;
	struct totemudp_instance *instance;
};

static int totemudp_build_sockets (
	struct totemudp_instance *instance,
	struct totem_ip_address *bindnet_address,
	struct totem_ip_address *mcastaddress,
	struct totemudp_socket *sockets,
	struct totem_ip_address *bound_to);

static struct totem_ip_address localhost;

static void totemudp_instance_initialize (struct totemudp_instance *instance)
{
	memset (instance, 0, sizeof (struct totemudp_instance));

	instance->netif_state_report = NETIF_STATE_REPORT_UP | NETIF_STATE_REPORT_DOWN;

	instance->totemudp_iov_recv.iov_base = instance->iov_buffer;

	instance->totemudp_iov_recv.iov_len = UDP_RECEIVE_FRAME_SIZE_MAX + 1; //sizeof (instance->iov_buffer) + 1;
	instance->totemudp_iov_recv_flush.iov_base = instance->iov_buffer_flush;

	instance->totemudp_iov_recv_flush.iov_len = UDP_RECEIVE_FRAME_SIZE_MAX + 1; //sizeof (instance->iov_buffer) + 1;

	/*
	 * There is always atleast 1 processor
	 */
	instance->my_memb_entries = 1;

	qb_list_init (&instance->member_list);
}

#define log_printf(level, format, args...)				\
do {									\
        instance->totemudp_log_printf (					\
		level, instance->totemudp_subsys_id,			\
                __FUNCTION__, __FILE__, __LINE__,			\
		(const char *)format, ##args);				\
} while (0);

#define LOGSYS_PERROR(err_num, level, fmt, args...)						\
do {												\
	char _error_str[LOGSYS_MAX_PERROR_MSG_LEN];						\
	const char *_error_ptr = qb_strerror_r(err_num, _error_str, sizeof(_error_str));	\
        instance->totemudp_log_printf (								\
		level, instance->totemudp_subsys_id,						\
                __FUNCTION__, __FILE__, __LINE__,						\
		fmt ": %s (%d)\n", ##args, _error_ptr, err_num);				\
	} while(0)

int totemudp_crypto_set (
	void *udp_context,
	const char *cipher_type,
	const char *hash_type)
{

	return (0);
}


static inline void ucast_sendmsg (
	struct totemudp_instance *instance,
	struct totem_ip_address *system_to,
	const void *msg,
	unsigned int msg_len)
{
	struct msghdr msg_ucast;
	int res = 0;
	struct sockaddr_storage sockaddr;
	struct iovec iovec;
	int addrlen;

	iovec.iov_base = (void*)msg;
	iovec.iov_len = msg_len;

	/*
	 * Build unicast message
	 */
	memset(&msg_ucast, 0, sizeof(msg_ucast));
	totemip_totemip_to_sockaddr_convert(system_to,
		instance->totem_interface->ip_port, &sockaddr, &addrlen);
	msg_ucast.msg_name = &sockaddr;
	msg_ucast.msg_namelen = addrlen;
	msg_ucast.msg_iov = (void *)&iovec;
	msg_ucast.msg_iovlen = 1;

	/*
	 * Transmit unicast message
	 * An error here is recovered by totemsrp
	 */
	res = sendmsg (instance->totemudp_sockets.mcast_send, &msg_ucast,
		MSG_NOSIGNAL);
	if (res < 0) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_debug,
			"sendmsg(ucast) failed (non-critical)");
	}
}

static inline void mcast_sendmsg (
	struct totemudp_instance *instance,
	const void *msg,
	unsigned int msg_len)
{
	struct msghdr msg_mcast;
	int res = 0;
	struct iovec iovec;
	struct sockaddr_storage sockaddr;
	int addrlen;

	iovec.iov_base = (void *)msg;
	iovec.iov_len = msg_len;

	/*
	 * Build multicast message
	 */
	totemip_totemip_to_sockaddr_convert(&instance->mcast_address,
		instance->totem_interface->ip_port, &sockaddr, &addrlen);
	memset(&msg_mcast, 0, sizeof(msg_mcast));
	msg_mcast.msg_name = &sockaddr;
	msg_mcast.msg_namelen = addrlen;
	msg_mcast.msg_iov = (void *)&iovec;
	msg_mcast.msg_iovlen = 1;

	/*
	 * Transmit multicast message
	 * An error here is recovered by totemsrp
	 */
	res = sendmsg (instance->totemudp_sockets.mcast_send, &msg_mcast,
		MSG_NOSIGNAL);
	if (res < 0) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_debug,
			"sendmsg(mcast) failed (non-critical)");
		instance->stats->continuous_sendmsg_failures++;
	} else {
		instance->stats->continuous_sendmsg_failures = 0;
	}

	/*
	 * Transmit multicast message to local unix mcast loop
	 * An error here is recovered by totemsrp
	 */
	msg_mcast.msg_name = NULL;
	msg_mcast.msg_namelen = 0;

	res = sendmsg (instance->totemudp_sockets.local_mcast_loop[1], &msg_mcast,
		MSG_NOSIGNAL);
	if (res < 0) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_debug,
			"sendmsg(local mcast loop) failed (non-critical)");
	}
}


int totemudp_finalize (
	void *udp_context)
{
	struct totemudp_instance *instance = (struct totemudp_instance *)udp_context;
	int res = 0;

	if (instance->totemudp_sockets.mcast_recv > 0) {
	 	qb_loop_poll_del (instance->totemudp_poll_handle,
			instance->totemudp_sockets.mcast_recv);
		close (instance->totemudp_sockets.mcast_recv);
	}
	if (instance->totemudp_sockets.mcast_send > 0) {
		close (instance->totemudp_sockets.mcast_send);
	}
	if (instance->totemudp_sockets.local_mcast_loop[0] > 0) {
		qb_loop_poll_del (instance->totemudp_poll_handle,
			instance->totemudp_sockets.local_mcast_loop[0]);
		close (instance->totemudp_sockets.local_mcast_loop[0]);
		close (instance->totemudp_sockets.local_mcast_loop[1]);
	}
	if (instance->totemudp_sockets.token > 0) {
		qb_loop_poll_del (instance->totemudp_poll_handle,
			instance->totemudp_sockets.token);
		close (instance->totemudp_sockets.token);
	}

	return (res);
}

/*
 * Only designed to work with a message with one iov
 */

static int net_deliver_fn (
	int fd,
	int revents,
	void *data)
{
	struct totemudp_instance *instance = (struct totemudp_instance *)data;
	struct msghdr msg_recv;
	struct iovec *iovec;
	struct sockaddr_storage system_from;
	int bytes_received;

	if (instance->flushing == 1) {
		iovec = &instance->totemudp_iov_recv_flush;
	} else {
		iovec = &instance->totemudp_iov_recv;
	}

	/*
	 * Receive datagram
	 */
	memset(&msg_recv, 0, sizeof(msg_recv));
	msg_recv.msg_name = &system_from;
	msg_recv.msg_namelen = sizeof (struct sockaddr_storage);
	msg_recv.msg_iov = iovec;
	msg_recv.msg_iovlen = 1;

	bytes_received = recvmsg (fd, &msg_recv, MSG_NOSIGNAL | MSG_DONTWAIT);
	if (bytes_received == -1) {
		return (0);
	} else {
		instance->stats_recv += bytes_received;
	}

	if (bytes_received >= UDP_RECEIVE_FRAME_SIZE_MAX + 1) {
		/*
		 * Maximum packet size should be UDP_RECEIVE_FRAME_SIZE_MAX.
		 * If received packet is UDP_RECEIVE_FRAME_SIZE_MAX + 1 it means packet was truncated
		 * (iov_buffer size and iov_len are intentionally set to UDP_RECEIVE_FRAME_SIZE_MAX + 1).
		 */
		log_printf (instance->totemudp_log_level_error,
				"Received too big message. This may be because something bad is happening "
				"on the network (attack?), or you tried join more nodes than corosync is "
				"compiled with (%u) or bug in the code (bad estimation of "
				"the UDP_RECEIVE_FRAME_SIZE_MAX). Dropping packet.", PROCESSOR_COUNT_MAX);
		return (0);
	}

	iovec->iov_len = bytes_received;

	/*
	 * Handle incoming message
	 */
	instance->totemudp_deliver_fn (
		instance->context,
		iovec->iov_base,
		iovec->iov_len,
		&system_from);

	iovec->iov_len = UDP_RECEIVE_FRAME_SIZE_MAX + 1;
	return (0);
}

static int netif_determine (
	struct totemudp_instance *instance,
	struct totem_ip_address *bindnet,
	struct totem_ip_address *bound_to,
	int *interface_up,
	int *interface_num)
{
	int res;

	res = totemip_iface_check (bindnet, bound_to,
		interface_up, interface_num,
                instance->totem_config->clear_node_high_bit);


	return (res);
}


/*
 * If the interface is up, the sockets for totem are built.  If the interface is down
 * this function is requeued in the timer list to retry building the sockets later.
 */
static void timer_function_netif_check_timeout (
	void *data)
{
	struct totemudp_instance *instance = (struct totemudp_instance *)data;
	int interface_up;
	int interface_num;
	struct totem_ip_address *bind_address;

	/*
	 * Build sockets for every interface
	 */
	netif_determine (instance,
		&instance->totem_interface->bindnet,
		&instance->totem_interface->boundto,
		&interface_up, &interface_num);
	/*
	 * If the network interface isn't back up and we are already
	 * in loopback mode, add timer to check again and return
	 */
	if ((instance->netif_bind_state == BIND_STATE_LOOPBACK &&
		interface_up == 0) ||

	(instance->my_memb_entries == 1 &&
		instance->netif_bind_state == BIND_STATE_REGULAR &&
		interface_up == 1)) {

		qb_loop_timer_add (instance->totemudp_poll_handle,
			QB_LOOP_MED,
			instance->totem_config->downcheck_timeout*QB_TIME_NS_IN_MSEC,
			(void *)instance,
			timer_function_netif_check_timeout,
			&instance->timer_netif_check_timeout);

		/*
		 * Add a timer to check for a downed regular interface
		 */
		return;
	}

	if (instance->totemudp_sockets.mcast_recv > 0) {
	 	qb_loop_poll_del (instance->totemudp_poll_handle,
			instance->totemudp_sockets.mcast_recv);
		close (instance->totemudp_sockets.mcast_recv);
	}
	if (instance->totemudp_sockets.mcast_send > 0) {
		close (instance->totemudp_sockets.mcast_send);
	}
	if (instance->totemudp_sockets.local_mcast_loop[0] > 0) {
		qb_loop_poll_del (instance->totemudp_poll_handle,
			instance->totemudp_sockets.local_mcast_loop[0]);
		close (instance->totemudp_sockets.local_mcast_loop[0]);
		close (instance->totemudp_sockets.local_mcast_loop[1]);
	}
	if (instance->totemudp_sockets.token > 0) {
		qb_loop_poll_del (instance->totemudp_poll_handle,
			instance->totemudp_sockets.token);
		close (instance->totemudp_sockets.token);
	}

	if (interface_up == 0) {
		/*
		 * Interface is not up
		 */
		instance->netif_bind_state = BIND_STATE_LOOPBACK;
		bind_address = &localhost;

		/*
		 * Add a timer to retry building interfaces and request memb_gather_enter
		 */
		qb_loop_timer_add (instance->totemudp_poll_handle,
			QB_LOOP_MED,
			instance->totem_config->downcheck_timeout*QB_TIME_NS_IN_MSEC,
			(void *)instance,
			timer_function_netif_check_timeout,
			&instance->timer_netif_check_timeout);
	} else {
		/*
		 * Interface is up
		 */
		instance->netif_bind_state = BIND_STATE_REGULAR;
		bind_address = &instance->totem_interface->bindnet;
	}
	/*
	 * Create and bind the multicast and unicast sockets
	 */
	(void)totemudp_build_sockets (instance,
		&instance->mcast_address,
		bind_address,
		&instance->totemudp_sockets,
		&instance->totem_interface->boundto);

	qb_loop_poll_add (
		instance->totemudp_poll_handle,
		QB_LOOP_MED,
		instance->totemudp_sockets.mcast_recv,
		POLLIN, instance, net_deliver_fn);

	qb_loop_poll_add (
		instance->totemudp_poll_handle,
		QB_LOOP_MED,
		instance->totemudp_sockets.local_mcast_loop[0],
		POLLIN, instance, net_deliver_fn);

	qb_loop_poll_add (
		instance->totemudp_poll_handle,
		QB_LOOP_MED,
		instance->totemudp_sockets.token,
		POLLIN, instance, net_deliver_fn);

	totemip_copy (&instance->my_id, &instance->totem_interface->boundto);

	/*
	 * This reports changes in the interface to the user and totemsrp
	 */
	if (instance->netif_bind_state == BIND_STATE_REGULAR) {
		if (instance->netif_state_report & NETIF_STATE_REPORT_UP) {
			log_printf (instance->totemudp_log_level_notice,
				"The network interface [%s] is now up.",
				totemip_print (&instance->totem_interface->boundto));
			instance->netif_state_report = NETIF_STATE_REPORT_DOWN;
			instance->totemudp_iface_change_fn (instance->context, &instance->my_id, 0);
		}
		/*
		 * Add a timer to check for interface going down in single membership
		 */
		if (instance->my_memb_entries == 1) {
			qb_loop_timer_add (instance->totemudp_poll_handle,
				QB_LOOP_MED,
				instance->totem_config->downcheck_timeout*QB_TIME_NS_IN_MSEC,
				(void *)instance,
				timer_function_netif_check_timeout,
				&instance->timer_netif_check_timeout);
		}

	} else {
		if (instance->netif_state_report & NETIF_STATE_REPORT_DOWN) {
			log_printf (instance->totemudp_log_level_notice,
				"The network interface is down.");
			instance->totemudp_iface_change_fn (instance->context, &instance->my_id, 0);
		}
		instance->netif_state_report = NETIF_STATE_REPORT_UP;

	}
}

/* Set the socket priority to INTERACTIVE to ensure
   that our messages don't get queued behind anything else */
static void totemudp_traffic_control_set(struct totemudp_instance *instance, int sock)
{
#ifdef SO_PRIORITY
	int prio = 6; /* TC_PRIO_INTERACTIVE */

	if (setsockopt(sock, SOL_SOCKET, SO_PRIORITY, &prio, sizeof(int))) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning, "Could not set traffic priority");
    }
#endif
}

static int totemudp_build_sockets_ip (
	struct totemudp_instance *instance,
	struct totem_ip_address *mcast_address,
	struct totem_ip_address *bindnet_address,
	struct totemudp_socket *sockets,
	struct totem_ip_address *bound_to,
	int interface_num)
{
	struct sockaddr_storage sockaddr;
	struct ipv6_mreq mreq6;
	struct ip_mreq mreq;
	struct sockaddr_storage mcast_ss, boundto_ss;
	struct sockaddr_in6 *mcast_sin6 = (struct sockaddr_in6 *)&mcast_ss;
	struct sockaddr_in  *mcast_sin = (struct sockaddr_in *)&mcast_ss;
	struct sockaddr_in  *boundto_sin = (struct sockaddr_in *)&boundto_ss;
	unsigned int sendbuf_size;
	unsigned int recvbuf_size;
	unsigned int optlen = sizeof (sendbuf_size);
	unsigned int retries;
	int addrlen;
	int res;
	int flag;
	uint8_t sflag;
	int i;

	/*
	 * Create multicast recv socket
	 */
	sockets->mcast_recv = socket (bindnet_address->family, SOCK_DGRAM, 0);
	if (sockets->mcast_recv == -1) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
			"socket() failed");
		return (-1);
	}

	totemip_nosigpipe (sockets->mcast_recv);
	res = fcntl (sockets->mcast_recv, F_SETFL, O_NONBLOCK);
	if (res == -1) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
			"Could not set non-blocking operation on multicast socket");
		return (-1);
	}

	/*
	 * Force reuse
	 */
	 flag = 1;
	 if ( setsockopt(sockets->mcast_recv, SOL_SOCKET, SO_REUSEADDR, (char *)&flag, sizeof (flag)) < 0) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
				"setsockopt(SO_REUSEADDR) failed");
		return (-1);
	}

	/*
	 * Create local multicast loop socket
	 */
	if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sockets->local_mcast_loop) == -1) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
			"socket() failed");
		return (-1);
	}

	for (i = 0; i < 2; i++) {
		totemip_nosigpipe (sockets->local_mcast_loop[i]);
		res = fcntl (sockets->local_mcast_loop[i], F_SETFL, O_NONBLOCK);
		if (res == -1) {
			LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
				"Could not set non-blocking operation on multicast socket");
			return (-1);
		}
	}



	/*
	 * Setup mcast send socket
	 */
	sockets->mcast_send = socket (bindnet_address->family, SOCK_DGRAM, 0);
	if (sockets->mcast_send == -1) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
			"socket() failed");
		return (-1);
	}

	totemip_nosigpipe (sockets->mcast_send);
	res = fcntl (sockets->mcast_send, F_SETFL, O_NONBLOCK);
	if (res == -1) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
			"Could not set non-blocking operation on multicast socket");
		return (-1);
	}

	/*
	 * Force reuse
	 */
	 flag = 1;
	 if ( setsockopt(sockets->mcast_send, SOL_SOCKET, SO_REUSEADDR, (char *)&flag, sizeof (flag)) < 0) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
			"setsockopt(SO_REUSEADDR) failed");
		return (-1);
	}

	res = set_socket_dscp(sockets->mcast_send,
		instance->totem_config->ip_dscp);
	if (res == -1) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
			"Could not set IP_TOS bits");
		return (-1);
	}

	totemip_totemip_to_sockaddr_convert(bound_to, instance->totem_interface->ip_port - 1,
		&sockaddr, &addrlen);

	retries = 0;
	while (1) {
		res = bind (sockets->mcast_send, (struct sockaddr *)&sockaddr, addrlen);
		if (res == 0) {
			break;
		}
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
			"Unable to bind the socket to send multicast packets");
		if (++retries > BIND_MAX_RETRIES) {
			break;
		}

		/*
		 * Wait for a while
		 */
		(void)poll(NULL, 0, BIND_RETRIES_INTERVAL * retries);
	}
	if (res == -1) {
		return (-1);
	}

	/*
	 * Setup unicast socket
	 */
	sockets->token = socket (bindnet_address->family, SOCK_DGRAM, 0);
	if (sockets->token == -1) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
			"socket() failed");
		return (-1);
	}

	totemip_nosigpipe (sockets->token);
	res = fcntl (sockets->token, F_SETFL, O_NONBLOCK);
	if (res == -1) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
			"Could not set non-blocking operation on token socket");
		return (-1);
	}

	/*
	 * Force reuse
	 */
	 flag = 1;
	 if ( setsockopt(sockets->token, SOL_SOCKET, SO_REUSEADDR, (char *)&flag, sizeof (flag)) < 0) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
			"setsockopt(SO_REUSEADDR) failed");
		return (-1);
	}

	res = set_socket_dscp(sockets->token, instance->totem_config->ip_dscp);
	if (res == -1) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
			"Could not set IP_TOS bits");
		return (-1);
	}

	/*
	 * Bind to unicast socket used for token send/receives
	 * This has the side effect of binding to the correct interface
	 */
	totemip_totemip_to_sockaddr_convert(bound_to, instance->totem_interface->ip_port, &sockaddr, &addrlen);

	retries = 0;
	while (1) {
		res = bind (sockets->token, (struct sockaddr *)&sockaddr, addrlen);
		if (res == 0) {
			break;
		}
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
			"Unable to bind UDP unicast socket");
		if (++retries > BIND_MAX_RETRIES) {
			break;
		}

		/*
		 * Wait for a while
		 */
		(void)poll(NULL, 0, BIND_RETRIES_INTERVAL * retries);
	}
	if (res == -1) {
		return (-1);
	}

	recvbuf_size = MCAST_SOCKET_BUFFER_SIZE;
	sendbuf_size = MCAST_SOCKET_BUFFER_SIZE;
	/*
	 * Set buffer sizes to avoid overruns
	 */
	res = setsockopt (sockets->mcast_recv, SOL_SOCKET, SO_RCVBUF, &recvbuf_size, optlen);
	if (res == -1) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_debug,
			"Unable to set SO_RCVBUF size on UDP mcast socket");
		return (-1);
	}
	res = setsockopt (sockets->mcast_send, SOL_SOCKET, SO_SNDBUF, &sendbuf_size, optlen);
	if (res == -1) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_debug,
			"Unable to set SO_SNDBUF size on UDP mcast socket");
		return (-1);
	}
	res = setsockopt (sockets->local_mcast_loop[0], SOL_SOCKET, SO_RCVBUF, &recvbuf_size, optlen);
	if (res == -1) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_debug,
			"Unable to set SO_RCVBUF size on UDP local mcast loop socket");
		return (-1);
	}
	res = setsockopt (sockets->local_mcast_loop[1], SOL_SOCKET, SO_SNDBUF, &sendbuf_size, optlen);
	if (res == -1) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_debug,
			"Unable to set SO_SNDBUF size on UDP local mcast loop socket");
		return (-1);
	}

	res = getsockopt (sockets->mcast_recv, SOL_SOCKET, SO_RCVBUF, &recvbuf_size, &optlen);
	if (res == 0) {
		log_printf (instance->totemudp_log_level_debug,
			"Receive multicast socket recv buffer size (%d bytes).", recvbuf_size);
	}

	res = getsockopt (sockets->mcast_send, SOL_SOCKET, SO_SNDBUF, &sendbuf_size, &optlen);
	if (res == 0) {
		log_printf (instance->totemudp_log_level_debug,
			"Transmit multicast socket send buffer size (%d bytes).", sendbuf_size);
	}

	res = getsockopt (sockets->local_mcast_loop[0], SOL_SOCKET, SO_RCVBUF, &recvbuf_size, &optlen);
	if (res == 0) {
		log_printf (instance->totemudp_log_level_debug,
			"Local receive multicast loop socket recv buffer size (%d bytes).", recvbuf_size);
	}

	res = getsockopt (sockets->local_mcast_loop[1], SOL_SOCKET, SO_SNDBUF, &sendbuf_size, &optlen);
	if (res == 0) {
		log_printf (instance->totemudp_log_level_debug,
			"Local transmit multicast loop socket send buffer size (%d bytes).", sendbuf_size);
	}


	/*
	 * Join group membership on socket
	 */
	totemip_totemip_to_sockaddr_convert(mcast_address, instance->totem_interface->ip_port, &mcast_ss, &addrlen);
	totemip_totemip_to_sockaddr_convert(bound_to, instance->totem_interface->ip_port, &boundto_ss, &addrlen);

	if (instance->totem_config->broadcast_use == 1) {
		unsigned int broadcast = 1;

		if ((setsockopt(sockets->mcast_recv, SOL_SOCKET,
			SO_BROADCAST, &broadcast, sizeof (broadcast))) == -1) {
			LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
				"setting broadcast option failed");
			return (-1);
		}
		if ((setsockopt(sockets->mcast_send, SOL_SOCKET,
			SO_BROADCAST, &broadcast, sizeof (broadcast))) == -1) {
			LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
				"setting broadcast option failed");
			return (-1);
		}
	} else {
		switch (bindnet_address->family) {
			case AF_INET:
			memset(&mreq, 0, sizeof(mreq));
			mreq.imr_multiaddr.s_addr = mcast_sin->sin_addr.s_addr;
			mreq.imr_interface.s_addr = boundto_sin->sin_addr.s_addr;
			res = setsockopt (sockets->mcast_recv, IPPROTO_IP, IP_ADD_MEMBERSHIP,
				&mreq, sizeof (mreq));
			if (res == -1) {
				LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
					"join ipv4 multicast group failed");
				return (-1);
			}
			break;
			case AF_INET6:
			memset(&mreq6, 0, sizeof(mreq6));
			memcpy(&mreq6.ipv6mr_multiaddr, &mcast_sin6->sin6_addr, sizeof(struct in6_addr));
			mreq6.ipv6mr_interface = interface_num;

			res = setsockopt (sockets->mcast_recv, IPPROTO_IPV6, IPV6_JOIN_GROUP,
				&mreq6, sizeof (mreq6));
			if (res == -1) {
				LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
					"join ipv6 multicast group failed");
				return (-1);
			}
			break;
		}
	}

	/*
	 * Turn off multicast loopback
	 */

	flag = 0;
	switch ( bindnet_address->family ) {
		case AF_INET:
		sflag = 0;
		res = setsockopt (sockets->mcast_send, IPPROTO_IP, IP_MULTICAST_LOOP,
			&sflag, sizeof (sflag));
		break;
		case AF_INET6:
		res = setsockopt (sockets->mcast_send, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
			&flag, sizeof (flag));
	}
	if (res == -1) {
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
			"Unable to turn off multicast loopback");
		return (-1);
	}

	/*
	 * Set multicast packets TTL
	 */
	flag = instance->totem_interface->ttl;
	if (bindnet_address->family == AF_INET6) {
		res = setsockopt (sockets->mcast_send, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
			&flag, sizeof (flag));
		if (res == -1) {
			LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
				"set mcast v6 TTL failed");
			return (-1);
		}
	} else {
		sflag = flag;
		res = setsockopt(sockets->mcast_send, IPPROTO_IP, IP_MULTICAST_TTL,
			&sflag, sizeof(sflag));
		if (res == -1) {
			LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
				"set mcast v4 TTL failed");
			return (-1);
		}
	}

	/*
	 * Bind to a specific interface for multicast send and receive
	 */
	switch ( bindnet_address->family ) {
		case AF_INET:
		if (setsockopt (sockets->mcast_send, IPPROTO_IP, IP_MULTICAST_IF,
			&boundto_sin->sin_addr, sizeof (boundto_sin->sin_addr)) < 0) {
			LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
				"cannot select interface for multicast packets (send)");
			return (-1);
		}
		if (setsockopt (sockets->mcast_recv, IPPROTO_IP, IP_MULTICAST_IF,
			&boundto_sin->sin_addr, sizeof (boundto_sin->sin_addr)) < 0) {
			LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
				"cannot select interface for multicast packets (recv)");
			return (-1);
		}
		break;
		case AF_INET6:
		if (setsockopt (sockets->mcast_send, IPPROTO_IPV6, IPV6_MULTICAST_IF,
			&interface_num, sizeof (interface_num)) < 0) {
			LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
				"cannot select interface for multicast packets (send v6)");
			return (-1);
		}
		if (setsockopt (sockets->mcast_recv, IPPROTO_IPV6, IPV6_MULTICAST_IF,
			&interface_num, sizeof (interface_num)) < 0) {
			LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
				"cannot select interface for multicast packets (recv v6)");
			return (-1);
		}
		break;
	}

	/*
	 * Bind to multicast socket used for multicast receives
	 * This needs to happen after all of the multicast setsockopt() calls
	 * as the kernel seems to only put them into effect (for IPV6) when bind()
	 * is called.
	 */
	totemip_totemip_to_sockaddr_convert(mcast_address,
		instance->totem_interface->ip_port, &sockaddr, &addrlen);

	retries = 0;
	while (1) {
		res = bind (sockets->mcast_recv, (struct sockaddr *)&sockaddr, addrlen);
		if (res == 0) {
			break;
		}
		LOGSYS_PERROR (errno, instance->totemudp_log_level_warning,
				"Unable to bind the socket to receive multicast packets");
		if (++retries > BIND_MAX_RETRIES) {
			break;
		}

		/*
		 * Wait for a while
		 */
		(void)poll(NULL, 0, BIND_RETRIES_INTERVAL * retries);
	}

	if (res == -1) {
		return (-1);
	}
	return 0;
}

static int totemudp_build_sockets (
	struct totemudp_instance *instance,
	struct totem_ip_address *mcast_address,
	struct totem_ip_address *bindnet_address,
	struct totemudp_socket *sockets,
	struct totem_ip_address *bound_to)
{
	int interface_num;
	int interface_up;
	int res;

	/*
	 * Determine the ip address bound to and the interface name
	 */
	res = netif_determine (instance,
		bindnet_address,
		bound_to,
		&interface_up,
		&interface_num);

	if (res == -1) {
		return (-1);
	}

	totemip_copy(&instance->my_id, bound_to);

	res = totemudp_build_sockets_ip (instance, mcast_address,
		bindnet_address, sockets, bound_to, interface_num);

	if (res == -1) {
		/* if we get here, corosync won't work anyway, so better leaving than faking to work */
		LOGSYS_PERROR (errno, instance->totemudp_log_level_error,
			"Unable to create sockets, exiting");
		exit(EXIT_FAILURE);
	}

	/* We only send out of the token socket */
	totemudp_traffic_control_set(instance, sockets->token);
	return res;
}

/*
 * Totem Network interface
 * depends on poll abstraction, POSIX, IPV4
 */

/*
 * Create an instance
 */
int totemudp_initialize (
	qb_loop_t *poll_handle,
	void **udp_context,
	struct totem_config *totem_config,
	totemsrp_stats_t *stats,

	void *context,

	int (*deliver_fn) (
		void *context,
		const void *msg,
		unsigned int msg_len,
		const struct sockaddr_storage *system_from),

	int (*iface_change_fn) (
		void *context,
		const struct totem_ip_address *iface_address,
		unsigned int ring_no),

	void (*mtu_changed) (
		void *context,
		int net_mtu),

	void (*target_set_completed) (
		void *context))
{
	struct totemudp_instance *instance;

	instance = malloc (sizeof (struct totemudp_instance));
	if (instance == NULL) {
		return (-1);
	}

	totemudp_instance_initialize (instance);

	instance->totem_config = totem_config;
	instance->stats = stats;

	/*
	* Configure logging
	*/
	instance->totemudp_log_level_security = 1; //totem_config->totem_logging_configuration.log_level_security;
	instance->totemudp_log_level_error = totem_config->totem_logging_configuration.log_level_error;
	instance->totemudp_log_level_warning = totem_config->totem_logging_configuration.log_level_warning;
	instance->totemudp_log_level_notice = totem_config->totem_logging_configuration.log_level_notice;
	instance->totemudp_log_level_debug = totem_config->totem_logging_configuration.log_level_debug;
	instance->totemudp_subsys_id = totem_config->totem_logging_configuration.log_subsys_id;
	instance->totemudp_log_printf = totem_config->totem_logging_configuration.log_printf;

	/*
	 * Initialize local variables for totemudp
	 */
	instance->totem_interface = &totem_config->interfaces[0];
	totemip_copy (&instance->mcast_address, &instance->totem_interface->mcast_addr);
	memset (instance->iov_buffer, 0, UDP_RECEIVE_FRAME_SIZE_MAX + 1);
	memset (instance->iov_buffer_flush, 0, UDP_RECEIVE_FRAME_SIZE_MAX + 1);

	instance->totemudp_poll_handle = poll_handle;

	instance->totem_interface->bindnet.nodeid = instance->totem_config->node_id;

	instance->context = context;
	instance->totemudp_deliver_fn = deliver_fn;

	instance->totemudp_iface_change_fn = iface_change_fn;

	instance->totemudp_target_set_completed = target_set_completed;

	totemip_localhost (instance->mcast_address.family, &localhost);
	localhost.nodeid = instance->totem_config->node_id;

	/*
	 * RRP layer isn't ready to receive message because it hasn't
	 * initialized yet.  Add short timer to check the interfaces.
	 */
	qb_loop_timer_add (instance->totemudp_poll_handle,
		QB_LOOP_MED,
		100*QB_TIME_NS_IN_MSEC,
		(void *)instance,
		timer_function_netif_check_timeout,
		&instance->timer_netif_check_timeout);

	*udp_context = instance;
	return (0);
}

void *totemudp_buffer_alloc (void)
{
	return malloc (FRAME_SIZE_MAX);
}

void totemudp_buffer_release (void *ptr)
{
	return free (ptr);
}

int totemudp_processor_count_set (
	void *udp_context,
	int processor_count)
{
	struct totemudp_instance *instance = (struct totemudp_instance *)udp_context;
	int res = 0;

	instance->my_memb_entries = processor_count;
	qb_loop_timer_del (instance->totemudp_poll_handle,
		instance->timer_netif_check_timeout);
	if (processor_count == 1) {
		qb_loop_timer_add (instance->totemudp_poll_handle,
			QB_LOOP_MED,
			instance->totem_config->downcheck_timeout*QB_TIME_NS_IN_MSEC,
			(void *)instance,
			timer_function_netif_check_timeout,
			&instance->timer_netif_check_timeout);
	}

	return (res);
}

int totemudp_recv_flush (void *udp_context)
{
	struct totemudp_instance *instance = (struct totemudp_instance *)udp_context;
	struct pollfd ufd;
	int nfds;
	int res = 0;
	int i;
	int sock;

	instance->flushing = 1;

	for (i = 0; i < 2; i++) {
		sock = -1;
		if (i == 0) {
		    sock = instance->totemudp_sockets.mcast_recv;
		}
		if (i == 1) {
		    sock = instance->totemudp_sockets.local_mcast_loop[0];
		}
		assert(sock != -1);

		do {
			ufd.fd = sock;
			ufd.events = POLLIN;
			nfds = poll (&ufd, 1, 0);
			if (nfds == 1 && ufd.revents & POLLIN) {
			net_deliver_fn (sock, ufd.revents, instance);
			}
		} while (nfds == 1);
	}

	instance->flushing = 0;

	return (res);
}

int totemudp_send_flush (void *udp_context)
{
	return 0;
}

int totemudp_token_send (
	void *udp_context,
	const void *msg,
	unsigned int msg_len)
{
	struct totemudp_instance *instance = (struct totemudp_instance *)udp_context;
	int res = 0;

	ucast_sendmsg (instance, &instance->token_target, msg, msg_len);

	return (res);
}
int totemudp_mcast_flush_send (
	void *udp_context,
	const void *msg,
	unsigned int msg_len)
{
	struct totemudp_instance *instance = (struct totemudp_instance *)udp_context;
	int res = 0;

	mcast_sendmsg (instance, msg, msg_len);

	return (res);
}

int totemudp_mcast_noflush_send (
	void *udp_context,
	const void *msg,
	unsigned int msg_len)
{
	struct totemudp_instance *instance = (struct totemudp_instance *)udp_context;
	int res = 0;

	mcast_sendmsg (instance, msg, msg_len);

	return (res);
}

extern int totemudp_iface_check (void *udp_context)
{
	struct totemudp_instance *instance = (struct totemudp_instance *)udp_context;
	int res = 0;

	timer_function_netif_check_timeout (instance);

	return (res);
}

int totemudp_nodestatus_get (void *udp_context, unsigned int nodeid,
			     struct totem_node_status *node_status)
{
	struct totemudp_instance *instance = (struct totemudp_instance *)udp_context;
	struct qb_list_head *list;
	struct totemudp_member *member;

	qb_list_for_each(list, &(instance->member_list)) {
		member = qb_list_entry (list,
			struct totemudp_member,
			list);

		if (member->member.nodeid == nodeid) {
			node_status->nodeid = nodeid;
			/* reachable is filled in by totemsrp */
			node_status->link_status[0].enabled = 1;
			if (instance->netif_bind_state == BIND_STATE_REGULAR) {
				node_status->link_status[0].enabled = 1;
			} else {
				node_status->link_status[0].enabled = 0;
			}
			node_status->link_status[0].connected = node_status->reachable;
			node_status->link_status[0].mtu = instance->totem_config->net_mtu;
			strncpy(node_status->link_status[0].src_ipaddr, totemip_print(&member->member), KNET_MAX_HOST_LEN-1);
		}
	}
	return (0);
}

int totemudp_ifaces_get (
	void *net_context,
	char ***status,
	unsigned int *iface_count)
{
	static char *statuses[INTERFACE_MAX] = {(char*)"OK"};

	if (status) {
		*status = statuses;
	}
	*iface_count = 1;

	return (0);
}

extern void totemudp_net_mtu_adjust (void *udp_context, struct totem_config *totem_config)
{
	totem_config->net_mtu -= totemip_udpip_header_size(totem_config->interfaces[0].bindnet.family);
}

int totemudp_token_target_set (
	void *udp_context,
	unsigned int nodeid)
{
	struct totemudp_instance *instance = (struct totemudp_instance *)udp_context;
	struct qb_list_head *list;
	struct totemudp_member *member;
	int res = 0;

	qb_list_for_each(list, &(instance->member_list)) {
		member = qb_list_entry (list,
			struct totemudp_member,
			list);

		if (member->member.nodeid == nodeid) {
			memcpy (&instance->token_target, &member->member,
				sizeof (struct totem_ip_address));

			instance->totemudp_target_set_completed (instance->context);
			break;
		}
	}
	return (res);
}

extern int totemudp_recv_mcast_empty (
	void *udp_context)
{
	struct totemudp_instance *instance = (struct totemudp_instance *)udp_context;
	unsigned int res;
	struct sockaddr_storage system_from;
	struct msghdr msg_recv;
	struct pollfd ufd;
	int nfds;
	int msg_processed = 0;
	int i;
	int sock;

	/*
	 * Receive datagram
	 */
	memset(&msg_recv, 0, sizeof(msg_recv));
	msg_recv.msg_name = &system_from;
	msg_recv.msg_namelen = sizeof (struct sockaddr_storage);
	msg_recv.msg_iov = &instance->totemudp_iov_recv_flush;
	msg_recv.msg_iovlen = 1;

	for (i = 0; i < 2; i++) {
		sock = -1;
		if (i == 0) {
		    sock = instance->totemudp_sockets.mcast_recv;
		}
		if (i == 1) {
		    sock = instance->totemudp_sockets.local_mcast_loop[0];
		}
		assert(sock != -1);

		do {
			ufd.fd = sock;
			ufd.events = POLLIN;
			nfds = poll (&ufd, 1, 0);
			if (nfds == 1 && ufd.revents & POLLIN) {
				res = recvmsg (sock, &msg_recv, MSG_NOSIGNAL | MSG_DONTWAIT);
				if (res != -1) {
					msg_processed = 1;
				} else {
					msg_processed = -1;
				}
			}
		} while (nfds == 1);
	}

	return (msg_processed);
}


int totemudp_member_add (
	void *udp_context,
	const struct totem_ip_address *local,
	const struct totem_ip_address *member,
	int ring_no)
{
	struct totemudp_instance *instance = (struct totemudp_instance *)udp_context;

	struct totemudp_member *new_member;

	new_member = malloc (sizeof (struct totemudp_member));
	if (new_member == NULL) {
		return (-1);
	}

	memset(new_member, 0, sizeof(*new_member));

	qb_list_init (&new_member->list);
	qb_list_add_tail (&new_member->list, &instance->member_list);
	memcpy (&new_member->member, member, sizeof (struct totem_ip_address));

	return (0);
}

int totemudp_member_remove (
	void *udp_context,
	const struct totem_ip_address *token_target,
	int ring_no)
{
	int found = 0;
	struct qb_list_head *list;
	struct totemudp_member *member;
	struct totemudp_instance *instance = (struct totemudp_instance *)udp_context;

	/*
	 * Find the member to remove and close its socket
	 */
	qb_list_for_each(list, &(instance->member_list)) {
		member = qb_list_entry (list,
			struct totemudp_member,
			list);

		if (totemip_compare (token_target, &member->member)==0) {
			found = 1;
			break;
		}
	}

	/*
	 * Delete the member from the list
	 */
	if (found) {
		qb_list_del (list);
	}

	return (0);
}

int totemudp_iface_set (void *net_context,
	const struct totem_ip_address *local_addr,
	unsigned short ip_port,
	unsigned int iface_no)
{
	/* Not supported */
	return (-1);
}

int totemudp_reconfigure (
	void *udp_context,
	struct totem_config *totem_config)
{
	/* Not supported */
	return (-1);
}